G__Matrix.cxx

Go to the documentation of this file.

//
// File generated by core/utils/src/rootcint_tmp at Wed Apr 20 13:32:57 2011

// Do NOT change. Changes will be lost next time file is generated
//

#define R__DICTIONARY_FILENAME mathdImatrixdIsrcdIG__Matrix
#include "RConfig.h" //rootcint 4834
#if !defined(R__ACCESS_IN_SYMBOL)
//Break the privacy of classes -- Disabled for the moment
#define private public
#define protected public
#endif

// Since CINT ignores the std namespace, we need to do so in this file.
namespace std {} using namespace std;
#include "G__Matrix.h"

#include "TClass.h"
#include "TBuffer.h"
#include "TMemberInspector.h"
#include "TError.h"

#ifndef G__ROOT
#define G__ROOT
#endif

#include "RtypesImp.h"
#include "TIsAProxy.h"

// START OF SHADOWS

namespace ROOT {
   namespace Shadow {
      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::TMatrixTBase< float > TMatrixTBaselEfloatgR;
      #else
      class TMatrixTBaselEfloatgR  :  public ::TObject {
         public:
         //friend XX;
         #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
         typedef ::TMatrixTBase< float >::EMatrixStatusBits EMatrixStatusBits;
         #else
         enum EMatrixStatusBits  {
         };
         #endif

         // To force the creation of a virtual table, throw just in case.
         virtual ~TMatrixTBaselEfloatgR() throw() {};
         int fNrows; //number of rows
         int fNcols; //number of columns
         int fRowLwb; //lower bound of the row index
         int fColLwb; //lower bound of the col index
         int fNelems; //number of elements in matrix
         int fNrowIndex; //length of row index array (= fNrows+1) wich is only used for sparse matrices
         float fTol; //sqrt(epsilon); epsilon is smallest number number so that  1+epsilon > 1
         bool fIsOwner; //!default kTRUE, when Use array kFALSE
      };
      #endif

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::TMatrixTBase< double > TMatrixTBaselEdoublegR;
      #else
      class TMatrixTBaselEdoublegR  :  public ::TObject {
         public:
         //friend XX;
         #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
         typedef ::TMatrixTBase< double >::EMatrixStatusBits EMatrixStatusBits;
         #else
         enum EMatrixStatusBits  {
         };
         #endif

         // To force the creation of a virtual table, throw just in case.
         virtual ~TMatrixTBaselEdoublegR() throw() {};
         int fNrows; //number of rows
         int fNcols; //number of columns
         int fRowLwb; //lower bound of the row index
         int fColLwb; //lower bound of the col index
         int fNelems; //number of elements in matrix
         int fNrowIndex; //length of row index array (= fNrows+1) wich is only used for sparse matrices
         double fTol; //sqrt(epsilon); epsilon is smallest number number so that  1+epsilon > 1
         bool fIsOwner; //!default kTRUE, when Use array kFALSE
      };
      #endif

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::TVectorT< float > TVectorTlEfloatgR;
      #else
      class TVectorTlEfloatgR  :  public ::TObject {
         public:
         //friend XX;
         #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
         typedef ::TVectorT< float >::EVectorStatusBits EVectorStatusBits;
         #else
         enum EVectorStatusBits  {
         };
         #endif

         // To force the creation of a virtual table, throw just in case.
         virtual ~TVectorTlEfloatgR() throw() {};
         int fNrows; //number of rows
         int fRowLwb; //lower bound of the row index
         float* fElements; //[fNrows] elements themselves
         float fDataStack[5]; //! data container
         bool fIsOwner; //!default kTRUE, when Use array kFALSE
      };
      #endif

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::TVectorT< double > TVectorTlEdoublegR;
      #else
      class TVectorTlEdoublegR  :  public ::TObject {
         public:
         //friend XX;
         #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
         typedef ::TVectorT< double >::EVectorStatusBits EVectorStatusBits;
         #else
         enum EVectorStatusBits  {
         };
         #endif

         // To force the creation of a virtual table, throw just in case.
         virtual ~TVectorTlEdoublegR() throw() {};
         int fNrows; //number of rows
         int fRowLwb; //lower bound of the row index
         double* fElements; //[fNrows] elements themselves
         double fDataStack[5]; //! data container
         bool fIsOwner; //!default kTRUE, when Use array kFALSE
      };
      #endif

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::TMatrixT< double > TMatrixTlEdoublegR;
      #else
      class TMatrixTlEdoublegR  :  public ::TMatrixTBase< double > {
         public:
         //friend XX;
         #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
         typedef ::TMatrixT< double >::EMatrixCreatorsOp1 EMatrixCreatorsOp1;
         #else
         enum EMatrixCreatorsOp1  {
         };
         #endif

         #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
         typedef ::TMatrixT< double >::EMatrixCreatorsOp2 EMatrixCreatorsOp2;
         #else
         enum EMatrixCreatorsOp2  {
         };
         #endif

         // To force the creation of a virtual table, throw just in case.
         virtual ~TMatrixTlEdoublegR() throw() {};
         double fDataStack[25]; //! data container
         double* fElements; //[fNelems] elements themselves
      };
      #endif

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::TMatrixTSym< double > TMatrixTSymlEdoublegR;
      #else
      class TMatrixTSymlEdoublegR  :  public ::TMatrixTBase< double > {
         public:
         //friend XX;
         #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
         typedef ::TMatrixTSym< double >::EMatrixCreatorsOp1 EMatrixCreatorsOp1;
         #else
         enum EMatrixCreatorsOp1  {
         };
         #endif

         #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
         typedef ::TMatrixTSym< double >::EMatrixCreatorsOp2 EMatrixCreatorsOp2;
         #else
         enum EMatrixCreatorsOp2  {
         };
         #endif

         // To force the creation of a virtual table, throw just in case.
         virtual ~TMatrixTSymlEdoublegR() throw() {};
         double fDataStack[25]; //! data container
         double* fElements; //[fNelems] elements themselves
      };
      #endif

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::TMatrixTSparse< double > TMatrixTSparselEdoublegR;
      #else
      class TMatrixTSparselEdoublegR  :  public ::TMatrixTBase< double > {
         public:
         //friend XX;
         #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
         typedef ::TMatrixTSparse< double >::EMatrixCreatorsOp1 EMatrixCreatorsOp1;
         #else
         enum EMatrixCreatorsOp1  {
         };
         #endif

         #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
         typedef ::TMatrixTSparse< double >::EMatrixCreatorsOp2 EMatrixCreatorsOp2;
         #else
         enum EMatrixCreatorsOp2  {
         };
         #endif

         // To force the creation of a virtual table, throw just in case.
         virtual ~TMatrixTSparselEdoublegR() throw() {};
         int* fRowIndex; //[fNrowIndex] row index
         int* fColIndex; //[fNelems]    column index
         double* fElements; //[fNelems]
      };
      #endif

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::TMatrixTLazy< double > TMatrixTLazylEdoublegR;
      #else
      class TMatrixTLazylEdoublegR  :  public ::TObject {
         public:
         //friend XX;
         // To force the creation of a virtual table, throw just in case.
         virtual ~TMatrixTLazylEdoublegR() throw() {};
         int fRowUpb; //
         int fRowLwb; //
         int fColUpb; //
         int fColLwb; //
      };
      #endif

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::TMatrixTRow_const< double > TMatrixTRow_constlEdoublegR;
      #else
      class TMatrixTRow_constlEdoublegR  {
         public:
         //friend XX;
         // To force the creation of a virtual table, throw just in case.
         virtual ~TMatrixTRow_constlEdoublegR() throw() {};
         :: TMatrixTBase< double >* fMatrix; //the matrix I am a row of
         int fRowInd; //effective row index
         int fInc; //if ptr = @a[row,i], then ptr+inc = @a[row,i+1]
          double* fPtr; //pointer to the a[row,0]
      };
      #endif

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::TMatrixTRow< double > TMatrixTRowlEdoublegR;
      #else
      class TMatrixTRowlEdoublegR  :  public ::TMatrixTRow_const< double > {
         public:
         //friend XX;
         // To force the creation of a virtual table, throw just in case.
         virtual ~TMatrixTRowlEdoublegR() throw() {};
      };
      #endif

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::TMatrixTDiag_const< double > TMatrixTDiag_constlEdoublegR;
      #else
      class TMatrixTDiag_constlEdoublegR  {
         public:
         //friend XX;
         // To force the creation of a virtual table, throw just in case.
         virtual ~TMatrixTDiag_constlEdoublegR() throw() {};
         :: TMatrixTBase< double >* fMatrix; //the matrix I am the diagonal of
         int fInc; //if ptr=@a[i,i], then ptr+inc = @a[i+1,i+1]
         int fNdiag; //number of diag elems, min(nrows,ncols)
          double* fPtr; //pointer to the a[0,0]
      };
      #endif

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::TMatrixTColumn_const< double > TMatrixTColumn_constlEdoublegR;
      #else
      class TMatrixTColumn_constlEdoublegR  {
         public:
         //friend XX;
         // To force the creation of a virtual table, throw just in case.
         virtual ~TMatrixTColumn_constlEdoublegR() throw() {};
         :: TMatrixTBase< double >* fMatrix; //the matrix I am a column of
         int fColInd; //effective column index
         int fInc; //if ptr = @a[i,col], then ptr+inc = @a[i+1,col]
          double* fPtr; //pointer to the a[0,col] column
      };
      #endif

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::TMatrixTFlat_const< double > TMatrixTFlat_constlEdoublegR;
      #else
      class TMatrixTFlat_constlEdoublegR  {
         public:
         //friend XX;
         // To force the creation of a virtual table, throw just in case.
         virtual ~TMatrixTFlat_constlEdoublegR() throw() {};
         :: TMatrixTBase< double >* fMatrix; //the matrix I am the diagonal of
         int fNelems; //
          double* fPtr; //pointer to the a[0,0]
      };
      #endif

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::TMatrixTSub_const< double > TMatrixTSub_constlEdoublegR;
      #else
      class TMatrixTSub_constlEdoublegR  {
         public:
         //friend XX;
         // To force the creation of a virtual table, throw just in case.
         virtual ~TMatrixTSub_constlEdoublegR() throw() {};
         :: TMatrixTBase< double >* fMatrix; //the matrix I am a submatrix of
         int fRowOff; //
         int fColOff; //
         int fNrowsSub; //
         int fNcolsSub; //
      };
      #endif

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::TMatrixTSparseRow_const< double > TMatrixTSparseRow_constlEdoublegR;
      #else
      class TMatrixTSparseRow_constlEdoublegR  {
         public:
         //friend XX;
         // To force the creation of a virtual table, throw just in case.
         virtual ~TMatrixTSparseRow_constlEdoublegR() throw() {};
         :: TMatrixTBase< double >* fMatrix; //the matrix I am a row of
         int fRowInd; //effective row index
         int fNindex; //index range
          int* fColPtr; //column index pointer
          double* fDataPtr; //data pointer
      };
      #endif

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::TMatrixTSparseDiag_const< double > TMatrixTSparseDiag_constlEdoublegR;
      #else
      class TMatrixTSparseDiag_constlEdoublegR  {
         public:
         //friend XX;
         // To force the creation of a virtual table, throw just in case.
         virtual ~TMatrixTSparseDiag_constlEdoublegR() throw() {};
         :: TMatrixTBase< double >* fMatrix; //the matrix I am the diagonal of
         int fNdiag; //number of diag elems, min(nrows,ncols)
          double* fDataPtr; //data pointer
      };
      #endif

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::TMatrixTColumn< double > TMatrixTColumnlEdoublegR;
      #else
      class TMatrixTColumnlEdoublegR  :  public ::TMatrixTColumn_const< double > {
         public:
         //friend XX;
         // To force the creation of a virtual table, throw just in case.
         virtual ~TMatrixTColumnlEdoublegR() throw() {};
      };
      #endif

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::TMatrixTDiag< double > TMatrixTDiaglEdoublegR;
      #else
      class TMatrixTDiaglEdoublegR  :  public ::TMatrixTDiag_const< double > {
         public:
         //friend XX;
         // To force the creation of a virtual table, throw just in case.
         virtual ~TMatrixTDiaglEdoublegR() throw() {};
      };
      #endif

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::TMatrixTFlat< double > TMatrixTFlatlEdoublegR;
      #else
      class TMatrixTFlatlEdoublegR  :  public ::TMatrixTFlat_const< double > {
         public:
         //friend XX;
         // To force the creation of a virtual table, throw just in case.
         virtual ~TMatrixTFlatlEdoublegR() throw() {};
      };
      #endif

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::TMatrixTSub< double > TMatrixTSublEdoublegR;
      #else
      class TMatrixTSublEdoublegR  :  public ::TMatrixTSub_const< double > {
         public:
         //friend XX;
         // To force the creation of a virtual table, throw just in case.
         virtual ~TMatrixTSublEdoublegR() throw() {};
      };
      #endif

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::TMatrixTSparseRow< double > TMatrixTSparseRowlEdoublegR;
      #else
      class TMatrixTSparseRowlEdoublegR  :  public ::TMatrixTSparseRow_const< double > {
         public:
         //friend XX;
         // To force the creation of a virtual table, throw just in case.
         virtual ~TMatrixTSparseRowlEdoublegR() throw() {};
      };
      #endif

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::TMatrixTSparseDiag< double > TMatrixTSparseDiaglEdoublegR;
      #else
      class TMatrixTSparseDiaglEdoublegR  :  public ::TMatrixTSparseDiag_const< double > {
         public:
         //friend XX;
         // To force the creation of a virtual table, throw just in case.
         virtual ~TMatrixTSparseDiaglEdoublegR() throw() {};
      };
      #endif

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::TMatrixTSymLazy< double > TMatrixTSymLazylEdoublegR;
      #else
      class TMatrixTSymLazylEdoublegR  :  public ::TObject {
         public:
         //friend XX;
         // To force the creation of a virtual table, throw just in case.
         virtual ~TMatrixTSymLazylEdoublegR() throw() {};
         int fRowUpb; //
         int fRowLwb; //
      };
      #endif

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::TMatrixTRow_const< float > TMatrixTRow_constlEfloatgR;
      #else
      class TMatrixTRow_constlEfloatgR  {
         public:
         //friend XX;
         // To force the creation of a virtual table, throw just in case.
         virtual ~TMatrixTRow_constlEfloatgR() throw() {};
         :: TMatrixTBase< float >* fMatrix; //the matrix I am a row of
         int fRowInd; //effective row index
         int fInc; //if ptr = @a[row,i], then ptr+inc = @a[row,i+1]
          float* fPtr; //pointer to the a[row,0]
      };
      #endif

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::TMatrixT< float > TMatrixTlEfloatgR;
      #else
      class TMatrixTlEfloatgR  :  public ::TMatrixTBase< float > {
         public:
         //friend XX;
         #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
         typedef ::TMatrixT< float >::EMatrixCreatorsOp1 EMatrixCreatorsOp1;
         #else
         enum EMatrixCreatorsOp1  {
         };
         #endif

         #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
         typedef ::TMatrixT< float >::EMatrixCreatorsOp2 EMatrixCreatorsOp2;
         #else
         enum EMatrixCreatorsOp2  {
         };
         #endif

         // To force the creation of a virtual table, throw just in case.
         virtual ~TMatrixTlEfloatgR() throw() {};
         float fDataStack[25]; //! data container
         float* fElements; //[fNelems] elements themselves
      };
      #endif

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::TMatrixTSym< float > TMatrixTSymlEfloatgR;
      #else
      class TMatrixTSymlEfloatgR  :  public ::TMatrixTBase< float > {
         public:
         //friend XX;
         #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
         typedef ::TMatrixTSym< float >::EMatrixCreatorsOp1 EMatrixCreatorsOp1;
         #else
         enum EMatrixCreatorsOp1  {
         };
         #endif

         #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
         typedef ::TMatrixTSym< float >::EMatrixCreatorsOp2 EMatrixCreatorsOp2;
         #else
         enum EMatrixCreatorsOp2  {
         };
         #endif

         // To force the creation of a virtual table, throw just in case.
         virtual ~TMatrixTSymlEfloatgR() throw() {};
         float fDataStack[25]; //! data container
         float* fElements; //[fNelems] elements themselves
      };
      #endif

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::TMatrixTSymLazy< float > TMatrixTSymLazylEfloatgR;
      #else
      class TMatrixTSymLazylEfloatgR  :  public ::TObject {
         public:
         //friend XX;
         // To force the creation of a virtual table, throw just in case.
         virtual ~TMatrixTSymLazylEfloatgR() throw() {};
         int fRowUpb; //
         int fRowLwb; //
      };
      #endif

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::TMatrixTRow< float > TMatrixTRowlEfloatgR;
      #else
      class TMatrixTRowlEfloatgR  :  public ::TMatrixTRow_const< float > {
         public:
         //friend XX;
         // To force the creation of a virtual table, throw just in case.
         virtual ~TMatrixTRowlEfloatgR() throw() {};
      };
      #endif

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::TMatrixTSparse< float > TMatrixTSparselEfloatgR;
      #else
      class TMatrixTSparselEfloatgR  :  public ::TMatrixTBase< float > {
         public:
         //friend XX;
         #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
         typedef ::TMatrixTSparse< float >::EMatrixCreatorsOp1 EMatrixCreatorsOp1;
         #else
         enum EMatrixCreatorsOp1  {
         };
         #endif

         #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
         typedef ::TMatrixTSparse< float >::EMatrixCreatorsOp2 EMatrixCreatorsOp2;
         #else
         enum EMatrixCreatorsOp2  {
         };
         #endif

         // To force the creation of a virtual table, throw just in case.
         virtual ~TMatrixTSparselEfloatgR() throw() {};
         int* fRowIndex; //[fNrowIndex] row index
         int* fColIndex; //[fNelems]    column index
         float* fElements; //[fNelems]
      };
      #endif

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::TMatrixTSparseRow_const< float > TMatrixTSparseRow_constlEfloatgR;
      #else
      class TMatrixTSparseRow_constlEfloatgR  {
         public:
         //friend XX;
         // To force the creation of a virtual table, throw just in case.
         virtual ~TMatrixTSparseRow_constlEfloatgR() throw() {};
         :: TMatrixTBase< float >* fMatrix; //the matrix I am a row of
         int fRowInd; //effective row index
         int fNindex; //index range
          int* fColPtr; //column index pointer
          float* fDataPtr; //data pointer
      };
      #endif

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::TMatrixTSparseRow< float > TMatrixTSparseRowlEfloatgR;
      #else
      class TMatrixTSparseRowlEfloatgR  :  public ::TMatrixTSparseRow_const< float > {
         public:
         //friend XX;
         // To force the creation of a virtual table, throw just in case.
         virtual ~TMatrixTSparseRowlEfloatgR() throw() {};
      };
      #endif

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::TMatrixTLazy< float > TMatrixTLazylEfloatgR;
      #else
      class TMatrixTLazylEfloatgR  :  public ::TObject {
         public:
         //friend XX;
         // To force the creation of a virtual table, throw just in case.
         virtual ~TMatrixTLazylEfloatgR() throw() {};
         int fRowUpb; //
         int fRowLwb; //
         int fColUpb; //
         int fColLwb; //
      };
      #endif

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::TMatrixTDiag_const< float > TMatrixTDiag_constlEfloatgR;
      #else
      class TMatrixTDiag_constlEfloatgR  {
         public:
         //friend XX;
         // To force the creation of a virtual table, throw just in case.
         virtual ~TMatrixTDiag_constlEfloatgR() throw() {};
         :: TMatrixTBase< float >* fMatrix; //the matrix I am the diagonal of
         int fInc; //if ptr=@a[i,i], then ptr+inc = @a[i+1,i+1]
         int fNdiag; //number of diag elems, min(nrows,ncols)
          float* fPtr; //pointer to the a[0,0]
      };
      #endif

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::TMatrixTColumn_const< float > TMatrixTColumn_constlEfloatgR;
      #else
      class TMatrixTColumn_constlEfloatgR  {
         public:
         //friend XX;
         // To force the creation of a virtual table, throw just in case.
         virtual ~TMatrixTColumn_constlEfloatgR() throw() {};
         :: TMatrixTBase< float >* fMatrix; //the matrix I am a column of
         int fColInd; //effective column index
         int fInc; //if ptr = @a[i,col], then ptr+inc = @a[i+1,col]
          float* fPtr; //pointer to the a[0,col] column
      };
      #endif

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::TMatrixTSparseDiag_const< float > TMatrixTSparseDiag_constlEfloatgR;
      #else
      class TMatrixTSparseDiag_constlEfloatgR  {
         public:
         //friend XX;
         // To force the creation of a virtual table, throw just in case.
         virtual ~TMatrixTSparseDiag_constlEfloatgR() throw() {};
         :: TMatrixTBase< float >* fMatrix; //the matrix I am the diagonal of
         int fNdiag; //number of diag elems, min(nrows,ncols)
          float* fDataPtr; //data pointer
      };
      #endif

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::THaarMatrixT< double > THaarMatrixTlEdoublegR;
      #else
      class THaarMatrixTlEdoublegR  :  public ::TMatrixTLazy< double > {
         public:
         //friend XX;
         // To force the creation of a virtual table, throw just in case.
         virtual ~THaarMatrixTlEdoublegR() throw() {};
      };
      #endif

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::THilbertMatrixT< double > THilbertMatrixTlEdoublegR;
      #else
      class THilbertMatrixTlEdoublegR  :  public ::TMatrixTLazy< double > {
         public:
         //friend XX;
         // To force the creation of a virtual table, throw just in case.
         virtual ~THilbertMatrixTlEdoublegR() throw() {};
      };
      #endif

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::THilbertMatrixTSym< double > THilbertMatrixTSymlEdoublegR;
      #else
      class THilbertMatrixTSymlEdoublegR  :  public ::TMatrixTSymLazy< double > {
         public:
         //friend XX;
         // To force the creation of a virtual table, throw just in case.
         virtual ~THilbertMatrixTSymlEdoublegR() throw() {};
      };
      #endif

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::TMatrixTFlat_const< float > TMatrixTFlat_constlEfloatgR;
      #else
      class TMatrixTFlat_constlEfloatgR  {
         public:
         //friend XX;
         // To force the creation of a virtual table, throw just in case.
         virtual ~TMatrixTFlat_constlEfloatgR() throw() {};
         :: TMatrixTBase< float >* fMatrix; //the matrix I am the diagonal of
         int fNelems; //
          float* fPtr; //pointer to the a[0,0]
      };
      #endif

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::TMatrixTSub_const< float > TMatrixTSub_constlEfloatgR;
      #else
      class TMatrixTSub_constlEfloatgR  {
         public:
         //friend XX;
         // To force the creation of a virtual table, throw just in case.
         virtual ~TMatrixTSub_constlEfloatgR() throw() {};
         :: TMatrixTBase< float >* fMatrix; //the matrix I am a submatrix of
         int fRowOff; //
         int fColOff; //
         int fNrowsSub; //
         int fNcolsSub; //
      };
      #endif

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::TMatrixTColumn< float > TMatrixTColumnlEfloatgR;
      #else
      class TMatrixTColumnlEfloatgR  :  public ::TMatrixTColumn_const< float > {
         public:
         //friend XX;
         // To force the creation of a virtual table, throw just in case.
         virtual ~TMatrixTColumnlEfloatgR() throw() {};
      };
      #endif

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::TMatrixTDiag< float > TMatrixTDiaglEfloatgR;
      #else
      class TMatrixTDiaglEfloatgR  :  public ::TMatrixTDiag_const< float > {
         public:
         //friend XX;
         // To force the creation of a virtual table, throw just in case.
         virtual ~TMatrixTDiaglEfloatgR() throw() {};
      };
      #endif

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::TMatrixTFlat< float > TMatrixTFlatlEfloatgR;
      #else
      class TMatrixTFlatlEfloatgR  :  public ::TMatrixTFlat_const< float > {
         public:
         //friend XX;
         // To force the creation of a virtual table, throw just in case.
         virtual ~TMatrixTFlatlEfloatgR() throw() {};
      };
      #endif

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::TMatrixTSub< float > TMatrixTSublEfloatgR;
      #else
      class TMatrixTSublEfloatgR  :  public ::TMatrixTSub_const< float > {
         public:
         //friend XX;
         // To force the creation of a virtual table, throw just in case.
         virtual ~TMatrixTSublEfloatgR() throw() {};
      };
      #endif

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::TMatrixTSparseDiag< float > TMatrixTSparseDiaglEfloatgR;
      #else
      class TMatrixTSparseDiaglEfloatgR  :  public ::TMatrixTSparseDiag_const< float > {
         public:
         //friend XX;
         // To force the creation of a virtual table, throw just in case.
         virtual ~TMatrixTSparseDiaglEfloatgR() throw() {};
      };
      #endif

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::THaarMatrixT< float > THaarMatrixTlEfloatgR;
      #else
      class THaarMatrixTlEfloatgR  :  public ::TMatrixTLazy< float > {
         public:
         //friend XX;
         // To force the creation of a virtual table, throw just in case.
         virtual ~THaarMatrixTlEfloatgR() throw() {};
      };
      #endif

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::THilbertMatrixT< float > THilbertMatrixTlEfloatgR;
      #else
      class THilbertMatrixTlEfloatgR  :  public ::TMatrixTLazy< float > {
         public:
         //friend XX;
         // To force the creation of a virtual table, throw just in case.
         virtual ~THilbertMatrixTlEfloatgR() throw() {};
      };
      #endif

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::THilbertMatrixTSym< float > THilbertMatrixTSymlEfloatgR;
      #else
      class THilbertMatrixTSymlEfloatgR  :  public ::TMatrixTSymLazy< float > {
         public:
         //friend XX;
         // To force the creation of a virtual table, throw just in case.
         virtual ~THilbertMatrixTSymlEfloatgR() throw() {};
      };
      #endif

   } // of namespace Shadow
} // of namespace ROOT
// END OF SHADOWS

namespace ROOT {
   void TMatrixTBaselEfloatgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void TMatrixTBaselEfloatgR_Dictionary();
   static void delete_TMatrixTBaselEfloatgR(void *p);
   static void deleteArray_TMatrixTBaselEfloatgR(void *p);
   static void destruct_TMatrixTBaselEfloatgR(void *p);
   static void streamer_TMatrixTBaselEfloatgR(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMatrixTBase<float>*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::TMatrixTBase<float>) == sizeof(::ROOT::Shadow::TMatrixTBaselEfloatgR));
      ::TMatrixTBase<float> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMatrixTBase<float> >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TMatrixTBase<float>", ::TMatrixTBase<float>::Class_Version(), "include/TMatrixTBase.h", 95,
                  typeid(::TMatrixTBase<float>), DefineBehavior(ptr, ptr),
                  &TMatrixTBaselEfloatgR_Dictionary, isa_proxy, 1,
                  sizeof(::TMatrixTBase<float>) );
      instance.SetDelete(&delete_TMatrixTBaselEfloatgR);
      instance.SetDeleteArray(&deleteArray_TMatrixTBaselEfloatgR);
      instance.SetDestructor(&destruct_TMatrixTBaselEfloatgR);
      instance.SetStreamerFunc(&streamer_TMatrixTBaselEfloatgR);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TMatrixTBase<float>*)
   {
      return GenerateInitInstanceLocal((::TMatrixTBase<float>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMatrixTBase<float>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void TMatrixTBaselEfloatgR_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTBase<float>*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   void TMatrixTBaselEdoublegR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void TMatrixTBaselEdoublegR_Dictionary();
   static void delete_TMatrixTBaselEdoublegR(void *p);
   static void deleteArray_TMatrixTBaselEdoublegR(void *p);
   static void destruct_TMatrixTBaselEdoublegR(void *p);
   static void streamer_TMatrixTBaselEdoublegR(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMatrixTBase<double>*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::TMatrixTBase<double>) == sizeof(::ROOT::Shadow::TMatrixTBaselEdoublegR));
      ::TMatrixTBase<double> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMatrixTBase<double> >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TMatrixTBase<double>", ::TMatrixTBase<double>::Class_Version(), "include/TMatrixTBase.h", 95,
                  typeid(::TMatrixTBase<double>), DefineBehavior(ptr, ptr),
                  &TMatrixTBaselEdoublegR_Dictionary, isa_proxy, 1,
                  sizeof(::TMatrixTBase<double>) );
      instance.SetDelete(&delete_TMatrixTBaselEdoublegR);
      instance.SetDeleteArray(&deleteArray_TMatrixTBaselEdoublegR);
      instance.SetDestructor(&destruct_TMatrixTBaselEdoublegR);
      instance.SetStreamerFunc(&streamer_TMatrixTBaselEdoublegR);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TMatrixTBase<double>*)
   {
      return GenerateInitInstanceLocal((::TMatrixTBase<double>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMatrixTBase<double>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void TMatrixTBaselEdoublegR_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTBase<double>*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   void TVectorTlEfloatgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void TVectorTlEfloatgR_Dictionary();
   static void *new_TVectorTlEfloatgR(void *p = 0);
   static void *newArray_TVectorTlEfloatgR(Long_t size, void *p);
   static void delete_TVectorTlEfloatgR(void *p);
   static void deleteArray_TVectorTlEfloatgR(void *p);
   static void destruct_TVectorTlEfloatgR(void *p);
   static void streamer_TVectorTlEfloatgR(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TVectorT<float>*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::TVectorT<float>) == sizeof(::ROOT::Shadow::TVectorTlEfloatgR));
      ::TVectorT<float> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TVectorT<float> >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TVectorT<float>", ::TVectorT<float>::Class_Version(), "include/TVectorT.h", 33,
                  typeid(::TVectorT<float>), DefineBehavior(ptr, ptr),
                  &TVectorTlEfloatgR_Dictionary, isa_proxy, 1,
                  sizeof(::TVectorT<float>) );
      instance.SetNew(&new_TVectorTlEfloatgR);
      instance.SetNewArray(&newArray_TVectorTlEfloatgR);
      instance.SetDelete(&delete_TVectorTlEfloatgR);
      instance.SetDeleteArray(&deleteArray_TVectorTlEfloatgR);
      instance.SetDestructor(&destruct_TVectorTlEfloatgR);
      instance.SetStreamerFunc(&streamer_TVectorTlEfloatgR);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TVectorT<float>*)
   {
      return GenerateInitInstanceLocal((::TVectorT<float>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TVectorT<float>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void TVectorTlEfloatgR_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::TVectorT<float>*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   void TVectorTlEdoublegR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void TVectorTlEdoublegR_Dictionary();
   static void *new_TVectorTlEdoublegR(void *p = 0);
   static void *newArray_TVectorTlEdoublegR(Long_t size, void *p);
   static void delete_TVectorTlEdoublegR(void *p);
   static void deleteArray_TVectorTlEdoublegR(void *p);
   static void destruct_TVectorTlEdoublegR(void *p);
   static void streamer_TVectorTlEdoublegR(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TVectorT<double>*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::TVectorT<double>) == sizeof(::ROOT::Shadow::TVectorTlEdoublegR));
      ::TVectorT<double> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TVectorT<double> >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TVectorT<double>", ::TVectorT<double>::Class_Version(), "include/TVectorT.h", 33,
                  typeid(::TVectorT<double>), DefineBehavior(ptr, ptr),
                  &TVectorTlEdoublegR_Dictionary, isa_proxy, 1,
                  sizeof(::TVectorT<double>) );
      instance.SetNew(&new_TVectorTlEdoublegR);
      instance.SetNewArray(&newArray_TVectorTlEdoublegR);
      instance.SetDelete(&delete_TVectorTlEdoublegR);
      instance.SetDeleteArray(&deleteArray_TVectorTlEdoublegR);
      instance.SetDestructor(&destruct_TVectorTlEdoublegR);
      instance.SetStreamerFunc(&streamer_TVectorTlEdoublegR);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TVectorT<double>*)
   {
      return GenerateInitInstanceLocal((::TVectorT<double>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TVectorT<double>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void TVectorTlEdoublegR_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::TVectorT<double>*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   void TMatrixTlEdoublegR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void TMatrixTlEdoublegR_Dictionary();
   static void *new_TMatrixTlEdoublegR(void *p = 0);
   static void *newArray_TMatrixTlEdoublegR(Long_t size, void *p);
   static void delete_TMatrixTlEdoublegR(void *p);
   static void deleteArray_TMatrixTlEdoublegR(void *p);
   static void destruct_TMatrixTlEdoublegR(void *p);
   static void streamer_TMatrixTlEdoublegR(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMatrixT<double>*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::TMatrixT<double>) == sizeof(::ROOT::Shadow::TMatrixTlEdoublegR));
      ::TMatrixT<double> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMatrixT<double> >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TMatrixT<double>", ::TMatrixT<double>::Class_Version(), "include/TMatrixT.h", 39,
                  typeid(::TMatrixT<double>), DefineBehavior(ptr, ptr),
                  &TMatrixTlEdoublegR_Dictionary, isa_proxy, 1,
                  sizeof(::TMatrixT<double>) );
      instance.SetNew(&new_TMatrixTlEdoublegR);
      instance.SetNewArray(&newArray_TMatrixTlEdoublegR);
      instance.SetDelete(&delete_TMatrixTlEdoublegR);
      instance.SetDeleteArray(&deleteArray_TMatrixTlEdoublegR);
      instance.SetDestructor(&destruct_TMatrixTlEdoublegR);
      instance.SetStreamerFunc(&streamer_TMatrixTlEdoublegR);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TMatrixT<double>*)
   {
      return GenerateInitInstanceLocal((::TMatrixT<double>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMatrixT<double>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void TMatrixTlEdoublegR_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::TMatrixT<double>*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   void TMatrixTSymlEdoublegR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void TMatrixTSymlEdoublegR_Dictionary();
   static void *new_TMatrixTSymlEdoublegR(void *p = 0);
   static void *newArray_TMatrixTSymlEdoublegR(Long_t size, void *p);
   static void delete_TMatrixTSymlEdoublegR(void *p);
   static void deleteArray_TMatrixTSymlEdoublegR(void *p);
   static void destruct_TMatrixTSymlEdoublegR(void *p);
   static void streamer_TMatrixTSymlEdoublegR(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMatrixTSym<double>*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::TMatrixTSym<double>) == sizeof(::ROOT::Shadow::TMatrixTSymlEdoublegR));
      ::TMatrixTSym<double> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMatrixTSym<double> >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TMatrixTSym<double>", ::TMatrixTSym<double>::Class_Version(), "include/TMatrixTSym.h", 38,
                  typeid(::TMatrixTSym<double>), DefineBehavior(ptr, ptr),
                  &TMatrixTSymlEdoublegR_Dictionary, isa_proxy, 1,
                  sizeof(::TMatrixTSym<double>) );
      instance.SetNew(&new_TMatrixTSymlEdoublegR);
      instance.SetNewArray(&newArray_TMatrixTSymlEdoublegR);
      instance.SetDelete(&delete_TMatrixTSymlEdoublegR);
      instance.SetDeleteArray(&deleteArray_TMatrixTSymlEdoublegR);
      instance.SetDestructor(&destruct_TMatrixTSymlEdoublegR);
      instance.SetStreamerFunc(&streamer_TMatrixTSymlEdoublegR);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TMatrixTSym<double>*)
   {
      return GenerateInitInstanceLocal((::TMatrixTSym<double>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMatrixTSym<double>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void TMatrixTSymlEdoublegR_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSym<double>*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   void TMatrixTSparselEdoublegR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void TMatrixTSparselEdoublegR_Dictionary();
   static void *new_TMatrixTSparselEdoublegR(void *p = 0);
   static void *newArray_TMatrixTSparselEdoublegR(Long_t size, void *p);
   static void delete_TMatrixTSparselEdoublegR(void *p);
   static void deleteArray_TMatrixTSparselEdoublegR(void *p);
   static void destruct_TMatrixTSparselEdoublegR(void *p);
   static void streamer_TMatrixTSparselEdoublegR(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMatrixTSparse<double>*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::TMatrixTSparse<double>) == sizeof(::ROOT::Shadow::TMatrixTSparselEdoublegR));
      ::TMatrixTSparse<double> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMatrixTSparse<double> >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TMatrixTSparse<double>", ::TMatrixTSparse<double>::Class_Version(), "include/TMatrixTSparse.h", 39,
                  typeid(::TMatrixTSparse<double>), DefineBehavior(ptr, ptr),
                  &TMatrixTSparselEdoublegR_Dictionary, isa_proxy, 1,
                  sizeof(::TMatrixTSparse<double>) );
      instance.SetNew(&new_TMatrixTSparselEdoublegR);
      instance.SetNewArray(&newArray_TMatrixTSparselEdoublegR);
      instance.SetDelete(&delete_TMatrixTSparselEdoublegR);
      instance.SetDeleteArray(&deleteArray_TMatrixTSparselEdoublegR);
      instance.SetDestructor(&destruct_TMatrixTSparselEdoublegR);
      instance.SetStreamerFunc(&streamer_TMatrixTSparselEdoublegR);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TMatrixTSparse<double>*)
   {
      return GenerateInitInstanceLocal((::TMatrixTSparse<double>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMatrixTSparse<double>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void TMatrixTSparselEdoublegR_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSparse<double>*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   void TMatrixTLazylEdoublegR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void TMatrixTLazylEdoublegR_Dictionary();
   static void delete_TMatrixTLazylEdoublegR(void *p);
   static void deleteArray_TMatrixTLazylEdoublegR(void *p);
   static void destruct_TMatrixTLazylEdoublegR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMatrixTLazy<double>*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::TMatrixTLazy<double>) == sizeof(::ROOT::Shadow::TMatrixTLazylEdoublegR));
      ::TMatrixTLazy<double> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMatrixTLazy<double> >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TMatrixTLazy<double>", ::TMatrixTLazy<double>::Class_Version(), "include/TMatrixTLazy.h", 45,
                  typeid(::TMatrixTLazy<double>), DefineBehavior(ptr, ptr),
                  &TMatrixTLazylEdoublegR_Dictionary, isa_proxy, 4,
                  sizeof(::TMatrixTLazy<double>) );
      instance.SetDelete(&delete_TMatrixTLazylEdoublegR);
      instance.SetDeleteArray(&deleteArray_TMatrixTLazylEdoublegR);
      instance.SetDestructor(&destruct_TMatrixTLazylEdoublegR);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TMatrixTLazy<double>*)
   {
      return GenerateInitInstanceLocal((::TMatrixTLazy<double>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMatrixTLazy<double>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void TMatrixTLazylEdoublegR_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTLazy<double>*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   void TMatrixTRow_constlEdoublegR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void TMatrixTRow_constlEdoublegR_Dictionary();
   static void *new_TMatrixTRow_constlEdoublegR(void *p = 0);
   static void *newArray_TMatrixTRow_constlEdoublegR(Long_t size, void *p);
   static void delete_TMatrixTRow_constlEdoublegR(void *p);
   static void deleteArray_TMatrixTRow_constlEdoublegR(void *p);
   static void destruct_TMatrixTRow_constlEdoublegR(void *p);
   static void streamer_TMatrixTRow_constlEdoublegR(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMatrixTRow_const<double>*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::TMatrixTRow_const<double>) == sizeof(::ROOT::Shadow::TMatrixTRow_constlEdoublegR));
      ::TMatrixTRow_const<double> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMatrixTRow_const<double> >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TMatrixTRow_const<double>", ::TMatrixTRow_const<double>::Class_Version(), "include/TMatrixTUtils.h", 114,
                  typeid(::TMatrixTRow_const<double>), DefineBehavior(ptr, ptr),
                  &TMatrixTRow_constlEdoublegR_Dictionary, isa_proxy, 0,
                  sizeof(::TMatrixTRow_const<double>) );
      instance.SetNew(&new_TMatrixTRow_constlEdoublegR);
      instance.SetNewArray(&newArray_TMatrixTRow_constlEdoublegR);
      instance.SetDelete(&delete_TMatrixTRow_constlEdoublegR);
      instance.SetDeleteArray(&deleteArray_TMatrixTRow_constlEdoublegR);
      instance.SetDestructor(&destruct_TMatrixTRow_constlEdoublegR);
      instance.SetStreamerFunc(&streamer_TMatrixTRow_constlEdoublegR);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TMatrixTRow_const<double>*)
   {
      return GenerateInitInstanceLocal((::TMatrixTRow_const<double>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMatrixTRow_const<double>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void TMatrixTRow_constlEdoublegR_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTRow_const<double>*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   void TMatrixTRowlEdoublegR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void TMatrixTRowlEdoublegR_Dictionary();
   static void *new_TMatrixTRowlEdoublegR(void *p = 0);
   static void *newArray_TMatrixTRowlEdoublegR(Long_t size, void *p);
   static void delete_TMatrixTRowlEdoublegR(void *p);
   static void deleteArray_TMatrixTRowlEdoublegR(void *p);
   static void destruct_TMatrixTRowlEdoublegR(void *p);
   static void streamer_TMatrixTRowlEdoublegR(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMatrixTRow<double>*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::TMatrixTRow<double>) == sizeof(::ROOT::Shadow::TMatrixTRowlEdoublegR));
      ::TMatrixTRow<double> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMatrixTRow<double> >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TMatrixTRow<double>", ::TMatrixTRow<double>::Class_Version(), "include/TMatrixTUtils.h", 152,
                  typeid(::TMatrixTRow<double>), DefineBehavior(ptr, ptr),
                  &TMatrixTRowlEdoublegR_Dictionary, isa_proxy, 0,
                  sizeof(::TMatrixTRow<double>) );
      instance.SetNew(&new_TMatrixTRowlEdoublegR);
      instance.SetNewArray(&newArray_TMatrixTRowlEdoublegR);
      instance.SetDelete(&delete_TMatrixTRowlEdoublegR);
      instance.SetDeleteArray(&deleteArray_TMatrixTRowlEdoublegR);
      instance.SetDestructor(&destruct_TMatrixTRowlEdoublegR);
      instance.SetStreamerFunc(&streamer_TMatrixTRowlEdoublegR);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TMatrixTRow<double>*)
   {
      return GenerateInitInstanceLocal((::TMatrixTRow<double>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMatrixTRow<double>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void TMatrixTRowlEdoublegR_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTRow<double>*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   void TMatrixTDiag_constlEdoublegR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void TMatrixTDiag_constlEdoublegR_Dictionary();
   static void *new_TMatrixTDiag_constlEdoublegR(void *p = 0);
   static void *newArray_TMatrixTDiag_constlEdoublegR(Long_t size, void *p);
   static void delete_TMatrixTDiag_constlEdoublegR(void *p);
   static void deleteArray_TMatrixTDiag_constlEdoublegR(void *p);
   static void destruct_TMatrixTDiag_constlEdoublegR(void *p);
   static void streamer_TMatrixTDiag_constlEdoublegR(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMatrixTDiag_const<double>*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::TMatrixTDiag_const<double>) == sizeof(::ROOT::Shadow::TMatrixTDiag_constlEdoublegR));
      ::TMatrixTDiag_const<double> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMatrixTDiag_const<double> >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TMatrixTDiag_const<double>", ::TMatrixTDiag_const<double>::Class_Version(), "include/TMatrixTUtils.h", 305,
                  typeid(::TMatrixTDiag_const<double>), DefineBehavior(ptr, ptr),
                  &TMatrixTDiag_constlEdoublegR_Dictionary, isa_proxy, 0,
                  sizeof(::TMatrixTDiag_const<double>) );
      instance.SetNew(&new_TMatrixTDiag_constlEdoublegR);
      instance.SetNewArray(&newArray_TMatrixTDiag_constlEdoublegR);
      instance.SetDelete(&delete_TMatrixTDiag_constlEdoublegR);
      instance.SetDeleteArray(&deleteArray_TMatrixTDiag_constlEdoublegR);
      instance.SetDestructor(&destruct_TMatrixTDiag_constlEdoublegR);
      instance.SetStreamerFunc(&streamer_TMatrixTDiag_constlEdoublegR);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TMatrixTDiag_const<double>*)
   {
      return GenerateInitInstanceLocal((::TMatrixTDiag_const<double>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMatrixTDiag_const<double>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void TMatrixTDiag_constlEdoublegR_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTDiag_const<double>*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   void TMatrixTColumn_constlEdoublegR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void TMatrixTColumn_constlEdoublegR_Dictionary();
   static void *new_TMatrixTColumn_constlEdoublegR(void *p = 0);
   static void *newArray_TMatrixTColumn_constlEdoublegR(Long_t size, void *p);
   static void delete_TMatrixTColumn_constlEdoublegR(void *p);
   static void deleteArray_TMatrixTColumn_constlEdoublegR(void *p);
   static void destruct_TMatrixTColumn_constlEdoublegR(void *p);
   static void streamer_TMatrixTColumn_constlEdoublegR(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMatrixTColumn_const<double>*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::TMatrixTColumn_const<double>) == sizeof(::ROOT::Shadow::TMatrixTColumn_constlEdoublegR));
      ::TMatrixTColumn_const<double> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMatrixTColumn_const<double> >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TMatrixTColumn_const<double>", ::TMatrixTColumn_const<double>::Class_Version(), "include/TMatrixTUtils.h", 209,
                  typeid(::TMatrixTColumn_const<double>), DefineBehavior(ptr, ptr),
                  &TMatrixTColumn_constlEdoublegR_Dictionary, isa_proxy, 0,
                  sizeof(::TMatrixTColumn_const<double>) );
      instance.SetNew(&new_TMatrixTColumn_constlEdoublegR);
      instance.SetNewArray(&newArray_TMatrixTColumn_constlEdoublegR);
      instance.SetDelete(&delete_TMatrixTColumn_constlEdoublegR);
      instance.SetDeleteArray(&deleteArray_TMatrixTColumn_constlEdoublegR);
      instance.SetDestructor(&destruct_TMatrixTColumn_constlEdoublegR);
      instance.SetStreamerFunc(&streamer_TMatrixTColumn_constlEdoublegR);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TMatrixTColumn_const<double>*)
   {
      return GenerateInitInstanceLocal((::TMatrixTColumn_const<double>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMatrixTColumn_const<double>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void TMatrixTColumn_constlEdoublegR_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTColumn_const<double>*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   void TMatrixTFlat_constlEdoublegR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void TMatrixTFlat_constlEdoublegR_Dictionary();
   static void *new_TMatrixTFlat_constlEdoublegR(void *p = 0);
   static void *newArray_TMatrixTFlat_constlEdoublegR(Long_t size, void *p);
   static void delete_TMatrixTFlat_constlEdoublegR(void *p);
   static void deleteArray_TMatrixTFlat_constlEdoublegR(void *p);
   static void destruct_TMatrixTFlat_constlEdoublegR(void *p);
   static void streamer_TMatrixTFlat_constlEdoublegR(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMatrixTFlat_const<double>*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::TMatrixTFlat_const<double>) == sizeof(::ROOT::Shadow::TMatrixTFlat_constlEdoublegR));
      ::TMatrixTFlat_const<double> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMatrixTFlat_const<double> >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TMatrixTFlat_const<double>", ::TMatrixTFlat_const<double>::Class_Version(), "include/TMatrixTUtils.h", 395,
                  typeid(::TMatrixTFlat_const<double>), DefineBehavior(ptr, ptr),
                  &TMatrixTFlat_constlEdoublegR_Dictionary, isa_proxy, 0,
                  sizeof(::TMatrixTFlat_const<double>) );
      instance.SetNew(&new_TMatrixTFlat_constlEdoublegR);
      instance.SetNewArray(&newArray_TMatrixTFlat_constlEdoublegR);
      instance.SetDelete(&delete_TMatrixTFlat_constlEdoublegR);
      instance.SetDeleteArray(&deleteArray_TMatrixTFlat_constlEdoublegR);
      instance.SetDestructor(&destruct_TMatrixTFlat_constlEdoublegR);
      instance.SetStreamerFunc(&streamer_TMatrixTFlat_constlEdoublegR);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TMatrixTFlat_const<double>*)
   {
      return GenerateInitInstanceLocal((::TMatrixTFlat_const<double>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMatrixTFlat_const<double>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void TMatrixTFlat_constlEdoublegR_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTFlat_const<double>*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   void TMatrixTSub_constlEdoublegR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void TMatrixTSub_constlEdoublegR_Dictionary();
   static void *new_TMatrixTSub_constlEdoublegR(void *p = 0);
   static void *newArray_TMatrixTSub_constlEdoublegR(Long_t size, void *p);
   static void delete_TMatrixTSub_constlEdoublegR(void *p);
   static void deleteArray_TMatrixTSub_constlEdoublegR(void *p);
   static void destruct_TMatrixTSub_constlEdoublegR(void *p);
   static void streamer_TMatrixTSub_constlEdoublegR(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMatrixTSub_const<double>*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::TMatrixTSub_const<double>) == sizeof(::ROOT::Shadow::TMatrixTSub_constlEdoublegR));
      ::TMatrixTSub_const<double> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMatrixTSub_const<double> >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TMatrixTSub_const<double>", ::TMatrixTSub_const<double>::Class_Version(), "include/TMatrixTUtils.h", 481,
                  typeid(::TMatrixTSub_const<double>), DefineBehavior(ptr, ptr),
                  &TMatrixTSub_constlEdoublegR_Dictionary, isa_proxy, 0,
                  sizeof(::TMatrixTSub_const<double>) );
      instance.SetNew(&new_TMatrixTSub_constlEdoublegR);
      instance.SetNewArray(&newArray_TMatrixTSub_constlEdoublegR);
      instance.SetDelete(&delete_TMatrixTSub_constlEdoublegR);
      instance.SetDeleteArray(&deleteArray_TMatrixTSub_constlEdoublegR);
      instance.SetDestructor(&destruct_TMatrixTSub_constlEdoublegR);
      instance.SetStreamerFunc(&streamer_TMatrixTSub_constlEdoublegR);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TMatrixTSub_const<double>*)
   {
      return GenerateInitInstanceLocal((::TMatrixTSub_const<double>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMatrixTSub_const<double>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void TMatrixTSub_constlEdoublegR_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSub_const<double>*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   void TMatrixTSparseRow_constlEdoublegR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void TMatrixTSparseRow_constlEdoublegR_Dictionary();
   static void *new_TMatrixTSparseRow_constlEdoublegR(void *p = 0);
   static void *newArray_TMatrixTSparseRow_constlEdoublegR(Long_t size, void *p);
   static void delete_TMatrixTSparseRow_constlEdoublegR(void *p);
   static void deleteArray_TMatrixTSparseRow_constlEdoublegR(void *p);
   static void destruct_TMatrixTSparseRow_constlEdoublegR(void *p);
   static void streamer_TMatrixTSparseRow_constlEdoublegR(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMatrixTSparseRow_const<double>*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::TMatrixTSparseRow_const<double>) == sizeof(::ROOT::Shadow::TMatrixTSparseRow_constlEdoublegR));
      ::TMatrixTSparseRow_const<double> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMatrixTSparseRow_const<double> >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TMatrixTSparseRow_const<double>", ::TMatrixTSparseRow_const<double>::Class_Version(), "include/TMatrixTUtils.h", 574,
                  typeid(::TMatrixTSparseRow_const<double>), DefineBehavior(ptr, ptr),
                  &TMatrixTSparseRow_constlEdoublegR_Dictionary, isa_proxy, 0,
                  sizeof(::TMatrixTSparseRow_const<double>) );
      instance.SetNew(&new_TMatrixTSparseRow_constlEdoublegR);
      instance.SetNewArray(&newArray_TMatrixTSparseRow_constlEdoublegR);
      instance.SetDelete(&delete_TMatrixTSparseRow_constlEdoublegR);
      instance.SetDeleteArray(&deleteArray_TMatrixTSparseRow_constlEdoublegR);
      instance.SetDestructor(&destruct_TMatrixTSparseRow_constlEdoublegR);
      instance.SetStreamerFunc(&streamer_TMatrixTSparseRow_constlEdoublegR);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TMatrixTSparseRow_const<double>*)
   {
      return GenerateInitInstanceLocal((::TMatrixTSparseRow_const<double>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMatrixTSparseRow_const<double>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void TMatrixTSparseRow_constlEdoublegR_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSparseRow_const<double>*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   void TMatrixTSparseDiag_constlEdoublegR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void TMatrixTSparseDiag_constlEdoublegR_Dictionary();
   static void *new_TMatrixTSparseDiag_constlEdoublegR(void *p = 0);
   static void *newArray_TMatrixTSparseDiag_constlEdoublegR(Long_t size, void *p);
   static void delete_TMatrixTSparseDiag_constlEdoublegR(void *p);
   static void deleteArray_TMatrixTSparseDiag_constlEdoublegR(void *p);
   static void destruct_TMatrixTSparseDiag_constlEdoublegR(void *p);
   static void streamer_TMatrixTSparseDiag_constlEdoublegR(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMatrixTSparseDiag_const<double>*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::TMatrixTSparseDiag_const<double>) == sizeof(::ROOT::Shadow::TMatrixTSparseDiag_constlEdoublegR));
      ::TMatrixTSparseDiag_const<double> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMatrixTSparseDiag_const<double> >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TMatrixTSparseDiag_const<double>", ::TMatrixTSparseDiag_const<double>::Class_Version(), "include/TMatrixTUtils.h", 640,
                  typeid(::TMatrixTSparseDiag_const<double>), DefineBehavior(ptr, ptr),
                  &TMatrixTSparseDiag_constlEdoublegR_Dictionary, isa_proxy, 0,
                  sizeof(::TMatrixTSparseDiag_const<double>) );
      instance.SetNew(&new_TMatrixTSparseDiag_constlEdoublegR);
      instance.SetNewArray(&newArray_TMatrixTSparseDiag_constlEdoublegR);
      instance.SetDelete(&delete_TMatrixTSparseDiag_constlEdoublegR);
      instance.SetDeleteArray(&deleteArray_TMatrixTSparseDiag_constlEdoublegR);
      instance.SetDestructor(&destruct_TMatrixTSparseDiag_constlEdoublegR);
      instance.SetStreamerFunc(&streamer_TMatrixTSparseDiag_constlEdoublegR);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TMatrixTSparseDiag_const<double>*)
   {
      return GenerateInitInstanceLocal((::TMatrixTSparseDiag_const<double>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMatrixTSparseDiag_const<double>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void TMatrixTSparseDiag_constlEdoublegR_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSparseDiag_const<double>*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   void TMatrixTColumnlEdoublegR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void TMatrixTColumnlEdoublegR_Dictionary();
   static void *new_TMatrixTColumnlEdoublegR(void *p = 0);
   static void *newArray_TMatrixTColumnlEdoublegR(Long_t size, void *p);
   static void delete_TMatrixTColumnlEdoublegR(void *p);
   static void deleteArray_TMatrixTColumnlEdoublegR(void *p);
   static void destruct_TMatrixTColumnlEdoublegR(void *p);
   static void streamer_TMatrixTColumnlEdoublegR(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMatrixTColumn<double>*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::TMatrixTColumn<double>) == sizeof(::ROOT::Shadow::TMatrixTColumnlEdoublegR));
      ::TMatrixTColumn<double> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMatrixTColumn<double> >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TMatrixTColumn<double>", ::TMatrixTColumn<double>::Class_Version(), "include/TMatrixTUtils.h", 247,
                  typeid(::TMatrixTColumn<double>), DefineBehavior(ptr, ptr),
                  &TMatrixTColumnlEdoublegR_Dictionary, isa_proxy, 0,
                  sizeof(::TMatrixTColumn<double>) );
      instance.SetNew(&new_TMatrixTColumnlEdoublegR);
      instance.SetNewArray(&newArray_TMatrixTColumnlEdoublegR);
      instance.SetDelete(&delete_TMatrixTColumnlEdoublegR);
      instance.SetDeleteArray(&deleteArray_TMatrixTColumnlEdoublegR);
      instance.SetDestructor(&destruct_TMatrixTColumnlEdoublegR);
      instance.SetStreamerFunc(&streamer_TMatrixTColumnlEdoublegR);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TMatrixTColumn<double>*)
   {
      return GenerateInitInstanceLocal((::TMatrixTColumn<double>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMatrixTColumn<double>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void TMatrixTColumnlEdoublegR_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTColumn<double>*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   void TMatrixTDiaglEdoublegR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void TMatrixTDiaglEdoublegR_Dictionary();
   static void *new_TMatrixTDiaglEdoublegR(void *p = 0);
   static void *newArray_TMatrixTDiaglEdoublegR(Long_t size, void *p);
   static void delete_TMatrixTDiaglEdoublegR(void *p);
   static void deleteArray_TMatrixTDiaglEdoublegR(void *p);
   static void destruct_TMatrixTDiaglEdoublegR(void *p);
   static void streamer_TMatrixTDiaglEdoublegR(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMatrixTDiag<double>*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::TMatrixTDiag<double>) == sizeof(::ROOT::Shadow::TMatrixTDiaglEdoublegR));
      ::TMatrixTDiag<double> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMatrixTDiag<double> >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TMatrixTDiag<double>", ::TMatrixTDiag<double>::Class_Version(), "include/TMatrixTUtils.h", 342,
                  typeid(::TMatrixTDiag<double>), DefineBehavior(ptr, ptr),
                  &TMatrixTDiaglEdoublegR_Dictionary, isa_proxy, 0,
                  sizeof(::TMatrixTDiag<double>) );
      instance.SetNew(&new_TMatrixTDiaglEdoublegR);
      instance.SetNewArray(&newArray_TMatrixTDiaglEdoublegR);
      instance.SetDelete(&delete_TMatrixTDiaglEdoublegR);
      instance.SetDeleteArray(&deleteArray_TMatrixTDiaglEdoublegR);
      instance.SetDestructor(&destruct_TMatrixTDiaglEdoublegR);
      instance.SetStreamerFunc(&streamer_TMatrixTDiaglEdoublegR);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TMatrixTDiag<double>*)
   {
      return GenerateInitInstanceLocal((::TMatrixTDiag<double>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMatrixTDiag<double>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void TMatrixTDiaglEdoublegR_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTDiag<double>*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   void TMatrixTFlatlEdoublegR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void TMatrixTFlatlEdoublegR_Dictionary();
   static void *new_TMatrixTFlatlEdoublegR(void *p = 0);
   static void *newArray_TMatrixTFlatlEdoublegR(Long_t size, void *p);
   static void delete_TMatrixTFlatlEdoublegR(void *p);
   static void deleteArray_TMatrixTFlatlEdoublegR(void *p);
   static void destruct_TMatrixTFlatlEdoublegR(void *p);
   static void streamer_TMatrixTFlatlEdoublegR(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMatrixTFlat<double>*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::TMatrixTFlat<double>) == sizeof(::ROOT::Shadow::TMatrixTFlatlEdoublegR));
      ::TMatrixTFlat<double> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMatrixTFlat<double> >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TMatrixTFlat<double>", ::TMatrixTFlat<double>::Class_Version(), "include/TMatrixTUtils.h", 428,
                  typeid(::TMatrixTFlat<double>), DefineBehavior(ptr, ptr),
                  &TMatrixTFlatlEdoublegR_Dictionary, isa_proxy, 0,
                  sizeof(::TMatrixTFlat<double>) );
      instance.SetNew(&new_TMatrixTFlatlEdoublegR);
      instance.SetNewArray(&newArray_TMatrixTFlatlEdoublegR);
      instance.SetDelete(&delete_TMatrixTFlatlEdoublegR);
      instance.SetDeleteArray(&deleteArray_TMatrixTFlatlEdoublegR);
      instance.SetDestructor(&destruct_TMatrixTFlatlEdoublegR);
      instance.SetStreamerFunc(&streamer_TMatrixTFlatlEdoublegR);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TMatrixTFlat<double>*)
   {
      return GenerateInitInstanceLocal((::TMatrixTFlat<double>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMatrixTFlat<double>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void TMatrixTFlatlEdoublegR_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTFlat<double>*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   void TMatrixTSublEdoublegR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void TMatrixTSublEdoublegR_Dictionary();
   static void *new_TMatrixTSublEdoublegR(void *p = 0);
   static void *newArray_TMatrixTSublEdoublegR(Long_t size, void *p);
   static void delete_TMatrixTSublEdoublegR(void *p);
   static void deleteArray_TMatrixTSublEdoublegR(void *p);
   static void destruct_TMatrixTSublEdoublegR(void *p);
   static void streamer_TMatrixTSublEdoublegR(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMatrixTSub<double>*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::TMatrixTSub<double>) == sizeof(::ROOT::Shadow::TMatrixTSublEdoublegR));
      ::TMatrixTSub<double> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMatrixTSub<double> >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TMatrixTSub<double>", ::TMatrixTSub<double>::Class_Version(), "include/TMatrixTUtils.h", 520,
                  typeid(::TMatrixTSub<double>), DefineBehavior(ptr, ptr),
                  &TMatrixTSublEdoublegR_Dictionary, isa_proxy, 0,
                  sizeof(::TMatrixTSub<double>) );
      instance.SetNew(&new_TMatrixTSublEdoublegR);
      instance.SetNewArray(&newArray_TMatrixTSublEdoublegR);
      instance.SetDelete(&delete_TMatrixTSublEdoublegR);
      instance.SetDeleteArray(&deleteArray_TMatrixTSublEdoublegR);
      instance.SetDestructor(&destruct_TMatrixTSublEdoublegR);
      instance.SetStreamerFunc(&streamer_TMatrixTSublEdoublegR);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TMatrixTSub<double>*)
   {
      return GenerateInitInstanceLocal((::TMatrixTSub<double>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMatrixTSub<double>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void TMatrixTSublEdoublegR_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSub<double>*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   void TMatrixTSparseRowlEdoublegR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void TMatrixTSparseRowlEdoublegR_Dictionary();
   static void *new_TMatrixTSparseRowlEdoublegR(void *p = 0);
   static void *newArray_TMatrixTSparseRowlEdoublegR(Long_t size, void *p);
   static void delete_TMatrixTSparseRowlEdoublegR(void *p);
   static void deleteArray_TMatrixTSparseRowlEdoublegR(void *p);
   static void destruct_TMatrixTSparseRowlEdoublegR(void *p);
   static void streamer_TMatrixTSparseRowlEdoublegR(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMatrixTSparseRow<double>*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::TMatrixTSparseRow<double>) == sizeof(::ROOT::Shadow::TMatrixTSparseRowlEdoublegR));
      ::TMatrixTSparseRow<double> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMatrixTSparseRow<double> >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TMatrixTSparseRow<double>", ::TMatrixTSparseRow<double>::Class_Version(), "include/TMatrixTUtils.h", 604,
                  typeid(::TMatrixTSparseRow<double>), DefineBehavior(ptr, ptr),
                  &TMatrixTSparseRowlEdoublegR_Dictionary, isa_proxy, 0,
                  sizeof(::TMatrixTSparseRow<double>) );
      instance.SetNew(&new_TMatrixTSparseRowlEdoublegR);
      instance.SetNewArray(&newArray_TMatrixTSparseRowlEdoublegR);
      instance.SetDelete(&delete_TMatrixTSparseRowlEdoublegR);
      instance.SetDeleteArray(&deleteArray_TMatrixTSparseRowlEdoublegR);
      instance.SetDestructor(&destruct_TMatrixTSparseRowlEdoublegR);
      instance.SetStreamerFunc(&streamer_TMatrixTSparseRowlEdoublegR);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TMatrixTSparseRow<double>*)
   {
      return GenerateInitInstanceLocal((::TMatrixTSparseRow<double>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMatrixTSparseRow<double>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void TMatrixTSparseRowlEdoublegR_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSparseRow<double>*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   void TMatrixTSparseDiaglEdoublegR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void TMatrixTSparseDiaglEdoublegR_Dictionary();
   static void *new_TMatrixTSparseDiaglEdoublegR(void *p = 0);
   static void *newArray_TMatrixTSparseDiaglEdoublegR(Long_t size, void *p);
   static void delete_TMatrixTSparseDiaglEdoublegR(void *p);
   static void deleteArray_TMatrixTSparseDiaglEdoublegR(void *p);
   static void destruct_TMatrixTSparseDiaglEdoublegR(void *p);
   static void streamer_TMatrixTSparseDiaglEdoublegR(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMatrixTSparseDiag<double>*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::TMatrixTSparseDiag<double>) == sizeof(::ROOT::Shadow::TMatrixTSparseDiaglEdoublegR));
      ::TMatrixTSparseDiag<double> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMatrixTSparseDiag<double> >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TMatrixTSparseDiag<double>", ::TMatrixTSparseDiag<double>::Class_Version(), "include/TMatrixTUtils.h", 666,
                  typeid(::TMatrixTSparseDiag<double>), DefineBehavior(ptr, ptr),
                  &TMatrixTSparseDiaglEdoublegR_Dictionary, isa_proxy, 0,
                  sizeof(::TMatrixTSparseDiag<double>) );
      instance.SetNew(&new_TMatrixTSparseDiaglEdoublegR);
      instance.SetNewArray(&newArray_TMatrixTSparseDiaglEdoublegR);
      instance.SetDelete(&delete_TMatrixTSparseDiaglEdoublegR);
      instance.SetDeleteArray(&deleteArray_TMatrixTSparseDiaglEdoublegR);
      instance.SetDestructor(&destruct_TMatrixTSparseDiaglEdoublegR);
      instance.SetStreamerFunc(&streamer_TMatrixTSparseDiaglEdoublegR);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TMatrixTSparseDiag<double>*)
   {
      return GenerateInitInstanceLocal((::TMatrixTSparseDiag<double>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMatrixTSparseDiag<double>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void TMatrixTSparseDiaglEdoublegR_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSparseDiag<double>*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   void TMatrixTSymLazylEdoublegR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void TMatrixTSymLazylEdoublegR_Dictionary();
   static void delete_TMatrixTSymLazylEdoublegR(void *p);
   static void deleteArray_TMatrixTSymLazylEdoublegR(void *p);
   static void destruct_TMatrixTSymLazylEdoublegR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMatrixTSymLazy<double>*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::TMatrixTSymLazy<double>) == sizeof(::ROOT::Shadow::TMatrixTSymLazylEdoublegR));
      ::TMatrixTSymLazy<double> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMatrixTSymLazy<double> >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TMatrixTSymLazy<double>", ::TMatrixTSymLazy<double>::Class_Version(), "include/TMatrixTLazy.h", 88,
                  typeid(::TMatrixTSymLazy<double>), DefineBehavior(ptr, ptr),
                  &TMatrixTSymLazylEdoublegR_Dictionary, isa_proxy, 4,
                  sizeof(::TMatrixTSymLazy<double>) );
      instance.SetDelete(&delete_TMatrixTSymLazylEdoublegR);
      instance.SetDeleteArray(&deleteArray_TMatrixTSymLazylEdoublegR);
      instance.SetDestructor(&destruct_TMatrixTSymLazylEdoublegR);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TMatrixTSymLazy<double>*)
   {
      return GenerateInitInstanceLocal((::TMatrixTSymLazy<double>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMatrixTSymLazy<double>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void TMatrixTSymLazylEdoublegR_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSymLazy<double>*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   void TMatrixTRow_constlEfloatgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void TMatrixTRow_constlEfloatgR_Dictionary();
   static void *new_TMatrixTRow_constlEfloatgR(void *p = 0);
   static void *newArray_TMatrixTRow_constlEfloatgR(Long_t size, void *p);
   static void delete_TMatrixTRow_constlEfloatgR(void *p);
   static void deleteArray_TMatrixTRow_constlEfloatgR(void *p);
   static void destruct_TMatrixTRow_constlEfloatgR(void *p);
   static void streamer_TMatrixTRow_constlEfloatgR(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMatrixTRow_const<float>*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::TMatrixTRow_const<float>) == sizeof(::ROOT::Shadow::TMatrixTRow_constlEfloatgR));
      ::TMatrixTRow_const<float> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMatrixTRow_const<float> >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TMatrixTRow_const<float>", ::TMatrixTRow_const<float>::Class_Version(), "include/TMatrixTUtils.h", 114,
                  typeid(::TMatrixTRow_const<float>), DefineBehavior(ptr, ptr),
                  &TMatrixTRow_constlEfloatgR_Dictionary, isa_proxy, 0,
                  sizeof(::TMatrixTRow_const<float>) );
      instance.SetNew(&new_TMatrixTRow_constlEfloatgR);
      instance.SetNewArray(&newArray_TMatrixTRow_constlEfloatgR);
      instance.SetDelete(&delete_TMatrixTRow_constlEfloatgR);
      instance.SetDeleteArray(&deleteArray_TMatrixTRow_constlEfloatgR);
      instance.SetDestructor(&destruct_TMatrixTRow_constlEfloatgR);
      instance.SetStreamerFunc(&streamer_TMatrixTRow_constlEfloatgR);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TMatrixTRow_const<float>*)
   {
      return GenerateInitInstanceLocal((::TMatrixTRow_const<float>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMatrixTRow_const<float>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void TMatrixTRow_constlEfloatgR_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTRow_const<float>*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   void TMatrixTlEfloatgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void TMatrixTlEfloatgR_Dictionary();
   static void *new_TMatrixTlEfloatgR(void *p = 0);
   static void *newArray_TMatrixTlEfloatgR(Long_t size, void *p);
   static void delete_TMatrixTlEfloatgR(void *p);
   static void deleteArray_TMatrixTlEfloatgR(void *p);
   static void destruct_TMatrixTlEfloatgR(void *p);
   static void streamer_TMatrixTlEfloatgR(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMatrixT<float>*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::TMatrixT<float>) == sizeof(::ROOT::Shadow::TMatrixTlEfloatgR));
      ::TMatrixT<float> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMatrixT<float> >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TMatrixT<float>", ::TMatrixT<float>::Class_Version(), "include/TMatrixT.h", 39,
                  typeid(::TMatrixT<float>), DefineBehavior(ptr, ptr),
                  &TMatrixTlEfloatgR_Dictionary, isa_proxy, 1,
                  sizeof(::TMatrixT<float>) );
      instance.SetNew(&new_TMatrixTlEfloatgR);
      instance.SetNewArray(&newArray_TMatrixTlEfloatgR);
      instance.SetDelete(&delete_TMatrixTlEfloatgR);
      instance.SetDeleteArray(&deleteArray_TMatrixTlEfloatgR);
      instance.SetDestructor(&destruct_TMatrixTlEfloatgR);
      instance.SetStreamerFunc(&streamer_TMatrixTlEfloatgR);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TMatrixT<float>*)
   {
      return GenerateInitInstanceLocal((::TMatrixT<float>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMatrixT<float>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void TMatrixTlEfloatgR_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::TMatrixT<float>*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   void TMatrixTSymlEfloatgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void TMatrixTSymlEfloatgR_Dictionary();
   static void *new_TMatrixTSymlEfloatgR(void *p = 0);
   static void *newArray_TMatrixTSymlEfloatgR(Long_t size, void *p);
   static void delete_TMatrixTSymlEfloatgR(void *p);
   static void deleteArray_TMatrixTSymlEfloatgR(void *p);
   static void destruct_TMatrixTSymlEfloatgR(void *p);
   static void streamer_TMatrixTSymlEfloatgR(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMatrixTSym<float>*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::TMatrixTSym<float>) == sizeof(::ROOT::Shadow::TMatrixTSymlEfloatgR));
      ::TMatrixTSym<float> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMatrixTSym<float> >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TMatrixTSym<float>", ::TMatrixTSym<float>::Class_Version(), "include/TMatrixTSym.h", 38,
                  typeid(::TMatrixTSym<float>), DefineBehavior(ptr, ptr),
                  &TMatrixTSymlEfloatgR_Dictionary, isa_proxy, 1,
                  sizeof(::TMatrixTSym<float>) );
      instance.SetNew(&new_TMatrixTSymlEfloatgR);
      instance.SetNewArray(&newArray_TMatrixTSymlEfloatgR);
      instance.SetDelete(&delete_TMatrixTSymlEfloatgR);
      instance.SetDeleteArray(&deleteArray_TMatrixTSymlEfloatgR);
      instance.SetDestructor(&destruct_TMatrixTSymlEfloatgR);
      instance.SetStreamerFunc(&streamer_TMatrixTSymlEfloatgR);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TMatrixTSym<float>*)
   {
      return GenerateInitInstanceLocal((::TMatrixTSym<float>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMatrixTSym<float>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void TMatrixTSymlEfloatgR_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSym<float>*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   void TMatrixTSymLazylEfloatgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void TMatrixTSymLazylEfloatgR_Dictionary();
   static void delete_TMatrixTSymLazylEfloatgR(void *p);
   static void deleteArray_TMatrixTSymLazylEfloatgR(void *p);
   static void destruct_TMatrixTSymLazylEfloatgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMatrixTSymLazy<float>*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::TMatrixTSymLazy<float>) == sizeof(::ROOT::Shadow::TMatrixTSymLazylEfloatgR));
      ::TMatrixTSymLazy<float> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMatrixTSymLazy<float> >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TMatrixTSymLazy<float>", ::TMatrixTSymLazy<float>::Class_Version(), "include/TMatrixTLazy.h", 88,
                  typeid(::TMatrixTSymLazy<float>), DefineBehavior(ptr, ptr),
                  &TMatrixTSymLazylEfloatgR_Dictionary, isa_proxy, 4,
                  sizeof(::TMatrixTSymLazy<float>) );
      instance.SetDelete(&delete_TMatrixTSymLazylEfloatgR);
      instance.SetDeleteArray(&deleteArray_TMatrixTSymLazylEfloatgR);
      instance.SetDestructor(&destruct_TMatrixTSymLazylEfloatgR);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TMatrixTSymLazy<float>*)
   {
      return GenerateInitInstanceLocal((::TMatrixTSymLazy<float>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMatrixTSymLazy<float>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void TMatrixTSymLazylEfloatgR_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSymLazy<float>*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   void TMatrixTRowlEfloatgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void TMatrixTRowlEfloatgR_Dictionary();
   static void *new_TMatrixTRowlEfloatgR(void *p = 0);
   static void *newArray_TMatrixTRowlEfloatgR(Long_t size, void *p);
   static void delete_TMatrixTRowlEfloatgR(void *p);
   static void deleteArray_TMatrixTRowlEfloatgR(void *p);
   static void destruct_TMatrixTRowlEfloatgR(void *p);
   static void streamer_TMatrixTRowlEfloatgR(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMatrixTRow<float>*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::TMatrixTRow<float>) == sizeof(::ROOT::Shadow::TMatrixTRowlEfloatgR));
      ::TMatrixTRow<float> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMatrixTRow<float> >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TMatrixTRow<float>", ::TMatrixTRow<float>::Class_Version(), "include/TMatrixTUtils.h", 152,
                  typeid(::TMatrixTRow<float>), DefineBehavior(ptr, ptr),
                  &TMatrixTRowlEfloatgR_Dictionary, isa_proxy, 0,
                  sizeof(::TMatrixTRow<float>) );
      instance.SetNew(&new_TMatrixTRowlEfloatgR);
      instance.SetNewArray(&newArray_TMatrixTRowlEfloatgR);
      instance.SetDelete(&delete_TMatrixTRowlEfloatgR);
      instance.SetDeleteArray(&deleteArray_TMatrixTRowlEfloatgR);
      instance.SetDestructor(&destruct_TMatrixTRowlEfloatgR);
      instance.SetStreamerFunc(&streamer_TMatrixTRowlEfloatgR);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TMatrixTRow<float>*)
   {
      return GenerateInitInstanceLocal((::TMatrixTRow<float>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMatrixTRow<float>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void TMatrixTRowlEfloatgR_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTRow<float>*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   void TMatrixTSparselEfloatgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void TMatrixTSparselEfloatgR_Dictionary();
   static void *new_TMatrixTSparselEfloatgR(void *p = 0);
   static void *newArray_TMatrixTSparselEfloatgR(Long_t size, void *p);
   static void delete_TMatrixTSparselEfloatgR(void *p);
   static void deleteArray_TMatrixTSparselEfloatgR(void *p);
   static void destruct_TMatrixTSparselEfloatgR(void *p);
   static void streamer_TMatrixTSparselEfloatgR(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMatrixTSparse<float>*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::TMatrixTSparse<float>) == sizeof(::ROOT::Shadow::TMatrixTSparselEfloatgR));
      ::TMatrixTSparse<float> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMatrixTSparse<float> >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TMatrixTSparse<float>", ::TMatrixTSparse<float>::Class_Version(), "include/TMatrixTSparse.h", 39,
                  typeid(::TMatrixTSparse<float>), DefineBehavior(ptr, ptr),
                  &TMatrixTSparselEfloatgR_Dictionary, isa_proxy, 1,
                  sizeof(::TMatrixTSparse<float>) );
      instance.SetNew(&new_TMatrixTSparselEfloatgR);
      instance.SetNewArray(&newArray_TMatrixTSparselEfloatgR);
      instance.SetDelete(&delete_TMatrixTSparselEfloatgR);
      instance.SetDeleteArray(&deleteArray_TMatrixTSparselEfloatgR);
      instance.SetDestructor(&destruct_TMatrixTSparselEfloatgR);
      instance.SetStreamerFunc(&streamer_TMatrixTSparselEfloatgR);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TMatrixTSparse<float>*)
   {
      return GenerateInitInstanceLocal((::TMatrixTSparse<float>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMatrixTSparse<float>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void TMatrixTSparselEfloatgR_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSparse<float>*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   void TMatrixTSparseRow_constlEfloatgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void TMatrixTSparseRow_constlEfloatgR_Dictionary();
   static void *new_TMatrixTSparseRow_constlEfloatgR(void *p = 0);
   static void *newArray_TMatrixTSparseRow_constlEfloatgR(Long_t size, void *p);
   static void delete_TMatrixTSparseRow_constlEfloatgR(void *p);
   static void deleteArray_TMatrixTSparseRow_constlEfloatgR(void *p);
   static void destruct_TMatrixTSparseRow_constlEfloatgR(void *p);
   static void streamer_TMatrixTSparseRow_constlEfloatgR(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMatrixTSparseRow_const<float>*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::TMatrixTSparseRow_const<float>) == sizeof(::ROOT::Shadow::TMatrixTSparseRow_constlEfloatgR));
      ::TMatrixTSparseRow_const<float> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMatrixTSparseRow_const<float> >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TMatrixTSparseRow_const<float>", ::TMatrixTSparseRow_const<float>::Class_Version(), "include/TMatrixTUtils.h", 574,
                  typeid(::TMatrixTSparseRow_const<float>), DefineBehavior(ptr, ptr),
                  &TMatrixTSparseRow_constlEfloatgR_Dictionary, isa_proxy, 0,
                  sizeof(::TMatrixTSparseRow_const<float>) );
      instance.SetNew(&new_TMatrixTSparseRow_constlEfloatgR);
      instance.SetNewArray(&newArray_TMatrixTSparseRow_constlEfloatgR);
      instance.SetDelete(&delete_TMatrixTSparseRow_constlEfloatgR);
      instance.SetDeleteArray(&deleteArray_TMatrixTSparseRow_constlEfloatgR);
      instance.SetDestructor(&destruct_TMatrixTSparseRow_constlEfloatgR);
      instance.SetStreamerFunc(&streamer_TMatrixTSparseRow_constlEfloatgR);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TMatrixTSparseRow_const<float>*)
   {
      return GenerateInitInstanceLocal((::TMatrixTSparseRow_const<float>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMatrixTSparseRow_const<float>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void TMatrixTSparseRow_constlEfloatgR_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSparseRow_const<float>*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   void TMatrixTSparseRowlEfloatgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void TMatrixTSparseRowlEfloatgR_Dictionary();
   static void *new_TMatrixTSparseRowlEfloatgR(void *p = 0);
   static void *newArray_TMatrixTSparseRowlEfloatgR(Long_t size, void *p);
   static void delete_TMatrixTSparseRowlEfloatgR(void *p);
   static void deleteArray_TMatrixTSparseRowlEfloatgR(void *p);
   static void destruct_TMatrixTSparseRowlEfloatgR(void *p);
   static void streamer_TMatrixTSparseRowlEfloatgR(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMatrixTSparseRow<float>*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::TMatrixTSparseRow<float>) == sizeof(::ROOT::Shadow::TMatrixTSparseRowlEfloatgR));
      ::TMatrixTSparseRow<float> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMatrixTSparseRow<float> >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TMatrixTSparseRow<float>", ::TMatrixTSparseRow<float>::Class_Version(), "include/TMatrixTUtils.h", 604,
                  typeid(::TMatrixTSparseRow<float>), DefineBehavior(ptr, ptr),
                  &TMatrixTSparseRowlEfloatgR_Dictionary, isa_proxy, 0,
                  sizeof(::TMatrixTSparseRow<float>) );
      instance.SetNew(&new_TMatrixTSparseRowlEfloatgR);
      instance.SetNewArray(&newArray_TMatrixTSparseRowlEfloatgR);
      instance.SetDelete(&delete_TMatrixTSparseRowlEfloatgR);
      instance.SetDeleteArray(&deleteArray_TMatrixTSparseRowlEfloatgR);
      instance.SetDestructor(&destruct_TMatrixTSparseRowlEfloatgR);
      instance.SetStreamerFunc(&streamer_TMatrixTSparseRowlEfloatgR);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TMatrixTSparseRow<float>*)
   {
      return GenerateInitInstanceLocal((::TMatrixTSparseRow<float>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMatrixTSparseRow<float>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void TMatrixTSparseRowlEfloatgR_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSparseRow<float>*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   void TMatrixTLazylEfloatgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void TMatrixTLazylEfloatgR_Dictionary();
   static void delete_TMatrixTLazylEfloatgR(void *p);
   static void deleteArray_TMatrixTLazylEfloatgR(void *p);
   static void destruct_TMatrixTLazylEfloatgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMatrixTLazy<float>*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::TMatrixTLazy<float>) == sizeof(::ROOT::Shadow::TMatrixTLazylEfloatgR));
      ::TMatrixTLazy<float> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMatrixTLazy<float> >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TMatrixTLazy<float>", ::TMatrixTLazy<float>::Class_Version(), "include/TMatrixTLazy.h", 45,
                  typeid(::TMatrixTLazy<float>), DefineBehavior(ptr, ptr),
                  &TMatrixTLazylEfloatgR_Dictionary, isa_proxy, 4,
                  sizeof(::TMatrixTLazy<float>) );
      instance.SetDelete(&delete_TMatrixTLazylEfloatgR);
      instance.SetDeleteArray(&deleteArray_TMatrixTLazylEfloatgR);
      instance.SetDestructor(&destruct_TMatrixTLazylEfloatgR);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TMatrixTLazy<float>*)
   {
      return GenerateInitInstanceLocal((::TMatrixTLazy<float>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMatrixTLazy<float>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void TMatrixTLazylEfloatgR_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTLazy<float>*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   void TMatrixTDiag_constlEfloatgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void TMatrixTDiag_constlEfloatgR_Dictionary();
   static void *new_TMatrixTDiag_constlEfloatgR(void *p = 0);
   static void *newArray_TMatrixTDiag_constlEfloatgR(Long_t size, void *p);
   static void delete_TMatrixTDiag_constlEfloatgR(void *p);
   static void deleteArray_TMatrixTDiag_constlEfloatgR(void *p);
   static void destruct_TMatrixTDiag_constlEfloatgR(void *p);
   static void streamer_TMatrixTDiag_constlEfloatgR(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMatrixTDiag_const<float>*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::TMatrixTDiag_const<float>) == sizeof(::ROOT::Shadow::TMatrixTDiag_constlEfloatgR));
      ::TMatrixTDiag_const<float> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMatrixTDiag_const<float> >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TMatrixTDiag_const<float>", ::TMatrixTDiag_const<float>::Class_Version(), "include/TMatrixTUtils.h", 305,
                  typeid(::TMatrixTDiag_const<float>), DefineBehavior(ptr, ptr),
                  &TMatrixTDiag_constlEfloatgR_Dictionary, isa_proxy, 0,
                  sizeof(::TMatrixTDiag_const<float>) );
      instance.SetNew(&new_TMatrixTDiag_constlEfloatgR);
      instance.SetNewArray(&newArray_TMatrixTDiag_constlEfloatgR);
      instance.SetDelete(&delete_TMatrixTDiag_constlEfloatgR);
      instance.SetDeleteArray(&deleteArray_TMatrixTDiag_constlEfloatgR);
      instance.SetDestructor(&destruct_TMatrixTDiag_constlEfloatgR);
      instance.SetStreamerFunc(&streamer_TMatrixTDiag_constlEfloatgR);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TMatrixTDiag_const<float>*)
   {
      return GenerateInitInstanceLocal((::TMatrixTDiag_const<float>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMatrixTDiag_const<float>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void TMatrixTDiag_constlEfloatgR_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTDiag_const<float>*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   void TMatrixTColumn_constlEfloatgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void TMatrixTColumn_constlEfloatgR_Dictionary();
   static void *new_TMatrixTColumn_constlEfloatgR(void *p = 0);
   static void *newArray_TMatrixTColumn_constlEfloatgR(Long_t size, void *p);
   static void delete_TMatrixTColumn_constlEfloatgR(void *p);
   static void deleteArray_TMatrixTColumn_constlEfloatgR(void *p);
   static void destruct_TMatrixTColumn_constlEfloatgR(void *p);
   static void streamer_TMatrixTColumn_constlEfloatgR(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMatrixTColumn_const<float>*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::TMatrixTColumn_const<float>) == sizeof(::ROOT::Shadow::TMatrixTColumn_constlEfloatgR));
      ::TMatrixTColumn_const<float> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMatrixTColumn_const<float> >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TMatrixTColumn_const<float>", ::TMatrixTColumn_const<float>::Class_Version(), "include/TMatrixTUtils.h", 209,
                  typeid(::TMatrixTColumn_const<float>), DefineBehavior(ptr, ptr),
                  &TMatrixTColumn_constlEfloatgR_Dictionary, isa_proxy, 0,
                  sizeof(::TMatrixTColumn_const<float>) );
      instance.SetNew(&new_TMatrixTColumn_constlEfloatgR);
      instance.SetNewArray(&newArray_TMatrixTColumn_constlEfloatgR);
      instance.SetDelete(&delete_TMatrixTColumn_constlEfloatgR);
      instance.SetDeleteArray(&deleteArray_TMatrixTColumn_constlEfloatgR);
      instance.SetDestructor(&destruct_TMatrixTColumn_constlEfloatgR);
      instance.SetStreamerFunc(&streamer_TMatrixTColumn_constlEfloatgR);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TMatrixTColumn_const<float>*)
   {
      return GenerateInitInstanceLocal((::TMatrixTColumn_const<float>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMatrixTColumn_const<float>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void TMatrixTColumn_constlEfloatgR_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTColumn_const<float>*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   void TMatrixTSparseDiag_constlEfloatgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void TMatrixTSparseDiag_constlEfloatgR_Dictionary();
   static void *new_TMatrixTSparseDiag_constlEfloatgR(void *p = 0);
   static void *newArray_TMatrixTSparseDiag_constlEfloatgR(Long_t size, void *p);
   static void delete_TMatrixTSparseDiag_constlEfloatgR(void *p);
   static void deleteArray_TMatrixTSparseDiag_constlEfloatgR(void *p);
   static void destruct_TMatrixTSparseDiag_constlEfloatgR(void *p);
   static void streamer_TMatrixTSparseDiag_constlEfloatgR(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMatrixTSparseDiag_const<float>*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::TMatrixTSparseDiag_const<float>) == sizeof(::ROOT::Shadow::TMatrixTSparseDiag_constlEfloatgR));
      ::TMatrixTSparseDiag_const<float> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMatrixTSparseDiag_const<float> >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TMatrixTSparseDiag_const<float>", ::TMatrixTSparseDiag_const<float>::Class_Version(), "include/TMatrixTUtils.h", 640,
                  typeid(::TMatrixTSparseDiag_const<float>), DefineBehavior(ptr, ptr),
                  &TMatrixTSparseDiag_constlEfloatgR_Dictionary, isa_proxy, 0,
                  sizeof(::TMatrixTSparseDiag_const<float>) );
      instance.SetNew(&new_TMatrixTSparseDiag_constlEfloatgR);
      instance.SetNewArray(&newArray_TMatrixTSparseDiag_constlEfloatgR);
      instance.SetDelete(&delete_TMatrixTSparseDiag_constlEfloatgR);
      instance.SetDeleteArray(&deleteArray_TMatrixTSparseDiag_constlEfloatgR);
      instance.SetDestructor(&destruct_TMatrixTSparseDiag_constlEfloatgR);
      instance.SetStreamerFunc(&streamer_TMatrixTSparseDiag_constlEfloatgR);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TMatrixTSparseDiag_const<float>*)
   {
      return GenerateInitInstanceLocal((::TMatrixTSparseDiag_const<float>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMatrixTSparseDiag_const<float>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void TMatrixTSparseDiag_constlEfloatgR_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSparseDiag_const<float>*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   void TDecompBase_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TDecompBase(void *p);
   static void deleteArray_TDecompBase(void *p);
   static void destruct_TDecompBase(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TDecompBase*)
   {
      ::TDecompBase *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TDecompBase >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TDecompBase", ::TDecompBase::Class_Version(), "include/TDecompBase.h", 37,
                  typeid(::TDecompBase), DefineBehavior(ptr, ptr),
                  &::TDecompBase::Dictionary, isa_proxy, 4,
                  sizeof(::TDecompBase) );
      instance.SetDelete(&delete_TDecompBase);
      instance.SetDeleteArray(&deleteArray_TDecompBase);
      instance.SetDestructor(&destruct_TDecompBase);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TDecompBase*)
   {
      return GenerateInitInstanceLocal((::TDecompBase*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TDecompBase*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TDecompBK_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TDecompBK(void *p = 0);
   static void *newArray_TDecompBK(Long_t size, void *p);
   static void delete_TDecompBK(void *p);
   static void deleteArray_TDecompBK(void *p);
   static void destruct_TDecompBK(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TDecompBK*)
   {
      ::TDecompBK *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TDecompBK >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TDecompBK", ::TDecompBK::Class_Version(), "include/TDecompBK.h", 32,
                  typeid(::TDecompBK), DefineBehavior(ptr, ptr),
                  &::TDecompBK::Dictionary, isa_proxy, 4,
                  sizeof(::TDecompBK) );
      instance.SetNew(&new_TDecompBK);
      instance.SetNewArray(&newArray_TDecompBK);
      instance.SetDelete(&delete_TDecompBK);
      instance.SetDeleteArray(&deleteArray_TDecompBK);
      instance.SetDestructor(&destruct_TDecompBK);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TDecompBK*)
   {
      return GenerateInitInstanceLocal((::TDecompBK*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TDecompBK*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TDecompChol_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TDecompChol(void *p = 0);
   static void *newArray_TDecompChol(Long_t size, void *p);
   static void delete_TDecompChol(void *p);
   static void deleteArray_TDecompChol(void *p);
   static void destruct_TDecompChol(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TDecompChol*)
   {
      ::TDecompChol *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TDecompChol >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TDecompChol", ::TDecompChol::Class_Version(), "include/TDecompChol.h", 29,
                  typeid(::TDecompChol), DefineBehavior(ptr, ptr),
                  &::TDecompChol::Dictionary, isa_proxy, 4,
                  sizeof(::TDecompChol) );
      instance.SetNew(&new_TDecompChol);
      instance.SetNewArray(&newArray_TDecompChol);
      instance.SetDelete(&delete_TDecompChol);
      instance.SetDeleteArray(&deleteArray_TDecompChol);
      instance.SetDestructor(&destruct_TDecompChol);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TDecompChol*)
   {
      return GenerateInitInstanceLocal((::TDecompChol*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TDecompChol*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TDecompLU_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TDecompLU(void *p = 0);
   static void *newArray_TDecompLU(Long_t size, void *p);
   static void delete_TDecompLU(void *p);
   static void deleteArray_TDecompLU(void *p);
   static void destruct_TDecompLU(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TDecompLU*)
   {
      ::TDecompLU *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TDecompLU >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TDecompLU", ::TDecompLU::Class_Version(), "include/TDecompLU.h", 26,
                  typeid(::TDecompLU), DefineBehavior(ptr, ptr),
                  &::TDecompLU::Dictionary, isa_proxy, 4,
                  sizeof(::TDecompLU) );
      instance.SetNew(&new_TDecompLU);
      instance.SetNewArray(&newArray_TDecompLU);
      instance.SetDelete(&delete_TDecompLU);
      instance.SetDeleteArray(&deleteArray_TDecompLU);
      instance.SetDestructor(&destruct_TDecompLU);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TDecompLU*)
   {
      return GenerateInitInstanceLocal((::TDecompLU*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TDecompLU*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TDecompQRH_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TDecompQRH(void *p = 0);
   static void *newArray_TDecompQRH(Long_t size, void *p);
   static void delete_TDecompQRH(void *p);
   static void deleteArray_TDecompQRH(void *p);
   static void destruct_TDecompQRH(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TDecompQRH*)
   {
      ::TDecompQRH *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TDecompQRH >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TDecompQRH", ::TDecompQRH::Class_Version(), "include/TDecompQRH.h", 26,
                  typeid(::TDecompQRH), DefineBehavior(ptr, ptr),
                  &::TDecompQRH::Dictionary, isa_proxy, 4,
                  sizeof(::TDecompQRH) );
      instance.SetNew(&new_TDecompQRH);
      instance.SetNewArray(&newArray_TDecompQRH);
      instance.SetDelete(&delete_TDecompQRH);
      instance.SetDeleteArray(&deleteArray_TDecompQRH);
      instance.SetDestructor(&destruct_TDecompQRH);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TDecompQRH*)
   {
      return GenerateInitInstanceLocal((::TDecompQRH*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TDecompQRH*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TDecompSparse_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TDecompSparse(void *p = 0);
   static void *newArray_TDecompSparse(Long_t size, void *p);
   static void delete_TDecompSparse(void *p);
   static void deleteArray_TDecompSparse(void *p);
   static void destruct_TDecompSparse(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TDecompSparse*)
   {
      ::TDecompSparse *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TDecompSparse >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TDecompSparse", ::TDecompSparse::Class_Version(), "include/TDecompSparse.h", 52,
                  typeid(::TDecompSparse), DefineBehavior(ptr, ptr),
                  &::TDecompSparse::Dictionary, isa_proxy, 4,
                  sizeof(::TDecompSparse) );
      instance.SetNew(&new_TDecompSparse);
      instance.SetNewArray(&newArray_TDecompSparse);
      instance.SetDelete(&delete_TDecompSparse);
      instance.SetDeleteArray(&deleteArray_TDecompSparse);
      instance.SetDestructor(&destruct_TDecompSparse);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TDecompSparse*)
   {
      return GenerateInitInstanceLocal((::TDecompSparse*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TDecompSparse*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TDecompSVD_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TDecompSVD(void *p = 0);
   static void *newArray_TDecompSVD(Long_t size, void *p);
   static void delete_TDecompSVD(void *p);
   static void deleteArray_TDecompSVD(void *p);
   static void destruct_TDecompSVD(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TDecompSVD*)
   {
      ::TDecompSVD *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TDecompSVD >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TDecompSVD", ::TDecompSVD::Class_Version(), "include/TDecompSVD.h", 26,
                  typeid(::TDecompSVD), DefineBehavior(ptr, ptr),
                  &::TDecompSVD::Dictionary, isa_proxy, 4,
                  sizeof(::TDecompSVD) );
      instance.SetNew(&new_TDecompSVD);
      instance.SetNewArray(&newArray_TDecompSVD);
      instance.SetDelete(&delete_TDecompSVD);
      instance.SetDeleteArray(&deleteArray_TDecompSVD);
      instance.SetDestructor(&destruct_TDecompSVD);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TDecompSVD*)
   {
      return GenerateInitInstanceLocal((::TDecompSVD*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TDecompSVD*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TMatrixDEigen_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TMatrixDEigen(void *p = 0);
   static void *newArray_TMatrixDEigen(Long_t size, void *p);
   static void delete_TMatrixDEigen(void *p);
   static void deleteArray_TMatrixDEigen(void *p);
   static void destruct_TMatrixDEigen(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMatrixDEigen*)
   {
      ::TMatrixDEigen *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMatrixDEigen >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TMatrixDEigen", ::TMatrixDEigen::Class_Version(), "include/TMatrixDEigen.h", 31,
                  typeid(::TMatrixDEigen), DefineBehavior(ptr, ptr),
                  &::TMatrixDEigen::Dictionary, isa_proxy, 4,
                  sizeof(::TMatrixDEigen) );
      instance.SetNew(&new_TMatrixDEigen);
      instance.SetNewArray(&newArray_TMatrixDEigen);
      instance.SetDelete(&delete_TMatrixDEigen);
      instance.SetDeleteArray(&deleteArray_TMatrixDEigen);
      instance.SetDestructor(&destruct_TMatrixDEigen);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TMatrixDEigen*)
   {
      return GenerateInitInstanceLocal((::TMatrixDEigen*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMatrixDEigen*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void THaarMatrixTlEdoublegR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void THaarMatrixTlEdoublegR_Dictionary();
   static void *new_THaarMatrixTlEdoublegR(void *p = 0);
   static void *newArray_THaarMatrixTlEdoublegR(Long_t size, void *p);
   static void delete_THaarMatrixTlEdoublegR(void *p);
   static void deleteArray_THaarMatrixTlEdoublegR(void *p);
   static void destruct_THaarMatrixTlEdoublegR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::THaarMatrixT<double>*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::THaarMatrixT<double>) == sizeof(::ROOT::Shadow::THaarMatrixTlEdoublegR));
      ::THaarMatrixT<double> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::THaarMatrixT<double> >(0);
      static ::ROOT::TGenericClassInfo 
         instance("THaarMatrixT<double>", ::THaarMatrixT<double>::Class_Version(), "include/TMatrixTLazy.h", 124,
                  typeid(::THaarMatrixT<double>), DefineBehavior(ptr, ptr),
                  &THaarMatrixTlEdoublegR_Dictionary, isa_proxy, 4,
                  sizeof(::THaarMatrixT<double>) );
      instance.SetNew(&new_THaarMatrixTlEdoublegR);
      instance.SetNewArray(&newArray_THaarMatrixTlEdoublegR);
      instance.SetDelete(&delete_THaarMatrixTlEdoublegR);
      instance.SetDeleteArray(&deleteArray_THaarMatrixTlEdoublegR);
      instance.SetDestructor(&destruct_THaarMatrixTlEdoublegR);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::THaarMatrixT<double>*)
   {
      return GenerateInitInstanceLocal((::THaarMatrixT<double>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::THaarMatrixT<double>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void THaarMatrixTlEdoublegR_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::THaarMatrixT<double>*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   void THilbertMatrixTlEdoublegR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void THilbertMatrixTlEdoublegR_Dictionary();
   static void *new_THilbertMatrixTlEdoublegR(void *p = 0);
   static void *newArray_THilbertMatrixTlEdoublegR(Long_t size, void *p);
   static void delete_THilbertMatrixTlEdoublegR(void *p);
   static void deleteArray_THilbertMatrixTlEdoublegR(void *p);
   static void destruct_THilbertMatrixTlEdoublegR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::THilbertMatrixT<double>*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::THilbertMatrixT<double>) == sizeof(::ROOT::Shadow::THilbertMatrixTlEdoublegR));
      ::THilbertMatrixT<double> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::THilbertMatrixT<double> >(0);
      static ::ROOT::TGenericClassInfo 
         instance("THilbertMatrixT<double>", ::THilbertMatrixT<double>::Class_Version(), "include/TMatrixTLazy.h", 143,
                  typeid(::THilbertMatrixT<double>), DefineBehavior(ptr, ptr),
                  &THilbertMatrixTlEdoublegR_Dictionary, isa_proxy, 4,
                  sizeof(::THilbertMatrixT<double>) );
      instance.SetNew(&new_THilbertMatrixTlEdoublegR);
      instance.SetNewArray(&newArray_THilbertMatrixTlEdoublegR);
      instance.SetDelete(&delete_THilbertMatrixTlEdoublegR);
      instance.SetDeleteArray(&deleteArray_THilbertMatrixTlEdoublegR);
      instance.SetDestructor(&destruct_THilbertMatrixTlEdoublegR);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::THilbertMatrixT<double>*)
   {
      return GenerateInitInstanceLocal((::THilbertMatrixT<double>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::THilbertMatrixT<double>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void THilbertMatrixTlEdoublegR_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::THilbertMatrixT<double>*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   void THilbertMatrixTSymlEdoublegR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void THilbertMatrixTSymlEdoublegR_Dictionary();
   static void *new_THilbertMatrixTSymlEdoublegR(void *p = 0);
   static void *newArray_THilbertMatrixTSymlEdoublegR(Long_t size, void *p);
   static void delete_THilbertMatrixTSymlEdoublegR(void *p);
   static void deleteArray_THilbertMatrixTSymlEdoublegR(void *p);
   static void destruct_THilbertMatrixTSymlEdoublegR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::THilbertMatrixTSym<double>*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::THilbertMatrixTSym<double>) == sizeof(::ROOT::Shadow::THilbertMatrixTSymlEdoublegR));
      ::THilbertMatrixTSym<double> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::THilbertMatrixTSym<double> >(0);
      static ::ROOT::TGenericClassInfo 
         instance("THilbertMatrixTSym<double>", ::THilbertMatrixTSym<double>::Class_Version(), "include/TMatrixTLazy.h", 163,
                  typeid(::THilbertMatrixTSym<double>), DefineBehavior(ptr, ptr),
                  &THilbertMatrixTSymlEdoublegR_Dictionary, isa_proxy, 4,
                  sizeof(::THilbertMatrixTSym<double>) );
      instance.SetNew(&new_THilbertMatrixTSymlEdoublegR);
      instance.SetNewArray(&newArray_THilbertMatrixTSymlEdoublegR);
      instance.SetDelete(&delete_THilbertMatrixTSymlEdoublegR);
      instance.SetDeleteArray(&deleteArray_THilbertMatrixTSymlEdoublegR);
      instance.SetDestructor(&destruct_THilbertMatrixTSymlEdoublegR);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::THilbertMatrixTSym<double>*)
   {
      return GenerateInitInstanceLocal((::THilbertMatrixTSym<double>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::THilbertMatrixTSym<double>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void THilbertMatrixTSymlEdoublegR_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::THilbertMatrixTSym<double>*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   void TMatrixDSymEigen_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TMatrixDSymEigen(void *p = 0);
   static void *newArray_TMatrixDSymEigen(Long_t size, void *p);
   static void delete_TMatrixDSymEigen(void *p);
   static void deleteArray_TMatrixDSymEigen(void *p);
   static void destruct_TMatrixDSymEigen(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMatrixDSymEigen*)
   {
      ::TMatrixDSymEigen *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMatrixDSymEigen >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TMatrixDSymEigen", ::TMatrixDSymEigen::Class_Version(), "include/TMatrixDSymEigen.h", 34,
                  typeid(::TMatrixDSymEigen), DefineBehavior(ptr, ptr),
                  &::TMatrixDSymEigen::Dictionary, isa_proxy, 4,
                  sizeof(::TMatrixDSymEigen) );
      instance.SetNew(&new_TMatrixDSymEigen);
      instance.SetNewArray(&newArray_TMatrixDSymEigen);
      instance.SetDelete(&delete_TMatrixDSymEigen);
      instance.SetDeleteArray(&deleteArray_TMatrixDSymEigen);
      instance.SetDestructor(&destruct_TMatrixDSymEigen);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TMatrixDSymEigen*)
   {
      return GenerateInitInstanceLocal((::TMatrixDSymEigen*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMatrixDSymEigen*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TMatrixTFlat_constlEfloatgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void TMatrixTFlat_constlEfloatgR_Dictionary();
   static void *new_TMatrixTFlat_constlEfloatgR(void *p = 0);
   static void *newArray_TMatrixTFlat_constlEfloatgR(Long_t size, void *p);
   static void delete_TMatrixTFlat_constlEfloatgR(void *p);
   static void deleteArray_TMatrixTFlat_constlEfloatgR(void *p);
   static void destruct_TMatrixTFlat_constlEfloatgR(void *p);
   static void streamer_TMatrixTFlat_constlEfloatgR(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMatrixTFlat_const<float>*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::TMatrixTFlat_const<float>) == sizeof(::ROOT::Shadow::TMatrixTFlat_constlEfloatgR));
      ::TMatrixTFlat_const<float> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMatrixTFlat_const<float> >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TMatrixTFlat_const<float>", ::TMatrixTFlat_const<float>::Class_Version(), "include/TMatrixTUtils.h", 395,
                  typeid(::TMatrixTFlat_const<float>), DefineBehavior(ptr, ptr),
                  &TMatrixTFlat_constlEfloatgR_Dictionary, isa_proxy, 0,
                  sizeof(::TMatrixTFlat_const<float>) );
      instance.SetNew(&new_TMatrixTFlat_constlEfloatgR);
      instance.SetNewArray(&newArray_TMatrixTFlat_constlEfloatgR);
      instance.SetDelete(&delete_TMatrixTFlat_constlEfloatgR);
      instance.SetDeleteArray(&deleteArray_TMatrixTFlat_constlEfloatgR);
      instance.SetDestructor(&destruct_TMatrixTFlat_constlEfloatgR);
      instance.SetStreamerFunc(&streamer_TMatrixTFlat_constlEfloatgR);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TMatrixTFlat_const<float>*)
   {
      return GenerateInitInstanceLocal((::TMatrixTFlat_const<float>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMatrixTFlat_const<float>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void TMatrixTFlat_constlEfloatgR_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTFlat_const<float>*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   void TMatrixTSub_constlEfloatgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void TMatrixTSub_constlEfloatgR_Dictionary();
   static void *new_TMatrixTSub_constlEfloatgR(void *p = 0);
   static void *newArray_TMatrixTSub_constlEfloatgR(Long_t size, void *p);
   static void delete_TMatrixTSub_constlEfloatgR(void *p);
   static void deleteArray_TMatrixTSub_constlEfloatgR(void *p);
   static void destruct_TMatrixTSub_constlEfloatgR(void *p);
   static void streamer_TMatrixTSub_constlEfloatgR(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMatrixTSub_const<float>*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::TMatrixTSub_const<float>) == sizeof(::ROOT::Shadow::TMatrixTSub_constlEfloatgR));
      ::TMatrixTSub_const<float> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMatrixTSub_const<float> >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TMatrixTSub_const<float>", ::TMatrixTSub_const<float>::Class_Version(), "include/TMatrixTUtils.h", 481,
                  typeid(::TMatrixTSub_const<float>), DefineBehavior(ptr, ptr),
                  &TMatrixTSub_constlEfloatgR_Dictionary, isa_proxy, 0,
                  sizeof(::TMatrixTSub_const<float>) );
      instance.SetNew(&new_TMatrixTSub_constlEfloatgR);
      instance.SetNewArray(&newArray_TMatrixTSub_constlEfloatgR);
      instance.SetDelete(&delete_TMatrixTSub_constlEfloatgR);
      instance.SetDeleteArray(&deleteArray_TMatrixTSub_constlEfloatgR);
      instance.SetDestructor(&destruct_TMatrixTSub_constlEfloatgR);
      instance.SetStreamerFunc(&streamer_TMatrixTSub_constlEfloatgR);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TMatrixTSub_const<float>*)
   {
      return GenerateInitInstanceLocal((::TMatrixTSub_const<float>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMatrixTSub_const<float>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void TMatrixTSub_constlEfloatgR_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSub_const<float>*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   void TMatrixTColumnlEfloatgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void TMatrixTColumnlEfloatgR_Dictionary();
   static void *new_TMatrixTColumnlEfloatgR(void *p = 0);
   static void *newArray_TMatrixTColumnlEfloatgR(Long_t size, void *p);
   static void delete_TMatrixTColumnlEfloatgR(void *p);
   static void deleteArray_TMatrixTColumnlEfloatgR(void *p);
   static void destruct_TMatrixTColumnlEfloatgR(void *p);
   static void streamer_TMatrixTColumnlEfloatgR(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMatrixTColumn<float>*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::TMatrixTColumn<float>) == sizeof(::ROOT::Shadow::TMatrixTColumnlEfloatgR));
      ::TMatrixTColumn<float> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMatrixTColumn<float> >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TMatrixTColumn<float>", ::TMatrixTColumn<float>::Class_Version(), "include/TMatrixTUtils.h", 247,
                  typeid(::TMatrixTColumn<float>), DefineBehavior(ptr, ptr),
                  &TMatrixTColumnlEfloatgR_Dictionary, isa_proxy, 0,
                  sizeof(::TMatrixTColumn<float>) );
      instance.SetNew(&new_TMatrixTColumnlEfloatgR);
      instance.SetNewArray(&newArray_TMatrixTColumnlEfloatgR);
      instance.SetDelete(&delete_TMatrixTColumnlEfloatgR);
      instance.SetDeleteArray(&deleteArray_TMatrixTColumnlEfloatgR);
      instance.SetDestructor(&destruct_TMatrixTColumnlEfloatgR);
      instance.SetStreamerFunc(&streamer_TMatrixTColumnlEfloatgR);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TMatrixTColumn<float>*)
   {
      return GenerateInitInstanceLocal((::TMatrixTColumn<float>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMatrixTColumn<float>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void TMatrixTColumnlEfloatgR_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTColumn<float>*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   void TMatrixTDiaglEfloatgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void TMatrixTDiaglEfloatgR_Dictionary();
   static void *new_TMatrixTDiaglEfloatgR(void *p = 0);
   static void *newArray_TMatrixTDiaglEfloatgR(Long_t size, void *p);
   static void delete_TMatrixTDiaglEfloatgR(void *p);
   static void deleteArray_TMatrixTDiaglEfloatgR(void *p);
   static void destruct_TMatrixTDiaglEfloatgR(void *p);
   static void streamer_TMatrixTDiaglEfloatgR(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMatrixTDiag<float>*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::TMatrixTDiag<float>) == sizeof(::ROOT::Shadow::TMatrixTDiaglEfloatgR));
      ::TMatrixTDiag<float> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMatrixTDiag<float> >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TMatrixTDiag<float>", ::TMatrixTDiag<float>::Class_Version(), "include/TMatrixTUtils.h", 342,
                  typeid(::TMatrixTDiag<float>), DefineBehavior(ptr, ptr),
                  &TMatrixTDiaglEfloatgR_Dictionary, isa_proxy, 0,
                  sizeof(::TMatrixTDiag<float>) );
      instance.SetNew(&new_TMatrixTDiaglEfloatgR);
      instance.SetNewArray(&newArray_TMatrixTDiaglEfloatgR);
      instance.SetDelete(&delete_TMatrixTDiaglEfloatgR);
      instance.SetDeleteArray(&deleteArray_TMatrixTDiaglEfloatgR);
      instance.SetDestructor(&destruct_TMatrixTDiaglEfloatgR);
      instance.SetStreamerFunc(&streamer_TMatrixTDiaglEfloatgR);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TMatrixTDiag<float>*)
   {
      return GenerateInitInstanceLocal((::TMatrixTDiag<float>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMatrixTDiag<float>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void TMatrixTDiaglEfloatgR_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTDiag<float>*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   void TMatrixTFlatlEfloatgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void TMatrixTFlatlEfloatgR_Dictionary();
   static void *new_TMatrixTFlatlEfloatgR(void *p = 0);
   static void *newArray_TMatrixTFlatlEfloatgR(Long_t size, void *p);
   static void delete_TMatrixTFlatlEfloatgR(void *p);
   static void deleteArray_TMatrixTFlatlEfloatgR(void *p);
   static void destruct_TMatrixTFlatlEfloatgR(void *p);
   static void streamer_TMatrixTFlatlEfloatgR(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMatrixTFlat<float>*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::TMatrixTFlat<float>) == sizeof(::ROOT::Shadow::TMatrixTFlatlEfloatgR));
      ::TMatrixTFlat<float> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMatrixTFlat<float> >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TMatrixTFlat<float>", ::TMatrixTFlat<float>::Class_Version(), "include/TMatrixTUtils.h", 428,
                  typeid(::TMatrixTFlat<float>), DefineBehavior(ptr, ptr),
                  &TMatrixTFlatlEfloatgR_Dictionary, isa_proxy, 0,
                  sizeof(::TMatrixTFlat<float>) );
      instance.SetNew(&new_TMatrixTFlatlEfloatgR);
      instance.SetNewArray(&newArray_TMatrixTFlatlEfloatgR);
      instance.SetDelete(&delete_TMatrixTFlatlEfloatgR);
      instance.SetDeleteArray(&deleteArray_TMatrixTFlatlEfloatgR);
      instance.SetDestructor(&destruct_TMatrixTFlatlEfloatgR);
      instance.SetStreamerFunc(&streamer_TMatrixTFlatlEfloatgR);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TMatrixTFlat<float>*)
   {
      return GenerateInitInstanceLocal((::TMatrixTFlat<float>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMatrixTFlat<float>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void TMatrixTFlatlEfloatgR_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTFlat<float>*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   void TMatrixTSublEfloatgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void TMatrixTSublEfloatgR_Dictionary();
   static void *new_TMatrixTSublEfloatgR(void *p = 0);
   static void *newArray_TMatrixTSublEfloatgR(Long_t size, void *p);
   static void delete_TMatrixTSublEfloatgR(void *p);
   static void deleteArray_TMatrixTSublEfloatgR(void *p);
   static void destruct_TMatrixTSublEfloatgR(void *p);
   static void streamer_TMatrixTSublEfloatgR(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMatrixTSub<float>*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::TMatrixTSub<float>) == sizeof(::ROOT::Shadow::TMatrixTSublEfloatgR));
      ::TMatrixTSub<float> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMatrixTSub<float> >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TMatrixTSub<float>", ::TMatrixTSub<float>::Class_Version(), "include/TMatrixTUtils.h", 520,
                  typeid(::TMatrixTSub<float>), DefineBehavior(ptr, ptr),
                  &TMatrixTSublEfloatgR_Dictionary, isa_proxy, 0,
                  sizeof(::TMatrixTSub<float>) );
      instance.SetNew(&new_TMatrixTSublEfloatgR);
      instance.SetNewArray(&newArray_TMatrixTSublEfloatgR);
      instance.SetDelete(&delete_TMatrixTSublEfloatgR);
      instance.SetDeleteArray(&deleteArray_TMatrixTSublEfloatgR);
      instance.SetDestructor(&destruct_TMatrixTSublEfloatgR);
      instance.SetStreamerFunc(&streamer_TMatrixTSublEfloatgR);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TMatrixTSub<float>*)
   {
      return GenerateInitInstanceLocal((::TMatrixTSub<float>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMatrixTSub<float>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void TMatrixTSublEfloatgR_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSub<float>*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   void TMatrixTSparseDiaglEfloatgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void TMatrixTSparseDiaglEfloatgR_Dictionary();
   static void *new_TMatrixTSparseDiaglEfloatgR(void *p = 0);
   static void *newArray_TMatrixTSparseDiaglEfloatgR(Long_t size, void *p);
   static void delete_TMatrixTSparseDiaglEfloatgR(void *p);
   static void deleteArray_TMatrixTSparseDiaglEfloatgR(void *p);
   static void destruct_TMatrixTSparseDiaglEfloatgR(void *p);
   static void streamer_TMatrixTSparseDiaglEfloatgR(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMatrixTSparseDiag<float>*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::TMatrixTSparseDiag<float>) == sizeof(::ROOT::Shadow::TMatrixTSparseDiaglEfloatgR));
      ::TMatrixTSparseDiag<float> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMatrixTSparseDiag<float> >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TMatrixTSparseDiag<float>", ::TMatrixTSparseDiag<float>::Class_Version(), "include/TMatrixTUtils.h", 666,
                  typeid(::TMatrixTSparseDiag<float>), DefineBehavior(ptr, ptr),
                  &TMatrixTSparseDiaglEfloatgR_Dictionary, isa_proxy, 0,
                  sizeof(::TMatrixTSparseDiag<float>) );
      instance.SetNew(&new_TMatrixTSparseDiaglEfloatgR);
      instance.SetNewArray(&newArray_TMatrixTSparseDiaglEfloatgR);
      instance.SetDelete(&delete_TMatrixTSparseDiaglEfloatgR);
      instance.SetDeleteArray(&deleteArray_TMatrixTSparseDiaglEfloatgR);
      instance.SetDestructor(&destruct_TMatrixTSparseDiaglEfloatgR);
      instance.SetStreamerFunc(&streamer_TMatrixTSparseDiaglEfloatgR);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TMatrixTSparseDiag<float>*)
   {
      return GenerateInitInstanceLocal((::TMatrixTSparseDiag<float>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMatrixTSparseDiag<float>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void TMatrixTSparseDiaglEfloatgR_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSparseDiag<float>*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   void THaarMatrixTlEfloatgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void THaarMatrixTlEfloatgR_Dictionary();
   static void *new_THaarMatrixTlEfloatgR(void *p = 0);
   static void *newArray_THaarMatrixTlEfloatgR(Long_t size, void *p);
   static void delete_THaarMatrixTlEfloatgR(void *p);
   static void deleteArray_THaarMatrixTlEfloatgR(void *p);
   static void destruct_THaarMatrixTlEfloatgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::THaarMatrixT<float>*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::THaarMatrixT<float>) == sizeof(::ROOT::Shadow::THaarMatrixTlEfloatgR));
      ::THaarMatrixT<float> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::THaarMatrixT<float> >(0);
      static ::ROOT::TGenericClassInfo 
         instance("THaarMatrixT<float>", ::THaarMatrixT<float>::Class_Version(), "include/TMatrixTLazy.h", 124,
                  typeid(::THaarMatrixT<float>), DefineBehavior(ptr, ptr),
                  &THaarMatrixTlEfloatgR_Dictionary, isa_proxy, 4,
                  sizeof(::THaarMatrixT<float>) );
      instance.SetNew(&new_THaarMatrixTlEfloatgR);
      instance.SetNewArray(&newArray_THaarMatrixTlEfloatgR);
      instance.SetDelete(&delete_THaarMatrixTlEfloatgR);
      instance.SetDeleteArray(&deleteArray_THaarMatrixTlEfloatgR);
      instance.SetDestructor(&destruct_THaarMatrixTlEfloatgR);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::THaarMatrixT<float>*)
   {
      return GenerateInitInstanceLocal((::THaarMatrixT<float>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::THaarMatrixT<float>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void THaarMatrixTlEfloatgR_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::THaarMatrixT<float>*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   void THilbertMatrixTlEfloatgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void THilbertMatrixTlEfloatgR_Dictionary();
   static void *new_THilbertMatrixTlEfloatgR(void *p = 0);
   static void *newArray_THilbertMatrixTlEfloatgR(Long_t size, void *p);
   static void delete_THilbertMatrixTlEfloatgR(void *p);
   static void deleteArray_THilbertMatrixTlEfloatgR(void *p);
   static void destruct_THilbertMatrixTlEfloatgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::THilbertMatrixT<float>*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::THilbertMatrixT<float>) == sizeof(::ROOT::Shadow::THilbertMatrixTlEfloatgR));
      ::THilbertMatrixT<float> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::THilbertMatrixT<float> >(0);
      static ::ROOT::TGenericClassInfo 
         instance("THilbertMatrixT<float>", ::THilbertMatrixT<float>::Class_Version(), "include/TMatrixTLazy.h", 143,
                  typeid(::THilbertMatrixT<float>), DefineBehavior(ptr, ptr),
                  &THilbertMatrixTlEfloatgR_Dictionary, isa_proxy, 4,
                  sizeof(::THilbertMatrixT<float>) );
      instance.SetNew(&new_THilbertMatrixTlEfloatgR);
      instance.SetNewArray(&newArray_THilbertMatrixTlEfloatgR);
      instance.SetDelete(&delete_THilbertMatrixTlEfloatgR);
      instance.SetDeleteArray(&deleteArray_THilbertMatrixTlEfloatgR);
      instance.SetDestructor(&destruct_THilbertMatrixTlEfloatgR);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::THilbertMatrixT<float>*)
   {
      return GenerateInitInstanceLocal((::THilbertMatrixT<float>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::THilbertMatrixT<float>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void THilbertMatrixTlEfloatgR_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::THilbertMatrixT<float>*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   void THilbertMatrixTSymlEfloatgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void THilbertMatrixTSymlEfloatgR_Dictionary();
   static void *new_THilbertMatrixTSymlEfloatgR(void *p = 0);
   static void *newArray_THilbertMatrixTSymlEfloatgR(Long_t size, void *p);
   static void delete_THilbertMatrixTSymlEfloatgR(void *p);
   static void deleteArray_THilbertMatrixTSymlEfloatgR(void *p);
   static void destruct_THilbertMatrixTSymlEfloatgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::THilbertMatrixTSym<float>*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::THilbertMatrixTSym<float>) == sizeof(::ROOT::Shadow::THilbertMatrixTSymlEfloatgR));
      ::THilbertMatrixTSym<float> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::THilbertMatrixTSym<float> >(0);
      static ::ROOT::TGenericClassInfo 
         instance("THilbertMatrixTSym<float>", ::THilbertMatrixTSym<float>::Class_Version(), "include/TMatrixTLazy.h", 163,
                  typeid(::THilbertMatrixTSym<float>), DefineBehavior(ptr, ptr),
                  &THilbertMatrixTSymlEfloatgR_Dictionary, isa_proxy, 4,
                  sizeof(::THilbertMatrixTSym<float>) );
      instance.SetNew(&new_THilbertMatrixTSymlEfloatgR);
      instance.SetNewArray(&newArray_THilbertMatrixTSymlEfloatgR);
      instance.SetDelete(&delete_THilbertMatrixTSymlEfloatgR);
      instance.SetDeleteArray(&deleteArray_THilbertMatrixTSymlEfloatgR);
      instance.SetDestructor(&destruct_THilbertMatrixTSymlEfloatgR);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::THilbertMatrixTSym<float>*)
   {
      return GenerateInitInstanceLocal((::THilbertMatrixTSym<float>*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::THilbertMatrixTSym<float>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void THilbertMatrixTSymlEfloatgR_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::THilbertMatrixTSym<float>*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace TMatrixTCramerInv {
   namespace ROOT {
      inline ::ROOT::TGenericClassInfo *GenerateInitInstance();
      static void TMatrixTCramerInv_Dictionary();

      // Function generating the singleton type initializer
      inline ::ROOT::TGenericClassInfo *GenerateInitInstance()
      {
         static ::ROOT::TGenericClassInfo 
            instance("TMatrixTCramerInv", 0 /*version*/, "include/TMatrixTCramerInv.h", 34,
                     ::ROOT::DefineBehavior((void*)0,(void*)0),
                     &TMatrixTCramerInv_Dictionary, 0);
         return &instance;
      }
      // Insure that the inline function is _not_ optimized away by the compiler
      ::ROOT::TGenericClassInfo *(*_R__UNIQUE_(InitFunctionKeeper))() = &GenerateInitInstance;  
      // Static variable to force the class initialization
      static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance(); R__UseDummy(_R__UNIQUE_(Init));

      // Dictionary for non-ClassDef classes
      static void TMatrixTCramerInv_Dictionary() {
         GenerateInitInstance()->GetClass();
      }

   }
}

namespace TMatrixTSymCramerInv {
   namespace ROOT {
      inline ::ROOT::TGenericClassInfo *GenerateInitInstance();
      static void TMatrixTSymCramerInv_Dictionary();

      // Function generating the singleton type initializer
      inline ::ROOT::TGenericClassInfo *GenerateInitInstance()
      {
         static ::ROOT::TGenericClassInfo 
            instance("TMatrixTSymCramerInv", 0 /*version*/, "include/TMatrixTSymCramerInv.h", 34,
                     ::ROOT::DefineBehavior((void*)0,(void*)0),
                     &TMatrixTSymCramerInv_Dictionary, 0);
         return &instance;
      }
      // Insure that the inline function is _not_ optimized away by the compiler
      ::ROOT::TGenericClassInfo *(*_R__UNIQUE_(InitFunctionKeeper))() = &GenerateInitInstance;  
      // Static variable to force the class initialization
      static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance(); R__UseDummy(_R__UNIQUE_(Init));

      // Dictionary for non-ClassDef classes
      static void TMatrixTSymCramerInv_Dictionary() {
         GenerateInitInstance()->GetClass();
      }

   }
}

//______________________________________________________________________________
template <> TClass *TMatrixTBase<float>::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
template <> const char *TMatrixTBase<float>::Class_Name()
{
   return "TMatrixTBase<float>";
}

//______________________________________________________________________________
template <> const char *TMatrixTBase<float>::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTBase<float>*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
template <> int TMatrixTBase<float>::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTBase<float>*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
template <> void TMatrixTBase<float>::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTBase<float>*)0x0)->GetClass();
}

//______________________________________________________________________________
template <> TClass *TMatrixTBase<float>::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTBase<float>*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
template <> TClass *TMatrixTBase<double>::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
template <> const char *TMatrixTBase<double>::Class_Name()
{
   return "TMatrixTBase<double>";
}

//______________________________________________________________________________
template <> const char *TMatrixTBase<double>::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTBase<double>*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
template <> int TMatrixTBase<double>::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTBase<double>*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
template <> void TMatrixTBase<double>::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTBase<double>*)0x0)->GetClass();
}

//______________________________________________________________________________
template <> TClass *TMatrixTBase<double>::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTBase<double>*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
template <> TClass *TVectorT<float>::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
template <> const char *TVectorT<float>::Class_Name()
{
   return "TVectorT<float>";
}

//______________________________________________________________________________
template <> const char *TVectorT<float>::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TVectorT<float>*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
template <> int TVectorT<float>::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TVectorT<float>*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
template <> void TVectorT<float>::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TVectorT<float>*)0x0)->GetClass();
}

//______________________________________________________________________________
template <> TClass *TVectorT<float>::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TVectorT<float>*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
template <> TClass *TVectorT<double>::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
template <> const char *TVectorT<double>::Class_Name()
{
   return "TVectorT<double>";
}

//______________________________________________________________________________
template <> const char *TVectorT<double>::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TVectorT<double>*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
template <> int TVectorT<double>::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TVectorT<double>*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
template <> void TVectorT<double>::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TVectorT<double>*)0x0)->GetClass();
}

//______________________________________________________________________________
template <> TClass *TVectorT<double>::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TVectorT<double>*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
template <> TClass *TMatrixT<double>::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
template <> const char *TMatrixT<double>::Class_Name()
{
   return "TMatrixT<double>";
}

//______________________________________________________________________________
template <> const char *TMatrixT<double>::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMatrixT<double>*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
template <> int TMatrixT<double>::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMatrixT<double>*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
template <> void TMatrixT<double>::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixT<double>*)0x0)->GetClass();
}

//______________________________________________________________________________
template <> TClass *TMatrixT<double>::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixT<double>*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
template <> TClass *TMatrixTSym<double>::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
template <> const char *TMatrixTSym<double>::Class_Name()
{
   return "TMatrixTSym<double>";
}

//______________________________________________________________________________
template <> const char *TMatrixTSym<double>::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSym<double>*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
template <> int TMatrixTSym<double>::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSym<double>*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
template <> void TMatrixTSym<double>::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSym<double>*)0x0)->GetClass();
}

//______________________________________________________________________________
template <> TClass *TMatrixTSym<double>::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSym<double>*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
template <> TClass *TMatrixTSparse<double>::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
template <> const char *TMatrixTSparse<double>::Class_Name()
{
   return "TMatrixTSparse<double>";
}

//______________________________________________________________________________
template <> const char *TMatrixTSparse<double>::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSparse<double>*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
template <> int TMatrixTSparse<double>::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSparse<double>*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
template <> void TMatrixTSparse<double>::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSparse<double>*)0x0)->GetClass();
}

//______________________________________________________________________________
template <> TClass *TMatrixTSparse<double>::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSparse<double>*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
template <> TClass *TMatrixTLazy<double>::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
template <> const char *TMatrixTLazy<double>::Class_Name()
{
   return "TMatrixTLazy<double>";
}

//______________________________________________________________________________
template <> const char *TMatrixTLazy<double>::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTLazy<double>*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
template <> int TMatrixTLazy<double>::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTLazy<double>*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
template <> void TMatrixTLazy<double>::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTLazy<double>*)0x0)->GetClass();
}

//______________________________________________________________________________
template <> TClass *TMatrixTLazy<double>::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTLazy<double>*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
template <> TClass *TMatrixTRow_const<double>::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
template <> const char *TMatrixTRow_const<double>::Class_Name()
{
   return "TMatrixTRow_const<double>";
}

//______________________________________________________________________________
template <> const char *TMatrixTRow_const<double>::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTRow_const<double>*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
template <> int TMatrixTRow_const<double>::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTRow_const<double>*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
template <> void TMatrixTRow_const<double>::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTRow_const<double>*)0x0)->GetClass();
}

//______________________________________________________________________________
template <> TClass *TMatrixTRow_const<double>::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTRow_const<double>*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
template <> TClass *TMatrixTRow<double>::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
template <> const char *TMatrixTRow<double>::Class_Name()
{
   return "TMatrixTRow<double>";
}

//______________________________________________________________________________
template <> const char *TMatrixTRow<double>::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTRow<double>*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
template <> int TMatrixTRow<double>::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTRow<double>*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
template <> void TMatrixTRow<double>::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTRow<double>*)0x0)->GetClass();
}

//______________________________________________________________________________
template <> TClass *TMatrixTRow<double>::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTRow<double>*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
template <> TClass *TMatrixTDiag_const<double>::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
template <> const char *TMatrixTDiag_const<double>::Class_Name()
{
   return "TMatrixTDiag_const<double>";
}

//______________________________________________________________________________
template <> const char *TMatrixTDiag_const<double>::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTDiag_const<double>*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
template <> int TMatrixTDiag_const<double>::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTDiag_const<double>*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
template <> void TMatrixTDiag_const<double>::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTDiag_const<double>*)0x0)->GetClass();
}

//______________________________________________________________________________
template <> TClass *TMatrixTDiag_const<double>::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTDiag_const<double>*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
template <> TClass *TMatrixTColumn_const<double>::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
template <> const char *TMatrixTColumn_const<double>::Class_Name()
{
   return "TMatrixTColumn_const<double>";
}

//______________________________________________________________________________
template <> const char *TMatrixTColumn_const<double>::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTColumn_const<double>*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
template <> int TMatrixTColumn_const<double>::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTColumn_const<double>*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
template <> void TMatrixTColumn_const<double>::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTColumn_const<double>*)0x0)->GetClass();
}

//______________________________________________________________________________
template <> TClass *TMatrixTColumn_const<double>::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTColumn_const<double>*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
template <> TClass *TMatrixTFlat_const<double>::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
template <> const char *TMatrixTFlat_const<double>::Class_Name()
{
   return "TMatrixTFlat_const<double>";
}

//______________________________________________________________________________
template <> const char *TMatrixTFlat_const<double>::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTFlat_const<double>*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
template <> int TMatrixTFlat_const<double>::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTFlat_const<double>*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
template <> void TMatrixTFlat_const<double>::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTFlat_const<double>*)0x0)->GetClass();
}

//______________________________________________________________________________
template <> TClass *TMatrixTFlat_const<double>::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTFlat_const<double>*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
template <> TClass *TMatrixTSub_const<double>::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
template <> const char *TMatrixTSub_const<double>::Class_Name()
{
   return "TMatrixTSub_const<double>";
}

//______________________________________________________________________________
template <> const char *TMatrixTSub_const<double>::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSub_const<double>*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
template <> int TMatrixTSub_const<double>::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSub_const<double>*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
template <> void TMatrixTSub_const<double>::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSub_const<double>*)0x0)->GetClass();
}

//______________________________________________________________________________
template <> TClass *TMatrixTSub_const<double>::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSub_const<double>*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
template <> TClass *TMatrixTSparseRow_const<double>::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
template <> const char *TMatrixTSparseRow_const<double>::Class_Name()
{
   return "TMatrixTSparseRow_const<double>";
}

//______________________________________________________________________________
template <> const char *TMatrixTSparseRow_const<double>::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSparseRow_const<double>*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
template <> int TMatrixTSparseRow_const<double>::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSparseRow_const<double>*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
template <> void TMatrixTSparseRow_const<double>::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSparseRow_const<double>*)0x0)->GetClass();
}

//______________________________________________________________________________
template <> TClass *TMatrixTSparseRow_const<double>::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSparseRow_const<double>*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
template <> TClass *TMatrixTSparseDiag_const<double>::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
template <> const char *TMatrixTSparseDiag_const<double>::Class_Name()
{
   return "TMatrixTSparseDiag_const<double>";
}

//______________________________________________________________________________
template <> const char *TMatrixTSparseDiag_const<double>::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSparseDiag_const<double>*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
template <> int TMatrixTSparseDiag_const<double>::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSparseDiag_const<double>*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
template <> void TMatrixTSparseDiag_const<double>::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSparseDiag_const<double>*)0x0)->GetClass();
}

//______________________________________________________________________________
template <> TClass *TMatrixTSparseDiag_const<double>::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSparseDiag_const<double>*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
template <> TClass *TMatrixTColumn<double>::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
template <> const char *TMatrixTColumn<double>::Class_Name()
{
   return "TMatrixTColumn<double>";
}

//______________________________________________________________________________
template <> const char *TMatrixTColumn<double>::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTColumn<double>*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
template <> int TMatrixTColumn<double>::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTColumn<double>*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
template <> void TMatrixTColumn<double>::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTColumn<double>*)0x0)->GetClass();
}

//______________________________________________________________________________
template <> TClass *TMatrixTColumn<double>::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTColumn<double>*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
template <> TClass *TMatrixTDiag<double>::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
template <> const char *TMatrixTDiag<double>::Class_Name()
{
   return "TMatrixTDiag<double>";
}

//______________________________________________________________________________
template <> const char *TMatrixTDiag<double>::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTDiag<double>*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
template <> int TMatrixTDiag<double>::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTDiag<double>*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
template <> void TMatrixTDiag<double>::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTDiag<double>*)0x0)->GetClass();
}

//______________________________________________________________________________
template <> TClass *TMatrixTDiag<double>::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTDiag<double>*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
template <> TClass *TMatrixTFlat<double>::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
template <> const char *TMatrixTFlat<double>::Class_Name()
{
   return "TMatrixTFlat<double>";
}

//______________________________________________________________________________
template <> const char *TMatrixTFlat<double>::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTFlat<double>*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
template <> int TMatrixTFlat<double>::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTFlat<double>*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
template <> void TMatrixTFlat<double>::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTFlat<double>*)0x0)->GetClass();
}

//______________________________________________________________________________
template <> TClass *TMatrixTFlat<double>::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTFlat<double>*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
template <> TClass *TMatrixTSub<double>::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
template <> const char *TMatrixTSub<double>::Class_Name()
{
   return "TMatrixTSub<double>";
}

//______________________________________________________________________________
template <> const char *TMatrixTSub<double>::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSub<double>*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
template <> int TMatrixTSub<double>::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSub<double>*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
template <> void TMatrixTSub<double>::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSub<double>*)0x0)->GetClass();
}

//______________________________________________________________________________
template <> TClass *TMatrixTSub<double>::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSub<double>*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
template <> TClass *TMatrixTSparseRow<double>::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
template <> const char *TMatrixTSparseRow<double>::Class_Name()
{
   return "TMatrixTSparseRow<double>";
}

//______________________________________________________________________________
template <> const char *TMatrixTSparseRow<double>::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSparseRow<double>*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
template <> int TMatrixTSparseRow<double>::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSparseRow<double>*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
template <> void TMatrixTSparseRow<double>::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSparseRow<double>*)0x0)->GetClass();
}

//______________________________________________________________________________
template <> TClass *TMatrixTSparseRow<double>::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSparseRow<double>*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
template <> TClass *TMatrixTSparseDiag<double>::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
template <> const char *TMatrixTSparseDiag<double>::Class_Name()
{
   return "TMatrixTSparseDiag<double>";
}

//______________________________________________________________________________
template <> const char *TMatrixTSparseDiag<double>::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSparseDiag<double>*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
template <> int TMatrixTSparseDiag<double>::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSparseDiag<double>*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
template <> void TMatrixTSparseDiag<double>::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSparseDiag<double>*)0x0)->GetClass();
}

//______________________________________________________________________________
template <> TClass *TMatrixTSparseDiag<double>::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSparseDiag<double>*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
template <> TClass *TMatrixTSymLazy<double>::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
template <> const char *TMatrixTSymLazy<double>::Class_Name()
{
   return "TMatrixTSymLazy<double>";
}

//______________________________________________________________________________
template <> const char *TMatrixTSymLazy<double>::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSymLazy<double>*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
template <> int TMatrixTSymLazy<double>::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSymLazy<double>*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
template <> void TMatrixTSymLazy<double>::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSymLazy<double>*)0x0)->GetClass();
}

//______________________________________________________________________________
template <> TClass *TMatrixTSymLazy<double>::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSymLazy<double>*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
template <> TClass *TMatrixTRow_const<float>::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
template <> const char *TMatrixTRow_const<float>::Class_Name()
{
   return "TMatrixTRow_const<float>";
}

//______________________________________________________________________________
template <> const char *TMatrixTRow_const<float>::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTRow_const<float>*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
template <> int TMatrixTRow_const<float>::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTRow_const<float>*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
template <> void TMatrixTRow_const<float>::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTRow_const<float>*)0x0)->GetClass();
}

//______________________________________________________________________________
template <> TClass *TMatrixTRow_const<float>::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTRow_const<float>*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
template <> TClass *TMatrixT<float>::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
template <> const char *TMatrixT<float>::Class_Name()
{
   return "TMatrixT<float>";
}

//______________________________________________________________________________
template <> const char *TMatrixT<float>::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMatrixT<float>*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
template <> int TMatrixT<float>::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMatrixT<float>*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
template <> void TMatrixT<float>::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixT<float>*)0x0)->GetClass();
}

//______________________________________________________________________________
template <> TClass *TMatrixT<float>::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixT<float>*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
template <> TClass *TMatrixTSym<float>::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
template <> const char *TMatrixTSym<float>::Class_Name()
{
   return "TMatrixTSym<float>";
}

//______________________________________________________________________________
template <> const char *TMatrixTSym<float>::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSym<float>*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
template <> int TMatrixTSym<float>::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSym<float>*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
template <> void TMatrixTSym<float>::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSym<float>*)0x0)->GetClass();
}

//______________________________________________________________________________
template <> TClass *TMatrixTSym<float>::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSym<float>*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
template <> TClass *TMatrixTSymLazy<float>::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
template <> const char *TMatrixTSymLazy<float>::Class_Name()
{
   return "TMatrixTSymLazy<float>";
}

//______________________________________________________________________________
template <> const char *TMatrixTSymLazy<float>::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSymLazy<float>*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
template <> int TMatrixTSymLazy<float>::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSymLazy<float>*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
template <> void TMatrixTSymLazy<float>::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSymLazy<float>*)0x0)->GetClass();
}

//______________________________________________________________________________
template <> TClass *TMatrixTSymLazy<float>::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSymLazy<float>*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
template <> TClass *TMatrixTRow<float>::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
template <> const char *TMatrixTRow<float>::Class_Name()
{
   return "TMatrixTRow<float>";
}

//______________________________________________________________________________
template <> const char *TMatrixTRow<float>::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTRow<float>*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
template <> int TMatrixTRow<float>::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTRow<float>*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
template <> void TMatrixTRow<float>::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTRow<float>*)0x0)->GetClass();
}

//______________________________________________________________________________
template <> TClass *TMatrixTRow<float>::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTRow<float>*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
template <> TClass *TMatrixTSparse<float>::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
template <> const char *TMatrixTSparse<float>::Class_Name()
{
   return "TMatrixTSparse<float>";
}

//______________________________________________________________________________
template <> const char *TMatrixTSparse<float>::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSparse<float>*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
template <> int TMatrixTSparse<float>::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSparse<float>*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
template <> void TMatrixTSparse<float>::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSparse<float>*)0x0)->GetClass();
}

//______________________________________________________________________________
template <> TClass *TMatrixTSparse<float>::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSparse<float>*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
template <> TClass *TMatrixTSparseRow_const<float>::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
template <> const char *TMatrixTSparseRow_const<float>::Class_Name()
{
   return "TMatrixTSparseRow_const<float>";
}

//______________________________________________________________________________
template <> const char *TMatrixTSparseRow_const<float>::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSparseRow_const<float>*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
template <> int TMatrixTSparseRow_const<float>::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSparseRow_const<float>*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
template <> void TMatrixTSparseRow_const<float>::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSparseRow_const<float>*)0x0)->GetClass();
}

//______________________________________________________________________________
template <> TClass *TMatrixTSparseRow_const<float>::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSparseRow_const<float>*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
template <> TClass *TMatrixTSparseRow<float>::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
template <> const char *TMatrixTSparseRow<float>::Class_Name()
{
   return "TMatrixTSparseRow<float>";
}

//______________________________________________________________________________
template <> const char *TMatrixTSparseRow<float>::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSparseRow<float>*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
template <> int TMatrixTSparseRow<float>::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSparseRow<float>*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
template <> void TMatrixTSparseRow<float>::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSparseRow<float>*)0x0)->GetClass();
}

//______________________________________________________________________________
template <> TClass *TMatrixTSparseRow<float>::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSparseRow<float>*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
template <> TClass *TMatrixTLazy<float>::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
template <> const char *TMatrixTLazy<float>::Class_Name()
{
   return "TMatrixTLazy<float>";
}

//______________________________________________________________________________
template <> const char *TMatrixTLazy<float>::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTLazy<float>*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
template <> int TMatrixTLazy<float>::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTLazy<float>*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
template <> void TMatrixTLazy<float>::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTLazy<float>*)0x0)->GetClass();
}

//______________________________________________________________________________
template <> TClass *TMatrixTLazy<float>::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTLazy<float>*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
template <> TClass *TMatrixTDiag_const<float>::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
template <> const char *TMatrixTDiag_const<float>::Class_Name()
{
   return "TMatrixTDiag_const<float>";
}

//______________________________________________________________________________
template <> const char *TMatrixTDiag_const<float>::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTDiag_const<float>*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
template <> int TMatrixTDiag_const<float>::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTDiag_const<float>*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
template <> void TMatrixTDiag_const<float>::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTDiag_const<float>*)0x0)->GetClass();
}

//______________________________________________________________________________
template <> TClass *TMatrixTDiag_const<float>::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTDiag_const<float>*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
template <> TClass *TMatrixTColumn_const<float>::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
template <> const char *TMatrixTColumn_const<float>::Class_Name()
{
   return "TMatrixTColumn_const<float>";
}

//______________________________________________________________________________
template <> const char *TMatrixTColumn_const<float>::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTColumn_const<float>*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
template <> int TMatrixTColumn_const<float>::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTColumn_const<float>*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
template <> void TMatrixTColumn_const<float>::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTColumn_const<float>*)0x0)->GetClass();
}

//______________________________________________________________________________
template <> TClass *TMatrixTColumn_const<float>::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTColumn_const<float>*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
template <> TClass *TMatrixTSparseDiag_const<float>::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
template <> const char *TMatrixTSparseDiag_const<float>::Class_Name()
{
   return "TMatrixTSparseDiag_const<float>";
}

//______________________________________________________________________________
template <> const char *TMatrixTSparseDiag_const<float>::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSparseDiag_const<float>*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
template <> int TMatrixTSparseDiag_const<float>::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSparseDiag_const<float>*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
template <> void TMatrixTSparseDiag_const<float>::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSparseDiag_const<float>*)0x0)->GetClass();
}

//______________________________________________________________________________
template <> TClass *TMatrixTSparseDiag_const<float>::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSparseDiag_const<float>*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
TClass *TDecompBase::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
const char *TDecompBase::Class_Name()
{
   return "TDecompBase";
}

//______________________________________________________________________________
const char *TDecompBase::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TDecompBase*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int TDecompBase::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TDecompBase*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void TDecompBase::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TDecompBase*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *TDecompBase::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TDecompBase*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
TClass *TDecompBK::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
const char *TDecompBK::Class_Name()
{
   return "TDecompBK";
}

//______________________________________________________________________________
const char *TDecompBK::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TDecompBK*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int TDecompBK::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TDecompBK*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void TDecompBK::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TDecompBK*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *TDecompBK::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TDecompBK*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
TClass *TDecompChol::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
const char *TDecompChol::Class_Name()
{
   return "TDecompChol";
}

//______________________________________________________________________________
const char *TDecompChol::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TDecompChol*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int TDecompChol::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TDecompChol*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void TDecompChol::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TDecompChol*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *TDecompChol::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TDecompChol*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
TClass *TDecompLU::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
const char *TDecompLU::Class_Name()
{
   return "TDecompLU";
}

//______________________________________________________________________________
const char *TDecompLU::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TDecompLU*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int TDecompLU::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TDecompLU*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void TDecompLU::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TDecompLU*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *TDecompLU::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TDecompLU*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
TClass *TDecompQRH::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
const char *TDecompQRH::Class_Name()
{
   return "TDecompQRH";
}

//______________________________________________________________________________
const char *TDecompQRH::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TDecompQRH*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int TDecompQRH::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TDecompQRH*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void TDecompQRH::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TDecompQRH*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *TDecompQRH::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TDecompQRH*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
TClass *TDecompSparse::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
const char *TDecompSparse::Class_Name()
{
   return "TDecompSparse";
}

//______________________________________________________________________________
const char *TDecompSparse::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TDecompSparse*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int TDecompSparse::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TDecompSparse*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void TDecompSparse::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TDecompSparse*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *TDecompSparse::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TDecompSparse*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
TClass *TDecompSVD::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
const char *TDecompSVD::Class_Name()
{
   return "TDecompSVD";
}

//______________________________________________________________________________
const char *TDecompSVD::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TDecompSVD*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int TDecompSVD::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TDecompSVD*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void TDecompSVD::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TDecompSVD*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *TDecompSVD::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TDecompSVD*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
TClass *TMatrixDEigen::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
const char *TMatrixDEigen::Class_Name()
{
   return "TMatrixDEigen";
}

//______________________________________________________________________________
const char *TMatrixDEigen::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMatrixDEigen*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int TMatrixDEigen::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMatrixDEigen*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void TMatrixDEigen::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixDEigen*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *TMatrixDEigen::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixDEigen*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
template <> TClass *THaarMatrixT<double>::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
template <> const char *THaarMatrixT<double>::Class_Name()
{
   return "THaarMatrixT<double>";
}

//______________________________________________________________________________
template <> const char *THaarMatrixT<double>::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::THaarMatrixT<double>*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
template <> int THaarMatrixT<double>::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::THaarMatrixT<double>*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
template <> void THaarMatrixT<double>::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::THaarMatrixT<double>*)0x0)->GetClass();
}

//______________________________________________________________________________
template <> TClass *THaarMatrixT<double>::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::THaarMatrixT<double>*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
template <> TClass *THilbertMatrixT<double>::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
template <> const char *THilbertMatrixT<double>::Class_Name()
{
   return "THilbertMatrixT<double>";
}

//______________________________________________________________________________
template <> const char *THilbertMatrixT<double>::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::THilbertMatrixT<double>*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
template <> int THilbertMatrixT<double>::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::THilbertMatrixT<double>*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
template <> void THilbertMatrixT<double>::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::THilbertMatrixT<double>*)0x0)->GetClass();
}

//______________________________________________________________________________
template <> TClass *THilbertMatrixT<double>::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::THilbertMatrixT<double>*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
template <> TClass *THilbertMatrixTSym<double>::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
template <> const char *THilbertMatrixTSym<double>::Class_Name()
{
   return "THilbertMatrixTSym<double>";
}

//______________________________________________________________________________
template <> const char *THilbertMatrixTSym<double>::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::THilbertMatrixTSym<double>*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
template <> int THilbertMatrixTSym<double>::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::THilbertMatrixTSym<double>*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
template <> void THilbertMatrixTSym<double>::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::THilbertMatrixTSym<double>*)0x0)->GetClass();
}

//______________________________________________________________________________
template <> TClass *THilbertMatrixTSym<double>::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::THilbertMatrixTSym<double>*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
TClass *TMatrixDSymEigen::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
const char *TMatrixDSymEigen::Class_Name()
{
   return "TMatrixDSymEigen";
}

//______________________________________________________________________________
const char *TMatrixDSymEigen::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMatrixDSymEigen*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int TMatrixDSymEigen::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMatrixDSymEigen*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void TMatrixDSymEigen::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixDSymEigen*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *TMatrixDSymEigen::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixDSymEigen*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
template <> TClass *TMatrixTFlat_const<float>::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
template <> const char *TMatrixTFlat_const<float>::Class_Name()
{
   return "TMatrixTFlat_const<float>";
}

//______________________________________________________________________________
template <> const char *TMatrixTFlat_const<float>::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTFlat_const<float>*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
template <> int TMatrixTFlat_const<float>::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTFlat_const<float>*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
template <> void TMatrixTFlat_const<float>::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTFlat_const<float>*)0x0)->GetClass();
}

//______________________________________________________________________________
template <> TClass *TMatrixTFlat_const<float>::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTFlat_const<float>*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
template <> TClass *TMatrixTSub_const<float>::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
template <> const char *TMatrixTSub_const<float>::Class_Name()
{
   return "TMatrixTSub_const<float>";
}

//______________________________________________________________________________
template <> const char *TMatrixTSub_const<float>::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSub_const<float>*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
template <> int TMatrixTSub_const<float>::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSub_const<float>*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
template <> void TMatrixTSub_const<float>::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSub_const<float>*)0x0)->GetClass();
}

//______________________________________________________________________________
template <> TClass *TMatrixTSub_const<float>::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSub_const<float>*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
template <> TClass *TMatrixTColumn<float>::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
template <> const char *TMatrixTColumn<float>::Class_Name()
{
   return "TMatrixTColumn<float>";
}

//______________________________________________________________________________
template <> const char *TMatrixTColumn<float>::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTColumn<float>*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
template <> int TMatrixTColumn<float>::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTColumn<float>*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
template <> void TMatrixTColumn<float>::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTColumn<float>*)0x0)->GetClass();
}

//______________________________________________________________________________
template <> TClass *TMatrixTColumn<float>::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTColumn<float>*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
template <> TClass *TMatrixTDiag<float>::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
template <> const char *TMatrixTDiag<float>::Class_Name()
{
   return "TMatrixTDiag<float>";
}

//______________________________________________________________________________
template <> const char *TMatrixTDiag<float>::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTDiag<float>*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
template <> int TMatrixTDiag<float>::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTDiag<float>*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
template <> void TMatrixTDiag<float>::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTDiag<float>*)0x0)->GetClass();
}

//______________________________________________________________________________
template <> TClass *TMatrixTDiag<float>::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTDiag<float>*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
template <> TClass *TMatrixTFlat<float>::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
template <> const char *TMatrixTFlat<float>::Class_Name()
{
   return "TMatrixTFlat<float>";
}

//______________________________________________________________________________
template <> const char *TMatrixTFlat<float>::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTFlat<float>*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
template <> int TMatrixTFlat<float>::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTFlat<float>*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
template <> void TMatrixTFlat<float>::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTFlat<float>*)0x0)->GetClass();
}

//______________________________________________________________________________
template <> TClass *TMatrixTFlat<float>::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTFlat<float>*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
template <> TClass *TMatrixTSub<float>::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
template <> const char *TMatrixTSub<float>::Class_Name()
{
   return "TMatrixTSub<float>";
}

//______________________________________________________________________________
template <> const char *TMatrixTSub<float>::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSub<float>*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
template <> int TMatrixTSub<float>::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSub<float>*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
template <> void TMatrixTSub<float>::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSub<float>*)0x0)->GetClass();
}

//______________________________________________________________________________
template <> TClass *TMatrixTSub<float>::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSub<float>*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
template <> TClass *TMatrixTSparseDiag<float>::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
template <> const char *TMatrixTSparseDiag<float>::Class_Name()
{
   return "TMatrixTSparseDiag<float>";
}

//______________________________________________________________________________
template <> const char *TMatrixTSparseDiag<float>::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSparseDiag<float>*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
template <> int TMatrixTSparseDiag<float>::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSparseDiag<float>*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
template <> void TMatrixTSparseDiag<float>::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSparseDiag<float>*)0x0)->GetClass();
}

//______________________________________________________________________________
template <> TClass *TMatrixTSparseDiag<float>::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSparseDiag<float>*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
template <> TClass *THaarMatrixT<float>::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
template <> const char *THaarMatrixT<float>::Class_Name()
{
   return "THaarMatrixT<float>";
}

//______________________________________________________________________________
template <> const char *THaarMatrixT<float>::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::THaarMatrixT<float>*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
template <> int THaarMatrixT<float>::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::THaarMatrixT<float>*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
template <> void THaarMatrixT<float>::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::THaarMatrixT<float>*)0x0)->GetClass();
}

//______________________________________________________________________________
template <> TClass *THaarMatrixT<float>::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::THaarMatrixT<float>*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
template <> TClass *THilbertMatrixT<float>::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
template <> const char *THilbertMatrixT<float>::Class_Name()
{
   return "THilbertMatrixT<float>";
}

//______________________________________________________________________________
template <> const char *THilbertMatrixT<float>::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::THilbertMatrixT<float>*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
template <> int THilbertMatrixT<float>::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::THilbertMatrixT<float>*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
template <> void THilbertMatrixT<float>::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::THilbertMatrixT<float>*)0x0)->GetClass();
}

//______________________________________________________________________________
template <> TClass *THilbertMatrixT<float>::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::THilbertMatrixT<float>*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
template <> TClass *THilbertMatrixTSym<float>::fgIsA = 0;  // static to hold class pointer

//______________________________________________________________________________
template <> const char *THilbertMatrixTSym<float>::Class_Name()
{
   return "THilbertMatrixTSym<float>";
}

//______________________________________________________________________________
template <> const char *THilbertMatrixTSym<float>::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::THilbertMatrixTSym<float>*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
template <> int THilbertMatrixTSym<float>::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::THilbertMatrixTSym<float>*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
template <> void THilbertMatrixTSym<float>::Dictionary()
{
   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::THilbertMatrixTSym<float>*)0x0)->GetClass();
}

//______________________________________________________________________________
template <> TClass *THilbertMatrixTSym<float>::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::THilbertMatrixTSym<float>*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
namespace ROOT {
   void TVectorTlEfloatgR_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class TVectorT<float>.
      typedef ::ROOT::Shadow::TVectorTlEfloatgR ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::TVectorT<float>*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNrows", &sobj->fNrows);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRowLwb", &sobj->fRowLwb);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fElements", &sobj->fElements);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDataStack[5]", sobj->fDataStack);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsOwner", &sobj->fIsOwner);
      sobj->TObject::ShowMembers(R__insp);
   }

}

template <> void TVectorT<float>::ShowMembers(TMemberInspector &R__insp)
{
   ::ROOT::TVectorTlEfloatgR_ShowMembers(this, R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TVectorTlEfloatgR(void *p) {
      return  p ? new(p) ::TVectorT<float> : new ::TVectorT<float>;
   }
   static void *newArray_TVectorTlEfloatgR(Long_t nElements, void *p) {
      return p ? new(p) ::TVectorT<float>[nElements] : new ::TVectorT<float>[nElements];
   }
   // Wrapper around operator delete
   static void delete_TVectorTlEfloatgR(void *p) {
      delete ((::TVectorT<float>*)p);
   }
   static void deleteArray_TVectorTlEfloatgR(void *p) {
      delete [] ((::TVectorT<float>*)p);
   }
   static void destruct_TVectorTlEfloatgR(void *p) {
      typedef ::TVectorT<float> current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TVectorTlEfloatgR(TBuffer &buf, void *obj) {
      ((::TVectorT<float>*)obj)->::TVectorT<float>::Streamer(buf);
   }
} // end of namespace ROOT for class ::TVectorT<float>

//______________________________________________________________________________
namespace ROOT {
   void TMatrixTBaselEfloatgR_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class TMatrixTBase<float>.
      typedef ::ROOT::Shadow::TMatrixTBaselEfloatgR ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTBase<float>*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNrows", &sobj->fNrows);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNcols", &sobj->fNcols);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRowLwb", &sobj->fRowLwb);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fColLwb", &sobj->fColLwb);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNelems", &sobj->fNelems);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNrowIndex", &sobj->fNrowIndex);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTol", &sobj->fTol);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsOwner", &sobj->fIsOwner);
      sobj->TObject::ShowMembers(R__insp);
   }

}

template <> void TMatrixTBase<float>::ShowMembers(TMemberInspector &R__insp)
{
   ::ROOT::TMatrixTBaselEfloatgR_ShowMembers(this, R__insp);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TMatrixTBaselEfloatgR(void *p) {
      delete ((::TMatrixTBase<float>*)p);
   }
   static void deleteArray_TMatrixTBaselEfloatgR(void *p) {
      delete [] ((::TMatrixTBase<float>*)p);
   }
   static void destruct_TMatrixTBaselEfloatgR(void *p) {
      typedef ::TMatrixTBase<float> current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TMatrixTBaselEfloatgR(TBuffer &buf, void *obj) {
      ((::TMatrixTBase<float>*)obj)->::TMatrixTBase<float>::Streamer(buf);
   }
} // end of namespace ROOT for class ::TMatrixTBase<float>

//______________________________________________________________________________
namespace ROOT {
   void TMatrixTlEfloatgR_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class TMatrixT<float>.
      typedef ::ROOT::Shadow::TMatrixTlEfloatgR ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixT<float>*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDataStack[25]", sobj->fDataStack);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fElements", &sobj->fElements);
      sobj->TMatrixTBase<float>::ShowMembers(R__insp);
   }

}

template <> void TMatrixT<float>::ShowMembers(TMemberInspector &R__insp)
{
   ::ROOT::TMatrixTlEfloatgR_ShowMembers(this, R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TMatrixTlEfloatgR(void *p) {
      return  p ? new(p) ::TMatrixT<float> : new ::TMatrixT<float>;
   }
   static void *newArray_TMatrixTlEfloatgR(Long_t nElements, void *p) {
      return p ? new(p) ::TMatrixT<float>[nElements] : new ::TMatrixT<float>[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMatrixTlEfloatgR(void *p) {
      delete ((::TMatrixT<float>*)p);
   }
   static void deleteArray_TMatrixTlEfloatgR(void *p) {
      delete [] ((::TMatrixT<float>*)p);
   }
   static void destruct_TMatrixTlEfloatgR(void *p) {
      typedef ::TMatrixT<float> current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TMatrixTlEfloatgR(TBuffer &buf, void *obj) {
      ((::TMatrixT<float>*)obj)->::TMatrixT<float>::Streamer(buf);
   }
} // end of namespace ROOT for class ::TMatrixT<float>

//______________________________________________________________________________
namespace ROOT {
   void TMatrixTSymlEfloatgR_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class TMatrixTSym<float>.
      typedef ::ROOT::Shadow::TMatrixTSymlEfloatgR ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSym<float>*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDataStack[25]", sobj->fDataStack);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fElements", &sobj->fElements);
      sobj->TMatrixTBase<float>::ShowMembers(R__insp);
   }

}

template <> void TMatrixTSym<float>::ShowMembers(TMemberInspector &R__insp)
{
   ::ROOT::TMatrixTSymlEfloatgR_ShowMembers(this, R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TMatrixTSymlEfloatgR(void *p) {
      return  p ? new(p) ::TMatrixTSym<float> : new ::TMatrixTSym<float>;
   }
   static void *newArray_TMatrixTSymlEfloatgR(Long_t nElements, void *p) {
      return p ? new(p) ::TMatrixTSym<float>[nElements] : new ::TMatrixTSym<float>[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMatrixTSymlEfloatgR(void *p) {
      delete ((::TMatrixTSym<float>*)p);
   }
   static void deleteArray_TMatrixTSymlEfloatgR(void *p) {
      delete [] ((::TMatrixTSym<float>*)p);
   }
   static void destruct_TMatrixTSymlEfloatgR(void *p) {
      typedef ::TMatrixTSym<float> current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TMatrixTSymlEfloatgR(TBuffer &buf, void *obj) {
      ((::TMatrixTSym<float>*)obj)->::TMatrixTSym<float>::Streamer(buf);
   }
} // end of namespace ROOT for class ::TMatrixTSym<float>

//______________________________________________________________________________
namespace ROOT {
   void TMatrixTSparselEfloatgR_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class TMatrixTSparse<float>.
      typedef ::ROOT::Shadow::TMatrixTSparselEfloatgR ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSparse<float>*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRowIndex", &sobj->fRowIndex);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fColIndex", &sobj->fColIndex);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fElements", &sobj->fElements);
      sobj->TMatrixTBase<float>::ShowMembers(R__insp);
   }

}

template <> void TMatrixTSparse<float>::ShowMembers(TMemberInspector &R__insp)
{
   ::ROOT::TMatrixTSparselEfloatgR_ShowMembers(this, R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TMatrixTSparselEfloatgR(void *p) {
      return  p ? new(p) ::TMatrixTSparse<float> : new ::TMatrixTSparse<float>;
   }
   static void *newArray_TMatrixTSparselEfloatgR(Long_t nElements, void *p) {
      return p ? new(p) ::TMatrixTSparse<float>[nElements] : new ::TMatrixTSparse<float>[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMatrixTSparselEfloatgR(void *p) {
      delete ((::TMatrixTSparse<float>*)p);
   }
   static void deleteArray_TMatrixTSparselEfloatgR(void *p) {
      delete [] ((::TMatrixTSparse<float>*)p);
   }
   static void destruct_TMatrixTSparselEfloatgR(void *p) {
      typedef ::TMatrixTSparse<float> current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TMatrixTSparselEfloatgR(TBuffer &buf, void *obj) {
      ((::TMatrixTSparse<float>*)obj)->::TMatrixTSparse<float>::Streamer(buf);
   }
} // end of namespace ROOT for class ::TMatrixTSparse<float>

//______________________________________________________________________________
template <> void TMatrixTLazy<float>::Streamer(TBuffer &R__b)
{
   // Stream an object of class TMatrixTLazy<float>.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TMatrixTLazy<float>::Class(),this);
   } else {
      R__b.WriteClassBuffer(TMatrixTLazy<float>::Class(),this);
   }
}

//______________________________________________________________________________
namespace ROOT {
   void TMatrixTLazylEfloatgR_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class TMatrixTLazy<float>.
      typedef ::ROOT::Shadow::TMatrixTLazylEfloatgR ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTLazy<float>*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRowUpb", &sobj->fRowUpb);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRowLwb", &sobj->fRowLwb);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fColUpb", &sobj->fColUpb);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fColLwb", &sobj->fColLwb);
      sobj->TObject::ShowMembers(R__insp);
   }

}

template <> void TMatrixTLazy<float>::ShowMembers(TMemberInspector &R__insp)
{
   ::ROOT::TMatrixTLazylEfloatgR_ShowMembers(this, R__insp);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TMatrixTLazylEfloatgR(void *p) {
      delete ((::TMatrixTLazy<float>*)p);
   }
   static void deleteArray_TMatrixTLazylEfloatgR(void *p) {
      delete [] ((::TMatrixTLazy<float>*)p);
   }
   static void destruct_TMatrixTLazylEfloatgR(void *p) {
      typedef ::TMatrixTLazy<float> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TMatrixTLazy<float>

//______________________________________________________________________________
template <> void TMatrixTSymLazy<float>::Streamer(TBuffer &R__b)
{
   // Stream an object of class TMatrixTSymLazy<float>.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TMatrixTSymLazy<float>::Class(),this);
   } else {
      R__b.WriteClassBuffer(TMatrixTSymLazy<float>::Class(),this);
   }
}

//______________________________________________________________________________
namespace ROOT {
   void TMatrixTSymLazylEfloatgR_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class TMatrixTSymLazy<float>.
      typedef ::ROOT::Shadow::TMatrixTSymLazylEfloatgR ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSymLazy<float>*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRowUpb", &sobj->fRowUpb);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRowLwb", &sobj->fRowLwb);
      sobj->TObject::ShowMembers(R__insp);
   }

}

template <> void TMatrixTSymLazy<float>::ShowMembers(TMemberInspector &R__insp)
{
   ::ROOT::TMatrixTSymLazylEfloatgR_ShowMembers(this, R__insp);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TMatrixTSymLazylEfloatgR(void *p) {
      delete ((::TMatrixTSymLazy<float>*)p);
   }
   static void deleteArray_TMatrixTSymLazylEfloatgR(void *p) {
      delete [] ((::TMatrixTSymLazy<float>*)p);
   }
   static void destruct_TMatrixTSymLazylEfloatgR(void *p) {
      typedef ::TMatrixTSymLazy<float> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TMatrixTSymLazy<float>

//______________________________________________________________________________
template <> void THaarMatrixT<float>::Streamer(TBuffer &R__b)
{
   // Stream an object of class THaarMatrixT<float>.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(THaarMatrixT<float>::Class(),this);
   } else {
      R__b.WriteClassBuffer(THaarMatrixT<float>::Class(),this);
   }
}

//______________________________________________________________________________
namespace ROOT {
   void THaarMatrixTlEfloatgR_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class THaarMatrixT<float>.
      typedef ::ROOT::Shadow::THaarMatrixTlEfloatgR ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::THaarMatrixT<float>*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      sobj->TMatrixTLazy<float>::ShowMembers(R__insp);
   }

}

template <> void THaarMatrixT<float>::ShowMembers(TMemberInspector &R__insp)
{
   ::ROOT::THaarMatrixTlEfloatgR_ShowMembers(this, R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_THaarMatrixTlEfloatgR(void *p) {
      return  p ? new(p) ::THaarMatrixT<float> : new ::THaarMatrixT<float>;
   }
   static void *newArray_THaarMatrixTlEfloatgR(Long_t nElements, void *p) {
      return p ? new(p) ::THaarMatrixT<float>[nElements] : new ::THaarMatrixT<float>[nElements];
   }
   // Wrapper around operator delete
   static void delete_THaarMatrixTlEfloatgR(void *p) {
      delete ((::THaarMatrixT<float>*)p);
   }
   static void deleteArray_THaarMatrixTlEfloatgR(void *p) {
      delete [] ((::THaarMatrixT<float>*)p);
   }
   static void destruct_THaarMatrixTlEfloatgR(void *p) {
      typedef ::THaarMatrixT<float> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::THaarMatrixT<float>

//______________________________________________________________________________
template <> void THilbertMatrixT<float>::Streamer(TBuffer &R__b)
{
   // Stream an object of class THilbertMatrixT<float>.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(THilbertMatrixT<float>::Class(),this);
   } else {
      R__b.WriteClassBuffer(THilbertMatrixT<float>::Class(),this);
   }
}

//______________________________________________________________________________
namespace ROOT {
   void THilbertMatrixTlEfloatgR_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class THilbertMatrixT<float>.
      typedef ::ROOT::Shadow::THilbertMatrixTlEfloatgR ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::THilbertMatrixT<float>*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      sobj->TMatrixTLazy<float>::ShowMembers(R__insp);
   }

}

template <> void THilbertMatrixT<float>::ShowMembers(TMemberInspector &R__insp)
{
   ::ROOT::THilbertMatrixTlEfloatgR_ShowMembers(this, R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_THilbertMatrixTlEfloatgR(void *p) {
      return  p ? new(p) ::THilbertMatrixT<float> : new ::THilbertMatrixT<float>;
   }
   static void *newArray_THilbertMatrixTlEfloatgR(Long_t nElements, void *p) {
      return p ? new(p) ::THilbertMatrixT<float>[nElements] : new ::THilbertMatrixT<float>[nElements];
   }
   // Wrapper around operator delete
   static void delete_THilbertMatrixTlEfloatgR(void *p) {
      delete ((::THilbertMatrixT<float>*)p);
   }
   static void deleteArray_THilbertMatrixTlEfloatgR(void *p) {
      delete [] ((::THilbertMatrixT<float>*)p);
   }
   static void destruct_THilbertMatrixTlEfloatgR(void *p) {
      typedef ::THilbertMatrixT<float> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::THilbertMatrixT<float>

//______________________________________________________________________________
template <> void THilbertMatrixTSym<float>::Streamer(TBuffer &R__b)
{
   // Stream an object of class THilbertMatrixTSym<float>.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(THilbertMatrixTSym<float>::Class(),this);
   } else {
      R__b.WriteClassBuffer(THilbertMatrixTSym<float>::Class(),this);
   }
}

//______________________________________________________________________________
namespace ROOT {
   void THilbertMatrixTSymlEfloatgR_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class THilbertMatrixTSym<float>.
      typedef ::ROOT::Shadow::THilbertMatrixTSymlEfloatgR ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::THilbertMatrixTSym<float>*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      sobj->TMatrixTSymLazy<float>::ShowMembers(R__insp);
   }

}

template <> void THilbertMatrixTSym<float>::ShowMembers(TMemberInspector &R__insp)
{
   ::ROOT::THilbertMatrixTSymlEfloatgR_ShowMembers(this, R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_THilbertMatrixTSymlEfloatgR(void *p) {
      return  p ? new(p) ::THilbertMatrixTSym<float> : new ::THilbertMatrixTSym<float>;
   }
   static void *newArray_THilbertMatrixTSymlEfloatgR(Long_t nElements, void *p) {
      return p ? new(p) ::THilbertMatrixTSym<float>[nElements] : new ::THilbertMatrixTSym<float>[nElements];
   }
   // Wrapper around operator delete
   static void delete_THilbertMatrixTSymlEfloatgR(void *p) {
      delete ((::THilbertMatrixTSym<float>*)p);
   }
   static void deleteArray_THilbertMatrixTSymlEfloatgR(void *p) {
      delete [] ((::THilbertMatrixTSym<float>*)p);
   }
   static void destruct_THilbertMatrixTSymlEfloatgR(void *p) {
      typedef ::THilbertMatrixTSym<float> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::THilbertMatrixTSym<float>

//______________________________________________________________________________
template <> void TMatrixTRow_const<float>::Streamer(TBuffer &R__b)
{
   // Stream an object of class TMatrixTRow_const<float>.

   ::Error("TMatrixTRow_const<float>::Streamer", "version id <=0 in ClassDef, dummy Streamer() called"); if (R__b.IsReading()) { }
}

//______________________________________________________________________________
namespace ROOT {
   void TMatrixTRow_constlEfloatgR_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class TMatrixTRow_const<float>.
      typedef ::ROOT::Shadow::TMatrixTRow_constlEfloatgR ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTRow_const<float>*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMatrix", &sobj->fMatrix);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRowInd", &sobj->fRowInd);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fInc", &sobj->fInc);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPtr", &sobj->fPtr);
   }

}

template <> void TMatrixTRow_const<float>::ShowMembers(TMemberInspector &R__insp)
{
   ::ROOT::TMatrixTRow_constlEfloatgR_ShowMembers(this, R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TMatrixTRow_constlEfloatgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMatrixTRow_const<float> : new ::TMatrixTRow_const<float>;
   }
   static void *newArray_TMatrixTRow_constlEfloatgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMatrixTRow_const<float>[nElements] : new ::TMatrixTRow_const<float>[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMatrixTRow_constlEfloatgR(void *p) {
      delete ((::TMatrixTRow_const<float>*)p);
   }
   static void deleteArray_TMatrixTRow_constlEfloatgR(void *p) {
      delete [] ((::TMatrixTRow_const<float>*)p);
   }
   static void destruct_TMatrixTRow_constlEfloatgR(void *p) {
      typedef ::TMatrixTRow_const<float> current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TMatrixTRow_constlEfloatgR(TBuffer &buf, void *obj) {
      ((::TMatrixTRow_const<float>*)obj)->::TMatrixTRow_const<float>::Streamer(buf);
   }
} // end of namespace ROOT for class ::TMatrixTRow_const<float>

//______________________________________________________________________________
template <> void TMatrixTColumn_const<float>::Streamer(TBuffer &R__b)
{
   // Stream an object of class TMatrixTColumn_const<float>.

   ::Error("TMatrixTColumn_const<float>::Streamer", "version id <=0 in ClassDef, dummy Streamer() called"); if (R__b.IsReading()) { }
}

//______________________________________________________________________________
namespace ROOT {
   void TMatrixTColumn_constlEfloatgR_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class TMatrixTColumn_const<float>.
      typedef ::ROOT::Shadow::TMatrixTColumn_constlEfloatgR ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTColumn_const<float>*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMatrix", &sobj->fMatrix);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fColInd", &sobj->fColInd);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fInc", &sobj->fInc);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPtr", &sobj->fPtr);
   }

}

template <> void TMatrixTColumn_const<float>::ShowMembers(TMemberInspector &R__insp)
{
   ::ROOT::TMatrixTColumn_constlEfloatgR_ShowMembers(this, R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TMatrixTColumn_constlEfloatgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMatrixTColumn_const<float> : new ::TMatrixTColumn_const<float>;
   }
   static void *newArray_TMatrixTColumn_constlEfloatgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMatrixTColumn_const<float>[nElements] : new ::TMatrixTColumn_const<float>[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMatrixTColumn_constlEfloatgR(void *p) {
      delete ((::TMatrixTColumn_const<float>*)p);
   }
   static void deleteArray_TMatrixTColumn_constlEfloatgR(void *p) {
      delete [] ((::TMatrixTColumn_const<float>*)p);
   }
   static void destruct_TMatrixTColumn_constlEfloatgR(void *p) {
      typedef ::TMatrixTColumn_const<float> current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TMatrixTColumn_constlEfloatgR(TBuffer &buf, void *obj) {
      ((::TMatrixTColumn_const<float>*)obj)->::TMatrixTColumn_const<float>::Streamer(buf);
   }
} // end of namespace ROOT for class ::TMatrixTColumn_const<float>

//______________________________________________________________________________
template <> void TMatrixTDiag_const<float>::Streamer(TBuffer &R__b)
{
   // Stream an object of class TMatrixTDiag_const<float>.

   ::Error("TMatrixTDiag_const<float>::Streamer", "version id <=0 in ClassDef, dummy Streamer() called"); if (R__b.IsReading()) { }
}

//______________________________________________________________________________
namespace ROOT {
   void TMatrixTDiag_constlEfloatgR_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class TMatrixTDiag_const<float>.
      typedef ::ROOT::Shadow::TMatrixTDiag_constlEfloatgR ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTDiag_const<float>*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMatrix", &sobj->fMatrix);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fInc", &sobj->fInc);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNdiag", &sobj->fNdiag);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPtr", &sobj->fPtr);
   }

}

template <> void TMatrixTDiag_const<float>::ShowMembers(TMemberInspector &R__insp)
{
   ::ROOT::TMatrixTDiag_constlEfloatgR_ShowMembers(this, R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TMatrixTDiag_constlEfloatgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMatrixTDiag_const<float> : new ::TMatrixTDiag_const<float>;
   }
   static void *newArray_TMatrixTDiag_constlEfloatgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMatrixTDiag_const<float>[nElements] : new ::TMatrixTDiag_const<float>[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMatrixTDiag_constlEfloatgR(void *p) {
      delete ((::TMatrixTDiag_const<float>*)p);
   }
   static void deleteArray_TMatrixTDiag_constlEfloatgR(void *p) {
      delete [] ((::TMatrixTDiag_const<float>*)p);
   }
   static void destruct_TMatrixTDiag_constlEfloatgR(void *p) {
      typedef ::TMatrixTDiag_const<float> current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TMatrixTDiag_constlEfloatgR(TBuffer &buf, void *obj) {
      ((::TMatrixTDiag_const<float>*)obj)->::TMatrixTDiag_const<float>::Streamer(buf);
   }
} // end of namespace ROOT for class ::TMatrixTDiag_const<float>

//______________________________________________________________________________
template <> void TMatrixTFlat_const<float>::Streamer(TBuffer &R__b)
{
   // Stream an object of class TMatrixTFlat_const<float>.

   ::Error("TMatrixTFlat_const<float>::Streamer", "version id <=0 in ClassDef, dummy Streamer() called"); if (R__b.IsReading()) { }
}

//______________________________________________________________________________
namespace ROOT {
   void TMatrixTFlat_constlEfloatgR_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class TMatrixTFlat_const<float>.
      typedef ::ROOT::Shadow::TMatrixTFlat_constlEfloatgR ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTFlat_const<float>*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMatrix", &sobj->fMatrix);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNelems", &sobj->fNelems);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPtr", &sobj->fPtr);
   }

}

template <> void TMatrixTFlat_const<float>::ShowMembers(TMemberInspector &R__insp)
{
   ::ROOT::TMatrixTFlat_constlEfloatgR_ShowMembers(this, R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TMatrixTFlat_constlEfloatgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMatrixTFlat_const<float> : new ::TMatrixTFlat_const<float>;
   }
   static void *newArray_TMatrixTFlat_constlEfloatgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMatrixTFlat_const<float>[nElements] : new ::TMatrixTFlat_const<float>[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMatrixTFlat_constlEfloatgR(void *p) {
      delete ((::TMatrixTFlat_const<float>*)p);
   }
   static void deleteArray_TMatrixTFlat_constlEfloatgR(void *p) {
      delete [] ((::TMatrixTFlat_const<float>*)p);
   }
   static void destruct_TMatrixTFlat_constlEfloatgR(void *p) {
      typedef ::TMatrixTFlat_const<float> current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TMatrixTFlat_constlEfloatgR(TBuffer &buf, void *obj) {
      ((::TMatrixTFlat_const<float>*)obj)->::TMatrixTFlat_const<float>::Streamer(buf);
   }
} // end of namespace ROOT for class ::TMatrixTFlat_const<float>

//______________________________________________________________________________
template <> void TMatrixTSub_const<float>::Streamer(TBuffer &R__b)
{
   // Stream an object of class TMatrixTSub_const<float>.

   ::Error("TMatrixTSub_const<float>::Streamer", "version id <=0 in ClassDef, dummy Streamer() called"); if (R__b.IsReading()) { }
}

//______________________________________________________________________________
namespace ROOT {
   void TMatrixTSub_constlEfloatgR_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class TMatrixTSub_const<float>.
      typedef ::ROOT::Shadow::TMatrixTSub_constlEfloatgR ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSub_const<float>*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMatrix", &sobj->fMatrix);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRowOff", &sobj->fRowOff);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fColOff", &sobj->fColOff);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNrowsSub", &sobj->fNrowsSub);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNcolsSub", &sobj->fNcolsSub);
   }

}

template <> void TMatrixTSub_const<float>::ShowMembers(TMemberInspector &R__insp)
{
   ::ROOT::TMatrixTSub_constlEfloatgR_ShowMembers(this, R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TMatrixTSub_constlEfloatgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMatrixTSub_const<float> : new ::TMatrixTSub_const<float>;
   }
   static void *newArray_TMatrixTSub_constlEfloatgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMatrixTSub_const<float>[nElements] : new ::TMatrixTSub_const<float>[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMatrixTSub_constlEfloatgR(void *p) {
      delete ((::TMatrixTSub_const<float>*)p);
   }
   static void deleteArray_TMatrixTSub_constlEfloatgR(void *p) {
      delete [] ((::TMatrixTSub_const<float>*)p);
   }
   static void destruct_TMatrixTSub_constlEfloatgR(void *p) {
      typedef ::TMatrixTSub_const<float> current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TMatrixTSub_constlEfloatgR(TBuffer &buf, void *obj) {
      ((::TMatrixTSub_const<float>*)obj)->::TMatrixTSub_const<float>::Streamer(buf);
   }
} // end of namespace ROOT for class ::TMatrixTSub_const<float>

//______________________________________________________________________________
template <> void TMatrixTRow<float>::Streamer(TBuffer &R__b)
{
   // Stream an object of class TMatrixTRow<float>.

   TMatrixTRow_const<float>::Streamer(R__b);
}

//______________________________________________________________________________
namespace ROOT {
   void TMatrixTRowlEfloatgR_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class TMatrixTRow<float>.
      typedef ::ROOT::Shadow::TMatrixTRowlEfloatgR ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTRow<float>*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      sobj->TMatrixTRow_const<float>::ShowMembers(R__insp);
   }

}

template <> void TMatrixTRow<float>::ShowMembers(TMemberInspector &R__insp)
{
   ::ROOT::TMatrixTRowlEfloatgR_ShowMembers(this, R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TMatrixTRowlEfloatgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMatrixTRow<float> : new ::TMatrixTRow<float>;
   }
   static void *newArray_TMatrixTRowlEfloatgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMatrixTRow<float>[nElements] : new ::TMatrixTRow<float>[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMatrixTRowlEfloatgR(void *p) {
      delete ((::TMatrixTRow<float>*)p);
   }
   static void deleteArray_TMatrixTRowlEfloatgR(void *p) {
      delete [] ((::TMatrixTRow<float>*)p);
   }
   static void destruct_TMatrixTRowlEfloatgR(void *p) {
      typedef ::TMatrixTRow<float> current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TMatrixTRowlEfloatgR(TBuffer &buf, void *obj) {
      ((::TMatrixTRow<float>*)obj)->::TMatrixTRow<float>::Streamer(buf);
   }
} // end of namespace ROOT for class ::TMatrixTRow<float>

//______________________________________________________________________________
template <> void TMatrixTColumn<float>::Streamer(TBuffer &R__b)
{
   // Stream an object of class TMatrixTColumn<float>.

   TMatrixTColumn_const<float>::Streamer(R__b);
}

//______________________________________________________________________________
namespace ROOT {
   void TMatrixTColumnlEfloatgR_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class TMatrixTColumn<float>.
      typedef ::ROOT::Shadow::TMatrixTColumnlEfloatgR ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTColumn<float>*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      sobj->TMatrixTColumn_const<float>::ShowMembers(R__insp);
   }

}

template <> void TMatrixTColumn<float>::ShowMembers(TMemberInspector &R__insp)
{
   ::ROOT::TMatrixTColumnlEfloatgR_ShowMembers(this, R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TMatrixTColumnlEfloatgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMatrixTColumn<float> : new ::TMatrixTColumn<float>;
   }
   static void *newArray_TMatrixTColumnlEfloatgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMatrixTColumn<float>[nElements] : new ::TMatrixTColumn<float>[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMatrixTColumnlEfloatgR(void *p) {
      delete ((::TMatrixTColumn<float>*)p);
   }
   static void deleteArray_TMatrixTColumnlEfloatgR(void *p) {
      delete [] ((::TMatrixTColumn<float>*)p);
   }
   static void destruct_TMatrixTColumnlEfloatgR(void *p) {
      typedef ::TMatrixTColumn<float> current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TMatrixTColumnlEfloatgR(TBuffer &buf, void *obj) {
      ((::TMatrixTColumn<float>*)obj)->::TMatrixTColumn<float>::Streamer(buf);
   }
} // end of namespace ROOT for class ::TMatrixTColumn<float>

//______________________________________________________________________________
template <> void TMatrixTDiag<float>::Streamer(TBuffer &R__b)
{
   // Stream an object of class TMatrixTDiag<float>.

   TMatrixTDiag_const<float>::Streamer(R__b);
}

//______________________________________________________________________________
namespace ROOT {
   void TMatrixTDiaglEfloatgR_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class TMatrixTDiag<float>.
      typedef ::ROOT::Shadow::TMatrixTDiaglEfloatgR ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTDiag<float>*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      sobj->TMatrixTDiag_const<float>::ShowMembers(R__insp);
   }

}

template <> void TMatrixTDiag<float>::ShowMembers(TMemberInspector &R__insp)
{
   ::ROOT::TMatrixTDiaglEfloatgR_ShowMembers(this, R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TMatrixTDiaglEfloatgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMatrixTDiag<float> : new ::TMatrixTDiag<float>;
   }
   static void *newArray_TMatrixTDiaglEfloatgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMatrixTDiag<float>[nElements] : new ::TMatrixTDiag<float>[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMatrixTDiaglEfloatgR(void *p) {
      delete ((::TMatrixTDiag<float>*)p);
   }
   static void deleteArray_TMatrixTDiaglEfloatgR(void *p) {
      delete [] ((::TMatrixTDiag<float>*)p);
   }
   static void destruct_TMatrixTDiaglEfloatgR(void *p) {
      typedef ::TMatrixTDiag<float> current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TMatrixTDiaglEfloatgR(TBuffer &buf, void *obj) {
      ((::TMatrixTDiag<float>*)obj)->::TMatrixTDiag<float>::Streamer(buf);
   }
} // end of namespace ROOT for class ::TMatrixTDiag<float>

//______________________________________________________________________________
template <> void TMatrixTFlat<float>::Streamer(TBuffer &R__b)
{
   // Stream an object of class TMatrixTFlat<float>.

   TMatrixTFlat_const<float>::Streamer(R__b);
}

//______________________________________________________________________________
namespace ROOT {
   void TMatrixTFlatlEfloatgR_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class TMatrixTFlat<float>.
      typedef ::ROOT::Shadow::TMatrixTFlatlEfloatgR ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTFlat<float>*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      sobj->TMatrixTFlat_const<float>::ShowMembers(R__insp);
   }

}

template <> void TMatrixTFlat<float>::ShowMembers(TMemberInspector &R__insp)
{
   ::ROOT::TMatrixTFlatlEfloatgR_ShowMembers(this, R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TMatrixTFlatlEfloatgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMatrixTFlat<float> : new ::TMatrixTFlat<float>;
   }
   static void *newArray_TMatrixTFlatlEfloatgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMatrixTFlat<float>[nElements] : new ::TMatrixTFlat<float>[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMatrixTFlatlEfloatgR(void *p) {
      delete ((::TMatrixTFlat<float>*)p);
   }
   static void deleteArray_TMatrixTFlatlEfloatgR(void *p) {
      delete [] ((::TMatrixTFlat<float>*)p);
   }
   static void destruct_TMatrixTFlatlEfloatgR(void *p) {
      typedef ::TMatrixTFlat<float> current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TMatrixTFlatlEfloatgR(TBuffer &buf, void *obj) {
      ((::TMatrixTFlat<float>*)obj)->::TMatrixTFlat<float>::Streamer(buf);
   }
} // end of namespace ROOT for class ::TMatrixTFlat<float>

//______________________________________________________________________________
template <> void TMatrixTSub<float>::Streamer(TBuffer &R__b)
{
   // Stream an object of class TMatrixTSub<float>.

   TMatrixTSub_const<float>::Streamer(R__b);
}

//______________________________________________________________________________
namespace ROOT {
   void TMatrixTSublEfloatgR_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class TMatrixTSub<float>.
      typedef ::ROOT::Shadow::TMatrixTSublEfloatgR ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSub<float>*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      sobj->TMatrixTSub_const<float>::ShowMembers(R__insp);
   }

}

template <> void TMatrixTSub<float>::ShowMembers(TMemberInspector &R__insp)
{
   ::ROOT::TMatrixTSublEfloatgR_ShowMembers(this, R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TMatrixTSublEfloatgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMatrixTSub<float> : new ::TMatrixTSub<float>;
   }
   static void *newArray_TMatrixTSublEfloatgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMatrixTSub<float>[nElements] : new ::TMatrixTSub<float>[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMatrixTSublEfloatgR(void *p) {
      delete ((::TMatrixTSub<float>*)p);
   }
   static void deleteArray_TMatrixTSublEfloatgR(void *p) {
      delete [] ((::TMatrixTSub<float>*)p);
   }
   static void destruct_TMatrixTSublEfloatgR(void *p) {
      typedef ::TMatrixTSub<float> current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TMatrixTSublEfloatgR(TBuffer &buf, void *obj) {
      ((::TMatrixTSub<float>*)obj)->::TMatrixTSub<float>::Streamer(buf);
   }
} // end of namespace ROOT for class ::TMatrixTSub<float>

//______________________________________________________________________________
template <> void TMatrixTSparseRow_const<float>::Streamer(TBuffer &R__b)
{
   // Stream an object of class TMatrixTSparseRow_const<float>.

   ::Error("TMatrixTSparseRow_const<float>::Streamer", "version id <=0 in ClassDef, dummy Streamer() called"); if (R__b.IsReading()) { }
}

//______________________________________________________________________________
namespace ROOT {
   void TMatrixTSparseRow_constlEfloatgR_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class TMatrixTSparseRow_const<float>.
      typedef ::ROOT::Shadow::TMatrixTSparseRow_constlEfloatgR ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSparseRow_const<float>*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMatrix", &sobj->fMatrix);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRowInd", &sobj->fRowInd);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNindex", &sobj->fNindex);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fColPtr", &sobj->fColPtr);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDataPtr", &sobj->fDataPtr);
   }

}

template <> void TMatrixTSparseRow_const<float>::ShowMembers(TMemberInspector &R__insp)
{
   ::ROOT::TMatrixTSparseRow_constlEfloatgR_ShowMembers(this, R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TMatrixTSparseRow_constlEfloatgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMatrixTSparseRow_const<float> : new ::TMatrixTSparseRow_const<float>;
   }
   static void *newArray_TMatrixTSparseRow_constlEfloatgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMatrixTSparseRow_const<float>[nElements] : new ::TMatrixTSparseRow_const<float>[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMatrixTSparseRow_constlEfloatgR(void *p) {
      delete ((::TMatrixTSparseRow_const<float>*)p);
   }
   static void deleteArray_TMatrixTSparseRow_constlEfloatgR(void *p) {
      delete [] ((::TMatrixTSparseRow_const<float>*)p);
   }
   static void destruct_TMatrixTSparseRow_constlEfloatgR(void *p) {
      typedef ::TMatrixTSparseRow_const<float> current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TMatrixTSparseRow_constlEfloatgR(TBuffer &buf, void *obj) {
      ((::TMatrixTSparseRow_const<float>*)obj)->::TMatrixTSparseRow_const<float>::Streamer(buf);
   }
} // end of namespace ROOT for class ::TMatrixTSparseRow_const<float>

//______________________________________________________________________________
template <> void TMatrixTSparseRow<float>::Streamer(TBuffer &R__b)
{
   // Stream an object of class TMatrixTSparseRow<float>.

   TMatrixTSparseRow_const<float>::Streamer(R__b);
}

//______________________________________________________________________________
namespace ROOT {
   void TMatrixTSparseRowlEfloatgR_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class TMatrixTSparseRow<float>.
      typedef ::ROOT::Shadow::TMatrixTSparseRowlEfloatgR ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSparseRow<float>*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      sobj->TMatrixTSparseRow_const<float>::ShowMembers(R__insp);
   }

}

template <> void TMatrixTSparseRow<float>::ShowMembers(TMemberInspector &R__insp)
{
   ::ROOT::TMatrixTSparseRowlEfloatgR_ShowMembers(this, R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TMatrixTSparseRowlEfloatgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMatrixTSparseRow<float> : new ::TMatrixTSparseRow<float>;
   }
   static void *newArray_TMatrixTSparseRowlEfloatgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMatrixTSparseRow<float>[nElements] : new ::TMatrixTSparseRow<float>[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMatrixTSparseRowlEfloatgR(void *p) {
      delete ((::TMatrixTSparseRow<float>*)p);
   }
   static void deleteArray_TMatrixTSparseRowlEfloatgR(void *p) {
      delete [] ((::TMatrixTSparseRow<float>*)p);
   }
   static void destruct_TMatrixTSparseRowlEfloatgR(void *p) {
      typedef ::TMatrixTSparseRow<float> current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TMatrixTSparseRowlEfloatgR(TBuffer &buf, void *obj) {
      ((::TMatrixTSparseRow<float>*)obj)->::TMatrixTSparseRow<float>::Streamer(buf);
   }
} // end of namespace ROOT for class ::TMatrixTSparseRow<float>

//______________________________________________________________________________
template <> void TMatrixTSparseDiag_const<float>::Streamer(TBuffer &R__b)
{
   // Stream an object of class TMatrixTSparseDiag_const<float>.

   ::Error("TMatrixTSparseDiag_const<float>::Streamer", "version id <=0 in ClassDef, dummy Streamer() called"); if (R__b.IsReading()) { }
}

//______________________________________________________________________________
namespace ROOT {
   void TMatrixTSparseDiag_constlEfloatgR_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class TMatrixTSparseDiag_const<float>.
      typedef ::ROOT::Shadow::TMatrixTSparseDiag_constlEfloatgR ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSparseDiag_const<float>*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMatrix", &sobj->fMatrix);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNdiag", &sobj->fNdiag);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDataPtr", &sobj->fDataPtr);
   }

}

template <> void TMatrixTSparseDiag_const<float>::ShowMembers(TMemberInspector &R__insp)
{
   ::ROOT::TMatrixTSparseDiag_constlEfloatgR_ShowMembers(this, R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TMatrixTSparseDiag_constlEfloatgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMatrixTSparseDiag_const<float> : new ::TMatrixTSparseDiag_const<float>;
   }
   static void *newArray_TMatrixTSparseDiag_constlEfloatgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMatrixTSparseDiag_const<float>[nElements] : new ::TMatrixTSparseDiag_const<float>[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMatrixTSparseDiag_constlEfloatgR(void *p) {
      delete ((::TMatrixTSparseDiag_const<float>*)p);
   }
   static void deleteArray_TMatrixTSparseDiag_constlEfloatgR(void *p) {
      delete [] ((::TMatrixTSparseDiag_const<float>*)p);
   }
   static void destruct_TMatrixTSparseDiag_constlEfloatgR(void *p) {
      typedef ::TMatrixTSparseDiag_const<float> current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TMatrixTSparseDiag_constlEfloatgR(TBuffer &buf, void *obj) {
      ((::TMatrixTSparseDiag_const<float>*)obj)->::TMatrixTSparseDiag_const<float>::Streamer(buf);
   }
} // end of namespace ROOT for class ::TMatrixTSparseDiag_const<float>

//______________________________________________________________________________
template <> void TMatrixTSparseDiag<float>::Streamer(TBuffer &R__b)
{
   // Stream an object of class TMatrixTSparseDiag<float>.

   TMatrixTSparseDiag_const<float>::Streamer(R__b);
}

//______________________________________________________________________________
namespace ROOT {
   void TMatrixTSparseDiaglEfloatgR_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class TMatrixTSparseDiag<float>.
      typedef ::ROOT::Shadow::TMatrixTSparseDiaglEfloatgR ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSparseDiag<float>*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      sobj->TMatrixTSparseDiag_const<float>::ShowMembers(R__insp);
   }

}

template <> void TMatrixTSparseDiag<float>::ShowMembers(TMemberInspector &R__insp)
{
   ::ROOT::TMatrixTSparseDiaglEfloatgR_ShowMembers(this, R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TMatrixTSparseDiaglEfloatgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMatrixTSparseDiag<float> : new ::TMatrixTSparseDiag<float>;
   }
   static void *newArray_TMatrixTSparseDiaglEfloatgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMatrixTSparseDiag<float>[nElements] : new ::TMatrixTSparseDiag<float>[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMatrixTSparseDiaglEfloatgR(void *p) {
      delete ((::TMatrixTSparseDiag<float>*)p);
   }
   static void deleteArray_TMatrixTSparseDiaglEfloatgR(void *p) {
      delete [] ((::TMatrixTSparseDiag<float>*)p);
   }
   static void destruct_TMatrixTSparseDiaglEfloatgR(void *p) {
      typedef ::TMatrixTSparseDiag<float> current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TMatrixTSparseDiaglEfloatgR(TBuffer &buf, void *obj) {
      ((::TMatrixTSparseDiag<float>*)obj)->::TMatrixTSparseDiag<float>::Streamer(buf);
   }
} // end of namespace ROOT for class ::TMatrixTSparseDiag<float>

//______________________________________________________________________________
namespace ROOT {
   void TVectorTlEdoublegR_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class TVectorT<double>.
      typedef ::ROOT::Shadow::TVectorTlEdoublegR ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::TVectorT<double>*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNrows", &sobj->fNrows);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRowLwb", &sobj->fRowLwb);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fElements", &sobj->fElements);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDataStack[5]", sobj->fDataStack);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsOwner", &sobj->fIsOwner);
      sobj->TObject::ShowMembers(R__insp);
   }

}

template <> void TVectorT<double>::ShowMembers(TMemberInspector &R__insp)
{
   ::ROOT::TVectorTlEdoublegR_ShowMembers(this, R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TVectorTlEdoublegR(void *p) {
      return  p ? new(p) ::TVectorT<double> : new ::TVectorT<double>;
   }
   static void *newArray_TVectorTlEdoublegR(Long_t nElements, void *p) {
      return p ? new(p) ::TVectorT<double>[nElements] : new ::TVectorT<double>[nElements];
   }
   // Wrapper around operator delete
   static void delete_TVectorTlEdoublegR(void *p) {
      delete ((::TVectorT<double>*)p);
   }
   static void deleteArray_TVectorTlEdoublegR(void *p) {
      delete [] ((::TVectorT<double>*)p);
   }
   static void destruct_TVectorTlEdoublegR(void *p) {
      typedef ::TVectorT<double> current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TVectorTlEdoublegR(TBuffer &buf, void *obj) {
      ((::TVectorT<double>*)obj)->::TVectorT<double>::Streamer(buf);
   }
} // end of namespace ROOT for class ::TVectorT<double>

//______________________________________________________________________________
namespace ROOT {
   void TMatrixTBaselEdoublegR_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class TMatrixTBase<double>.
      typedef ::ROOT::Shadow::TMatrixTBaselEdoublegR ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTBase<double>*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNrows", &sobj->fNrows);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNcols", &sobj->fNcols);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRowLwb", &sobj->fRowLwb);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fColLwb", &sobj->fColLwb);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNelems", &sobj->fNelems);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNrowIndex", &sobj->fNrowIndex);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTol", &sobj->fTol);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsOwner", &sobj->fIsOwner);
      sobj->TObject::ShowMembers(R__insp);
   }

}

template <> void TMatrixTBase<double>::ShowMembers(TMemberInspector &R__insp)
{
   ::ROOT::TMatrixTBaselEdoublegR_ShowMembers(this, R__insp);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TMatrixTBaselEdoublegR(void *p) {
      delete ((::TMatrixTBase<double>*)p);
   }
   static void deleteArray_TMatrixTBaselEdoublegR(void *p) {
      delete [] ((::TMatrixTBase<double>*)p);
   }
   static void destruct_TMatrixTBaselEdoublegR(void *p) {
      typedef ::TMatrixTBase<double> current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TMatrixTBaselEdoublegR(TBuffer &buf, void *obj) {
      ((::TMatrixTBase<double>*)obj)->::TMatrixTBase<double>::Streamer(buf);
   }
} // end of namespace ROOT for class ::TMatrixTBase<double>

//______________________________________________________________________________
namespace ROOT {
   void TMatrixTlEdoublegR_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class TMatrixT<double>.
      typedef ::ROOT::Shadow::TMatrixTlEdoublegR ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixT<double>*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDataStack[25]", sobj->fDataStack);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fElements", &sobj->fElements);
      sobj->TMatrixTBase<double>::ShowMembers(R__insp);
   }

}

template <> void TMatrixT<double>::ShowMembers(TMemberInspector &R__insp)
{
   ::ROOT::TMatrixTlEdoublegR_ShowMembers(this, R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TMatrixTlEdoublegR(void *p) {
      return  p ? new(p) ::TMatrixT<double> : new ::TMatrixT<double>;
   }
   static void *newArray_TMatrixTlEdoublegR(Long_t nElements, void *p) {
      return p ? new(p) ::TMatrixT<double>[nElements] : new ::TMatrixT<double>[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMatrixTlEdoublegR(void *p) {
      delete ((::TMatrixT<double>*)p);
   }
   static void deleteArray_TMatrixTlEdoublegR(void *p) {
      delete [] ((::TMatrixT<double>*)p);
   }
   static void destruct_TMatrixTlEdoublegR(void *p) {
      typedef ::TMatrixT<double> current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TMatrixTlEdoublegR(TBuffer &buf, void *obj) {
      ((::TMatrixT<double>*)obj)->::TMatrixT<double>::Streamer(buf);
   }
} // end of namespace ROOT for class ::TMatrixT<double>

//______________________________________________________________________________
namespace ROOT {
   void TMatrixTSymlEdoublegR_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class TMatrixTSym<double>.
      typedef ::ROOT::Shadow::TMatrixTSymlEdoublegR ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSym<double>*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDataStack[25]", sobj->fDataStack);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fElements", &sobj->fElements);
      sobj->TMatrixTBase<double>::ShowMembers(R__insp);
   }

}

template <> void TMatrixTSym<double>::ShowMembers(TMemberInspector &R__insp)
{
   ::ROOT::TMatrixTSymlEdoublegR_ShowMembers(this, R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TMatrixTSymlEdoublegR(void *p) {
      return  p ? new(p) ::TMatrixTSym<double> : new ::TMatrixTSym<double>;
   }
   static void *newArray_TMatrixTSymlEdoublegR(Long_t nElements, void *p) {
      return p ? new(p) ::TMatrixTSym<double>[nElements] : new ::TMatrixTSym<double>[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMatrixTSymlEdoublegR(void *p) {
      delete ((::TMatrixTSym<double>*)p);
   }
   static void deleteArray_TMatrixTSymlEdoublegR(void *p) {
      delete [] ((::TMatrixTSym<double>*)p);
   }
   static void destruct_TMatrixTSymlEdoublegR(void *p) {
      typedef ::TMatrixTSym<double> current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TMatrixTSymlEdoublegR(TBuffer &buf, void *obj) {
      ((::TMatrixTSym<double>*)obj)->::TMatrixTSym<double>::Streamer(buf);
   }
} // end of namespace ROOT for class ::TMatrixTSym<double>

//______________________________________________________________________________
namespace ROOT {
   void TMatrixTSparselEdoublegR_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class TMatrixTSparse<double>.
      typedef ::ROOT::Shadow::TMatrixTSparselEdoublegR ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSparse<double>*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRowIndex", &sobj->fRowIndex);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fColIndex", &sobj->fColIndex);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fElements", &sobj->fElements);
      sobj->TMatrixTBase<double>::ShowMembers(R__insp);
   }

}

template <> void TMatrixTSparse<double>::ShowMembers(TMemberInspector &R__insp)
{
   ::ROOT::TMatrixTSparselEdoublegR_ShowMembers(this, R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TMatrixTSparselEdoublegR(void *p) {
      return  p ? new(p) ::TMatrixTSparse<double> : new ::TMatrixTSparse<double>;
   }
   static void *newArray_TMatrixTSparselEdoublegR(Long_t nElements, void *p) {
      return p ? new(p) ::TMatrixTSparse<double>[nElements] : new ::TMatrixTSparse<double>[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMatrixTSparselEdoublegR(void *p) {
      delete ((::TMatrixTSparse<double>*)p);
   }
   static void deleteArray_TMatrixTSparselEdoublegR(void *p) {
      delete [] ((::TMatrixTSparse<double>*)p);
   }
   static void destruct_TMatrixTSparselEdoublegR(void *p) {
      typedef ::TMatrixTSparse<double> current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TMatrixTSparselEdoublegR(TBuffer &buf, void *obj) {
      ((::TMatrixTSparse<double>*)obj)->::TMatrixTSparse<double>::Streamer(buf);
   }
} // end of namespace ROOT for class ::TMatrixTSparse<double>

//______________________________________________________________________________
template <> void TMatrixTLazy<double>::Streamer(TBuffer &R__b)
{
   // Stream an object of class TMatrixTLazy<double>.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TMatrixTLazy<double>::Class(),this);
   } else {
      R__b.WriteClassBuffer(TMatrixTLazy<double>::Class(),this);
   }
}

//______________________________________________________________________________
namespace ROOT {
   void TMatrixTLazylEdoublegR_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class TMatrixTLazy<double>.
      typedef ::ROOT::Shadow::TMatrixTLazylEdoublegR ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTLazy<double>*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRowUpb", &sobj->fRowUpb);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRowLwb", &sobj->fRowLwb);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fColUpb", &sobj->fColUpb);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fColLwb", &sobj->fColLwb);
      sobj->TObject::ShowMembers(R__insp);
   }

}

template <> void TMatrixTLazy<double>::ShowMembers(TMemberInspector &R__insp)
{
   ::ROOT::TMatrixTLazylEdoublegR_ShowMembers(this, R__insp);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TMatrixTLazylEdoublegR(void *p) {
      delete ((::TMatrixTLazy<double>*)p);
   }
   static void deleteArray_TMatrixTLazylEdoublegR(void *p) {
      delete [] ((::TMatrixTLazy<double>*)p);
   }
   static void destruct_TMatrixTLazylEdoublegR(void *p) {
      typedef ::TMatrixTLazy<double> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TMatrixTLazy<double>

//______________________________________________________________________________
template <> void TMatrixTSymLazy<double>::Streamer(TBuffer &R__b)
{
   // Stream an object of class TMatrixTSymLazy<double>.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TMatrixTSymLazy<double>::Class(),this);
   } else {
      R__b.WriteClassBuffer(TMatrixTSymLazy<double>::Class(),this);
   }
}

//______________________________________________________________________________
namespace ROOT {
   void TMatrixTSymLazylEdoublegR_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class TMatrixTSymLazy<double>.
      typedef ::ROOT::Shadow::TMatrixTSymLazylEdoublegR ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSymLazy<double>*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRowUpb", &sobj->fRowUpb);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRowLwb", &sobj->fRowLwb);
      sobj->TObject::ShowMembers(R__insp);
   }

}

template <> void TMatrixTSymLazy<double>::ShowMembers(TMemberInspector &R__insp)
{
   ::ROOT::TMatrixTSymLazylEdoublegR_ShowMembers(this, R__insp);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TMatrixTSymLazylEdoublegR(void *p) {
      delete ((::TMatrixTSymLazy<double>*)p);
   }
   static void deleteArray_TMatrixTSymLazylEdoublegR(void *p) {
      delete [] ((::TMatrixTSymLazy<double>*)p);
   }
   static void destruct_TMatrixTSymLazylEdoublegR(void *p) {
      typedef ::TMatrixTSymLazy<double> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TMatrixTSymLazy<double>

//______________________________________________________________________________
template <> void THaarMatrixT<double>::Streamer(TBuffer &R__b)
{
   // Stream an object of class THaarMatrixT<double>.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(THaarMatrixT<double>::Class(),this);
   } else {
      R__b.WriteClassBuffer(THaarMatrixT<double>::Class(),this);
   }
}

//______________________________________________________________________________
namespace ROOT {
   void THaarMatrixTlEdoublegR_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class THaarMatrixT<double>.
      typedef ::ROOT::Shadow::THaarMatrixTlEdoublegR ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::THaarMatrixT<double>*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      sobj->TMatrixTLazy<double>::ShowMembers(R__insp);
   }

}

template <> void THaarMatrixT<double>::ShowMembers(TMemberInspector &R__insp)
{
   ::ROOT::THaarMatrixTlEdoublegR_ShowMembers(this, R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_THaarMatrixTlEdoublegR(void *p) {
      return  p ? new(p) ::THaarMatrixT<double> : new ::THaarMatrixT<double>;
   }
   static void *newArray_THaarMatrixTlEdoublegR(Long_t nElements, void *p) {
      return p ? new(p) ::THaarMatrixT<double>[nElements] : new ::THaarMatrixT<double>[nElements];
   }
   // Wrapper around operator delete
   static void delete_THaarMatrixTlEdoublegR(void *p) {
      delete ((::THaarMatrixT<double>*)p);
   }
   static void deleteArray_THaarMatrixTlEdoublegR(void *p) {
      delete [] ((::THaarMatrixT<double>*)p);
   }
   static void destruct_THaarMatrixTlEdoublegR(void *p) {
      typedef ::THaarMatrixT<double> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::THaarMatrixT<double>

//______________________________________________________________________________
template <> void THilbertMatrixT<double>::Streamer(TBuffer &R__b)
{
   // Stream an object of class THilbertMatrixT<double>.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(THilbertMatrixT<double>::Class(),this);
   } else {
      R__b.WriteClassBuffer(THilbertMatrixT<double>::Class(),this);
   }
}

//______________________________________________________________________________
namespace ROOT {
   void THilbertMatrixTlEdoublegR_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class THilbertMatrixT<double>.
      typedef ::ROOT::Shadow::THilbertMatrixTlEdoublegR ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::THilbertMatrixT<double>*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      sobj->TMatrixTLazy<double>::ShowMembers(R__insp);
   }

}

template <> void THilbertMatrixT<double>::ShowMembers(TMemberInspector &R__insp)
{
   ::ROOT::THilbertMatrixTlEdoublegR_ShowMembers(this, R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_THilbertMatrixTlEdoublegR(void *p) {
      return  p ? new(p) ::THilbertMatrixT<double> : new ::THilbertMatrixT<double>;
   }
   static void *newArray_THilbertMatrixTlEdoublegR(Long_t nElements, void *p) {
      return p ? new(p) ::THilbertMatrixT<double>[nElements] : new ::THilbertMatrixT<double>[nElements];
   }
   // Wrapper around operator delete
   static void delete_THilbertMatrixTlEdoublegR(void *p) {
      delete ((::THilbertMatrixT<double>*)p);
   }
   static void deleteArray_THilbertMatrixTlEdoublegR(void *p) {
      delete [] ((::THilbertMatrixT<double>*)p);
   }
   static void destruct_THilbertMatrixTlEdoublegR(void *p) {
      typedef ::THilbertMatrixT<double> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::THilbertMatrixT<double>

//______________________________________________________________________________
template <> void THilbertMatrixTSym<double>::Streamer(TBuffer &R__b)
{
   // Stream an object of class THilbertMatrixTSym<double>.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(THilbertMatrixTSym<double>::Class(),this);
   } else {
      R__b.WriteClassBuffer(THilbertMatrixTSym<double>::Class(),this);
   }
}

//______________________________________________________________________________
namespace ROOT {
   void THilbertMatrixTSymlEdoublegR_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class THilbertMatrixTSym<double>.
      typedef ::ROOT::Shadow::THilbertMatrixTSymlEdoublegR ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::THilbertMatrixTSym<double>*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      sobj->TMatrixTSymLazy<double>::ShowMembers(R__insp);
   }

}

template <> void THilbertMatrixTSym<double>::ShowMembers(TMemberInspector &R__insp)
{
   ::ROOT::THilbertMatrixTSymlEdoublegR_ShowMembers(this, R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_THilbertMatrixTSymlEdoublegR(void *p) {
      return  p ? new(p) ::THilbertMatrixTSym<double> : new ::THilbertMatrixTSym<double>;
   }
   static void *newArray_THilbertMatrixTSymlEdoublegR(Long_t nElements, void *p) {
      return p ? new(p) ::THilbertMatrixTSym<double>[nElements] : new ::THilbertMatrixTSym<double>[nElements];
   }
   // Wrapper around operator delete
   static void delete_THilbertMatrixTSymlEdoublegR(void *p) {
      delete ((::THilbertMatrixTSym<double>*)p);
   }
   static void deleteArray_THilbertMatrixTSymlEdoublegR(void *p) {
      delete [] ((::THilbertMatrixTSym<double>*)p);
   }
   static void destruct_THilbertMatrixTSymlEdoublegR(void *p) {
      typedef ::THilbertMatrixTSym<double> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::THilbertMatrixTSym<double>

//______________________________________________________________________________
template <> void TMatrixTRow_const<double>::Streamer(TBuffer &R__b)
{
   // Stream an object of class TMatrixTRow_const<double>.

   ::Error("TMatrixTRow_const<double>::Streamer", "version id <=0 in ClassDef, dummy Streamer() called"); if (R__b.IsReading()) { }
}

//______________________________________________________________________________
namespace ROOT {
   void TMatrixTRow_constlEdoublegR_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class TMatrixTRow_const<double>.
      typedef ::ROOT::Shadow::TMatrixTRow_constlEdoublegR ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTRow_const<double>*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMatrix", &sobj->fMatrix);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRowInd", &sobj->fRowInd);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fInc", &sobj->fInc);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPtr", &sobj->fPtr);
   }

}

template <> void TMatrixTRow_const<double>::ShowMembers(TMemberInspector &R__insp)
{
   ::ROOT::TMatrixTRow_constlEdoublegR_ShowMembers(this, R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TMatrixTRow_constlEdoublegR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMatrixTRow_const<double> : new ::TMatrixTRow_const<double>;
   }
   static void *newArray_TMatrixTRow_constlEdoublegR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMatrixTRow_const<double>[nElements] : new ::TMatrixTRow_const<double>[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMatrixTRow_constlEdoublegR(void *p) {
      delete ((::TMatrixTRow_const<double>*)p);
   }
   static void deleteArray_TMatrixTRow_constlEdoublegR(void *p) {
      delete [] ((::TMatrixTRow_const<double>*)p);
   }
   static void destruct_TMatrixTRow_constlEdoublegR(void *p) {
      typedef ::TMatrixTRow_const<double> current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TMatrixTRow_constlEdoublegR(TBuffer &buf, void *obj) {
      ((::TMatrixTRow_const<double>*)obj)->::TMatrixTRow_const<double>::Streamer(buf);
   }
} // end of namespace ROOT for class ::TMatrixTRow_const<double>

//______________________________________________________________________________
template <> void TMatrixTColumn_const<double>::Streamer(TBuffer &R__b)
{
   // Stream an object of class TMatrixTColumn_const<double>.

   ::Error("TMatrixTColumn_const<double>::Streamer", "version id <=0 in ClassDef, dummy Streamer() called"); if (R__b.IsReading()) { }
}

//______________________________________________________________________________
namespace ROOT {
   void TMatrixTColumn_constlEdoublegR_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class TMatrixTColumn_const<double>.
      typedef ::ROOT::Shadow::TMatrixTColumn_constlEdoublegR ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTColumn_const<double>*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMatrix", &sobj->fMatrix);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fColInd", &sobj->fColInd);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fInc", &sobj->fInc);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPtr", &sobj->fPtr);
   }

}

template <> void TMatrixTColumn_const<double>::ShowMembers(TMemberInspector &R__insp)
{
   ::ROOT::TMatrixTColumn_constlEdoublegR_ShowMembers(this, R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TMatrixTColumn_constlEdoublegR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMatrixTColumn_const<double> : new ::TMatrixTColumn_const<double>;
   }
   static void *newArray_TMatrixTColumn_constlEdoublegR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMatrixTColumn_const<double>[nElements] : new ::TMatrixTColumn_const<double>[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMatrixTColumn_constlEdoublegR(void *p) {
      delete ((::TMatrixTColumn_const<double>*)p);
   }
   static void deleteArray_TMatrixTColumn_constlEdoublegR(void *p) {
      delete [] ((::TMatrixTColumn_const<double>*)p);
   }
   static void destruct_TMatrixTColumn_constlEdoublegR(void *p) {
      typedef ::TMatrixTColumn_const<double> current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TMatrixTColumn_constlEdoublegR(TBuffer &buf, void *obj) {
      ((::TMatrixTColumn_const<double>*)obj)->::TMatrixTColumn_const<double>::Streamer(buf);
   }
} // end of namespace ROOT for class ::TMatrixTColumn_const<double>

//______________________________________________________________________________
template <> void TMatrixTDiag_const<double>::Streamer(TBuffer &R__b)
{
   // Stream an object of class TMatrixTDiag_const<double>.

   ::Error("TMatrixTDiag_const<double>::Streamer", "version id <=0 in ClassDef, dummy Streamer() called"); if (R__b.IsReading()) { }
}

//______________________________________________________________________________
namespace ROOT {
   void TMatrixTDiag_constlEdoublegR_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class TMatrixTDiag_const<double>.
      typedef ::ROOT::Shadow::TMatrixTDiag_constlEdoublegR ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTDiag_const<double>*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMatrix", &sobj->fMatrix);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fInc", &sobj->fInc);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNdiag", &sobj->fNdiag);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPtr", &sobj->fPtr);
   }

}

template <> void TMatrixTDiag_const<double>::ShowMembers(TMemberInspector &R__insp)
{
   ::ROOT::TMatrixTDiag_constlEdoublegR_ShowMembers(this, R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TMatrixTDiag_constlEdoublegR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMatrixTDiag_const<double> : new ::TMatrixTDiag_const<double>;
   }
   static void *newArray_TMatrixTDiag_constlEdoublegR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMatrixTDiag_const<double>[nElements] : new ::TMatrixTDiag_const<double>[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMatrixTDiag_constlEdoublegR(void *p) {
      delete ((::TMatrixTDiag_const<double>*)p);
   }
   static void deleteArray_TMatrixTDiag_constlEdoublegR(void *p) {
      delete [] ((::TMatrixTDiag_const<double>*)p);
   }
   static void destruct_TMatrixTDiag_constlEdoublegR(void *p) {
      typedef ::TMatrixTDiag_const<double> current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TMatrixTDiag_constlEdoublegR(TBuffer &buf, void *obj) {
      ((::TMatrixTDiag_const<double>*)obj)->::TMatrixTDiag_const<double>::Streamer(buf);
   }
} // end of namespace ROOT for class ::TMatrixTDiag_const<double>

//______________________________________________________________________________
template <> void TMatrixTFlat_const<double>::Streamer(TBuffer &R__b)
{
   // Stream an object of class TMatrixTFlat_const<double>.

   ::Error("TMatrixTFlat_const<double>::Streamer", "version id <=0 in ClassDef, dummy Streamer() called"); if (R__b.IsReading()) { }
}

//______________________________________________________________________________
namespace ROOT {
   void TMatrixTFlat_constlEdoublegR_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class TMatrixTFlat_const<double>.
      typedef ::ROOT::Shadow::TMatrixTFlat_constlEdoublegR ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTFlat_const<double>*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMatrix", &sobj->fMatrix);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNelems", &sobj->fNelems);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPtr", &sobj->fPtr);
   }

}

template <> void TMatrixTFlat_const<double>::ShowMembers(TMemberInspector &R__insp)
{
   ::ROOT::TMatrixTFlat_constlEdoublegR_ShowMembers(this, R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TMatrixTFlat_constlEdoublegR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMatrixTFlat_const<double> : new ::TMatrixTFlat_const<double>;
   }
   static void *newArray_TMatrixTFlat_constlEdoublegR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMatrixTFlat_const<double>[nElements] : new ::TMatrixTFlat_const<double>[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMatrixTFlat_constlEdoublegR(void *p) {
      delete ((::TMatrixTFlat_const<double>*)p);
   }
   static void deleteArray_TMatrixTFlat_constlEdoublegR(void *p) {
      delete [] ((::TMatrixTFlat_const<double>*)p);
   }
   static void destruct_TMatrixTFlat_constlEdoublegR(void *p) {
      typedef ::TMatrixTFlat_const<double> current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TMatrixTFlat_constlEdoublegR(TBuffer &buf, void *obj) {
      ((::TMatrixTFlat_const<double>*)obj)->::TMatrixTFlat_const<double>::Streamer(buf);
   }
} // end of namespace ROOT for class ::TMatrixTFlat_const<double>

//______________________________________________________________________________
template <> void TMatrixTSub_const<double>::Streamer(TBuffer &R__b)
{
   // Stream an object of class TMatrixTSub_const<double>.

   ::Error("TMatrixTSub_const<double>::Streamer", "version id <=0 in ClassDef, dummy Streamer() called"); if (R__b.IsReading()) { }
}

//______________________________________________________________________________
namespace ROOT {
   void TMatrixTSub_constlEdoublegR_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class TMatrixTSub_const<double>.
      typedef ::ROOT::Shadow::TMatrixTSub_constlEdoublegR ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSub_const<double>*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMatrix", &sobj->fMatrix);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRowOff", &sobj->fRowOff);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fColOff", &sobj->fColOff);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNrowsSub", &sobj->fNrowsSub);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNcolsSub", &sobj->fNcolsSub);
   }

}

template <> void TMatrixTSub_const<double>::ShowMembers(TMemberInspector &R__insp)
{
   ::ROOT::TMatrixTSub_constlEdoublegR_ShowMembers(this, R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TMatrixTSub_constlEdoublegR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMatrixTSub_const<double> : new ::TMatrixTSub_const<double>;
   }
   static void *newArray_TMatrixTSub_constlEdoublegR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMatrixTSub_const<double>[nElements] : new ::TMatrixTSub_const<double>[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMatrixTSub_constlEdoublegR(void *p) {
      delete ((::TMatrixTSub_const<double>*)p);
   }
   static void deleteArray_TMatrixTSub_constlEdoublegR(void *p) {
      delete [] ((::TMatrixTSub_const<double>*)p);
   }
   static void destruct_TMatrixTSub_constlEdoublegR(void *p) {
      typedef ::TMatrixTSub_const<double> current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TMatrixTSub_constlEdoublegR(TBuffer &buf, void *obj) {
      ((::TMatrixTSub_const<double>*)obj)->::TMatrixTSub_const<double>::Streamer(buf);
   }
} // end of namespace ROOT for class ::TMatrixTSub_const<double>

//______________________________________________________________________________
template <> void TMatrixTRow<double>::Streamer(TBuffer &R__b)
{
   // Stream an object of class TMatrixTRow<double>.

   TMatrixTRow_const<double>::Streamer(R__b);
}

//______________________________________________________________________________
namespace ROOT {
   void TMatrixTRowlEdoublegR_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class TMatrixTRow<double>.
      typedef ::ROOT::Shadow::TMatrixTRowlEdoublegR ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTRow<double>*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      sobj->TMatrixTRow_const<double>::ShowMembers(R__insp);
   }

}

template <> void TMatrixTRow<double>::ShowMembers(TMemberInspector &R__insp)
{
   ::ROOT::TMatrixTRowlEdoublegR_ShowMembers(this, R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TMatrixTRowlEdoublegR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMatrixTRow<double> : new ::TMatrixTRow<double>;
   }
   static void *newArray_TMatrixTRowlEdoublegR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMatrixTRow<double>[nElements] : new ::TMatrixTRow<double>[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMatrixTRowlEdoublegR(void *p) {
      delete ((::TMatrixTRow<double>*)p);
   }
   static void deleteArray_TMatrixTRowlEdoublegR(void *p) {
      delete [] ((::TMatrixTRow<double>*)p);
   }
   static void destruct_TMatrixTRowlEdoublegR(void *p) {
      typedef ::TMatrixTRow<double> current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TMatrixTRowlEdoublegR(TBuffer &buf, void *obj) {
      ((::TMatrixTRow<double>*)obj)->::TMatrixTRow<double>::Streamer(buf);
   }
} // end of namespace ROOT for class ::TMatrixTRow<double>

//______________________________________________________________________________
template <> void TMatrixTColumn<double>::Streamer(TBuffer &R__b)
{
   // Stream an object of class TMatrixTColumn<double>.

   TMatrixTColumn_const<double>::Streamer(R__b);
}

//______________________________________________________________________________
namespace ROOT {
   void TMatrixTColumnlEdoublegR_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class TMatrixTColumn<double>.
      typedef ::ROOT::Shadow::TMatrixTColumnlEdoublegR ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTColumn<double>*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      sobj->TMatrixTColumn_const<double>::ShowMembers(R__insp);
   }

}

template <> void TMatrixTColumn<double>::ShowMembers(TMemberInspector &R__insp)
{
   ::ROOT::TMatrixTColumnlEdoublegR_ShowMembers(this, R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TMatrixTColumnlEdoublegR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMatrixTColumn<double> : new ::TMatrixTColumn<double>;
   }
   static void *newArray_TMatrixTColumnlEdoublegR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMatrixTColumn<double>[nElements] : new ::TMatrixTColumn<double>[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMatrixTColumnlEdoublegR(void *p) {
      delete ((::TMatrixTColumn<double>*)p);
   }
   static void deleteArray_TMatrixTColumnlEdoublegR(void *p) {
      delete [] ((::TMatrixTColumn<double>*)p);
   }
   static void destruct_TMatrixTColumnlEdoublegR(void *p) {
      typedef ::TMatrixTColumn<double> current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TMatrixTColumnlEdoublegR(TBuffer &buf, void *obj) {
      ((::TMatrixTColumn<double>*)obj)->::TMatrixTColumn<double>::Streamer(buf);
   }
} // end of namespace ROOT for class ::TMatrixTColumn<double>

//______________________________________________________________________________
template <> void TMatrixTDiag<double>::Streamer(TBuffer &R__b)
{
   // Stream an object of class TMatrixTDiag<double>.

   TMatrixTDiag_const<double>::Streamer(R__b);
}

//______________________________________________________________________________
namespace ROOT {
   void TMatrixTDiaglEdoublegR_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class TMatrixTDiag<double>.
      typedef ::ROOT::Shadow::TMatrixTDiaglEdoublegR ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTDiag<double>*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      sobj->TMatrixTDiag_const<double>::ShowMembers(R__insp);
   }

}

template <> void TMatrixTDiag<double>::ShowMembers(TMemberInspector &R__insp)
{
   ::ROOT::TMatrixTDiaglEdoublegR_ShowMembers(this, R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TMatrixTDiaglEdoublegR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMatrixTDiag<double> : new ::TMatrixTDiag<double>;
   }
   static void *newArray_TMatrixTDiaglEdoublegR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMatrixTDiag<double>[nElements] : new ::TMatrixTDiag<double>[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMatrixTDiaglEdoublegR(void *p) {
      delete ((::TMatrixTDiag<double>*)p);
   }
   static void deleteArray_TMatrixTDiaglEdoublegR(void *p) {
      delete [] ((::TMatrixTDiag<double>*)p);
   }
   static void destruct_TMatrixTDiaglEdoublegR(void *p) {
      typedef ::TMatrixTDiag<double> current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TMatrixTDiaglEdoublegR(TBuffer &buf, void *obj) {
      ((::TMatrixTDiag<double>*)obj)->::TMatrixTDiag<double>::Streamer(buf);
   }
} // end of namespace ROOT for class ::TMatrixTDiag<double>

//______________________________________________________________________________
template <> void TMatrixTFlat<double>::Streamer(TBuffer &R__b)
{
   // Stream an object of class TMatrixTFlat<double>.

   TMatrixTFlat_const<double>::Streamer(R__b);
}

//______________________________________________________________________________
namespace ROOT {
   void TMatrixTFlatlEdoublegR_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class TMatrixTFlat<double>.
      typedef ::ROOT::Shadow::TMatrixTFlatlEdoublegR ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTFlat<double>*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      sobj->TMatrixTFlat_const<double>::ShowMembers(R__insp);
   }

}

template <> void TMatrixTFlat<double>::ShowMembers(TMemberInspector &R__insp)
{
   ::ROOT::TMatrixTFlatlEdoublegR_ShowMembers(this, R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TMatrixTFlatlEdoublegR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMatrixTFlat<double> : new ::TMatrixTFlat<double>;
   }
   static void *newArray_TMatrixTFlatlEdoublegR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMatrixTFlat<double>[nElements] : new ::TMatrixTFlat<double>[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMatrixTFlatlEdoublegR(void *p) {
      delete ((::TMatrixTFlat<double>*)p);
   }
   static void deleteArray_TMatrixTFlatlEdoublegR(void *p) {
      delete [] ((::TMatrixTFlat<double>*)p);
   }
   static void destruct_TMatrixTFlatlEdoublegR(void *p) {
      typedef ::TMatrixTFlat<double> current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TMatrixTFlatlEdoublegR(TBuffer &buf, void *obj) {
      ((::TMatrixTFlat<double>*)obj)->::TMatrixTFlat<double>::Streamer(buf);
   }
} // end of namespace ROOT for class ::TMatrixTFlat<double>

//______________________________________________________________________________
template <> void TMatrixTSub<double>::Streamer(TBuffer &R__b)
{
   // Stream an object of class TMatrixTSub<double>.

   TMatrixTSub_const<double>::Streamer(R__b);
}

//______________________________________________________________________________
namespace ROOT {
   void TMatrixTSublEdoublegR_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class TMatrixTSub<double>.
      typedef ::ROOT::Shadow::TMatrixTSublEdoublegR ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSub<double>*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      sobj->TMatrixTSub_const<double>::ShowMembers(R__insp);
   }

}

template <> void TMatrixTSub<double>::ShowMembers(TMemberInspector &R__insp)
{
   ::ROOT::TMatrixTSublEdoublegR_ShowMembers(this, R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TMatrixTSublEdoublegR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMatrixTSub<double> : new ::TMatrixTSub<double>;
   }
   static void *newArray_TMatrixTSublEdoublegR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMatrixTSub<double>[nElements] : new ::TMatrixTSub<double>[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMatrixTSublEdoublegR(void *p) {
      delete ((::TMatrixTSub<double>*)p);
   }
   static void deleteArray_TMatrixTSublEdoublegR(void *p) {
      delete [] ((::TMatrixTSub<double>*)p);
   }
   static void destruct_TMatrixTSublEdoublegR(void *p) {
      typedef ::TMatrixTSub<double> current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TMatrixTSublEdoublegR(TBuffer &buf, void *obj) {
      ((::TMatrixTSub<double>*)obj)->::TMatrixTSub<double>::Streamer(buf);
   }
} // end of namespace ROOT for class ::TMatrixTSub<double>

//______________________________________________________________________________
template <> void TMatrixTSparseRow_const<double>::Streamer(TBuffer &R__b)
{
   // Stream an object of class TMatrixTSparseRow_const<double>.

   ::Error("TMatrixTSparseRow_const<double>::Streamer", "version id <=0 in ClassDef, dummy Streamer() called"); if (R__b.IsReading()) { }
}

//______________________________________________________________________________
namespace ROOT {
   void TMatrixTSparseRow_constlEdoublegR_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class TMatrixTSparseRow_const<double>.
      typedef ::ROOT::Shadow::TMatrixTSparseRow_constlEdoublegR ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSparseRow_const<double>*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMatrix", &sobj->fMatrix);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRowInd", &sobj->fRowInd);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNindex", &sobj->fNindex);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fColPtr", &sobj->fColPtr);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDataPtr", &sobj->fDataPtr);
   }

}

template <> void TMatrixTSparseRow_const<double>::ShowMembers(TMemberInspector &R__insp)
{
   ::ROOT::TMatrixTSparseRow_constlEdoublegR_ShowMembers(this, R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TMatrixTSparseRow_constlEdoublegR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMatrixTSparseRow_const<double> : new ::TMatrixTSparseRow_const<double>;
   }
   static void *newArray_TMatrixTSparseRow_constlEdoublegR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMatrixTSparseRow_const<double>[nElements] : new ::TMatrixTSparseRow_const<double>[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMatrixTSparseRow_constlEdoublegR(void *p) {
      delete ((::TMatrixTSparseRow_const<double>*)p);
   }
   static void deleteArray_TMatrixTSparseRow_constlEdoublegR(void *p) {
      delete [] ((::TMatrixTSparseRow_const<double>*)p);
   }
   static void destruct_TMatrixTSparseRow_constlEdoublegR(void *p) {
      typedef ::TMatrixTSparseRow_const<double> current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TMatrixTSparseRow_constlEdoublegR(TBuffer &buf, void *obj) {
      ((::TMatrixTSparseRow_const<double>*)obj)->::TMatrixTSparseRow_const<double>::Streamer(buf);
   }
} // end of namespace ROOT for class ::TMatrixTSparseRow_const<double>

//______________________________________________________________________________
template <> void TMatrixTSparseRow<double>::Streamer(TBuffer &R__b)
{
   // Stream an object of class TMatrixTSparseRow<double>.

   TMatrixTSparseRow_const<double>::Streamer(R__b);
}

//______________________________________________________________________________
namespace ROOT {
   void TMatrixTSparseRowlEdoublegR_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class TMatrixTSparseRow<double>.
      typedef ::ROOT::Shadow::TMatrixTSparseRowlEdoublegR ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSparseRow<double>*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      sobj->TMatrixTSparseRow_const<double>::ShowMembers(R__insp);
   }

}

template <> void TMatrixTSparseRow<double>::ShowMembers(TMemberInspector &R__insp)
{
   ::ROOT::TMatrixTSparseRowlEdoublegR_ShowMembers(this, R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TMatrixTSparseRowlEdoublegR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMatrixTSparseRow<double> : new ::TMatrixTSparseRow<double>;
   }
   static void *newArray_TMatrixTSparseRowlEdoublegR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMatrixTSparseRow<double>[nElements] : new ::TMatrixTSparseRow<double>[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMatrixTSparseRowlEdoublegR(void *p) {
      delete ((::TMatrixTSparseRow<double>*)p);
   }
   static void deleteArray_TMatrixTSparseRowlEdoublegR(void *p) {
      delete [] ((::TMatrixTSparseRow<double>*)p);
   }
   static void destruct_TMatrixTSparseRowlEdoublegR(void *p) {
      typedef ::TMatrixTSparseRow<double> current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TMatrixTSparseRowlEdoublegR(TBuffer &buf, void *obj) {
      ((::TMatrixTSparseRow<double>*)obj)->::TMatrixTSparseRow<double>::Streamer(buf);
   }
} // end of namespace ROOT for class ::TMatrixTSparseRow<double>

//______________________________________________________________________________
template <> void TMatrixTSparseDiag_const<double>::Streamer(TBuffer &R__b)
{
   // Stream an object of class TMatrixTSparseDiag_const<double>.

   ::Error("TMatrixTSparseDiag_const<double>::Streamer", "version id <=0 in ClassDef, dummy Streamer() called"); if (R__b.IsReading()) { }
}

//______________________________________________________________________________
namespace ROOT {
   void TMatrixTSparseDiag_constlEdoublegR_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class TMatrixTSparseDiag_const<double>.
      typedef ::ROOT::Shadow::TMatrixTSparseDiag_constlEdoublegR ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSparseDiag_const<double>*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMatrix", &sobj->fMatrix);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNdiag", &sobj->fNdiag);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDataPtr", &sobj->fDataPtr);
   }

}

template <> void TMatrixTSparseDiag_const<double>::ShowMembers(TMemberInspector &R__insp)
{
   ::ROOT::TMatrixTSparseDiag_constlEdoublegR_ShowMembers(this, R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TMatrixTSparseDiag_constlEdoublegR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMatrixTSparseDiag_const<double> : new ::TMatrixTSparseDiag_const<double>;
   }
   static void *newArray_TMatrixTSparseDiag_constlEdoublegR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMatrixTSparseDiag_const<double>[nElements] : new ::TMatrixTSparseDiag_const<double>[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMatrixTSparseDiag_constlEdoublegR(void *p) {
      delete ((::TMatrixTSparseDiag_const<double>*)p);
   }
   static void deleteArray_TMatrixTSparseDiag_constlEdoublegR(void *p) {
      delete [] ((::TMatrixTSparseDiag_const<double>*)p);
   }
   static void destruct_TMatrixTSparseDiag_constlEdoublegR(void *p) {
      typedef ::TMatrixTSparseDiag_const<double> current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TMatrixTSparseDiag_constlEdoublegR(TBuffer &buf, void *obj) {
      ((::TMatrixTSparseDiag_const<double>*)obj)->::TMatrixTSparseDiag_const<double>::Streamer(buf);
   }
} // end of namespace ROOT for class ::TMatrixTSparseDiag_const<double>

//______________________________________________________________________________
template <> void TMatrixTSparseDiag<double>::Streamer(TBuffer &R__b)
{
   // Stream an object of class TMatrixTSparseDiag<double>.

   TMatrixTSparseDiag_const<double>::Streamer(R__b);
}

//______________________________________________________________________________
namespace ROOT {
   void TMatrixTSparseDiaglEdoublegR_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class TMatrixTSparseDiag<double>.
      typedef ::ROOT::Shadow::TMatrixTSparseDiaglEdoublegR ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::TMatrixTSparseDiag<double>*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      sobj->TMatrixTSparseDiag_const<double>::ShowMembers(R__insp);
   }

}

template <> void TMatrixTSparseDiag<double>::ShowMembers(TMemberInspector &R__insp)
{
   ::ROOT::TMatrixTSparseDiaglEdoublegR_ShowMembers(this, R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TMatrixTSparseDiaglEdoublegR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMatrixTSparseDiag<double> : new ::TMatrixTSparseDiag<double>;
   }
   static void *newArray_TMatrixTSparseDiaglEdoublegR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMatrixTSparseDiag<double>[nElements] : new ::TMatrixTSparseDiag<double>[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMatrixTSparseDiaglEdoublegR(void *p) {
      delete ((::TMatrixTSparseDiag<double>*)p);
   }
   static void deleteArray_TMatrixTSparseDiaglEdoublegR(void *p) {
      delete [] ((::TMatrixTSparseDiag<double>*)p);
   }
   static void destruct_TMatrixTSparseDiaglEdoublegR(void *p) {
      typedef ::TMatrixTSparseDiag<double> current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TMatrixTSparseDiaglEdoublegR(TBuffer &buf, void *obj) {
      ((::TMatrixTSparseDiag<double>*)obj)->::TMatrixTSparseDiag<double>::Streamer(buf);
   }
} // end of namespace ROOT for class ::TMatrixTSparseDiag<double>

//______________________________________________________________________________
void TMatrixDEigen::Streamer(TBuffer &R__b)
{
   // Stream an object of class TMatrixDEigen.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TMatrixDEigen::Class(),this);
   } else {
      R__b.WriteClassBuffer(TMatrixDEigen::Class(),this);
   }
}

//______________________________________________________________________________
void TMatrixDEigen::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TMatrixDEigen.
      TClass *R__cl = ::TMatrixDEigen::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEigenVectors", &fEigenVectors);
      R__insp.InspectMember(fEigenVectors, "fEigenVectors.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEigenValuesRe", &fEigenValuesRe);
      R__insp.InspectMember(fEigenValuesRe, "fEigenValuesRe.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEigenValuesIm", &fEigenValuesIm);
      R__insp.InspectMember(fEigenValuesIm, "fEigenValuesIm.");
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TMatrixDEigen(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMatrixDEigen : new ::TMatrixDEigen;
   }
   static void *newArray_TMatrixDEigen(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMatrixDEigen[nElements] : new ::TMatrixDEigen[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMatrixDEigen(void *p) {
      delete ((::TMatrixDEigen*)p);
   }
   static void deleteArray_TMatrixDEigen(void *p) {
      delete [] ((::TMatrixDEigen*)p);
   }
   static void destruct_TMatrixDEigen(void *p) {
      typedef ::TMatrixDEigen current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TMatrixDEigen

//______________________________________________________________________________
void TMatrixDSymEigen::Streamer(TBuffer &R__b)
{
   // Stream an object of class TMatrixDSymEigen.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TMatrixDSymEigen::Class(),this);
   } else {
      R__b.WriteClassBuffer(TMatrixDSymEigen::Class(),this);
   }
}

//______________________________________________________________________________
void TMatrixDSymEigen::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TMatrixDSymEigen.
      TClass *R__cl = ::TMatrixDSymEigen::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEigenVectors", &fEigenVectors);
      R__insp.InspectMember(fEigenVectors, "fEigenVectors.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEigenValues", &fEigenValues);
      R__insp.InspectMember(fEigenValues, "fEigenValues.");
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TMatrixDSymEigen(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMatrixDSymEigen : new ::TMatrixDSymEigen;
   }
   static void *newArray_TMatrixDSymEigen(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMatrixDSymEigen[nElements] : new ::TMatrixDSymEigen[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMatrixDSymEigen(void *p) {
      delete ((::TMatrixDSymEigen*)p);
   }
   static void deleteArray_TMatrixDSymEigen(void *p) {
      delete [] ((::TMatrixDSymEigen*)p);
   }
   static void destruct_TMatrixDSymEigen(void *p) {
      typedef ::TMatrixDSymEigen current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TMatrixDSymEigen

//______________________________________________________________________________
void TDecompBase::Streamer(TBuffer &R__b)
{
   // Stream an object of class TDecompBase.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TDecompBase::Class(),this);
   } else {
      R__b.WriteClassBuffer(TDecompBase::Class(),this);
   }
}

//______________________________________________________________________________
void TDecompBase::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TDecompBase.
      TClass *R__cl = ::TDecompBase::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTol", &fTol);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDet1", &fDet1);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDet2", &fDet2);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCondition", &fCondition);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRowLwb", &fRowLwb);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fColLwb", &fColLwb);
      TObject::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TDecompBase(void *p) {
      delete ((::TDecompBase*)p);
   }
   static void deleteArray_TDecompBase(void *p) {
      delete [] ((::TDecompBase*)p);
   }
   static void destruct_TDecompBase(void *p) {
      typedef ::TDecompBase current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TDecompBase

//______________________________________________________________________________
void TDecompBK::Streamer(TBuffer &R__b)
{
   // Stream an object of class TDecompBK.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TDecompBK::Class(),this);
   } else {
      R__b.WriteClassBuffer(TDecompBK::Class(),this);
   }
}

//______________________________________________________________________________
void TDecompBK::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TDecompBK.
      TClass *R__cl = ::TDecompBK::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNIpiv", &fNIpiv);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fIpiv", &fIpiv);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fU", &fU);
      R__insp.InspectMember(fU, "fU.");
      TDecompBase::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TDecompBK(void *p) {
      return  p ? new(p) ::TDecompBK : new ::TDecompBK;
   }
   static void *newArray_TDecompBK(Long_t nElements, void *p) {
      return p ? new(p) ::TDecompBK[nElements] : new ::TDecompBK[nElements];
   }
   // Wrapper around operator delete
   static void delete_TDecompBK(void *p) {
      delete ((::TDecompBK*)p);
   }
   static void deleteArray_TDecompBK(void *p) {
      delete [] ((::TDecompBK*)p);
   }
   static void destruct_TDecompBK(void *p) {
      typedef ::TDecompBK current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TDecompBK

//______________________________________________________________________________
void TDecompChol::Streamer(TBuffer &R__b)
{
   // Stream an object of class TDecompChol.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TDecompChol::Class(),this);
   } else {
      R__b.WriteClassBuffer(TDecompChol::Class(),this);
   }
}

//______________________________________________________________________________
void TDecompChol::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TDecompChol.
      TClass *R__cl = ::TDecompChol::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fU", &fU);
      R__insp.InspectMember(fU, "fU.");
      TDecompBase::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TDecompChol(void *p) {
      return  p ? new(p) ::TDecompChol : new ::TDecompChol;
   }
   static void *newArray_TDecompChol(Long_t nElements, void *p) {
      return p ? new(p) ::TDecompChol[nElements] : new ::TDecompChol[nElements];
   }
   // Wrapper around operator delete
   static void delete_TDecompChol(void *p) {
      delete ((::TDecompChol*)p);
   }
   static void deleteArray_TDecompChol(void *p) {
      delete [] ((::TDecompChol*)p);
   }
   static void destruct_TDecompChol(void *p) {
      typedef ::TDecompChol current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TDecompChol

//______________________________________________________________________________
void TDecompLU::Streamer(TBuffer &R__b)
{
   // Stream an object of class TDecompLU.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TDecompLU::Class(),this);
   } else {
      R__b.WriteClassBuffer(TDecompLU::Class(),this);
   }
}

//______________________________________________________________________________
void TDecompLU::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TDecompLU.
      TClass *R__cl = ::TDecompLU::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fImplicitPivot", &fImplicitPivot);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNIndex", &fNIndex);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fIndex", &fIndex);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSign", &fSign);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLU", &fLU);
      R__insp.InspectMember(fLU, "fLU.");
      TDecompBase::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TDecompLU(void *p) {
      return  p ? new(p) ::TDecompLU : new ::TDecompLU;
   }
   static void *newArray_TDecompLU(Long_t nElements, void *p) {
      return p ? new(p) ::TDecompLU[nElements] : new ::TDecompLU[nElements];
   }
   // Wrapper around operator delete
   static void delete_TDecompLU(void *p) {
      delete ((::TDecompLU*)p);
   }
   static void deleteArray_TDecompLU(void *p) {
      delete [] ((::TDecompLU*)p);
   }
   static void destruct_TDecompLU(void *p) {
      typedef ::TDecompLU current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TDecompLU

//______________________________________________________________________________
void TDecompQRH::Streamer(TBuffer &R__b)
{
   // Stream an object of class TDecompQRH.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TDecompQRH::Class(),this);
   } else {
      R__b.WriteClassBuffer(TDecompQRH::Class(),this);
   }
}

//______________________________________________________________________________
void TDecompQRH::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TDecompQRH.
      TClass *R__cl = ::TDecompQRH::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fQ", &fQ);
      R__insp.InspectMember(fQ, "fQ.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fR", &fR);
      R__insp.InspectMember(fR, "fR.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fUp", &fUp);
      R__insp.InspectMember(fUp, "fUp.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fW", &fW);
      R__insp.InspectMember(fW, "fW.");
      TDecompBase::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TDecompQRH(void *p) {
      return  p ? new(p) ::TDecompQRH : new ::TDecompQRH;
   }
   static void *newArray_TDecompQRH(Long_t nElements, void *p) {
      return p ? new(p) ::TDecompQRH[nElements] : new ::TDecompQRH[nElements];
   }
   // Wrapper around operator delete
   static void delete_TDecompQRH(void *p) {
      delete ((::TDecompQRH*)p);
   }
   static void deleteArray_TDecompQRH(void *p) {
      delete [] ((::TDecompQRH*)p);
   }
   static void destruct_TDecompQRH(void *p) {
      typedef ::TDecompQRH current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TDecompQRH

//______________________________________________________________________________
void TDecompSVD::Streamer(TBuffer &R__b)
{
   // Stream an object of class TDecompSVD.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TDecompSVD::Class(),this);
   } else {
      R__b.WriteClassBuffer(TDecompSVD::Class(),this);
   }
}

//______________________________________________________________________________
void TDecompSVD::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TDecompSVD.
      TClass *R__cl = ::TDecompSVD::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fU", &fU);
      R__insp.InspectMember(fU, "fU.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fV", &fV);
      R__insp.InspectMember(fV, "fV.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSig", &fSig);
      R__insp.InspectMember(fSig, "fSig.");
      TDecompBase::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TDecompSVD(void *p) {
      return  p ? new(p) ::TDecompSVD : new ::TDecompSVD;
   }
   static void *newArray_TDecompSVD(Long_t nElements, void *p) {
      return p ? new(p) ::TDecompSVD[nElements] : new ::TDecompSVD[nElements];
   }
   // Wrapper around operator delete
   static void delete_TDecompSVD(void *p) {
      delete ((::TDecompSVD*)p);
   }
   static void deleteArray_TDecompSVD(void *p) {
      delete [] ((::TDecompSVD*)p);
   }
   static void destruct_TDecompSVD(void *p) {
      typedef ::TDecompSVD current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TDecompSVD

//______________________________________________________________________________
void TDecompSparse::Streamer(TBuffer &R__b)
{
   // Stream an object of class TDecompSparse.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TDecompSparse::Class(),this);
   } else {
      R__b.WriteClassBuffer(TDecompSparse::Class(),this);
   }
}

//______________________________________________________________________________
void TDecompSparse::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TDecompSparse.
      TClass *R__cl = ::TDecompSparse::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fVerbose", &fVerbose);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIcntl[31]", fIcntl);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCntl[6]", fCntl);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fInfo[21]", fInfo);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPrecision", &fPrecision);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIkeep", &fIkeep);
      R__insp.InspectMember(fIkeep, "fIkeep.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIw", &fIw);
      R__insp.InspectMember(fIw, "fIw.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIw1", &fIw1);
      R__insp.InspectMember(fIw1, "fIw1.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIw2", &fIw2);
      R__insp.InspectMember(fIw2, "fIw2.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNsteps", &fNsteps);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaxfrt", &fMaxfrt);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fW", &fW);
      R__insp.InspectMember(fW, "fW.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIPessimism", &fIPessimism);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRPessimism", &fRPessimism);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fA", &fA);
      R__insp.InspectMember(fA, "fA.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNrows", &fNrows);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNnonZeros", &fNnonZeros);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFact", &fFact);
      R__insp.InspectMember(fFact, "fFact.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRowFact", &fRowFact);
      R__insp.InspectMember(fRowFact, "fRowFact.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fColFact", &fColFact);
      R__insp.InspectMember(fColFact, "fColFact.");
      TDecompBase::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TDecompSparse(void *p) {
      return  p ? new(p) ::TDecompSparse : new ::TDecompSparse;
   }
   static void *newArray_TDecompSparse(Long_t nElements, void *p) {
      return p ? new(p) ::TDecompSparse[nElements] : new ::TDecompSparse[nElements];
   }
   // Wrapper around operator delete
   static void delete_TDecompSparse(void *p) {
      delete ((::TDecompSparse*)p);
   }
   static void deleteArray_TDecompSparse(void *p) {
      delete [] ((::TDecompSparse*)p);
   }
   static void destruct_TDecompSparse(void *p) {
      typedef ::TDecompSparse current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TDecompSparse

/********************************************************
* math/matrix/src/G__Matrix.cxx
* CAUTION: DON'T CHANGE THIS FILE. THIS FILE IS AUTOMATICALLY GENERATED
*          FROM HEADER FILES LISTED IN G__setup_cpp_environmentXXX().
*          CHANGE THOSE HEADER FILES AND REGENERATE THIS FILE.
********************************************************/

#ifdef G__MEMTEST
#undef malloc
#undef free
#endif

#if defined(__GNUC__) && __GNUC__ >= 4 && ((__GNUC_MINOR__ == 2 && __GNUC_PATCHLEVEL__ >= 1) || (__GNUC_MINOR__ >= 3))
#pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif

extern "C" void G__cpp_reset_tagtableG__Matrix();

extern "C" void G__set_cpp_environmentG__Matrix() {
  G__add_compiledheader("TObject.h");
  G__add_compiledheader("TMemberInspector.h");
  G__add_compiledheader("TDecompBase.h");
  G__add_compiledheader("TDecompBK.h");
  G__add_compiledheader("TDecompChol.h");
  G__add_compiledheader("TDecompLU.h");
  G__add_compiledheader("TDecompQRH.h");
  G__add_compiledheader("TDecompSparse.h");
  G__add_compiledheader("TDecompSVD.h");
  G__add_compiledheader("TMatrixDBasefwd.h");
  G__add_compiledheader("TMatrixDBase.h");
  G__add_compiledheader("TMatrixDEigen.h");
  G__add_compiledheader("TMatrixDfwd.h");
  G__add_compiledheader("TMatrixD.h");
  G__add_compiledheader("TMatrixDLazy.h");
  G__add_compiledheader("TMatrixDSparsefwd.h");
  G__add_compiledheader("TMatrixDSparse.h");
  G__add_compiledheader("TMatrixDSymEigen.h");
  G__add_compiledheader("TMatrixDSymfwd.h");
  G__add_compiledheader("TMatrixDSym.h");
  G__add_compiledheader("TMatrixDUtilsfwd.h");
  G__add_compiledheader("TMatrixDUtils.h");
  G__add_compiledheader("TMatrixFBasefwd.h");
  G__add_compiledheader("TMatrixFBase.h");
  G__add_compiledheader("TMatrixFfwd.h");
  G__add_compiledheader("TMatrixF.h");
  G__add_compiledheader("TMatrixFLazy.h");
  G__add_compiledheader("TMatrixFSparsefwd.h");
  G__add_compiledheader("TMatrixFSparse.h");
  G__add_compiledheader("TMatrixFSymfwd.h");
  G__add_compiledheader("TMatrixFSym.h");
  G__add_compiledheader("TMatrixFUtilsfwd.h");
  G__add_compiledheader("TMatrixFUtils.h");
  G__add_compiledheader("TMatrix.h");
  G__add_compiledheader("TMatrixTBase.h");
  G__add_compiledheader("TMatrixTCramerInv.h");
  G__add_compiledheader("TMatrixT.h");
  G__add_compiledheader("TMatrixTLazy.h");
  G__add_compiledheader("TMatrixTSparse.h");
  G__add_compiledheader("TMatrixTSymCramerInv.h");
  G__add_compiledheader("TMatrixTSym.h");
  G__add_compiledheader("TMatrixTUtils.h");
  G__add_compiledheader("TVectorDfwd.h");
  G__add_compiledheader("TVectorD.h");
  G__add_compiledheader("TVectorFfwd.h");
  G__add_compiledheader("TVectorF.h");
  G__add_compiledheader("TVectorfwd.h");
  G__add_compiledheader("TVector.h");
  G__add_compiledheader("TVectorT.h");
  G__cpp_reset_tagtableG__Matrix();
}
#include <new>
extern "C" int G__cpp_dllrevG__Matrix() { return(30051515); }

/*********************************************************
* Member function Interface Method
*********************************************************/

/* TMatrixTBase<float> */
static int G__G__Matrix_110_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMatrixTBase<float>*) G__getstructoffset())->GetRowLwb());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_110_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMatrixTBase<float>*) G__getstructoffset())->GetRowUpb());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_110_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMatrixTBase<float>*) G__getstructoffset())->GetNrows());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_110_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMatrixTBase<float>*) G__getstructoffset())->GetColLwb());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_110_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMatrixTBase<float>*) G__getstructoffset())->GetColUpb());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_110_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMatrixTBase<float>*) G__getstructoffset())->GetNcols());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_110_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMatrixTBase<float>*) G__getstructoffset())->GetNoElements());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_110_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TMatrixTBase<float>*) G__getstructoffset())->GetTol());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_110_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 70, (long) ((const TMatrixTBase<float>*) G__getstructoffset())->GetMatrixArray());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_110_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 70, (long) ((TMatrixTBase<float>*) G__getstructoffset())->GetMatrixArray());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_110_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 73, (long) ((const TMatrixTBase<float>*) G__getstructoffset())->GetRowIndexArray());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_110_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 73, (long) ((TMatrixTBase<float>*) G__getstructoffset())->GetRowIndexArray());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_110_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 73, (long) ((const TMatrixTBase<float>*) G__getstructoffset())->GetColIndexArray());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_110_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 73, (long) ((TMatrixTBase<float>*) G__getstructoffset())->GetColIndexArray());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_110_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTBase<float>& obj = ((TMatrixTBase<float>*) G__getstructoffset())->SetRowIndexArray((Int_t*) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_110_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTBase<float>& obj = ((TMatrixTBase<float>*) G__getstructoffset())->SetColIndexArray((Int_t*) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_110_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      {
         const TMatrixTBase<float>& obj = ((TMatrixTBase<float>*) G__getstructoffset())->SetMatrixArray((float*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
      break;
   case 1:
      {
         const TMatrixTBase<float>& obj = ((TMatrixTBase<float>*) G__getstructoffset())->SetMatrixArray((float*) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_110_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((TMatrixTBase<float>*) G__getstructoffset())->SetTol((float) G__double(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_110_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTBase<float>*) G__getstructoffset())->Invalidate();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_110_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTBase<float>*) G__getstructoffset())->MakeValid();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_110_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TMatrixTBase<float>*) G__getstructoffset())->IsValid());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_110_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TMatrixTBase<float>*) G__getstructoffset())->IsOwner());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_110_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TMatrixTBase<float>*) G__getstructoffset())->IsSymmetric());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_110_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 6:
      {
         const TMatrixTBase<float>& obj = ((const TMatrixTBase<float>*) G__getstructoffset())->GetSub((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, *(TMatrixTBase<float>*) libp->para[4].ref, (Option_t*) G__int(libp->para[5]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
      break;
   case 5:
      {
         const TMatrixTBase<float>& obj = ((const TMatrixTBase<float>*) G__getstructoffset())->GetSub((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, *(TMatrixTBase<float>*) libp->para[4].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_110_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTBase<float>& obj = ((TMatrixTBase<float>*) G__getstructoffset())->SetSub((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, *(TMatrixTBase<float>*) libp->para[2].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_110_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((const TMatrixTBase<float>*) G__getstructoffset())->GetMatrix2Array((float*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((const TMatrixTBase<float>*) G__getstructoffset())->GetMatrix2Array((float*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_110_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      {
         const TMatrixTBase<float>& obj = ((TMatrixTBase<float>*) G__getstructoffset())->InsertRow((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (float*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
      break;
   case 3:
      {
         const TMatrixTBase<float>& obj = ((TMatrixTBase<float>*) G__getstructoffset())->InsertRow((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (float*) G__int(libp->para[2]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_110_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      ((const TMatrixTBase<float>*) G__getstructoffset())->ExtractRow((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (float*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((const TMatrixTBase<float>*) G__getstructoffset())->ExtractRow((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (float*) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_110_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTBase<float>& obj = ((TMatrixTBase<float>*) G__getstructoffset())->Shift((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_110_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      {
         const TMatrixTBase<float>& obj = ((TMatrixTBase<float>*) G__getstructoffset())->ResizeTo((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
      break;
   case 2:
      {
         const TMatrixTBase<float>& obj = ((TMatrixTBase<float>*) G__getstructoffset())->ResizeTo((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_110_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      {
         const TMatrixTBase<float>& obj = ((TMatrixTBase<float>*) G__getstructoffset())->ResizeTo((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
      break;
   case 4:
      {
         const TMatrixTBase<float>& obj = ((TMatrixTBase<float>*) G__getstructoffset())->ResizeTo((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_110_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMatrixTBase<float>*) G__getstructoffset())->Determinant());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_110_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TMatrixTBase<float>*) G__getstructoffset())->Determinant(*(Double_t*) G__Doubleref(&libp->para[0]), *(Double_t*) G__Doubleref(&libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_110_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTBase<float>& obj = ((TMatrixTBase<float>*) G__getstructoffset())->Zero();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_110_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTBase<float>& obj = ((TMatrixTBase<float>*) G__getstructoffset())->Abs();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_110_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTBase<float>& obj = ((TMatrixTBase<float>*) G__getstructoffset())->Sqr();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_110_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTBase<float>& obj = ((TMatrixTBase<float>*) G__getstructoffset())->Sqrt();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_110_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTBase<float>& obj = ((TMatrixTBase<float>*) G__getstructoffset())->UnitMatrix();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_110_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      {
         const TMatrixTBase<float>& obj = ((TMatrixTBase<float>*) G__getstructoffset())->NormByDiag(*(TVectorT<float>*) libp->para[0].ref, (Option_t*) G__int(libp->para[1]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
      break;
   case 1:
      {
         const TMatrixTBase<float>& obj = ((TMatrixTBase<float>*) G__getstructoffset())->NormByDiag(*(TVectorT<float>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_110_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TMatrixTBase<float>*) G__getstructoffset())->RowNorm());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_110_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TMatrixTBase<float>*) G__getstructoffset())->ColNorm());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_110_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TMatrixTBase<float>*) G__getstructoffset())->E2Norm());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_110_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TMatrixTBase<float>*) G__getstructoffset())->NormInf());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_110_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TMatrixTBase<float>*) G__getstructoffset())->Norm1());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_110_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMatrixTBase<float>*) G__getstructoffset())->NonZeros());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_110_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TMatrixTBase<float>*) G__getstructoffset())->Sum());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_110_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TMatrixTBase<float>*) G__getstructoffset())->Min());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_110_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TMatrixTBase<float>*) G__getstructoffset())->Max());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_110_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TMatrixTBase<float>*) G__getstructoffset())->operator()((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_110_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const float& obj = ((TMatrixTBase<float>*) G__getstructoffset())->operator()((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
         result7->ref = (long) (&obj);
         result7->obj.d = (double) (obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_110_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TMatrixTBase<float>*) G__getstructoffset())->operator==((float) G__double(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_110_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TMatrixTBase<float>*) G__getstructoffset())->operator!=((float) G__double(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_110_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TMatrixTBase<float>*) G__getstructoffset())->operator<((float) G__double(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_110_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TMatrixTBase<float>*) G__getstructoffset())->operator<=((float) G__double(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_110_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TMatrixTBase<float>*) G__getstructoffset())->operator>((float) G__double(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_110_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TMatrixTBase<float>*) G__getstructoffset())->operator>=((float) G__double(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_110_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTBase<float>& obj = ((TMatrixTBase<float>*) G__getstructoffset())->Apply(*(TElementActionT<float>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_110_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTBase<float>& obj = ((TMatrixTBase<float>*) G__getstructoffset())->Apply(*(TElementPosActionT<float>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_110_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTBase<float>& obj = ((TMatrixTBase<float>*) G__getstructoffset())->Randomize((float) G__double(libp->para[0]), (float) G__double(libp->para[1])
, *(Double_t*) G__Doubleref(&libp->para[2]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_110_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TMatrixTBase<float>::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_110_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTBase<float>::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_110_0_69(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TMatrixTBase<float>::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_110_0_70(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TMatrixTBase<float>::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_110_0_74(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTBase<float>*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_110_0_75(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTBase<float>::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_110_0_76(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMatrixTBase<float>::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_110_0_77(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTBase<float>::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_110_0_78(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMatrixTBase<float>::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TMatrixTBase<float> G__TTMatrixTBaselEfloatgR;
static int G__G__Matrix_110_0_79(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TMatrixTBase<float>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMatrixTBase<float>*) (soff+(sizeof(TMatrixTBase<float>)*i)))->~G__TTMatrixTBaselEfloatgR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMatrixTBase<float>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMatrixTBase<float>*) (soff))->~G__TTMatrixTBaselEfloatgR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Matrix_110_0_80(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTBase<float>* dest = (TMatrixTBase<float>*) G__getstructoffset();
   *dest = *(TMatrixTBase<float>*) libp->para[0].ref;
   const TMatrixTBase<float>& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TMatrixTBase<double> */
static int G__G__Matrix_111_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMatrixTBase<double>*) G__getstructoffset())->GetRowLwb());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_111_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMatrixTBase<double>*) G__getstructoffset())->GetRowUpb());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_111_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMatrixTBase<double>*) G__getstructoffset())->GetNrows());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_111_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMatrixTBase<double>*) G__getstructoffset())->GetColLwb());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_111_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMatrixTBase<double>*) G__getstructoffset())->GetColUpb());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_111_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMatrixTBase<double>*) G__getstructoffset())->GetNcols());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_111_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMatrixTBase<double>*) G__getstructoffset())->GetNoElements());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_111_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMatrixTBase<double>*) G__getstructoffset())->GetTol());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_111_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((const TMatrixTBase<double>*) G__getstructoffset())->GetMatrixArray());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_111_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((TMatrixTBase<double>*) G__getstructoffset())->GetMatrixArray());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_111_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 73, (long) ((const TMatrixTBase<double>*) G__getstructoffset())->GetRowIndexArray());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_111_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 73, (long) ((TMatrixTBase<double>*) G__getstructoffset())->GetRowIndexArray());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_111_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 73, (long) ((const TMatrixTBase<double>*) G__getstructoffset())->GetColIndexArray());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_111_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 73, (long) ((TMatrixTBase<double>*) G__getstructoffset())->GetColIndexArray());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_111_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTBase<double>& obj = ((TMatrixTBase<double>*) G__getstructoffset())->SetRowIndexArray((Int_t*) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_111_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTBase<double>& obj = ((TMatrixTBase<double>*) G__getstructoffset())->SetColIndexArray((Int_t*) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_111_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      {
         const TMatrixTBase<double>& obj = ((TMatrixTBase<double>*) G__getstructoffset())->SetMatrixArray((double*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
      break;
   case 1:
      {
         const TMatrixTBase<double>& obj = ((TMatrixTBase<double>*) G__getstructoffset())->SetMatrixArray((double*) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_111_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((TMatrixTBase<double>*) G__getstructoffset())->SetTol((double) G__double(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_111_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTBase<double>*) G__getstructoffset())->Invalidate();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_111_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTBase<double>*) G__getstructoffset())->MakeValid();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_111_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TMatrixTBase<double>*) G__getstructoffset())->IsValid());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_111_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TMatrixTBase<double>*) G__getstructoffset())->IsOwner());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_111_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TMatrixTBase<double>*) G__getstructoffset())->IsSymmetric());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_111_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 6:
      {
         const TMatrixTBase<double>& obj = ((const TMatrixTBase<double>*) G__getstructoffset())->GetSub((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, *(TMatrixTBase<double>*) libp->para[4].ref, (Option_t*) G__int(libp->para[5]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
      break;
   case 5:
      {
         const TMatrixTBase<double>& obj = ((const TMatrixTBase<double>*) G__getstructoffset())->GetSub((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, *(TMatrixTBase<double>*) libp->para[4].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_111_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTBase<double>& obj = ((TMatrixTBase<double>*) G__getstructoffset())->SetSub((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, *(TMatrixTBase<double>*) libp->para[2].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_111_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((const TMatrixTBase<double>*) G__getstructoffset())->GetMatrix2Array((double*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((const TMatrixTBase<double>*) G__getstructoffset())->GetMatrix2Array((double*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_111_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      {
         const TMatrixTBase<double>& obj = ((TMatrixTBase<double>*) G__getstructoffset())->InsertRow((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (double*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
      break;
   case 3:
      {
         const TMatrixTBase<double>& obj = ((TMatrixTBase<double>*) G__getstructoffset())->InsertRow((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (double*) G__int(libp->para[2]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_111_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      ((const TMatrixTBase<double>*) G__getstructoffset())->ExtractRow((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (double*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((const TMatrixTBase<double>*) G__getstructoffset())->ExtractRow((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (double*) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_111_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTBase<double>& obj = ((TMatrixTBase<double>*) G__getstructoffset())->Shift((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_111_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      {
         const TMatrixTBase<double>& obj = ((TMatrixTBase<double>*) G__getstructoffset())->ResizeTo((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
      break;
   case 2:
      {
         const TMatrixTBase<double>& obj = ((TMatrixTBase<double>*) G__getstructoffset())->ResizeTo((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_111_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      {
         const TMatrixTBase<double>& obj = ((TMatrixTBase<double>*) G__getstructoffset())->ResizeTo((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
      break;
   case 4:
      {
         const TMatrixTBase<double>& obj = ((TMatrixTBase<double>*) G__getstructoffset())->ResizeTo((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_111_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMatrixTBase<double>*) G__getstructoffset())->Determinant());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_111_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TMatrixTBase<double>*) G__getstructoffset())->Determinant(*(Double_t*) G__Doubleref(&libp->para[0]), *(Double_t*) G__Doubleref(&libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_111_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTBase<double>& obj = ((TMatrixTBase<double>*) G__getstructoffset())->Zero();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_111_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTBase<double>& obj = ((TMatrixTBase<double>*) G__getstructoffset())->Abs();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_111_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTBase<double>& obj = ((TMatrixTBase<double>*) G__getstructoffset())->Sqr();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_111_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTBase<double>& obj = ((TMatrixTBase<double>*) G__getstructoffset())->Sqrt();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_111_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTBase<double>& obj = ((TMatrixTBase<double>*) G__getstructoffset())->UnitMatrix();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_111_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      {
         const TMatrixTBase<double>& obj = ((TMatrixTBase<double>*) G__getstructoffset())->NormByDiag(*(TVectorT<double>*) libp->para[0].ref, (Option_t*) G__int(libp->para[1]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
      break;
   case 1:
      {
         const TMatrixTBase<double>& obj = ((TMatrixTBase<double>*) G__getstructoffset())->NormByDiag(*(TVectorT<double>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_111_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMatrixTBase<double>*) G__getstructoffset())->RowNorm());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_111_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMatrixTBase<double>*) G__getstructoffset())->ColNorm());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_111_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMatrixTBase<double>*) G__getstructoffset())->E2Norm());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_111_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMatrixTBase<double>*) G__getstructoffset())->NormInf());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_111_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMatrixTBase<double>*) G__getstructoffset())->Norm1());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_111_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMatrixTBase<double>*) G__getstructoffset())->NonZeros());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_111_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMatrixTBase<double>*) G__getstructoffset())->Sum());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_111_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMatrixTBase<double>*) G__getstructoffset())->Min());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_111_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMatrixTBase<double>*) G__getstructoffset())->Max());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_111_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMatrixTBase<double>*) G__getstructoffset())->operator()((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_111_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const double& obj = ((TMatrixTBase<double>*) G__getstructoffset())->operator()((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
         result7->ref = (long) (&obj);
         result7->obj.d = (double) (obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_111_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TMatrixTBase<double>*) G__getstructoffset())->operator==((double) G__double(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_111_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TMatrixTBase<double>*) G__getstructoffset())->operator!=((double) G__double(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_111_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TMatrixTBase<double>*) G__getstructoffset())->operator<((double) G__double(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_111_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TMatrixTBase<double>*) G__getstructoffset())->operator<=((double) G__double(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_111_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TMatrixTBase<double>*) G__getstructoffset())->operator>((double) G__double(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_111_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TMatrixTBase<double>*) G__getstructoffset())->operator>=((double) G__double(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_111_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTBase<double>& obj = ((TMatrixTBase<double>*) G__getstructoffset())->Apply(*(TElementActionT<double>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_111_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTBase<double>& obj = ((TMatrixTBase<double>*) G__getstructoffset())->Apply(*(TElementPosActionT<double>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_111_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTBase<double>& obj = ((TMatrixTBase<double>*) G__getstructoffset())->Randomize((double) G__double(libp->para[0]), (double) G__double(libp->para[1])
, *(Double_t*) G__Doubleref(&libp->para[2]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_111_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TMatrixTBase<double>::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_111_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTBase<double>::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_111_0_69(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TMatrixTBase<double>::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_111_0_70(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TMatrixTBase<double>::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_111_0_74(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTBase<double>*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_111_0_75(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTBase<double>::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_111_0_76(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMatrixTBase<double>::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_111_0_77(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTBase<double>::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_111_0_78(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMatrixTBase<double>::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TMatrixTBase<double> G__TTMatrixTBaselEdoublegR;
static int G__G__Matrix_111_0_79(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TMatrixTBase<double>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMatrixTBase<double>*) (soff+(sizeof(TMatrixTBase<double>)*i)))->~G__TTMatrixTBaselEdoublegR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMatrixTBase<double>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMatrixTBase<double>*) (soff))->~G__TTMatrixTBaselEdoublegR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__Matrix_111_0_80(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTBase<double>* dest = (TMatrixTBase<double>*) G__getstructoffset();
   *dest = *(TMatrixTBase<double>*) libp->para[0].ref;
   const TMatrixTBase<double>& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TVectorT<float> */
static int G__G__Matrix_112_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TVectorT<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TVectorT<float>[n];
     } else {
       p = new((void*) gvp) TVectorT<float>[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TVectorT<float>;
     } else {
       p = new((void*) gvp) TVectorT<float>;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_112_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TVectorT<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TVectorT<float>((Int_t) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TVectorT<float>((Int_t) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_112_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TVectorT<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TVectorT<float>((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TVectorT<float>((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_112_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TVectorT<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TVectorT<float>((Int_t) G__int(libp->para[0]), (float*) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TVectorT<float>((Int_t) G__int(libp->para[0]), (float*) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_112_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TVectorT<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TVectorT<float>(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (float*) G__int(libp->para[2]));
   } else {
     p = new((void*) gvp) TVectorT<float>(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (float*) G__int(libp->para[2]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_112_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TVectorT<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TVectorT<float>(*(TVectorT<float>*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TVectorT<float>(*(TVectorT<float>*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_112_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TVectorT<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TVectorT<float>(*(TMatrixTRow_const<float>*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TVectorT<float>(*(TMatrixTRow_const<float>*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_112_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TVectorT<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TVectorT<float>(*(TMatrixTColumn_const<float>*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TVectorT<float>(*(TMatrixTColumn_const<float>*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_112_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TVectorT<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TVectorT<float>(*(TMatrixTDiag_const<float>*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TVectorT<float>(*(TMatrixTDiag_const<float>*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_112_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TVectorT<float>*) G__getstructoffset())->GetLwb());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_112_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TVectorT<float>*) G__getstructoffset())->GetUpb());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_112_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TVectorT<float>*) G__getstructoffset())->GetNrows());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_112_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TVectorT<float>*) G__getstructoffset())->GetNoElements());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_112_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 70, (long) ((TVectorT<float>*) G__getstructoffset())->GetMatrixArray());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_112_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 70, (long) ((const TVectorT<float>*) G__getstructoffset())->GetMatrixArray());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_112_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVectorT<float>*) G__getstructoffset())->Invalidate();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_112_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVectorT<float>*) G__getstructoffset())->MakeValid();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_112_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TVectorT<float>*) G__getstructoffset())->IsValid());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_112_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TVectorT<float>*) G__getstructoffset())->IsOwner());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_112_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVectorT<float>*) G__getstructoffset())->SetElements((float*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_112_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVectorT<float>& obj = ((TVectorT<float>*) G__getstructoffset())->Shift((Int_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_112_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVectorT<float>& obj = ((TVectorT<float>*) G__getstructoffset())->ResizeTo((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_112_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVectorT<float>& obj = ((TVectorT<float>*) G__getstructoffset())->ResizeTo((Int_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_112_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVectorT<float>& obj = ((TVectorT<float>*) G__getstructoffset())->ResizeTo(*(TVectorT<float>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_112_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVectorT<float>& obj = ((TVectorT<float>*) G__getstructoffset())->Use((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (float*) G__int(libp->para[2]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_112_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVectorT<float>& obj = ((const TVectorT<float>*) G__getstructoffset())->Use((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (float*) G__int(libp->para[2]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_112_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVectorT<float>& obj = ((TVectorT<float>*) G__getstructoffset())->Use((Int_t) G__int(libp->para[0]), (float*) G__int(libp->para[1]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_112_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVectorT<float>& obj = ((const TVectorT<float>*) G__getstructoffset())->Use((Int_t) G__int(libp->para[0]), (float*) G__int(libp->para[1]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_112_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVectorT<float>& obj = ((TVectorT<float>*) G__getstructoffset())->Use(*(TVectorT<float>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_112_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVectorT<float>& obj = ((const TVectorT<float>*) G__getstructoffset())->Use(*(TVectorT<float>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_112_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      {
         const TVectorT<float>& obj = ((const TVectorT<float>*) G__getstructoffset())->GetSub((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, *(TVectorT<float>*) libp->para[2].ref, (Option_t*) G__int(libp->para[3]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
      break;
   case 3:
      {
         const TVectorT<float>& obj = ((const TVectorT<float>*) G__getstructoffset())->GetSub((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, *(TVectorT<float>*) libp->para[2].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_112_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      {
         const TVectorT<float>* pobj;
         const TVectorT<float> xobj = ((const TVectorT<float>*) G__getstructoffset())->GetSub((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Option_t*) G__int(libp->para[2]));
         pobj = new TVectorT<float>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 2:
      {
         const TVectorT<float>* pobj;
         const TVectorT<float> xobj = ((const TVectorT<float>*) G__getstructoffset())->GetSub((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
         pobj = new TVectorT<float>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_112_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVectorT<float>& obj = ((TVectorT<float>*) G__getstructoffset())->SetSub((Int_t) G__int(libp->para[0]), *(TVectorT<float>*) libp->para[1].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_112_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVectorT<float>& obj = ((TVectorT<float>*) G__getstructoffset())->Zero();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_112_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVectorT<float>& obj = ((TVectorT<float>*) G__getstructoffset())->Abs();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_112_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVectorT<float>& obj = ((TVectorT<float>*) G__getstructoffset())->Sqr();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_112_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVectorT<float>& obj = ((TVectorT<float>*) G__getstructoffset())->Sqrt();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_112_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVectorT<float>& obj = ((TVectorT<float>*) G__getstructoffset())->Invert();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_112_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVectorT<float>& obj = ((TVectorT<float>*) G__getstructoffset())->SelectNonZeros(*(TVectorT<float>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_112_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TVectorT<float>*) G__getstructoffset())->Norm1());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_112_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TVectorT<float>*) G__getstructoffset())->Norm2Sqr());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_112_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TVectorT<float>*) G__getstructoffset())->NormInf());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_112_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TVectorT<float>*) G__getstructoffset())->NonZeros());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_112_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TVectorT<float>*) G__getstructoffset())->Sum());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_112_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TVectorT<float>*) G__getstructoffset())->Min());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_112_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TVectorT<float>*) G__getstructoffset())->Max());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_112_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const float& obj = ((const TVectorT<float>*) G__getstructoffset())->operator()((Int_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.d = (double) (obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_112_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const float& obj = ((TVectorT<float>*) G__getstructoffset())->operator()((Int_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.d = (double) (obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_112_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const float& obj = ((const TVectorT<float>*) G__getstructoffset())->operator[]((Int_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.d = (double) (obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_112_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const float& obj = ((TVectorT<float>*) G__getstructoffset())->operator[]((Int_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.d = (double) (obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_112_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVectorT<float>& obj = ((TVectorT<float>*) G__getstructoffset())->operator=(*(TVectorT<float>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_112_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVectorT<float>& obj = ((TVectorT<float>*) G__getstructoffset())->operator=(*(TMatrixTRow_const<float>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_112_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVectorT<float>& obj = ((TVectorT<float>*) G__getstructoffset())->operator=(*(TMatrixTColumn_const<float>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_112_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVectorT<float>& obj = ((TVectorT<float>*) G__getstructoffset())->operator=(*(TMatrixTDiag_const<float>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_112_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVectorT<float>& obj = ((TVectorT<float>*) G__getstructoffset())->operator=(*(TMatrixTSparseRow_const<float>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_112_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVectorT<float>& obj = ((TVectorT<float>*) G__getstructoffset())->operator=(*(TMatrixTSparseDiag_const<float>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_112_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVectorT<float>& obj = ((TVectorT<float>*) G__getstructoffset())->operator=((float) G__double(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_112_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVectorT<float>& obj = ((TVectorT<float>*) G__getstructoffset())->operator+=((float) G__double(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_112_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVectorT<float>& obj = ((TVectorT<float>*) G__getstructoffset())->operator-=((float) G__double(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_112_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVectorT<float>& obj = ((TVectorT<float>*) G__getstructoffset())->operator*=((float) G__double(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_112_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVectorT<float>& obj = ((TVectorT<float>*) G__getstructoffset())->operator+=(*(TVectorT<float>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_112_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVectorT<float>& obj = ((TVectorT<float>*) G__getstructoffset())->operator-=(*(TVectorT<float>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_112_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVectorT<float>& obj = ((TVectorT<float>*) G__getstructoffset())->operator*=(*(TMatrixT<float>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_112_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVectorT<float>& obj = ((TVectorT<float>*) G__getstructoffset())->operator*=(*(TMatrixTSym<float>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_112_0_69(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVectorT<float>& obj = ((TVectorT<float>*) G__getstructoffset())->operator*=(*(TMatrixTSparse<float>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_112_0_70(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TVectorT<float>*) G__getstructoffset())->operator==((float) G__double(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_112_0_71(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TVectorT<float>*) G__getstructoffset())->operator!=((float) G__double(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_112_0_72(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TVectorT<float>*) G__getstructoffset())->operator<((float) G__double(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_112_0_73(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TVectorT<float>*) G__getstructoffset())->operator<=((float) G__double(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_112_0_74(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TVectorT<float>*) G__getstructoffset())->operator>((float) G__double(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_112_0_75(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TVectorT<float>*) G__getstructoffset())->operator>=((float) G__double(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_112_0_76(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TVectorT<float>*) G__getstructoffset())->MatchesNonZeroPattern(*(TVectorT<float>*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_112_0_77(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TVectorT<float>*) G__getstructoffset())->SomePositive(*(TVectorT<float>*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_112_0_78(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVectorT<float>*) G__getstructoffset())->AddSomeConstant((float) G__double(libp->para[0]), *(TVectorT<float>*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_112_0_79(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVectorT<float>*) G__getstructoffset())->Randomize((float) G__double(libp->para[0]), (float) G__double(libp->para[1])
, *(Double_t*) G__Doubleref(&libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_112_0_80(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVectorT<float>& obj = ((TVectorT<float>*) G__getstructoffset())->Apply(*(TElementActionT<float>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_112_0_81(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVectorT<float>& obj = ((TVectorT<float>*) G__getstructoffset())->Apply(*(TElementPosActionT<float>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_112_0_82(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVectorT<float>*) G__getstructoffset())->Add(*(TVectorT<float>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_112_0_83(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVectorT<float>*) G__getstructoffset())->Add(*(TVectorT<float>*) libp->para[0].ref, *(TVectorT<float>*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_112_0_87(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TVectorT<float>::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_112_0_88(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TVectorT<float>::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_112_0_89(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TVectorT<float>::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_112_0_90(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TVectorT<float>::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_112_0_94(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVectorT<float>*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_112_0_95(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TVectorT<float>::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_112_0_96(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TVectorT<float>::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_112_0_97(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TVectorT<float>::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_112_0_98(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TVectorT<float>::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_112_0_99(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TVectorT<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TVectorT<float>(*(TVectorT<double>*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TVectorT<float>(*(TVectorT<double>*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TVectorT<float> G__TTVectorTlEfloatgR;
static int G__G__Matrix_112_0_100(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TVectorT<float>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TVectorT<float>*) (soff+(sizeof(TVectorT<float>)*i)))->~G__TTVectorTlEfloatgR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TVectorT<float>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TVectorT<float>*) (soff))->~G__TTVectorTlEfloatgR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TVectorT<double> */
static int G__G__Matrix_113_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TVectorT<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TVectorT<double>[n];
     } else {
       p = new((void*) gvp) TVectorT<double>[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TVectorT<double>;
     } else {
       p = new((void*) gvp) TVectorT<double>;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_113_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TVectorT<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TVectorT<double>((Int_t) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TVectorT<double>((Int_t) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_113_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TVectorT<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TVectorT<double>((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TVectorT<double>((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_113_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TVectorT<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TVectorT<double>((Int_t) G__int(libp->para[0]), (double*) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TVectorT<double>((Int_t) G__int(libp->para[0]), (double*) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_113_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TVectorT<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TVectorT<double>(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (double*) G__int(libp->para[2]));
   } else {
     p = new((void*) gvp) TVectorT<double>(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (double*) G__int(libp->para[2]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_113_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TVectorT<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TVectorT<double>(*(TVectorT<double>*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TVectorT<double>(*(TVectorT<double>*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_113_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TVectorT<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TVectorT<double>(*(TMatrixTRow_const<double>*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TVectorT<double>(*(TMatrixTRow_const<double>*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_113_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TVectorT<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TVectorT<double>(*(TMatrixTColumn_const<double>*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TVectorT<double>(*(TMatrixTColumn_const<double>*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_113_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TVectorT<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TVectorT<double>(*(TMatrixTDiag_const<double>*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TVectorT<double>(*(TMatrixTDiag_const<double>*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_113_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TVectorT<double>*) G__getstructoffset())->GetLwb());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_113_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TVectorT<double>*) G__getstructoffset())->GetUpb());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_113_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TVectorT<double>*) G__getstructoffset())->GetNrows());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_113_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TVectorT<double>*) G__getstructoffset())->GetNoElements());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_113_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((TVectorT<double>*) G__getstructoffset())->GetMatrixArray());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_113_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((const TVectorT<double>*) G__getstructoffset())->GetMatrixArray());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_113_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVectorT<double>*) G__getstructoffset())->Invalidate();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_113_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVectorT<double>*) G__getstructoffset())->MakeValid();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_113_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TVectorT<double>*) G__getstructoffset())->IsValid());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_113_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TVectorT<double>*) G__getstructoffset())->IsOwner());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_113_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVectorT<double>*) G__getstructoffset())->SetElements((double*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_113_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVectorT<double>& obj = ((TVectorT<double>*) G__getstructoffset())->Shift((Int_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_113_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVectorT<double>& obj = ((TVectorT<double>*) G__getstructoffset())->ResizeTo((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_113_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVectorT<double>& obj = ((TVectorT<double>*) G__getstructoffset())->ResizeTo((Int_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_113_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVectorT<double>& obj = ((TVectorT<double>*) G__getstructoffset())->ResizeTo(*(TVectorT<double>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_113_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVectorT<double>& obj = ((TVectorT<double>*) G__getstructoffset())->Use((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (double*) G__int(libp->para[2]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_113_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVectorT<double>& obj = ((const TVectorT<double>*) G__getstructoffset())->Use((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (double*) G__int(libp->para[2]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_113_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVectorT<double>& obj = ((TVectorT<double>*) G__getstructoffset())->Use((Int_t) G__int(libp->para[0]), (double*) G__int(libp->para[1]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_113_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVectorT<double>& obj = ((const TVectorT<double>*) G__getstructoffset())->Use((Int_t) G__int(libp->para[0]), (double*) G__int(libp->para[1]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_113_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVectorT<double>& obj = ((TVectorT<double>*) G__getstructoffset())->Use(*(TVectorT<double>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_113_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVectorT<double>& obj = ((const TVectorT<double>*) G__getstructoffset())->Use(*(TVectorT<double>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_113_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      {
         const TVectorT<double>& obj = ((const TVectorT<double>*) G__getstructoffset())->GetSub((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, *(TVectorT<double>*) libp->para[2].ref, (Option_t*) G__int(libp->para[3]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
      break;
   case 3:
      {
         const TVectorT<double>& obj = ((const TVectorT<double>*) G__getstructoffset())->GetSub((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, *(TVectorT<double>*) libp->para[2].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_113_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      {
         const TVectorT<double>* pobj;
         const TVectorT<double> xobj = ((const TVectorT<double>*) G__getstructoffset())->GetSub((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Option_t*) G__int(libp->para[2]));
         pobj = new TVectorT<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 2:
      {
         const TVectorT<double>* pobj;
         const TVectorT<double> xobj = ((const TVectorT<double>*) G__getstructoffset())->GetSub((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
         pobj = new TVectorT<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_113_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVectorT<double>& obj = ((TVectorT<double>*) G__getstructoffset())->SetSub((Int_t) G__int(libp->para[0]), *(TVectorT<double>*) libp->para[1].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_113_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVectorT<double>& obj = ((TVectorT<double>*) G__getstructoffset())->Zero();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_113_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVectorT<double>& obj = ((TVectorT<double>*) G__getstructoffset())->Abs();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_113_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVectorT<double>& obj = ((TVectorT<double>*) G__getstructoffset())->Sqr();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_113_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVectorT<double>& obj = ((TVectorT<double>*) G__getstructoffset())->Sqrt();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_113_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVectorT<double>& obj = ((TVectorT<double>*) G__getstructoffset())->Invert();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_113_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVectorT<double>& obj = ((TVectorT<double>*) G__getstructoffset())->SelectNonZeros(*(TVectorT<double>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_113_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TVectorT<double>*) G__getstructoffset())->Norm1());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_113_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TVectorT<double>*) G__getstructoffset())->Norm2Sqr());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_113_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TVectorT<double>*) G__getstructoffset())->NormInf());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_113_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TVectorT<double>*) G__getstructoffset())->NonZeros());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_113_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TVectorT<double>*) G__getstructoffset())->Sum());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_113_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TVectorT<double>*) G__getstructoffset())->Min());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_113_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TVectorT<double>*) G__getstructoffset())->Max());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_113_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const double& obj = ((const TVectorT<double>*) G__getstructoffset())->operator()((Int_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.d = (double) (obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_113_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const double& obj = ((TVectorT<double>*) G__getstructoffset())->operator()((Int_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.d = (double) (obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_113_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const double& obj = ((const TVectorT<double>*) G__getstructoffset())->operator[]((Int_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.d = (double) (obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_113_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const double& obj = ((TVectorT<double>*) G__getstructoffset())->operator[]((Int_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.d = (double) (obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_113_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVectorT<double>& obj = ((TVectorT<double>*) G__getstructoffset())->operator=(*(TVectorT<double>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_113_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVectorT<double>& obj = ((TVectorT<double>*) G__getstructoffset())->operator=(*(TMatrixTRow_const<double>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_113_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVectorT<double>& obj = ((TVectorT<double>*) G__getstructoffset())->operator=(*(TMatrixTColumn_const<double>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_113_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVectorT<double>& obj = ((TVectorT<double>*) G__getstructoffset())->operator=(*(TMatrixTDiag_const<double>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_113_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVectorT<double>& obj = ((TVectorT<double>*) G__getstructoffset())->operator=(*(TMatrixTSparseRow_const<double>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_113_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVectorT<double>& obj = ((TVectorT<double>*) G__getstructoffset())->operator=(*(TMatrixTSparseDiag_const<double>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_113_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVectorT<double>& obj = ((TVectorT<double>*) G__getstructoffset())->operator=((double) G__double(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_113_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVectorT<double>& obj = ((TVectorT<double>*) G__getstructoffset())->operator+=((double) G__double(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_113_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVectorT<double>& obj = ((TVectorT<double>*) G__getstructoffset())->operator-=((double) G__double(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_113_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVectorT<double>& obj = ((TVectorT<double>*) G__getstructoffset())->operator*=((double) G__double(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_113_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVectorT<double>& obj = ((TVectorT<double>*) G__getstructoffset())->operator+=(*(TVectorT<double>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_113_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVectorT<double>& obj = ((TVectorT<double>*) G__getstructoffset())->operator-=(*(TVectorT<double>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_113_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVectorT<double>& obj = ((TVectorT<double>*) G__getstructoffset())->operator*=(*(TMatrixT<double>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_113_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVectorT<double>& obj = ((TVectorT<double>*) G__getstructoffset())->operator*=(*(TMatrixTSym<double>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_113_0_69(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVectorT<double>& obj = ((TVectorT<double>*) G__getstructoffset())->operator*=(*(TMatrixTSparse<double>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_113_0_70(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TVectorT<double>*) G__getstructoffset())->operator==((double) G__double(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_113_0_71(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TVectorT<double>*) G__getstructoffset())->operator!=((double) G__double(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_113_0_72(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TVectorT<double>*) G__getstructoffset())->operator<((double) G__double(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_113_0_73(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TVectorT<double>*) G__getstructoffset())->operator<=((double) G__double(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_113_0_74(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TVectorT<double>*) G__getstructoffset())->operator>((double) G__double(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_113_0_75(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TVectorT<double>*) G__getstructoffset())->operator>=((double) G__double(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_113_0_76(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TVectorT<double>*) G__getstructoffset())->MatchesNonZeroPattern(*(TVectorT<double>*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_113_0_77(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TVectorT<double>*) G__getstructoffset())->SomePositive(*(TVectorT<double>*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_113_0_78(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVectorT<double>*) G__getstructoffset())->AddSomeConstant((double) G__double(libp->para[0]), *(TVectorT<double>*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_113_0_79(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVectorT<double>*) G__getstructoffset())->Randomize((double) G__double(libp->para[0]), (double) G__double(libp->para[1])
, *(Double_t*) G__Doubleref(&libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_113_0_80(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVectorT<double>& obj = ((TVectorT<double>*) G__getstructoffset())->Apply(*(TElementActionT<double>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_113_0_81(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVectorT<double>& obj = ((TVectorT<double>*) G__getstructoffset())->Apply(*(TElementPosActionT<double>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_113_0_82(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVectorT<double>*) G__getstructoffset())->Add(*(TVectorT<double>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_113_0_83(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVectorT<double>*) G__getstructoffset())->Add(*(TVectorT<double>*) libp->para[0].ref, *(TVectorT<double>*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_113_0_87(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TVectorT<double>::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_113_0_88(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TVectorT<double>::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_113_0_89(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TVectorT<double>::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_113_0_90(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TVectorT<double>::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_113_0_94(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TVectorT<double>*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_113_0_95(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TVectorT<double>::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_113_0_96(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TVectorT<double>::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_113_0_97(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TVectorT<double>::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_113_0_98(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TVectorT<double>::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_113_0_99(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TVectorT<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TVectorT<double>(*(TVectorT<float>*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TVectorT<double>(*(TVectorT<float>*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TVectorT<double> G__TTVectorTlEdoublegR;
static int G__G__Matrix_113_0_100(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TVectorT<double>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TVectorT<double>*) (soff+(sizeof(TVectorT<double>)*i)))->~G__TTVectorTlEdoublegR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TVectorT<double>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TVectorT<double>*) (soff))->~G__TTVectorTlEdoublegR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TMatrixT<double> */
static int G__G__Matrix_122_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixT<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMatrixT<double>[n];
     } else {
       p = new((void*) gvp) TMatrixT<double>[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMatrixT<double>;
     } else {
       p = new((void*) gvp) TMatrixT<double>;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_122_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixT<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixT<double>((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TMatrixT<double>((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_122_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixT<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 4
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixT<double>(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
   } else {
     p = new((void*) gvp) TMatrixT<double>(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_122_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixT<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMatrixT<double>(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (double*) G__int(libp->para[2]), (Option_t*) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TMatrixT<double>(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (double*) G__int(libp->para[2]), (Option_t*) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMatrixT<double>(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (double*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TMatrixT<double>(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (double*) G__int(libp->para[2]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_122_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixT<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMatrixT<double>(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (double*) G__int(libp->para[4]), (Option_t*) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TMatrixT<double>(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (double*) G__int(libp->para[4]), (Option_t*) G__int(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMatrixT<double>(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (double*) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TMatrixT<double>(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (double*) G__int(libp->para[4]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_122_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixT<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixT<double>(*(TMatrixT<double>*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TMatrixT<double>(*(TMatrixT<double>*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_122_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixT<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixT<double>(*(TMatrixTSym<double>*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TMatrixT<double>(*(TMatrixTSym<double>*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_122_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixT<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixT<double>(*(TMatrixTSparse<double>*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TMatrixT<double>(*(TMatrixTSparse<double>*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_122_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixT<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixT<double>((TMatrixT<double>::EMatrixCreatorsOp1) G__int(libp->para[0]), *(TMatrixT<double>*) libp->para[1].ref);
   } else {
     p = new((void*) gvp) TMatrixT<double>((TMatrixT<double>::EMatrixCreatorsOp1) G__int(libp->para[0]), *(TMatrixT<double>*) libp->para[1].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_122_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixT<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixT<double>(
*(TMatrixT<double>*) libp->para[0].ref, (TMatrixT<double>::EMatrixCreatorsOp2) G__int(libp->para[1])
, *(TMatrixT<double>*) libp->para[2].ref);
   } else {
     p = new((void*) gvp) TMatrixT<double>(
*(TMatrixT<double>*) libp->para[0].ref, (TMatrixT<double>::EMatrixCreatorsOp2) G__int(libp->para[1])
, *(TMatrixT<double>*) libp->para[2].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_122_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixT<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixT<double>(
*(TMatrixT<double>*) libp->para[0].ref, (TMatrixT<double>::EMatrixCreatorsOp2) G__int(libp->para[1])
, *(TMatrixTSym<double>*) libp->para[2].ref);
   } else {
     p = new((void*) gvp) TMatrixT<double>(
*(TMatrixT<double>*) libp->para[0].ref, (TMatrixT<double>::EMatrixCreatorsOp2) G__int(libp->para[1])
, *(TMatrixTSym<double>*) libp->para[2].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_122_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixT<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixT<double>(
*(TMatrixTSym<double>*) libp->para[0].ref, (TMatrixT<double>::EMatrixCreatorsOp2) G__int(libp->para[1])
, *(TMatrixT<double>*) libp->para[2].ref);
   } else {
     p = new((void*) gvp) TMatrixT<double>(
*(TMatrixTSym<double>*) libp->para[0].ref, (TMatrixT<double>::EMatrixCreatorsOp2) G__int(libp->para[1])
, *(TMatrixT<double>*) libp->para[2].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_122_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixT<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixT<double>(
*(TMatrixTSym<double>*) libp->para[0].ref, (TMatrixT<double>::EMatrixCreatorsOp2) G__int(libp->para[1])
, *(TMatrixTSym<double>*) libp->para[2].ref);
   } else {
     p = new((void*) gvp) TMatrixT<double>(
*(TMatrixTSym<double>*) libp->para[0].ref, (TMatrixT<double>::EMatrixCreatorsOp2) G__int(libp->para[1])
, *(TMatrixTSym<double>*) libp->para[2].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_122_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixT<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixT<double>(*(TMatrixTLazy<double>*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TMatrixT<double>(*(TMatrixTLazy<double>*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_122_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixT<double>*) G__getstructoffset())->Plus(*(TMatrixT<double>*) libp->para[0].ref, *(TMatrixT<double>*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_122_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixT<double>*) G__getstructoffset())->Plus(*(TMatrixT<double>*) libp->para[0].ref, *(TMatrixTSym<double>*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_122_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixT<double>*) G__getstructoffset())->Plus(*(TMatrixTSym<double>*) libp->para[0].ref, *(TMatrixT<double>*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_122_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixT<double>*) G__getstructoffset())->Minus(*(TMatrixT<double>*) libp->para[0].ref, *(TMatrixT<double>*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_122_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixT<double>*) G__getstructoffset())->Minus(*(TMatrixT<double>*) libp->para[0].ref, *(TMatrixTSym<double>*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_122_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixT<double>*) G__getstructoffset())->Minus(*(TMatrixTSym<double>*) libp->para[0].ref, *(TMatrixT<double>*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_122_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixT<double>*) G__getstructoffset())->Mult(*(TMatrixT<double>*) libp->para[0].ref, *(TMatrixT<double>*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_122_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixT<double>*) G__getstructoffset())->Mult(*(TMatrixT<double>*) libp->para[0].ref, *(TMatrixTSym<double>*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_122_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixT<double>*) G__getstructoffset())->Mult(*(TMatrixTSym<double>*) libp->para[0].ref, *(TMatrixT<double>*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_122_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixT<double>*) G__getstructoffset())->Mult(*(TMatrixTSym<double>*) libp->para[0].ref, *(TMatrixTSym<double>*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_122_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixT<double>*) G__getstructoffset())->TMult(*(TMatrixT<double>*) libp->para[0].ref, *(TMatrixT<double>*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_122_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixT<double>*) G__getstructoffset())->TMult(*(TMatrixT<double>*) libp->para[0].ref, *(TMatrixTSym<double>*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_122_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixT<double>*) G__getstructoffset())->TMult(*(TMatrixTSym<double>*) libp->para[0].ref, *(TMatrixT<double>*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_122_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixT<double>*) G__getstructoffset())->TMult(*(TMatrixTSym<double>*) libp->para[0].ref, *(TMatrixTSym<double>*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_122_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixT<double>*) G__getstructoffset())->MultT(*(TMatrixT<double>*) libp->para[0].ref, *(TMatrixT<double>*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_122_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixT<double>*) G__getstructoffset())->MultT(*(TMatrixT<double>*) libp->para[0].ref, *(TMatrixTSym<double>*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_122_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixT<double>*) G__getstructoffset())->MultT(*(TMatrixTSym<double>*) libp->para[0].ref, *(TMatrixT<double>*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_122_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixT<double>*) G__getstructoffset())->MultT(*(TMatrixTSym<double>*) libp->para[0].ref, *(TMatrixTSym<double>*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_122_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixT<double>& obj = ((TMatrixT<double>*) G__getstructoffset())->Use((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (double*) G__int(libp->para[4]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_122_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixT<double>& obj = ((const TMatrixT<double>*) G__getstructoffset())->Use((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (double*) G__int(libp->para[4]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_122_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixT<double>& obj = ((TMatrixT<double>*) G__getstructoffset())->Use((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (double*) G__int(libp->para[2]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_122_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixT<double>& obj = ((const TMatrixT<double>*) G__getstructoffset())->Use((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (double*) G__int(libp->para[2]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_122_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixT<double>& obj = ((TMatrixT<double>*) G__getstructoffset())->Use(*(TMatrixT<double>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_122_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixT<double>& obj = ((const TMatrixT<double>*) G__getstructoffset())->Use(*(TMatrixT<double>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_122_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      {
         const TMatrixT<double>* pobj;
         const TMatrixT<double> xobj = ((const TMatrixT<double>*) G__getstructoffset())->GetSub((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Option_t*) G__int(libp->para[4]));
         pobj = new TMatrixT<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 4:
      {
         const TMatrixT<double>* pobj;
         const TMatrixT<double> xobj = ((const TMatrixT<double>*) G__getstructoffset())->GetSub((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
         pobj = new TMatrixT<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_122_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTBase<double>& obj = ((TMatrixT<double>*) G__getstructoffset())->ResizeTo(*(TMatrixT<double>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_122_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      {
         const TMatrixT<double>& obj = ((TMatrixT<double>*) G__getstructoffset())->Invert((Double_t*) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
      break;
   case 0:
      {
         const TMatrixT<double>& obj = ((TMatrixT<double>*) G__getstructoffset())->Invert();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_122_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      {
         const TMatrixT<double>& obj = ((TMatrixT<double>*) G__getstructoffset())->InvertFast((Double_t*) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
      break;
   case 0:
      {
         const TMatrixT<double>& obj = ((TMatrixT<double>*) G__getstructoffset())->InvertFast();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_122_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixT<double>& obj = ((TMatrixT<double>*) G__getstructoffset())->Transpose(*(TMatrixT<double>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_122_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixT<double>& obj = ((TMatrixT<double>*) G__getstructoffset())->T();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_122_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      {
         const TMatrixT<double>& obj = ((TMatrixT<double>*) G__getstructoffset())->Rank1Update(*(TVectorT<double>*) libp->para[0].ref, (double) G__double(libp->para[1]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
      break;
   case 1:
      {
         const TMatrixT<double>& obj = ((TMatrixT<double>*) G__getstructoffset())->Rank1Update(*(TVectorT<double>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_122_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      {
         const TMatrixT<double>& obj = ((TMatrixT<double>*) G__getstructoffset())->Rank1Update(*(TVectorT<double>*) libp->para[0].ref, *(TVectorT<double>*) libp->para[1].ref
, (double) G__double(libp->para[2]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
      break;
   case 2:
      {
         const TMatrixT<double>& obj = ((TMatrixT<double>*) G__getstructoffset())->Rank1Update(*(TVectorT<double>*) libp->para[0].ref, *(TVectorT<double>*) libp->para[1].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_122_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMatrixT<double>*) G__getstructoffset())->Similarity(*(TVectorT<double>*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_122_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      {
         const TMatrixT<double>& obj = ((TMatrixT<double>*) G__getstructoffset())->NormByColumn(*(TVectorT<double>*) libp->para[0].ref, (Option_t*) G__int(libp->para[1]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
      break;
   case 1:
      {
         const TMatrixT<double>& obj = ((TMatrixT<double>*) G__getstructoffset())->NormByColumn(*(TVectorT<double>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_122_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      {
         const TMatrixT<double>& obj = ((TMatrixT<double>*) G__getstructoffset())->NormByRow(*(TVectorT<double>*) libp->para[0].ref, (Option_t*) G__int(libp->para[1]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
      break;
   case 1:
      {
         const TMatrixT<double>& obj = ((TMatrixT<double>*) G__getstructoffset())->NormByRow(*(TVectorT<double>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_122_0_71(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTRow_const<double>* pobj;
         const TMatrixTRow_const<double> xobj = ((const TMatrixT<double>*) G__getstructoffset())->operator[]((Int_t) G__int(libp->para[0]));
         pobj = new TMatrixTRow_const<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_122_0_72(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixTRow<double>* pobj;
         TMatrixTRow<double> xobj = ((TMatrixT<double>*) G__getstructoffset())->operator[]((Int_t) G__int(libp->para[0]));
         pobj = new TMatrixTRow<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_122_0_73(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixT<double>& obj = ((TMatrixT<double>*) G__getstructoffset())->operator=(*(TMatrixT<double>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_122_0_74(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixT<double>& obj = ((TMatrixT<double>*) G__getstructoffset())->operator=(*(TMatrixTSym<double>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_122_0_75(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixT<double>& obj = ((TMatrixT<double>*) G__getstructoffset())->operator=(*(TMatrixTSparse<double>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_122_0_76(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixT<double>& obj = ((TMatrixT<double>*) G__getstructoffset())->operator=(*(TMatrixTLazy<double>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_122_0_77(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixT<double>& obj = ((TMatrixT<double>*) G__getstructoffset())->operator=((double) G__double(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_122_0_78(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixT<double>& obj = ((TMatrixT<double>*) G__getstructoffset())->operator-=((double) G__double(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_122_0_79(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixT<double>& obj = ((TMatrixT<double>*) G__getstructoffset())->operator+=((double) G__double(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_122_0_80(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixT<double>& obj = ((TMatrixT<double>*) G__getstructoffset())->operator*=((double) G__double(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_122_0_81(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixT<double>& obj = ((TMatrixT<double>*) G__getstructoffset())->operator+=(*(TMatrixT<double>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_122_0_82(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixT<double>& obj = ((TMatrixT<double>*) G__getstructoffset())->operator+=(*(TMatrixTSym<double>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_122_0_83(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixT<double>& obj = ((TMatrixT<double>*) G__getstructoffset())->operator-=(*(TMatrixT<double>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_122_0_84(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixT<double>& obj = ((TMatrixT<double>*) G__getstructoffset())->operator-=(*(TMatrixTSym<double>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_122_0_85(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixT<double>& obj = ((TMatrixT<double>*) G__getstructoffset())->operator*=(*(TMatrixT<double>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_122_0_86(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixT<double>& obj = ((TMatrixT<double>*) G__getstructoffset())->operator*=(*(TMatrixTSym<double>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_122_0_87(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixT<double>& obj = ((TMatrixT<double>*) G__getstructoffset())->operator*=(*(TMatrixTDiag_const<double>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_122_0_88(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixT<double>& obj = ((TMatrixT<double>*) G__getstructoffset())->operator/=(*(TMatrixTDiag_const<double>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_122_0_89(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixT<double>& obj = ((TMatrixT<double>*) G__getstructoffset())->operator*=(*(TMatrixTRow_const<double>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_122_0_90(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixT<double>& obj = ((TMatrixT<double>*) G__getstructoffset())->operator/=(*(TMatrixTRow_const<double>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_122_0_91(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixT<double>& obj = ((TMatrixT<double>*) G__getstructoffset())->operator*=(*(TMatrixTColumn_const<double>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_122_0_92(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixT<double>& obj = ((TMatrixT<double>*) G__getstructoffset())->operator/=(*(TMatrixTColumn_const<double>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_122_0_93(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixT<double>* pobj;
         const TMatrixT<double> xobj = ((const TMatrixT<double>*) G__getstructoffset())->EigenVectors(*(TVectorT<double>*) libp->para[0].ref);
         pobj = new TMatrixT<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_122_0_94(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TMatrixT<double>::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_122_0_95(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixT<double>::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_122_0_96(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TMatrixT<double>::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_122_0_97(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TMatrixT<double>::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_122_0_101(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixT<double>*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_122_0_102(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixT<double>::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_122_0_103(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMatrixT<double>::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_122_0_104(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixT<double>::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_122_0_105(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMatrixT<double>::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TMatrixT<double> G__TTMatrixTlEdoublegR;
static int G__G__Matrix_122_0_106(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TMatrixT<double>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMatrixT<double>*) (soff+(sizeof(TMatrixT<double>)*i)))->~G__TTMatrixTlEdoublegR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMatrixT<double>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMatrixT<double>*) (soff))->~G__TTMatrixTlEdoublegR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TMatrixTSym<double> */
static int G__G__Matrix_126_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTSym<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMatrixTSym<double>[n];
     } else {
       p = new((void*) gvp) TMatrixTSym<double>[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMatrixTSym<double>;
     } else {
       p = new((void*) gvp) TMatrixTSym<double>;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_126_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTSym<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixTSym<double>((Int_t) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TMatrixTSym<double>((Int_t) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_126_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTSym<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixTSym<double>((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TMatrixTSym<double>((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_126_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTSym<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMatrixTSym<double>(
(Int_t) G__int(libp->para[0]), (double*) G__int(libp->para[1])
, (Option_t*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TMatrixTSym<double>(
(Int_t) G__int(libp->para[0]), (double*) G__int(libp->para[1])
, (Option_t*) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMatrixTSym<double>((Int_t) G__int(libp->para[0]), (double*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TMatrixTSym<double>((Int_t) G__int(libp->para[0]), (double*) G__int(libp->para[1]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_126_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTSym<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMatrixTSym<double>(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (double*) G__int(libp->para[2]), (Option_t*) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TMatrixTSym<double>(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (double*) G__int(libp->para[2]), (Option_t*) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMatrixTSym<double>(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (double*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TMatrixTSym<double>(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (double*) G__int(libp->para[2]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_126_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTSym<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixTSym<double>(*(TMatrixTSym<double>*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TMatrixTSym<double>(*(TMatrixTSym<double>*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_126_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTSym<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixTSym<double>((TMatrixTSym<double>::EMatrixCreatorsOp1) G__int(libp->para[0]), *(TMatrixTSym<double>*) libp->para[1].ref);
   } else {
     p = new((void*) gvp) TMatrixTSym<double>((TMatrixTSym<double>::EMatrixCreatorsOp1) G__int(libp->para[0]), *(TMatrixTSym<double>*) libp->para[1].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_126_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTSym<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixTSym<double>((TMatrixTSym<double>::EMatrixCreatorsOp1) G__int(libp->para[0]), *(TMatrixT<double>*) libp->para[1].ref);
   } else {
     p = new((void*) gvp) TMatrixTSym<double>((TMatrixTSym<double>::EMatrixCreatorsOp1) G__int(libp->para[0]), *(TMatrixT<double>*) libp->para[1].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_126_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTSym<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixTSym<double>(
*(TMatrixTSym<double>*) libp->para[0].ref, (TMatrixTSym<double>::EMatrixCreatorsOp2) G__int(libp->para[1])
, *(TMatrixTSym<double>*) libp->para[2].ref);
   } else {
     p = new((void*) gvp) TMatrixTSym<double>(
*(TMatrixTSym<double>*) libp->para[0].ref, (TMatrixTSym<double>::EMatrixCreatorsOp2) G__int(libp->para[1])
, *(TMatrixTSym<double>*) libp->para[2].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_126_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTSym<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixTSym<double>(*(TMatrixTSymLazy<double>*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TMatrixTSym<double>(*(TMatrixTSymLazy<double>*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_126_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTSym<double>*) G__getstructoffset())->TMult(*(TMatrixT<double>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_126_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTSym<double>*) G__getstructoffset())->TMult(*(TMatrixTSym<double>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_126_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTSym<double>*) G__getstructoffset())->Mult(*(TMatrixTSym<double>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_126_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTSym<double>*) G__getstructoffset())->Plus(*(TMatrixTSym<double>*) libp->para[0].ref, *(TMatrixTSym<double>*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_126_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTSym<double>*) G__getstructoffset())->Minus(*(TMatrixTSym<double>*) libp->para[0].ref, *(TMatrixTSym<double>*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_126_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSym<double>& obj = ((TMatrixTSym<double>*) G__getstructoffset())->Use((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (double*) G__int(libp->para[2]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_126_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSym<double>& obj = ((const TMatrixTSym<double>*) G__getstructoffset())->Use((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (double*) G__int(libp->para[2]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_126_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSym<double>& obj = ((TMatrixTSym<double>*) G__getstructoffset())->Use((Int_t) G__int(libp->para[0]), (double*) G__int(libp->para[1]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_126_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSym<double>& obj = ((const TMatrixTSym<double>*) G__getstructoffset())->Use((Int_t) G__int(libp->para[0]), (double*) G__int(libp->para[1]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_126_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSym<double>& obj = ((TMatrixTSym<double>*) G__getstructoffset())->Use(*(TMatrixTSym<double>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_126_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSym<double>& obj = ((const TMatrixTSym<double>*) G__getstructoffset())->Use(*(TMatrixTSym<double>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_126_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      {
         const TMatrixTSym<double>& obj = ((const TMatrixTSym<double>*) G__getstructoffset())->GetSub((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, *(TMatrixTSym<double>*) libp->para[2].ref, (Option_t*) G__int(libp->para[3]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
      break;
   case 3:
      {
         const TMatrixTSym<double>& obj = ((const TMatrixTSym<double>*) G__getstructoffset())->GetSub((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, *(TMatrixTSym<double>*) libp->para[2].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_126_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      {
         const TMatrixTSym<double>* pobj;
         const TMatrixTSym<double> xobj = ((const TMatrixTSym<double>*) G__getstructoffset())->GetSub((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Option_t*) G__int(libp->para[4]));
         pobj = new TMatrixTSym<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 4:
      {
         const TMatrixTSym<double>* pobj;
         const TMatrixTSym<double> xobj = ((const TMatrixTSym<double>*) G__getstructoffset())->GetSub((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
         pobj = new TMatrixTSym<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_126_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSym<double>& obj = ((TMatrixTSym<double>*) G__getstructoffset())->SetSub((Int_t) G__int(libp->para[0]), *(TMatrixTBase<double>*) libp->para[1].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_126_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTBase<double>& obj = ((TMatrixTSym<double>*) G__getstructoffset())->ResizeTo(*(TMatrixTSym<double>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_126_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      {
         const TMatrixTSym<double>& obj = ((TMatrixTSym<double>*) G__getstructoffset())->Invert((Double_t*) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
      break;
   case 0:
      {
         const TMatrixTSym<double>& obj = ((TMatrixTSym<double>*) G__getstructoffset())->Invert();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_126_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      {
         const TMatrixTSym<double>& obj = ((TMatrixTSym<double>*) G__getstructoffset())->InvertFast((Double_t*) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
      break;
   case 0:
      {
         const TMatrixTSym<double>& obj = ((TMatrixTSym<double>*) G__getstructoffset())->InvertFast();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_126_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSym<double>& obj = ((TMatrixTSym<double>*) G__getstructoffset())->Transpose(*(TMatrixTSym<double>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_126_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSym<double>& obj = ((TMatrixTSym<double>*) G__getstructoffset())->T();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_126_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      {
         const TMatrixTSym<double>& obj = ((TMatrixTSym<double>*) G__getstructoffset())->Rank1Update(*(TVectorT<double>*) libp->para[0].ref, (double) G__double(libp->para[1]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
      break;
   case 1:
      {
         const TMatrixTSym<double>& obj = ((TMatrixTSym<double>*) G__getstructoffset())->Rank1Update(*(TVectorT<double>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_126_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSym<double>& obj = ((TMatrixTSym<double>*) G__getstructoffset())->Similarity(*(TMatrixT<double>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_126_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSym<double>& obj = ((TMatrixTSym<double>*) G__getstructoffset())->Similarity(*(TMatrixTSym<double>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_126_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMatrixTSym<double>*) G__getstructoffset())->Similarity(*(TVectorT<double>*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_126_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSym<double>& obj = ((TMatrixTSym<double>*) G__getstructoffset())->SimilarityT(*(TMatrixT<double>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_126_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTRow_const<double>* pobj;
         const TMatrixTRow_const<double> xobj = ((const TMatrixTSym<double>*) G__getstructoffset())->operator[]((Int_t) G__int(libp->para[0]));
         pobj = new TMatrixTRow_const<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_126_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixTRow<double>* pobj;
         TMatrixTRow<double> xobj = ((TMatrixTSym<double>*) G__getstructoffset())->operator[]((Int_t) G__int(libp->para[0]));
         pobj = new TMatrixTRow<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_126_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSym<double>& obj = ((TMatrixTSym<double>*) G__getstructoffset())->operator=(*(TMatrixTSym<double>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_126_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSym<double>& obj = ((TMatrixTSym<double>*) G__getstructoffset())->operator=(*(TMatrixTSymLazy<double>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_126_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSym<double>& obj = ((TMatrixTSym<double>*) G__getstructoffset())->operator=((double) G__double(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_126_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSym<double>& obj = ((TMatrixTSym<double>*) G__getstructoffset())->operator-=((double) G__double(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_126_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSym<double>& obj = ((TMatrixTSym<double>*) G__getstructoffset())->operator+=((double) G__double(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_126_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSym<double>& obj = ((TMatrixTSym<double>*) G__getstructoffset())->operator*=((double) G__double(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_126_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSym<double>& obj = ((TMatrixTSym<double>*) G__getstructoffset())->operator+=(*(TMatrixTSym<double>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_126_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSym<double>& obj = ((TMatrixTSym<double>*) G__getstructoffset())->operator-=(*(TMatrixTSym<double>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_126_0_72(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSym<double>& obj = ((TMatrixTSym<double>*) G__getstructoffset())->RandomizePD((double) G__double(libp->para[0]), (double) G__double(libp->para[1])
, *(Double_t*) G__Doubleref(&libp->para[2]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_126_0_73(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixT<double>* pobj;
         const TMatrixT<double> xobj = ((const TMatrixTSym<double>*) G__getstructoffset())->EigenVectors(*(TVectorT<double>*) libp->para[0].ref);
         pobj = new TMatrixT<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_126_0_74(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TMatrixTSym<double>::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_126_0_75(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTSym<double>::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_126_0_76(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TMatrixTSym<double>::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_126_0_77(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TMatrixTSym<double>::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_126_0_81(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTSym<double>*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_126_0_82(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTSym<double>::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_126_0_83(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMatrixTSym<double>::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_126_0_84(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTSym<double>::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_126_0_85(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMatrixTSym<double>::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TMatrixTSym<double> G__TTMatrixTSymlEdoublegR;
static int G__G__Matrix_126_0_86(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TMatrixTSym<double>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMatrixTSym<double>*) (soff+(sizeof(TMatrixTSym<double>)*i)))->~G__TTMatrixTSymlEdoublegR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMatrixTSym<double>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMatrixTSym<double>*) (soff))->~G__TTMatrixTSymlEdoublegR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TMatrixTSparse<double> */
static int G__G__Matrix_127_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTSparse<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMatrixTSparse<double>[n];
     } else {
       p = new((void*) gvp) TMatrixTSparse<double>[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMatrixTSparse<double>;
     } else {
       p = new((void*) gvp) TMatrixTSparse<double>;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_127_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTSparse<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixTSparse<double>((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TMatrixTSparse<double>((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_127_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTSparse<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 4
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixTSparse<double>(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
   } else {
     p = new((void*) gvp) TMatrixTSparse<double>(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_127_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTSparse<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 8
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixTSparse<double>(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t*) G__int(libp->para[5])
, (Int_t*) G__int(libp->para[6]), (double*) G__int(libp->para[7]));
   } else {
     p = new((void*) gvp) TMatrixTSparse<double>(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t*) G__int(libp->para[5])
, (Int_t*) G__int(libp->para[6]), (double*) G__int(libp->para[7]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_127_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTSparse<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixTSparse<double>(*(TMatrixTSparse<double>*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TMatrixTSparse<double>(*(TMatrixTSparse<double>*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_127_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTSparse<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixTSparse<double>(*(TMatrixT<double>*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TMatrixTSparse<double>(*(TMatrixT<double>*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_127_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTSparse<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixTSparse<double>((TMatrixTSparse<double>::EMatrixCreatorsOp1) G__int(libp->para[0]), *(TMatrixTSparse<double>*) libp->para[1].ref);
   } else {
     p = new((void*) gvp) TMatrixTSparse<double>((TMatrixTSparse<double>::EMatrixCreatorsOp1) G__int(libp->para[0]), *(TMatrixTSparse<double>*) libp->para[1].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_127_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTSparse<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixTSparse<double>(
*(TMatrixTSparse<double>*) libp->para[0].ref, (TMatrixTSparse<double>::EMatrixCreatorsOp2) G__int(libp->para[1])
, *(TMatrixTSparse<double>*) libp->para[2].ref);
   } else {
     p = new((void*) gvp) TMatrixTSparse<double>(
*(TMatrixTSparse<double>*) libp->para[0].ref, (TMatrixTSparse<double>::EMatrixCreatorsOp2) G__int(libp->para[1])
, *(TMatrixTSparse<double>*) libp->para[2].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_127_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTSparse<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixTSparse<double>(
*(TMatrixTSparse<double>*) libp->para[0].ref, (TMatrixTSparse<double>::EMatrixCreatorsOp2) G__int(libp->para[1])
, *(TMatrixT<double>*) libp->para[2].ref);
   } else {
     p = new((void*) gvp) TMatrixTSparse<double>(
*(TMatrixTSparse<double>*) libp->para[0].ref, (TMatrixTSparse<double>::EMatrixCreatorsOp2) G__int(libp->para[1])
, *(TMatrixT<double>*) libp->para[2].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_127_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTSparse<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixTSparse<double>(
*(TMatrixT<double>*) libp->para[0].ref, (TMatrixTSparse<double>::EMatrixCreatorsOp2) G__int(libp->para[1])
, *(TMatrixTSparse<double>*) libp->para[2].ref);
   } else {
     p = new((void*) gvp) TMatrixTSparse<double>(
*(TMatrixT<double>*) libp->para[0].ref, (TMatrixTSparse<double>::EMatrixCreatorsOp2) G__int(libp->para[1])
, *(TMatrixTSparse<double>*) libp->para[2].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_127_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSparse<double>& obj = ((TMatrixTSparse<double>*) G__getstructoffset())->SetSparseIndex((Int_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_127_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSparse<double>& obj = ((TMatrixTSparse<double>*) G__getstructoffset())->SetSparseIndex(*(TMatrixTBase<double>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_127_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSparse<double>& obj = ((TMatrixTSparse<double>*) G__getstructoffset())->SetSparseIndexAB(*(TMatrixTSparse<double>*) libp->para[0].ref, *(TMatrixTSparse<double>*) libp->para[1].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_127_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSparse<double>& obj = ((TMatrixTSparse<double>*) G__getstructoffset())->SetSparseIndexAB(*(TMatrixT<double>*) libp->para[0].ref, *(TMatrixTSparse<double>*) libp->para[1].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_127_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSparse<double>& obj = ((TMatrixTSparse<double>*) G__getstructoffset())->SetSparseIndexAB(*(TMatrixTSparse<double>*) libp->para[0].ref, *(TMatrixT<double>*) libp->para[1].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_127_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTBase<double>& obj = ((TMatrixTSparse<double>*) G__getstructoffset())->SetMatrixArray((Int_t) G__int(libp->para[0]), (Int_t*) G__int(libp->para[1])
, (Int_t*) G__int(libp->para[2]), (double*) G__int(libp->para[3]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_127_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTBase<double>& obj = ((TMatrixTSparse<double>*) G__getstructoffset())->ResizeTo(*(TMatrixTSparse<double>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_127_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSparse<double>& obj = ((TMatrixTSparse<double>*) G__getstructoffset())->Use(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t*) G__int(libp->para[5])
, (Int_t*) G__int(libp->para[6]), (double*) G__int(libp->para[7]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_127_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSparse<double>& obj = ((const TMatrixTSparse<double>*) G__getstructoffset())->Use(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (const Int_t*) G__int(libp->para[5])
, (const Int_t*) G__int(libp->para[6]), (double*) G__int(libp->para[7]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_127_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSparse<double>& obj = ((TMatrixTSparse<double>*) G__getstructoffset())->Use((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t*) G__int(libp->para[3])
, (Int_t*) G__int(libp->para[4]), (double*) G__int(libp->para[5]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_127_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSparse<double>& obj = ((const TMatrixTSparse<double>*) G__getstructoffset())->Use((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (const Int_t*) G__int(libp->para[3])
, (const Int_t*) G__int(libp->para[4]), (double*) G__int(libp->para[5]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_127_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSparse<double>& obj = ((TMatrixTSparse<double>*) G__getstructoffset())->Use(*(TMatrixTSparse<double>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_127_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSparse<double>& obj = ((const TMatrixTSparse<double>*) G__getstructoffset())->Use(*(TMatrixTSparse<double>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_127_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      {
         const TMatrixTSparse<double>* pobj;
         const TMatrixTSparse<double> xobj = ((const TMatrixTSparse<double>*) G__getstructoffset())->GetSub((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Option_t*) G__int(libp->para[4]));
         pobj = new TMatrixTSparse<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 4:
      {
         const TMatrixTSparse<double>* pobj;
         const TMatrixTSparse<double> xobj = ((const TMatrixTSparse<double>*) G__getstructoffset())->GetSub((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
         pobj = new TMatrixTSparse<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_127_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSparse<double>& obj = ((TMatrixTSparse<double>*) G__getstructoffset())->Transpose(*(TMatrixTSparse<double>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_127_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSparse<double>& obj = ((TMatrixTSparse<double>*) G__getstructoffset())->T();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_127_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTSparse<double>*) G__getstructoffset())->Mult(*(TMatrixTSparse<double>*) libp->para[0].ref, *(TMatrixTSparse<double>*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_127_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSparseRow_const<double>* pobj;
         const TMatrixTSparseRow_const<double> xobj = ((const TMatrixTSparse<double>*) G__getstructoffset())->operator[]((Int_t) G__int(libp->para[0]));
         pobj = new TMatrixTSparseRow_const<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_127_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixTSparseRow<double>* pobj;
         TMatrixTSparseRow<double> xobj = ((TMatrixTSparse<double>*) G__getstructoffset())->operator[]((Int_t) G__int(libp->para[0]));
         pobj = new TMatrixTSparseRow<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_127_0_69(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSparse<double>& obj = ((TMatrixTSparse<double>*) G__getstructoffset())->operator=(*(TMatrixT<double>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_127_0_70(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSparse<double>& obj = ((TMatrixTSparse<double>*) G__getstructoffset())->operator=(*(TMatrixTSparse<double>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_127_0_71(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSparse<double>& obj = ((TMatrixTSparse<double>*) G__getstructoffset())->operator=((double) G__double(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_127_0_72(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSparse<double>& obj = ((TMatrixTSparse<double>*) G__getstructoffset())->operator-=((double) G__double(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_127_0_73(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSparse<double>& obj = ((TMatrixTSparse<double>*) G__getstructoffset())->operator+=((double) G__double(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_127_0_74(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSparse<double>& obj = ((TMatrixTSparse<double>*) G__getstructoffset())->operator*=((double) G__double(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_127_0_75(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSparse<double>& obj = ((TMatrixTSparse<double>*) G__getstructoffset())->operator+=(*(TMatrixTSparse<double>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_127_0_76(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSparse<double>& obj = ((TMatrixTSparse<double>*) G__getstructoffset())->operator+=(*(TMatrixT<double>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_127_0_77(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSparse<double>& obj = ((TMatrixTSparse<double>*) G__getstructoffset())->operator-=(*(TMatrixTSparse<double>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_127_0_78(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSparse<double>& obj = ((TMatrixTSparse<double>*) G__getstructoffset())->operator-=(*(TMatrixT<double>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_127_0_79(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSparse<double>& obj = ((TMatrixTSparse<double>*) G__getstructoffset())->operator*=(*(TMatrixTSparse<double>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_127_0_80(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSparse<double>& obj = ((TMatrixTSparse<double>*) G__getstructoffset())->operator*=(*(TMatrixT<double>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_127_0_82(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSparse<double>& obj = ((TMatrixTSparse<double>*) G__getstructoffset())->RandomizePD((double) G__double(libp->para[0]), (double) G__double(libp->para[1])
, *(Double_t*) G__Doubleref(&libp->para[2]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_127_0_83(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TMatrixTSparse<double>::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_127_0_84(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTSparse<double>::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_127_0_85(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TMatrixTSparse<double>::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_127_0_86(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TMatrixTSparse<double>::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_127_0_90(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTSparse<double>*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_127_0_91(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTSparse<double>::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_127_0_92(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMatrixTSparse<double>::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_127_0_93(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTSparse<double>::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_127_0_94(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMatrixTSparse<double>::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TMatrixTSparse<double> G__TTMatrixTSparselEdoublegR;
static int G__G__Matrix_127_0_95(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TMatrixTSparse<double>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMatrixTSparse<double>*) (soff+(sizeof(TMatrixTSparse<double>)*i)))->~G__TTMatrixTSparselEdoublegR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMatrixTSparse<double>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMatrixTSparse<double>*) (soff))->~G__TTMatrixTSparselEdoublegR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TMatrixTLazy<double> */
static int G__G__Matrix_128_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMatrixTLazy<double>*) G__getstructoffset())->GetRowLwb());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_128_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMatrixTLazy<double>*) G__getstructoffset())->GetRowUpb());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_128_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMatrixTLazy<double>*) G__getstructoffset())->GetColLwb());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_128_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMatrixTLazy<double>*) G__getstructoffset())->GetColUpb());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_128_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TMatrixTLazy<double>::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_128_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTLazy<double>::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_128_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TMatrixTLazy<double>::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_128_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TMatrixTLazy<double>::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_128_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTLazy<double>*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_128_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTLazy<double>::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_128_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMatrixTLazy<double>::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_128_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTLazy<double>::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_128_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMatrixTLazy<double>::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TMatrixTLazy<double> G__TTMatrixTLazylEdoublegR;
static int G__G__Matrix_128_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TMatrixTLazy<double>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMatrixTLazy<double>*) (soff+(sizeof(TMatrixTLazy<double>)*i)))->~G__TTMatrixTLazylEdoublegR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMatrixTLazy<double>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMatrixTLazy<double>*) (soff))->~G__TTMatrixTLazylEdoublegR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TMatrixTRow_const<double> */
static int G__G__Matrix_129_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTRow_const<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMatrixTRow_const<double>[n];
     } else {
       p = new((void*) gvp) TMatrixTRow_const<double>[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMatrixTRow_const<double>;
     } else {
       p = new((void*) gvp) TMatrixTRow_const<double>;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTRow_constlEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_129_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTRow_const<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixTRow_const<double>(*(TMatrixT<double>*) libp->para[0].ref, (Int_t) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TMatrixTRow_const<double>(*(TMatrixT<double>*) libp->para[0].ref, (Int_t) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTRow_constlEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_129_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTRow_const<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixTRow_const<double>(*(TMatrixTSym<double>*) libp->para[0].ref, (Int_t) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TMatrixTRow_const<double>(*(TMatrixTSym<double>*) libp->para[0].ref, (Int_t) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTRow_constlEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_129_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTRow_const<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixTRow_const<double>(*(TMatrixTRow_const<double>*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TMatrixTRow_const<double>(*(TMatrixTRow_const<double>*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTRow_constlEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_129_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTRow_const<double>& obj = ((TMatrixTRow_const<double>*) G__getstructoffset())->operator=(*(TMatrixTRow_const<double>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_129_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TMatrixTRow_const<double>*) G__getstructoffset())->GetMatrix());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_129_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMatrixTRow_const<double>*) G__getstructoffset())->GetRowIndex());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_129_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMatrixTRow_const<double>*) G__getstructoffset())->GetInc());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_129_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((const TMatrixTRow_const<double>*) G__getstructoffset())->GetPtr());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_129_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const double& obj = ((const TMatrixTRow_const<double>*) G__getstructoffset())->operator()((Int_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.d = (double) (obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_129_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const double& obj = ((const TMatrixTRow_const<double>*) G__getstructoffset())->operator[]((Int_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.d = (double) (obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_129_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TMatrixTRow_const<double>::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_129_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTRow_const<double>::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_129_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TMatrixTRow_const<double>::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_129_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TMatrixTRow_const<double>::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_129_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TMatrixTRow_const<double>*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_129_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTRow_const<double>*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_129_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTRow_const<double>*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_129_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTRow_const<double>*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_129_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTRow_const<double>::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_129_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMatrixTRow_const<double>::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_129_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTRow_const<double>::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_129_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMatrixTRow_const<double>::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TMatrixTRow_const<double> G__TTMatrixTRow_constlEdoublegR;
static int G__G__Matrix_129_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TMatrixTRow_const<double>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMatrixTRow_const<double>*) (soff+(sizeof(TMatrixTRow_const<double>)*i)))->~G__TTMatrixTRow_constlEdoublegR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMatrixTRow_const<double>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMatrixTRow_const<double>*) (soff))->~G__TTMatrixTRow_constlEdoublegR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TMatrixTRow<double> */
static int G__G__Matrix_130_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTRow<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMatrixTRow<double>[n];
     } else {
       p = new((void*) gvp) TMatrixTRow<double>[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMatrixTRow<double>;
     } else {
       p = new((void*) gvp) TMatrixTRow<double>;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTRowlEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_130_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTRow<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixTRow<double>(*(TMatrixT<double>*) libp->para[0].ref, (Int_t) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TMatrixTRow<double>(*(TMatrixT<double>*) libp->para[0].ref, (Int_t) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTRowlEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_130_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTRow<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixTRow<double>(*(TMatrixTSym<double>*) libp->para[0].ref, (Int_t) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TMatrixTRow<double>(*(TMatrixTSym<double>*) libp->para[0].ref, (Int_t) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTRowlEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_130_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTRow<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixTRow<double>(*(TMatrixTRow<double>*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TMatrixTRow<double>(*(TMatrixTRow<double>*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTRowlEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_130_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((const TMatrixTRow<double>*) G__getstructoffset())->GetPtr());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_130_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const double& obj = ((const TMatrixTRow<double>*) G__getstructoffset())->operator()((Int_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.d = (double) (obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_130_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const double& obj = ((TMatrixTRow<double>*) G__getstructoffset())->operator()((Int_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.d = (double) (obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_130_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const double& obj = ((const TMatrixTRow<double>*) G__getstructoffset())->operator[]((Int_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.d = (double) (obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_130_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const double& obj = ((TMatrixTRow<double>*) G__getstructoffset())->operator[]((Int_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.d = (double) (obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_130_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTRow<double>*) G__getstructoffset())->operator=((double) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_130_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTRow<double>*) G__getstructoffset())->operator+=((double) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_130_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTRow<double>*) G__getstructoffset())->operator*=((double) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_130_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTRow<double>*) G__getstructoffset())->operator=(*(TMatrixTRow_const<double>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_130_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTRow<double>& obj = ((TMatrixTRow<double>*) G__getstructoffset())->operator=(*(TMatrixTRow<double>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_130_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTRow<double>*) G__getstructoffset())->operator=(*(TVectorT<double>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_130_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTRow<double>*) G__getstructoffset())->operator+=(*(TMatrixTRow_const<double>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_130_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTRow<double>*) G__getstructoffset())->operator*=(*(TMatrixTRow_const<double>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_130_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TMatrixTRow<double>::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_130_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTRow<double>::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_130_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TMatrixTRow<double>::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_130_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TMatrixTRow<double>::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_130_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTRow<double>*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_130_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTRow<double>::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_130_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMatrixTRow<double>::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_130_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTRow<double>::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_130_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMatrixTRow<double>::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TMatrixTRow<double> G__TTMatrixTRowlEdoublegR;
static int G__G__Matrix_130_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TMatrixTRow<double>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMatrixTRow<double>*) (soff+(sizeof(TMatrixTRow<double>)*i)))->~G__TTMatrixTRowlEdoublegR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMatrixTRow<double>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMatrixTRow<double>*) (soff))->~G__TTMatrixTRowlEdoublegR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TMatrixTDiag_const<double> */
static int G__G__Matrix_131_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTDiag_const<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMatrixTDiag_const<double>[n];
     } else {
       p = new((void*) gvp) TMatrixTDiag_const<double>[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMatrixTDiag_const<double>;
     } else {
       p = new((void*) gvp) TMatrixTDiag_const<double>;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTDiag_constlEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_131_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTDiag_const<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixTDiag_const<double>(*(TMatrixT<double>*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TMatrixTDiag_const<double>(*(TMatrixT<double>*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTDiag_constlEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_131_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTDiag_const<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixTDiag_const<double>(*(TMatrixTSym<double>*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TMatrixTDiag_const<double>(*(TMatrixTSym<double>*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTDiag_constlEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_131_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTDiag_const<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixTDiag_const<double>(*(TMatrixTDiag_const<double>*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TMatrixTDiag_const<double>(*(TMatrixTDiag_const<double>*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTDiag_constlEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_131_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTDiag_const<double>& obj = ((TMatrixTDiag_const<double>*) G__getstructoffset())->operator=(*(TMatrixTDiag_const<double>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_131_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TMatrixTDiag_const<double>*) G__getstructoffset())->GetMatrix());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_131_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((const TMatrixTDiag_const<double>*) G__getstructoffset())->GetPtr());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_131_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMatrixTDiag_const<double>*) G__getstructoffset())->GetInc());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_131_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const double& obj = ((const TMatrixTDiag_const<double>*) G__getstructoffset())->operator()((Int_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.d = (double) (obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_131_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const double& obj = ((const TMatrixTDiag_const<double>*) G__getstructoffset())->operator[]((Int_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.d = (double) (obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_131_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMatrixTDiag_const<double>*) G__getstructoffset())->GetNdiags());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_131_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TMatrixTDiag_const<double>::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_131_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTDiag_const<double>::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_131_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TMatrixTDiag_const<double>::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_131_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TMatrixTDiag_const<double>::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_131_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TMatrixTDiag_const<double>*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_131_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTDiag_const<double>*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_131_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTDiag_const<double>*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_131_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTDiag_const<double>*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_131_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTDiag_const<double>::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_131_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMatrixTDiag_const<double>::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_131_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTDiag_const<double>::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_131_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMatrixTDiag_const<double>::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TMatrixTDiag_const<double> G__TTMatrixTDiag_constlEdoublegR;
static int G__G__Matrix_131_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TMatrixTDiag_const<double>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMatrixTDiag_const<double>*) (soff+(sizeof(TMatrixTDiag_const<double>)*i)))->~G__TTMatrixTDiag_constlEdoublegR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMatrixTDiag_const<double>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMatrixTDiag_const<double>*) (soff))->~G__TTMatrixTDiag_constlEdoublegR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TMatrixTColumn_const<double> */
static int G__G__Matrix_132_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTColumn_const<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMatrixTColumn_const<double>[n];
     } else {
       p = new((void*) gvp) TMatrixTColumn_const<double>[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMatrixTColumn_const<double>;
     } else {
       p = new((void*) gvp) TMatrixTColumn_const<double>;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTColumn_constlEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_132_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTColumn_const<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixTColumn_const<double>(*(TMatrixT<double>*) libp->para[0].ref, (Int_t) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TMatrixTColumn_const<double>(*(TMatrixT<double>*) libp->para[0].ref, (Int_t) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTColumn_constlEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_132_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTColumn_const<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixTColumn_const<double>(*(TMatrixTSym<double>*) libp->para[0].ref, (Int_t) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TMatrixTColumn_const<double>(*(TMatrixTSym<double>*) libp->para[0].ref, (Int_t) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTColumn_constlEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_132_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTColumn_const<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixTColumn_const<double>(*(TMatrixTColumn_const<double>*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TMatrixTColumn_const<double>(*(TMatrixTColumn_const<double>*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTColumn_constlEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_132_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTColumn_const<double>& obj = ((TMatrixTColumn_const<double>*) G__getstructoffset())->operator=(*(TMatrixTColumn_const<double>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_132_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TMatrixTColumn_const<double>*) G__getstructoffset())->GetMatrix());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_132_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMatrixTColumn_const<double>*) G__getstructoffset())->GetColIndex());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_132_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMatrixTColumn_const<double>*) G__getstructoffset())->GetInc());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_132_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((const TMatrixTColumn_const<double>*) G__getstructoffset())->GetPtr());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_132_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const double& obj = ((const TMatrixTColumn_const<double>*) G__getstructoffset())->operator()((Int_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.d = (double) (obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_132_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const double& obj = ((const TMatrixTColumn_const<double>*) G__getstructoffset())->operator[]((Int_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.d = (double) (obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_132_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TMatrixTColumn_const<double>::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_132_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTColumn_const<double>::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_132_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TMatrixTColumn_const<double>::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_132_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TMatrixTColumn_const<double>::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_132_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TMatrixTColumn_const<double>*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_132_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTColumn_const<double>*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_132_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTColumn_const<double>*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_132_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTColumn_const<double>*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_132_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTColumn_const<double>::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_132_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMatrixTColumn_const<double>::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_132_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTColumn_const<double>::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_132_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMatrixTColumn_const<double>::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TMatrixTColumn_const<double> G__TTMatrixTColumn_constlEdoublegR;
static int G__G__Matrix_132_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TMatrixTColumn_const<double>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMatrixTColumn_const<double>*) (soff+(sizeof(TMatrixTColumn_const<double>)*i)))->~G__TTMatrixTColumn_constlEdoublegR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMatrixTColumn_const<double>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMatrixTColumn_const<double>*) (soff))->~G__TTMatrixTColumn_constlEdoublegR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TMatrixTFlat_const<double> */
static int G__G__Matrix_133_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTFlat_const<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMatrixTFlat_const<double>[n];
     } else {
       p = new((void*) gvp) TMatrixTFlat_const<double>[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMatrixTFlat_const<double>;
     } else {
       p = new((void*) gvp) TMatrixTFlat_const<double>;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTFlat_constlEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_133_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTFlat_const<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixTFlat_const<double>(*(TMatrixT<double>*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TMatrixTFlat_const<double>(*(TMatrixT<double>*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTFlat_constlEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_133_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTFlat_const<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixTFlat_const<double>(*(TMatrixTSym<double>*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TMatrixTFlat_const<double>(*(TMatrixTSym<double>*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTFlat_constlEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_133_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTFlat_const<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixTFlat_const<double>(*(TMatrixTFlat_const<double>*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TMatrixTFlat_const<double>(*(TMatrixTFlat_const<double>*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTFlat_constlEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_133_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTFlat_const<double>& obj = ((TMatrixTFlat_const<double>*) G__getstructoffset())->operator=(*(TMatrixTFlat_const<double>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_133_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TMatrixTFlat_const<double>*) G__getstructoffset())->GetMatrix());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_133_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((const TMatrixTFlat_const<double>*) G__getstructoffset())->GetPtr());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_133_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const double& obj = ((const TMatrixTFlat_const<double>*) G__getstructoffset())->operator()((Int_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.d = (double) (obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_133_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const double& obj = ((const TMatrixTFlat_const<double>*) G__getstructoffset())->operator[]((Int_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.d = (double) (obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_133_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TMatrixTFlat_const<double>::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_133_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTFlat_const<double>::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_133_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TMatrixTFlat_const<double>::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_133_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TMatrixTFlat_const<double>::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_133_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TMatrixTFlat_const<double>*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_133_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTFlat_const<double>*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_133_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTFlat_const<double>*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_133_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTFlat_const<double>*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_133_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTFlat_const<double>::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_133_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMatrixTFlat_const<double>::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_133_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTFlat_const<double>::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_133_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMatrixTFlat_const<double>::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TMatrixTFlat_const<double> G__TTMatrixTFlat_constlEdoublegR;
static int G__G__Matrix_133_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TMatrixTFlat_const<double>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMatrixTFlat_const<double>*) (soff+(sizeof(TMatrixTFlat_const<double>)*i)))->~G__TTMatrixTFlat_constlEdoublegR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMatrixTFlat_const<double>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMatrixTFlat_const<double>*) (soff))->~G__TTMatrixTFlat_constlEdoublegR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TMatrixTSub_const<double> */
static int G__G__Matrix_134_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTSub_const<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMatrixTSub_const<double>[n];
     } else {
       p = new((void*) gvp) TMatrixTSub_const<double>[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMatrixTSub_const<double>;
     } else {
       p = new((void*) gvp) TMatrixTSub_const<double>;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSub_constlEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_134_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTSub_const<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 5
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixTSub_const<double>(
*(TMatrixT<double>*) libp->para[0].ref, (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
   } else {
     p = new((void*) gvp) TMatrixTSub_const<double>(
*(TMatrixT<double>*) libp->para[0].ref, (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSub_constlEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_134_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTSub_const<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 5
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixTSub_const<double>(
*(TMatrixTSym<double>*) libp->para[0].ref, (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
   } else {
     p = new((void*) gvp) TMatrixTSub_const<double>(
*(TMatrixTSym<double>*) libp->para[0].ref, (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSub_constlEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_134_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TMatrixTSub_const<double>*) G__getstructoffset())->GetMatrix());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_134_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMatrixTSub_const<double>*) G__getstructoffset())->GetRowOff());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_134_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMatrixTSub_const<double>*) G__getstructoffset())->GetColOff());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_134_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMatrixTSub_const<double>*) G__getstructoffset())->GetNrows());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_134_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMatrixTSub_const<double>*) G__getstructoffset())->GetNcols());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_134_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const double& obj = ((const TMatrixTSub_const<double>*) G__getstructoffset())->operator()((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
         result7->ref = (long) (&obj);
         result7->obj.d = (double) (obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_134_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TMatrixTSub_const<double>::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_134_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTSub_const<double>::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_134_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TMatrixTSub_const<double>::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_134_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TMatrixTSub_const<double>::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_134_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TMatrixTSub_const<double>*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_134_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTSub_const<double>*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_134_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTSub_const<double>*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_134_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTSub_const<double>*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_134_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTSub_const<double>::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_134_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMatrixTSub_const<double>::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_134_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTSub_const<double>::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_134_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMatrixTSub_const<double>::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Matrix_134_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TMatrixTSub_const<double>* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TMatrixTSub_const<double>(*(TMatrixTSub_const<double>*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSub_constlEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TMatrixTSub_const<double> G__TTMatrixTSub_constlEdoublegR;
static int G__G__Matrix_134_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TMatrixTSub_const<double>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMatrixTSub_const<double>*) (soff+(sizeof(TMatrixTSub_const<double>)*i)))->~G__TTMatrixTSub_constlEdoublegR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMatrixTSub_const<double>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMatrixTSub_const<double>*) (soff))->~G__TTMatrixTSub_constlEdoublegR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TMatrixTSparseRow_const<double> */
static int G__G__Matrix_135_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTSparseRow_const<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMatrixTSparseRow_const<double>[n];
     } else {
       p = new((void*) gvp) TMatrixTSparseRow_const<double>[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMatrixTSparseRow_const<double>;
     } else {
       p = new((void*) gvp) TMatrixTSparseRow_const<double>;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparseRow_constlEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_135_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTSparseRow_const<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixTSparseRow_const<double>(*(TMatrixTSparse<double>*) libp->para[0].ref, (Int_t) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TMatrixTSparseRow_const<double>(*(TMatrixTSparse<double>*) libp->para[0].ref, (Int_t) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparseRow_constlEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_135_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTSparseRow_const<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixTSparseRow_const<double>(*(TMatrixTSparseRow_const<double>*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TMatrixTSparseRow_const<double>(*(TMatrixTSparseRow_const<double>*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparseRow_constlEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_135_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSparseRow_const<double>& obj = ((TMatrixTSparseRow_const<double>*) G__getstructoffset())->operator=(*(TMatrixTSparseRow_const<double>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_135_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TMatrixTSparseRow_const<double>*) G__getstructoffset())->GetMatrix());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_135_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((const TMatrixTSparseRow_const<double>*) G__getstructoffset())->GetDataPtr());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_135_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 73, (long) ((const TMatrixTSparseRow_const<double>*) G__getstructoffset())->GetColPtr());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_135_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMatrixTSparseRow_const<double>*) G__getstructoffset())->GetRowIndex());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_135_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMatrixTSparseRow_const<double>*) G__getstructoffset())->GetNindex());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_135_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMatrixTSparseRow_const<double>*) G__getstructoffset())->operator()((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_135_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMatrixTSparseRow_const<double>*) G__getstructoffset())->operator[]((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_135_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TMatrixTSparseRow_const<double>::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_135_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTSparseRow_const<double>::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_135_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TMatrixTSparseRow_const<double>::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_135_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TMatrixTSparseRow_const<double>::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_135_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TMatrixTSparseRow_const<double>*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_135_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTSparseRow_const<double>*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_135_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTSparseRow_const<double>*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_135_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTSparseRow_const<double>*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_135_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTSparseRow_const<double>::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_135_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMatrixTSparseRow_const<double>::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_135_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTSparseRow_const<double>::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_135_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMatrixTSparseRow_const<double>::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TMatrixTSparseRow_const<double> G__TTMatrixTSparseRow_constlEdoublegR;
static int G__G__Matrix_135_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TMatrixTSparseRow_const<double>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMatrixTSparseRow_const<double>*) (soff+(sizeof(TMatrixTSparseRow_const<double>)*i)))->~G__TTMatrixTSparseRow_constlEdoublegR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMatrixTSparseRow_const<double>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMatrixTSparseRow_const<double>*) (soff))->~G__TTMatrixTSparseRow_constlEdoublegR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TMatrixTSparseDiag_const<double> */
static int G__G__Matrix_136_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTSparseDiag_const<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMatrixTSparseDiag_const<double>[n];
     } else {
       p = new((void*) gvp) TMatrixTSparseDiag_const<double>[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMatrixTSparseDiag_const<double>;
     } else {
       p = new((void*) gvp) TMatrixTSparseDiag_const<double>;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparseDiag_constlEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_136_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTSparseDiag_const<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixTSparseDiag_const<double>(*(TMatrixTSparse<double>*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TMatrixTSparseDiag_const<double>(*(TMatrixTSparse<double>*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparseDiag_constlEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_136_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTSparseDiag_const<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixTSparseDiag_const<double>(*(TMatrixTSparseDiag_const<double>*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TMatrixTSparseDiag_const<double>(*(TMatrixTSparseDiag_const<double>*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparseDiag_constlEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_136_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSparseDiag_const<double>& obj = ((TMatrixTSparseDiag_const<double>*) G__getstructoffset())->operator=(*(TMatrixTSparseDiag_const<double>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_136_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TMatrixTSparseDiag_const<double>*) G__getstructoffset())->GetMatrix());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_136_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((const TMatrixTSparseDiag_const<double>*) G__getstructoffset())->GetDataPtr());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_136_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMatrixTSparseDiag_const<double>*) G__getstructoffset())->GetNdiags());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_136_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMatrixTSparseDiag_const<double>*) G__getstructoffset())->operator()((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_136_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMatrixTSparseDiag_const<double>*) G__getstructoffset())->operator[]((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_136_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TMatrixTSparseDiag_const<double>::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_136_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTSparseDiag_const<double>::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_136_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TMatrixTSparseDiag_const<double>::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_136_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TMatrixTSparseDiag_const<double>::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_136_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TMatrixTSparseDiag_const<double>*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_136_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTSparseDiag_const<double>*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_136_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTSparseDiag_const<double>*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_136_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTSparseDiag_const<double>*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_136_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTSparseDiag_const<double>::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_136_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMatrixTSparseDiag_const<double>::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_136_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTSparseDiag_const<double>::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_136_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMatrixTSparseDiag_const<double>::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TMatrixTSparseDiag_const<double> G__TTMatrixTSparseDiag_constlEdoublegR;
static int G__G__Matrix_136_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TMatrixTSparseDiag_const<double>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMatrixTSparseDiag_const<double>*) (soff+(sizeof(TMatrixTSparseDiag_const<double>)*i)))->~G__TTMatrixTSparseDiag_constlEdoublegR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMatrixTSparseDiag_const<double>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMatrixTSparseDiag_const<double>*) (soff))->~G__TTMatrixTSparseDiag_constlEdoublegR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TMatrixTColumn<double> */
static int G__G__Matrix_137_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTColumn<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMatrixTColumn<double>[n];
     } else {
       p = new((void*) gvp) TMatrixTColumn<double>[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMatrixTColumn<double>;
     } else {
       p = new((void*) gvp) TMatrixTColumn<double>;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTColumnlEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_137_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTColumn<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixTColumn<double>(*(TMatrixT<double>*) libp->para[0].ref, (Int_t) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TMatrixTColumn<double>(*(TMatrixT<double>*) libp->para[0].ref, (Int_t) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTColumnlEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_137_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTColumn<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixTColumn<double>(*(TMatrixTSym<double>*) libp->para[0].ref, (Int_t) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TMatrixTColumn<double>(*(TMatrixTSym<double>*) libp->para[0].ref, (Int_t) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTColumnlEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_137_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTColumn<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixTColumn<double>(*(TMatrixTColumn<double>*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TMatrixTColumn<double>(*(TMatrixTColumn<double>*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTColumnlEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_137_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((const TMatrixTColumn<double>*) G__getstructoffset())->GetPtr());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_137_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const double& obj = ((const TMatrixTColumn<double>*) G__getstructoffset())->operator()((Int_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.d = (double) (obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_137_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const double& obj = ((TMatrixTColumn<double>*) G__getstructoffset())->operator()((Int_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.d = (double) (obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_137_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const double& obj = ((const TMatrixTColumn<double>*) G__getstructoffset())->operator[]((Int_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.d = (double) (obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_137_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const double& obj = ((TMatrixTColumn<double>*) G__getstructoffset())->operator[]((Int_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.d = (double) (obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_137_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTColumn<double>*) G__getstructoffset())->operator=((double) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_137_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTColumn<double>*) G__getstructoffset())->operator+=((double) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_137_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTColumn<double>*) G__getstructoffset())->operator*=((double) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_137_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTColumn<double>*) G__getstructoffset())->operator=(*(TMatrixTColumn_const<double>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_137_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTColumn<double>& obj = ((TMatrixTColumn<double>*) G__getstructoffset())->operator=(*(TMatrixTColumn<double>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_137_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTColumn<double>*) G__getstructoffset())->operator=(*(TVectorT<double>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_137_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTColumn<double>*) G__getstructoffset())->operator+=(*(TMatrixTColumn_const<double>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_137_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTColumn<double>*) G__getstructoffset())->operator*=(*(TMatrixTColumn_const<double>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_137_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TMatrixTColumn<double>::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_137_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTColumn<double>::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_137_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TMatrixTColumn<double>::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_137_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TMatrixTColumn<double>::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_137_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTColumn<double>*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_137_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTColumn<double>::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_137_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMatrixTColumn<double>::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_137_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTColumn<double>::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_137_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMatrixTColumn<double>::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TMatrixTColumn<double> G__TTMatrixTColumnlEdoublegR;
static int G__G__Matrix_137_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TMatrixTColumn<double>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMatrixTColumn<double>*) (soff+(sizeof(TMatrixTColumn<double>)*i)))->~G__TTMatrixTColumnlEdoublegR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMatrixTColumn<double>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMatrixTColumn<double>*) (soff))->~G__TTMatrixTColumnlEdoublegR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TMatrixTDiag<double> */
static int G__G__Matrix_138_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTDiag<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMatrixTDiag<double>[n];
     } else {
       p = new((void*) gvp) TMatrixTDiag<double>[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMatrixTDiag<double>;
     } else {
       p = new((void*) gvp) TMatrixTDiag<double>;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTDiaglEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_138_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTDiag<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixTDiag<double>(*(TMatrixT<double>*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TMatrixTDiag<double>(*(TMatrixT<double>*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTDiaglEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_138_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTDiag<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixTDiag<double>(*(TMatrixTSym<double>*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TMatrixTDiag<double>(*(TMatrixTSym<double>*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTDiaglEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_138_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTDiag<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixTDiag<double>(*(TMatrixTDiag<double>*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TMatrixTDiag<double>(*(TMatrixTDiag<double>*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTDiaglEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_138_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((const TMatrixTDiag<double>*) G__getstructoffset())->GetPtr());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_138_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const double& obj = ((const TMatrixTDiag<double>*) G__getstructoffset())->operator()((Int_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.d = (double) (obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_138_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const double& obj = ((TMatrixTDiag<double>*) G__getstructoffset())->operator()((Int_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.d = (double) (obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_138_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const double& obj = ((const TMatrixTDiag<double>*) G__getstructoffset())->operator[]((Int_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.d = (double) (obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_138_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const double& obj = ((TMatrixTDiag<double>*) G__getstructoffset())->operator[]((Int_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.d = (double) (obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_138_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTDiag<double>*) G__getstructoffset())->operator=((double) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_138_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTDiag<double>*) G__getstructoffset())->operator+=((double) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_138_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTDiag<double>*) G__getstructoffset())->operator*=((double) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_138_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTDiag<double>*) G__getstructoffset())->operator=(*(TMatrixTDiag_const<double>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_138_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTDiag<double>& obj = ((TMatrixTDiag<double>*) G__getstructoffset())->operator=(*(TMatrixTDiag<double>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_138_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTDiag<double>*) G__getstructoffset())->operator=(*(TVectorT<double>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_138_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTDiag<double>*) G__getstructoffset())->operator+=(*(TMatrixTDiag_const<double>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_138_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTDiag<double>*) G__getstructoffset())->operator*=(*(TMatrixTDiag_const<double>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_138_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TMatrixTDiag<double>::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_138_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTDiag<double>::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_138_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TMatrixTDiag<double>::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_138_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TMatrixTDiag<double>::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_138_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTDiag<double>*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_138_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTDiag<double>::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_138_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMatrixTDiag<double>::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_138_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTDiag<double>::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_138_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMatrixTDiag<double>::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TMatrixTDiag<double> G__TTMatrixTDiaglEdoublegR;
static int G__G__Matrix_138_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TMatrixTDiag<double>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMatrixTDiag<double>*) (soff+(sizeof(TMatrixTDiag<double>)*i)))->~G__TTMatrixTDiaglEdoublegR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMatrixTDiag<double>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMatrixTDiag<double>*) (soff))->~G__TTMatrixTDiaglEdoublegR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TMatrixTFlat<double> */
static int G__G__Matrix_139_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTFlat<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMatrixTFlat<double>[n];
     } else {
       p = new((void*) gvp) TMatrixTFlat<double>[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMatrixTFlat<double>;
     } else {
       p = new((void*) gvp) TMatrixTFlat<double>;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTFlatlEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_139_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTFlat<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixTFlat<double>(*(TMatrixT<double>*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TMatrixTFlat<double>(*(TMatrixT<double>*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTFlatlEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_139_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTFlat<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixTFlat<double>(*(TMatrixTSym<double>*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TMatrixTFlat<double>(*(TMatrixTSym<double>*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTFlatlEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_139_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTFlat<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixTFlat<double>(*(TMatrixTFlat<double>*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TMatrixTFlat<double>(*(TMatrixTFlat<double>*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTFlatlEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_139_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((const TMatrixTFlat<double>*) G__getstructoffset())->GetPtr());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_139_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const double& obj = ((const TMatrixTFlat<double>*) G__getstructoffset())->operator()((Int_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.d = (double) (obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_139_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const double& obj = ((TMatrixTFlat<double>*) G__getstructoffset())->operator()((Int_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.d = (double) (obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_139_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const double& obj = ((const TMatrixTFlat<double>*) G__getstructoffset())->operator[]((Int_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.d = (double) (obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_139_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const double& obj = ((TMatrixTFlat<double>*) G__getstructoffset())->operator[]((Int_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.d = (double) (obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_139_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTFlat<double>*) G__getstructoffset())->operator=((double) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_139_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTFlat<double>*) G__getstructoffset())->operator+=((double) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_139_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTFlat<double>*) G__getstructoffset())->operator*=((double) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_139_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTFlat<double>*) G__getstructoffset())->operator=(*(TMatrixTFlat_const<double>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_139_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTFlat<double>& obj = ((TMatrixTFlat<double>*) G__getstructoffset())->operator=(*(TMatrixTFlat<double>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_139_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTFlat<double>*) G__getstructoffset())->operator=(*(TVectorT<double>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_139_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTFlat<double>*) G__getstructoffset())->operator+=(*(TMatrixTFlat_const<double>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_139_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTFlat<double>*) G__getstructoffset())->operator*=(*(TMatrixTFlat_const<double>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_139_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TMatrixTFlat<double>::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_139_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTFlat<double>::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_139_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TMatrixTFlat<double>::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_139_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TMatrixTFlat<double>::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_139_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTFlat<double>*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_139_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTFlat<double>::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_139_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMatrixTFlat<double>::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_139_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTFlat<double>::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_139_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMatrixTFlat<double>::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TMatrixTFlat<double> G__TTMatrixTFlatlEdoublegR;
static int G__G__Matrix_139_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TMatrixTFlat<double>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMatrixTFlat<double>*) (soff+(sizeof(TMatrixTFlat<double>)*i)))->~G__TTMatrixTFlatlEdoublegR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMatrixTFlat<double>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMatrixTFlat<double>*) (soff))->~G__TTMatrixTFlatlEdoublegR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TMatrixTSub<double> */
static int G__G__Matrix_140_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTSub<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMatrixTSub<double>[n];
     } else {
       p = new((void*) gvp) TMatrixTSub<double>[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMatrixTSub<double>;
     } else {
       p = new((void*) gvp) TMatrixTSub<double>;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSublEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_140_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTSub<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 5
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixTSub<double>(
*(TMatrixT<double>*) libp->para[0].ref, (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
   } else {
     p = new((void*) gvp) TMatrixTSub<double>(
*(TMatrixT<double>*) libp->para[0].ref, (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSublEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_140_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTSub<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 5
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixTSub<double>(
*(TMatrixTSym<double>*) libp->para[0].ref, (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
   } else {
     p = new((void*) gvp) TMatrixTSub<double>(
*(TMatrixTSym<double>*) libp->para[0].ref, (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSublEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_140_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTSub<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixTSub<double>(*(TMatrixTSub<double>*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TMatrixTSub<double>(*(TMatrixTSub<double>*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSublEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_140_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const double& obj = ((TMatrixTSub<double>*) G__getstructoffset())->operator()((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
         result7->ref = (long) (&obj);
         result7->obj.d = (double) (obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_140_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TMatrixTSub<double>*) G__getstructoffset())->Rank1Update(*(TVectorT<double>*) libp->para[0].ref, (double) G__double(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TMatrixTSub<double>*) G__getstructoffset())->Rank1Update(*(TVectorT<double>*) libp->para[0].ref);
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_140_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTSub<double>*) G__getstructoffset())->operator=((double) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_140_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTSub<double>*) G__getstructoffset())->operator+=((double) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_140_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTSub<double>*) G__getstructoffset())->operator*=((double) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_140_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTSub<double>*) G__getstructoffset())->operator=(*(TMatrixTSub_const<double>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_140_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSub<double>& obj = ((TMatrixTSub<double>*) G__getstructoffset())->operator=(*(TMatrixTSub<double>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_140_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTSub<double>*) G__getstructoffset())->operator=(*(TMatrixTBase<double>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_140_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTSub<double>*) G__getstructoffset())->operator+=(*(TMatrixTSub_const<double>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_140_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTSub<double>*) G__getstructoffset())->operator*=(*(TMatrixTSub_const<double>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_140_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTSub<double>*) G__getstructoffset())->operator+=(*(TMatrixTBase<double>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_140_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTSub<double>*) G__getstructoffset())->operator*=(*(TMatrixT<double>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_140_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTSub<double>*) G__getstructoffset())->operator*=(*(TMatrixTSym<double>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_140_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TMatrixTSub<double>::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_140_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTSub<double>::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_140_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TMatrixTSub<double>::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_140_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TMatrixTSub<double>::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_140_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTSub<double>*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_140_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTSub<double>::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_140_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMatrixTSub<double>::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_140_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTSub<double>::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_140_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMatrixTSub<double>::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TMatrixTSub<double> G__TTMatrixTSublEdoublegR;
static int G__G__Matrix_140_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TMatrixTSub<double>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMatrixTSub<double>*) (soff+(sizeof(TMatrixTSub<double>)*i)))->~G__TTMatrixTSublEdoublegR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMatrixTSub<double>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMatrixTSub<double>*) (soff))->~G__TTMatrixTSublEdoublegR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TMatrixTSparseRow<double> */
static int G__G__Matrix_142_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTSparseRow<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMatrixTSparseRow<double>[n];
     } else {
       p = new((void*) gvp) TMatrixTSparseRow<double>[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMatrixTSparseRow<double>;
     } else {
       p = new((void*) gvp) TMatrixTSparseRow<double>;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparseRowlEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_142_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTSparseRow<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixTSparseRow<double>(*(TMatrixTSparse<double>*) libp->para[0].ref, (Int_t) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TMatrixTSparseRow<double>(*(TMatrixTSparse<double>*) libp->para[0].ref, (Int_t) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparseRowlEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_142_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTSparseRow<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixTSparseRow<double>(*(TMatrixTSparseRow<double>*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TMatrixTSparseRow<double>(*(TMatrixTSparseRow<double>*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparseRowlEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_142_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((const TMatrixTSparseRow<double>*) G__getstructoffset())->GetDataPtr());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_142_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMatrixTSparseRow<double>*) G__getstructoffset())->operator()((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_142_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const double& obj = ((TMatrixTSparseRow<double>*) G__getstructoffset())->operator()((Int_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.d = (double) (obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_142_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMatrixTSparseRow<double>*) G__getstructoffset())->operator[]((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_142_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const double& obj = ((TMatrixTSparseRow<double>*) G__getstructoffset())->operator[]((Int_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.d = (double) (obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_142_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTSparseRow<double>*) G__getstructoffset())->operator=((double) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_142_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTSparseRow<double>*) G__getstructoffset())->operator+=((double) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_142_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTSparseRow<double>*) G__getstructoffset())->operator*=((double) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_142_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTSparseRow<double>*) G__getstructoffset())->operator=(*(TMatrixTSparseRow_const<double>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_142_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSparseRow<double>& obj = ((TMatrixTSparseRow<double>*) G__getstructoffset())->operator=(*(TMatrixTSparseRow<double>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_142_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTSparseRow<double>*) G__getstructoffset())->operator=(*(TVectorT<double>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_142_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTSparseRow<double>*) G__getstructoffset())->operator+=(*(TMatrixTSparseRow_const<double>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_142_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTSparseRow<double>*) G__getstructoffset())->operator*=(*(TMatrixTSparseRow_const<double>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_142_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TMatrixTSparseRow<double>::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_142_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTSparseRow<double>::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_142_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TMatrixTSparseRow<double>::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_142_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TMatrixTSparseRow<double>::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_142_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTSparseRow<double>*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_142_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTSparseRow<double>::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_142_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMatrixTSparseRow<double>::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_142_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTSparseRow<double>::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_142_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMatrixTSparseRow<double>::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TMatrixTSparseRow<double> G__TTMatrixTSparseRowlEdoublegR;
static int G__G__Matrix_142_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TMatrixTSparseRow<double>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMatrixTSparseRow<double>*) (soff+(sizeof(TMatrixTSparseRow<double>)*i)))->~G__TTMatrixTSparseRowlEdoublegR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMatrixTSparseRow<double>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMatrixTSparseRow<double>*) (soff))->~G__TTMatrixTSparseRowlEdoublegR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TMatrixTSparseDiag<double> */
static int G__G__Matrix_143_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTSparseDiag<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMatrixTSparseDiag<double>[n];
     } else {
       p = new((void*) gvp) TMatrixTSparseDiag<double>[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMatrixTSparseDiag<double>;
     } else {
       p = new((void*) gvp) TMatrixTSparseDiag<double>;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparseDiaglEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_143_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTSparseDiag<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixTSparseDiag<double>(*(TMatrixTSparse<double>*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TMatrixTSparseDiag<double>(*(TMatrixTSparse<double>*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparseDiaglEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_143_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTSparseDiag<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixTSparseDiag<double>(*(TMatrixTSparseDiag<double>*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TMatrixTSparseDiag<double>(*(TMatrixTSparseDiag<double>*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparseDiaglEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_143_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((const TMatrixTSparseDiag<double>*) G__getstructoffset())->GetDataPtr());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_143_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMatrixTSparseDiag<double>*) G__getstructoffset())->operator()((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_143_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const double& obj = ((TMatrixTSparseDiag<double>*) G__getstructoffset())->operator()((Int_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.d = (double) (obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_143_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMatrixTSparseDiag<double>*) G__getstructoffset())->operator[]((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_143_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const double& obj = ((TMatrixTSparseDiag<double>*) G__getstructoffset())->operator[]((Int_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.d = (double) (obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_143_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTSparseDiag<double>*) G__getstructoffset())->operator=((double) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_143_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTSparseDiag<double>*) G__getstructoffset())->operator+=((double) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_143_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTSparseDiag<double>*) G__getstructoffset())->operator*=((double) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_143_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTSparseDiag<double>*) G__getstructoffset())->operator=(*(TMatrixTSparseDiag_const<double>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_143_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSparseDiag<double>& obj = ((TMatrixTSparseDiag<double>*) G__getstructoffset())->operator=(*(TMatrixTSparseDiag<double>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_143_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTSparseDiag<double>*) G__getstructoffset())->operator=(*(TVectorT<double>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_143_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTSparseDiag<double>*) G__getstructoffset())->operator+=(*(TMatrixTSparseDiag_const<double>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_143_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTSparseDiag<double>*) G__getstructoffset())->operator*=(*(TMatrixTSparseDiag_const<double>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_143_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TMatrixTSparseDiag<double>::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_143_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTSparseDiag<double>::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_143_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TMatrixTSparseDiag<double>::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_143_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TMatrixTSparseDiag<double>::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_143_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTSparseDiag<double>*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_143_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTSparseDiag<double>::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_143_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMatrixTSparseDiag<double>::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_143_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTSparseDiag<double>::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_143_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMatrixTSparseDiag<double>::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TMatrixTSparseDiag<double> G__TTMatrixTSparseDiaglEdoublegR;
static int G__G__Matrix_143_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TMatrixTSparseDiag<double>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMatrixTSparseDiag<double>*) (soff+(sizeof(TMatrixTSparseDiag<double>)*i)))->~G__TTMatrixTSparseDiaglEdoublegR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMatrixTSparseDiag<double>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMatrixTSparseDiag<double>*) (soff))->~G__TTMatrixTSparseDiaglEdoublegR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TMatrixTSymLazy<double> */
static int G__G__Matrix_147_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMatrixTSymLazy<double>*) G__getstructoffset())->GetRowLwb());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_147_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMatrixTSymLazy<double>*) G__getstructoffset())->GetRowUpb());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_147_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TMatrixTSymLazy<double>::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_147_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTSymLazy<double>::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_147_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TMatrixTSymLazy<double>::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_147_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TMatrixTSymLazy<double>::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_147_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTSymLazy<double>*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_147_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTSymLazy<double>::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_147_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMatrixTSymLazy<double>::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_147_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTSymLazy<double>::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_147_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMatrixTSymLazy<double>::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TMatrixTSymLazy<double> G__TTMatrixTSymLazylEdoublegR;
static int G__G__Matrix_147_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TMatrixTSymLazy<double>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMatrixTSymLazy<double>*) (soff+(sizeof(TMatrixTSymLazy<double>)*i)))->~G__TTMatrixTSymLazylEdoublegR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMatrixTSymLazy<double>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMatrixTSymLazy<double>*) (soff))->~G__TTMatrixTSymLazylEdoublegR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TMatrixTRow_const<float> */
static int G__G__Matrix_152_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTRow_const<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMatrixTRow_const<float>[n];
     } else {
       p = new((void*) gvp) TMatrixTRow_const<float>[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMatrixTRow_const<float>;
     } else {
       p = new((void*) gvp) TMatrixTRow_const<float>;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTRow_constlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_152_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTRow_const<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixTRow_const<float>(*(TMatrixT<float>*) libp->para[0].ref, (Int_t) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TMatrixTRow_const<float>(*(TMatrixT<float>*) libp->para[0].ref, (Int_t) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTRow_constlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_152_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTRow_const<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixTRow_const<float>(*(TMatrixTSym<float>*) libp->para[0].ref, (Int_t) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TMatrixTRow_const<float>(*(TMatrixTSym<float>*) libp->para[0].ref, (Int_t) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTRow_constlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_152_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTRow_const<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixTRow_const<float>(*(TMatrixTRow_const<float>*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TMatrixTRow_const<float>(*(TMatrixTRow_const<float>*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTRow_constlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_152_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTRow_const<float>& obj = ((TMatrixTRow_const<float>*) G__getstructoffset())->operator=(*(TMatrixTRow_const<float>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_152_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TMatrixTRow_const<float>*) G__getstructoffset())->GetMatrix());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_152_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMatrixTRow_const<float>*) G__getstructoffset())->GetRowIndex());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_152_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMatrixTRow_const<float>*) G__getstructoffset())->GetInc());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_152_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 70, (long) ((const TMatrixTRow_const<float>*) G__getstructoffset())->GetPtr());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_152_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const float& obj = ((const TMatrixTRow_const<float>*) G__getstructoffset())->operator()((Int_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.d = (double) (obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_152_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const float& obj = ((const TMatrixTRow_const<float>*) G__getstructoffset())->operator[]((Int_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.d = (double) (obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_152_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TMatrixTRow_const<float>::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_152_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTRow_const<float>::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_152_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TMatrixTRow_const<float>::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_152_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TMatrixTRow_const<float>::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_152_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TMatrixTRow_const<float>*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_152_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTRow_const<float>*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_152_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTRow_const<float>*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_152_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTRow_const<float>*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_152_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTRow_const<float>::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_152_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMatrixTRow_const<float>::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_152_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTRow_const<float>::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_152_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMatrixTRow_const<float>::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TMatrixTRow_const<float> G__TTMatrixTRow_constlEfloatgR;
static int G__G__Matrix_152_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TMatrixTRow_const<float>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMatrixTRow_const<float>*) (soff+(sizeof(TMatrixTRow_const<float>)*i)))->~G__TTMatrixTRow_constlEfloatgR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMatrixTRow_const<float>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMatrixTRow_const<float>*) (soff))->~G__TTMatrixTRow_constlEfloatgR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TMatrixT<float> */
static int G__G__Matrix_153_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixT<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMatrixT<float>[n];
     } else {
       p = new((void*) gvp) TMatrixT<float>[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMatrixT<float>;
     } else {
       p = new((void*) gvp) TMatrixT<float>;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_153_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixT<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixT<float>((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TMatrixT<float>((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_153_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixT<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 4
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixT<float>(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
   } else {
     p = new((void*) gvp) TMatrixT<float>(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_153_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixT<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMatrixT<float>(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (float*) G__int(libp->para[2]), (Option_t*) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TMatrixT<float>(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (float*) G__int(libp->para[2]), (Option_t*) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMatrixT<float>(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (float*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TMatrixT<float>(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (float*) G__int(libp->para[2]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_153_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixT<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMatrixT<float>(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (float*) G__int(libp->para[4]), (Option_t*) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TMatrixT<float>(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (float*) G__int(libp->para[4]), (Option_t*) G__int(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMatrixT<float>(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (float*) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TMatrixT<float>(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (float*) G__int(libp->para[4]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_153_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixT<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixT<float>(*(TMatrixT<float>*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TMatrixT<float>(*(TMatrixT<float>*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_153_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixT<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixT<float>(*(TMatrixTSym<float>*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TMatrixT<float>(*(TMatrixTSym<float>*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_153_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixT<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixT<float>(*(TMatrixTSparse<float>*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TMatrixT<float>(*(TMatrixTSparse<float>*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_153_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixT<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixT<float>((TMatrixT<float>::EMatrixCreatorsOp1) G__int(libp->para[0]), *(TMatrixT<float>*) libp->para[1].ref);
   } else {
     p = new((void*) gvp) TMatrixT<float>((TMatrixT<float>::EMatrixCreatorsOp1) G__int(libp->para[0]), *(TMatrixT<float>*) libp->para[1].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_153_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixT<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixT<float>(
*(TMatrixT<float>*) libp->para[0].ref, (TMatrixT<float>::EMatrixCreatorsOp2) G__int(libp->para[1])
, *(TMatrixT<float>*) libp->para[2].ref);
   } else {
     p = new((void*) gvp) TMatrixT<float>(
*(TMatrixT<float>*) libp->para[0].ref, (TMatrixT<float>::EMatrixCreatorsOp2) G__int(libp->para[1])
, *(TMatrixT<float>*) libp->para[2].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_153_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixT<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixT<float>(
*(TMatrixT<float>*) libp->para[0].ref, (TMatrixT<float>::EMatrixCreatorsOp2) G__int(libp->para[1])
, *(TMatrixTSym<float>*) libp->para[2].ref);
   } else {
     p = new((void*) gvp) TMatrixT<float>(
*(TMatrixT<float>*) libp->para[0].ref, (TMatrixT<float>::EMatrixCreatorsOp2) G__int(libp->para[1])
, *(TMatrixTSym<float>*) libp->para[2].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_153_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixT<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixT<float>(
*(TMatrixTSym<float>*) libp->para[0].ref, (TMatrixT<float>::EMatrixCreatorsOp2) G__int(libp->para[1])
, *(TMatrixT<float>*) libp->para[2].ref);
   } else {
     p = new((void*) gvp) TMatrixT<float>(
*(TMatrixTSym<float>*) libp->para[0].ref, (TMatrixT<float>::EMatrixCreatorsOp2) G__int(libp->para[1])
, *(TMatrixT<float>*) libp->para[2].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_153_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixT<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixT<float>(
*(TMatrixTSym<float>*) libp->para[0].ref, (TMatrixT<float>::EMatrixCreatorsOp2) G__int(libp->para[1])
, *(TMatrixTSym<float>*) libp->para[2].ref);
   } else {
     p = new((void*) gvp) TMatrixT<float>(
*(TMatrixTSym<float>*) libp->para[0].ref, (TMatrixT<float>::EMatrixCreatorsOp2) G__int(libp->para[1])
, *(TMatrixTSym<float>*) libp->para[2].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_153_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixT<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixT<float>(*(TMatrixTLazy<float>*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TMatrixT<float>(*(TMatrixTLazy<float>*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_153_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixT<float>*) G__getstructoffset())->Plus(*(TMatrixT<float>*) libp->para[0].ref, *(TMatrixT<float>*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_153_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixT<float>*) G__getstructoffset())->Plus(*(TMatrixT<float>*) libp->para[0].ref, *(TMatrixTSym<float>*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_153_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixT<float>*) G__getstructoffset())->Plus(*(TMatrixTSym<float>*) libp->para[0].ref, *(TMatrixT<float>*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_153_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixT<float>*) G__getstructoffset())->Minus(*(TMatrixT<float>*) libp->para[0].ref, *(TMatrixT<float>*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_153_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixT<float>*) G__getstructoffset())->Minus(*(TMatrixT<float>*) libp->para[0].ref, *(TMatrixTSym<float>*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_153_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixT<float>*) G__getstructoffset())->Minus(*(TMatrixTSym<float>*) libp->para[0].ref, *(TMatrixT<float>*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_153_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixT<float>*) G__getstructoffset())->Mult(*(TMatrixT<float>*) libp->para[0].ref, *(TMatrixT<float>*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_153_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixT<float>*) G__getstructoffset())->Mult(*(TMatrixT<float>*) libp->para[0].ref, *(TMatrixTSym<float>*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_153_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixT<float>*) G__getstructoffset())->Mult(*(TMatrixTSym<float>*) libp->para[0].ref, *(TMatrixT<float>*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_153_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixT<float>*) G__getstructoffset())->Mult(*(TMatrixTSym<float>*) libp->para[0].ref, *(TMatrixTSym<float>*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_153_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixT<float>*) G__getstructoffset())->TMult(*(TMatrixT<float>*) libp->para[0].ref, *(TMatrixT<float>*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_153_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixT<float>*) G__getstructoffset())->TMult(*(TMatrixT<float>*) libp->para[0].ref, *(TMatrixTSym<float>*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_153_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixT<float>*) G__getstructoffset())->TMult(*(TMatrixTSym<float>*) libp->para[0].ref, *(TMatrixT<float>*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_153_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixT<float>*) G__getstructoffset())->TMult(*(TMatrixTSym<float>*) libp->para[0].ref, *(TMatrixTSym<float>*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_153_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixT<float>*) G__getstructoffset())->MultT(*(TMatrixT<float>*) libp->para[0].ref, *(TMatrixT<float>*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_153_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixT<float>*) G__getstructoffset())->MultT(*(TMatrixT<float>*) libp->para[0].ref, *(TMatrixTSym<float>*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_153_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixT<float>*) G__getstructoffset())->MultT(*(TMatrixTSym<float>*) libp->para[0].ref, *(TMatrixT<float>*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_153_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixT<float>*) G__getstructoffset())->MultT(*(TMatrixTSym<float>*) libp->para[0].ref, *(TMatrixTSym<float>*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_153_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixT<float>& obj = ((TMatrixT<float>*) G__getstructoffset())->Use((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (float*) G__int(libp->para[4]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_153_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixT<float>& obj = ((const TMatrixT<float>*) G__getstructoffset())->Use((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (float*) G__int(libp->para[4]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_153_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixT<float>& obj = ((TMatrixT<float>*) G__getstructoffset())->Use((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (float*) G__int(libp->para[2]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_153_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixT<float>& obj = ((const TMatrixT<float>*) G__getstructoffset())->Use((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (float*) G__int(libp->para[2]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_153_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixT<float>& obj = ((TMatrixT<float>*) G__getstructoffset())->Use(*(TMatrixT<float>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_153_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixT<float>& obj = ((const TMatrixT<float>*) G__getstructoffset())->Use(*(TMatrixT<float>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_153_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      {
         const TMatrixT<float>* pobj;
         const TMatrixT<float> xobj = ((const TMatrixT<float>*) G__getstructoffset())->GetSub((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Option_t*) G__int(libp->para[4]));
         pobj = new TMatrixT<float>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 4:
      {
         const TMatrixT<float>* pobj;
         const TMatrixT<float> xobj = ((const TMatrixT<float>*) G__getstructoffset())->GetSub((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
         pobj = new TMatrixT<float>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_153_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTBase<float>& obj = ((TMatrixT<float>*) G__getstructoffset())->ResizeTo(*(TMatrixT<float>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_153_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      {
         const TMatrixT<float>& obj = ((TMatrixT<float>*) G__getstructoffset())->Invert((Double_t*) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
      break;
   case 0:
      {
         const TMatrixT<float>& obj = ((TMatrixT<float>*) G__getstructoffset())->Invert();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_153_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      {
         const TMatrixT<float>& obj = ((TMatrixT<float>*) G__getstructoffset())->InvertFast((Double_t*) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
      break;
   case 0:
      {
         const TMatrixT<float>& obj = ((TMatrixT<float>*) G__getstructoffset())->InvertFast();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_153_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixT<float>& obj = ((TMatrixT<float>*) G__getstructoffset())->Transpose(*(TMatrixT<float>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_153_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixT<float>& obj = ((TMatrixT<float>*) G__getstructoffset())->T();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_153_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      {
         const TMatrixT<float>& obj = ((TMatrixT<float>*) G__getstructoffset())->Rank1Update(*(TVectorT<float>*) libp->para[0].ref, (float) G__double(libp->para[1]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
      break;
   case 1:
      {
         const TMatrixT<float>& obj = ((TMatrixT<float>*) G__getstructoffset())->Rank1Update(*(TVectorT<float>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_153_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      {
         const TMatrixT<float>& obj = ((TMatrixT<float>*) G__getstructoffset())->Rank1Update(*(TVectorT<float>*) libp->para[0].ref, *(TVectorT<float>*) libp->para[1].ref
, (float) G__double(libp->para[2]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
      break;
   case 2:
      {
         const TMatrixT<float>& obj = ((TMatrixT<float>*) G__getstructoffset())->Rank1Update(*(TVectorT<float>*) libp->para[0].ref, *(TVectorT<float>*) libp->para[1].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_153_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TMatrixT<float>*) G__getstructoffset())->Similarity(*(TVectorT<float>*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_153_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      {
         const TMatrixT<float>& obj = ((TMatrixT<float>*) G__getstructoffset())->NormByColumn(*(TVectorT<float>*) libp->para[0].ref, (Option_t*) G__int(libp->para[1]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
      break;
   case 1:
      {
         const TMatrixT<float>& obj = ((TMatrixT<float>*) G__getstructoffset())->NormByColumn(*(TVectorT<float>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_153_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      {
         const TMatrixT<float>& obj = ((TMatrixT<float>*) G__getstructoffset())->NormByRow(*(TVectorT<float>*) libp->para[0].ref, (Option_t*) G__int(libp->para[1]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
      break;
   case 1:
      {
         const TMatrixT<float>& obj = ((TMatrixT<float>*) G__getstructoffset())->NormByRow(*(TVectorT<float>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_153_0_71(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTRow_const<float>* pobj;
         const TMatrixTRow_const<float> xobj = ((const TMatrixT<float>*) G__getstructoffset())->operator[]((Int_t) G__int(libp->para[0]));
         pobj = new TMatrixTRow_const<float>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_153_0_72(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixTRow<float>* pobj;
         TMatrixTRow<float> xobj = ((TMatrixT<float>*) G__getstructoffset())->operator[]((Int_t) G__int(libp->para[0]));
         pobj = new TMatrixTRow<float>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_153_0_73(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixT<float>& obj = ((TMatrixT<float>*) G__getstructoffset())->operator=(*(TMatrixT<float>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_153_0_74(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixT<float>& obj = ((TMatrixT<float>*) G__getstructoffset())->operator=(*(TMatrixTSym<float>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_153_0_75(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixT<float>& obj = ((TMatrixT<float>*) G__getstructoffset())->operator=(*(TMatrixTSparse<float>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_153_0_76(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixT<float>& obj = ((TMatrixT<float>*) G__getstructoffset())->operator=(*(TMatrixTLazy<float>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_153_0_77(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixT<float>& obj = ((TMatrixT<float>*) G__getstructoffset())->operator=((float) G__double(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_153_0_78(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixT<float>& obj = ((TMatrixT<float>*) G__getstructoffset())->operator-=((float) G__double(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_153_0_79(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixT<float>& obj = ((TMatrixT<float>*) G__getstructoffset())->operator+=((float) G__double(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_153_0_80(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixT<float>& obj = ((TMatrixT<float>*) G__getstructoffset())->operator*=((float) G__double(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_153_0_81(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixT<float>& obj = ((TMatrixT<float>*) G__getstructoffset())->operator+=(*(TMatrixT<float>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_153_0_82(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixT<float>& obj = ((TMatrixT<float>*) G__getstructoffset())->operator+=(*(TMatrixTSym<float>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_153_0_83(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixT<float>& obj = ((TMatrixT<float>*) G__getstructoffset())->operator-=(*(TMatrixT<float>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_153_0_84(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixT<float>& obj = ((TMatrixT<float>*) G__getstructoffset())->operator-=(*(TMatrixTSym<float>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_153_0_85(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixT<float>& obj = ((TMatrixT<float>*) G__getstructoffset())->operator*=(*(TMatrixT<float>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_153_0_86(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixT<float>& obj = ((TMatrixT<float>*) G__getstructoffset())->operator*=(*(TMatrixTSym<float>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_153_0_87(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixT<float>& obj = ((TMatrixT<float>*) G__getstructoffset())->operator*=(*(TMatrixTDiag_const<float>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_153_0_88(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixT<float>& obj = ((TMatrixT<float>*) G__getstructoffset())->operator/=(*(TMatrixTDiag_const<float>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_153_0_89(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixT<float>& obj = ((TMatrixT<float>*) G__getstructoffset())->operator*=(*(TMatrixTRow_const<float>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_153_0_90(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixT<float>& obj = ((TMatrixT<float>*) G__getstructoffset())->operator/=(*(TMatrixTRow_const<float>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_153_0_91(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixT<float>& obj = ((TMatrixT<float>*) G__getstructoffset())->operator*=(*(TMatrixTColumn_const<float>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_153_0_92(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixT<float>& obj = ((TMatrixT<float>*) G__getstructoffset())->operator/=(*(TMatrixTColumn_const<float>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_153_0_93(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixT<float>* pobj;
         const TMatrixT<float> xobj = ((const TMatrixT<float>*) G__getstructoffset())->EigenVectors(*(TVectorT<float>*) libp->para[0].ref);
         pobj = new TMatrixT<float>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_153_0_94(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TMatrixT<float>::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_153_0_95(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixT<float>::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_153_0_96(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TMatrixT<float>::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_153_0_97(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TMatrixT<float>::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_153_0_101(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixT<float>*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_153_0_102(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixT<float>::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_153_0_103(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMatrixT<float>::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_153_0_104(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixT<float>::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_153_0_105(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMatrixT<float>::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_153_0_106(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixT<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixT<float>(*(TMatrixT<double>*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TMatrixT<float>(*(TMatrixT<double>*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TMatrixT<float> G__TTMatrixTlEfloatgR;
static int G__G__Matrix_153_0_107(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TMatrixT<float>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMatrixT<float>*) (soff+(sizeof(TMatrixT<float>)*i)))->~G__TTMatrixTlEfloatgR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMatrixT<float>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMatrixT<float>*) (soff))->~G__TTMatrixTlEfloatgR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TMatrixTSym<float> */
static int G__G__Matrix_157_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTSym<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMatrixTSym<float>[n];
     } else {
       p = new((void*) gvp) TMatrixTSym<float>[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMatrixTSym<float>;
     } else {
       p = new((void*) gvp) TMatrixTSym<float>;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_157_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTSym<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixTSym<float>((Int_t) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TMatrixTSym<float>((Int_t) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_157_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTSym<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixTSym<float>((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TMatrixTSym<float>((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_157_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTSym<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMatrixTSym<float>(
(Int_t) G__int(libp->para[0]), (float*) G__int(libp->para[1])
, (Option_t*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TMatrixTSym<float>(
(Int_t) G__int(libp->para[0]), (float*) G__int(libp->para[1])
, (Option_t*) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMatrixTSym<float>((Int_t) G__int(libp->para[0]), (float*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TMatrixTSym<float>((Int_t) G__int(libp->para[0]), (float*) G__int(libp->para[1]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_157_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTSym<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMatrixTSym<float>(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (float*) G__int(libp->para[2]), (Option_t*) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TMatrixTSym<float>(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (float*) G__int(libp->para[2]), (Option_t*) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMatrixTSym<float>(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (float*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TMatrixTSym<float>(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (float*) G__int(libp->para[2]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_157_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTSym<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixTSym<float>(*(TMatrixTSym<float>*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TMatrixTSym<float>(*(TMatrixTSym<float>*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_157_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTSym<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixTSym<float>((TMatrixTSym<float>::EMatrixCreatorsOp1) G__int(libp->para[0]), *(TMatrixTSym<float>*) libp->para[1].ref);
   } else {
     p = new((void*) gvp) TMatrixTSym<float>((TMatrixTSym<float>::EMatrixCreatorsOp1) G__int(libp->para[0]), *(TMatrixTSym<float>*) libp->para[1].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_157_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTSym<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixTSym<float>((TMatrixTSym<float>::EMatrixCreatorsOp1) G__int(libp->para[0]), *(TMatrixT<float>*) libp->para[1].ref);
   } else {
     p = new((void*) gvp) TMatrixTSym<float>((TMatrixTSym<float>::EMatrixCreatorsOp1) G__int(libp->para[0]), *(TMatrixT<float>*) libp->para[1].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_157_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTSym<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixTSym<float>(
*(TMatrixTSym<float>*) libp->para[0].ref, (TMatrixTSym<float>::EMatrixCreatorsOp2) G__int(libp->para[1])
, *(TMatrixTSym<float>*) libp->para[2].ref);
   } else {
     p = new((void*) gvp) TMatrixTSym<float>(
*(TMatrixTSym<float>*) libp->para[0].ref, (TMatrixTSym<float>::EMatrixCreatorsOp2) G__int(libp->para[1])
, *(TMatrixTSym<float>*) libp->para[2].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_157_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTSym<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixTSym<float>(*(TMatrixTSymLazy<float>*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TMatrixTSym<float>(*(TMatrixTSymLazy<float>*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_157_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTSym<float>*) G__getstructoffset())->TMult(*(TMatrixT<float>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_157_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTSym<float>*) G__getstructoffset())->TMult(*(TMatrixTSym<float>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_157_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTSym<float>*) G__getstructoffset())->Mult(*(TMatrixTSym<float>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_157_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTSym<float>*) G__getstructoffset())->Plus(*(TMatrixTSym<float>*) libp->para[0].ref, *(TMatrixTSym<float>*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_157_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTSym<float>*) G__getstructoffset())->Minus(*(TMatrixTSym<float>*) libp->para[0].ref, *(TMatrixTSym<float>*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_157_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSym<float>& obj = ((TMatrixTSym<float>*) G__getstructoffset())->Use((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (float*) G__int(libp->para[2]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_157_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSym<float>& obj = ((const TMatrixTSym<float>*) G__getstructoffset())->Use((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (float*) G__int(libp->para[2]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_157_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSym<float>& obj = ((TMatrixTSym<float>*) G__getstructoffset())->Use((Int_t) G__int(libp->para[0]), (float*) G__int(libp->para[1]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_157_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSym<float>& obj = ((const TMatrixTSym<float>*) G__getstructoffset())->Use((Int_t) G__int(libp->para[0]), (float*) G__int(libp->para[1]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_157_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSym<float>& obj = ((TMatrixTSym<float>*) G__getstructoffset())->Use(*(TMatrixTSym<float>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_157_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSym<float>& obj = ((const TMatrixTSym<float>*) G__getstructoffset())->Use(*(TMatrixTSym<float>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_157_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      {
         const TMatrixTSym<float>& obj = ((const TMatrixTSym<float>*) G__getstructoffset())->GetSub((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, *(TMatrixTSym<float>*) libp->para[2].ref, (Option_t*) G__int(libp->para[3]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
      break;
   case 3:
      {
         const TMatrixTSym<float>& obj = ((const TMatrixTSym<float>*) G__getstructoffset())->GetSub((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, *(TMatrixTSym<float>*) libp->para[2].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_157_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      {
         const TMatrixTSym<float>* pobj;
         const TMatrixTSym<float> xobj = ((const TMatrixTSym<float>*) G__getstructoffset())->GetSub((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Option_t*) G__int(libp->para[4]));
         pobj = new TMatrixTSym<float>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 4:
      {
         const TMatrixTSym<float>* pobj;
         const TMatrixTSym<float> xobj = ((const TMatrixTSym<float>*) G__getstructoffset())->GetSub((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
         pobj = new TMatrixTSym<float>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_157_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSym<float>& obj = ((TMatrixTSym<float>*) G__getstructoffset())->SetSub((Int_t) G__int(libp->para[0]), *(TMatrixTBase<float>*) libp->para[1].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_157_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTBase<float>& obj = ((TMatrixTSym<float>*) G__getstructoffset())->ResizeTo(*(TMatrixTSym<float>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_157_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      {
         const TMatrixTSym<float>& obj = ((TMatrixTSym<float>*) G__getstructoffset())->Invert((Double_t*) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
      break;
   case 0:
      {
         const TMatrixTSym<float>& obj = ((TMatrixTSym<float>*) G__getstructoffset())->Invert();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_157_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      {
         const TMatrixTSym<float>& obj = ((TMatrixTSym<float>*) G__getstructoffset())->InvertFast((Double_t*) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
      break;
   case 0:
      {
         const TMatrixTSym<float>& obj = ((TMatrixTSym<float>*) G__getstructoffset())->InvertFast();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_157_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSym<float>& obj = ((TMatrixTSym<float>*) G__getstructoffset())->Transpose(*(TMatrixTSym<float>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_157_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSym<float>& obj = ((TMatrixTSym<float>*) G__getstructoffset())->T();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_157_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      {
         const TMatrixTSym<float>& obj = ((TMatrixTSym<float>*) G__getstructoffset())->Rank1Update(*(TVectorT<float>*) libp->para[0].ref, (float) G__double(libp->para[1]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
      break;
   case 1:
      {
         const TMatrixTSym<float>& obj = ((TMatrixTSym<float>*) G__getstructoffset())->Rank1Update(*(TVectorT<float>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_157_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSym<float>& obj = ((TMatrixTSym<float>*) G__getstructoffset())->Similarity(*(TMatrixT<float>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_157_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSym<float>& obj = ((TMatrixTSym<float>*) G__getstructoffset())->Similarity(*(TMatrixTSym<float>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_157_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TMatrixTSym<float>*) G__getstructoffset())->Similarity(*(TVectorT<float>*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_157_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSym<float>& obj = ((TMatrixTSym<float>*) G__getstructoffset())->SimilarityT(*(TMatrixT<float>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_157_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTRow_const<float>* pobj;
         const TMatrixTRow_const<float> xobj = ((const TMatrixTSym<float>*) G__getstructoffset())->operator[]((Int_t) G__int(libp->para[0]));
         pobj = new TMatrixTRow_const<float>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_157_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixTRow<float>* pobj;
         TMatrixTRow<float> xobj = ((TMatrixTSym<float>*) G__getstructoffset())->operator[]((Int_t) G__int(libp->para[0]));
         pobj = new TMatrixTRow<float>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_157_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSym<float>& obj = ((TMatrixTSym<float>*) G__getstructoffset())->operator=(*(TMatrixTSym<float>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_157_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSym<float>& obj = ((TMatrixTSym<float>*) G__getstructoffset())->operator=(*(TMatrixTSymLazy<float>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_157_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSym<float>& obj = ((TMatrixTSym<float>*) G__getstructoffset())->operator=((float) G__double(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_157_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSym<float>& obj = ((TMatrixTSym<float>*) G__getstructoffset())->operator-=((float) G__double(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_157_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSym<float>& obj = ((TMatrixTSym<float>*) G__getstructoffset())->operator+=((float) G__double(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_157_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSym<float>& obj = ((TMatrixTSym<float>*) G__getstructoffset())->operator*=((float) G__double(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_157_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSym<float>& obj = ((TMatrixTSym<float>*) G__getstructoffset())->operator+=(*(TMatrixTSym<float>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_157_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSym<float>& obj = ((TMatrixTSym<float>*) G__getstructoffset())->operator-=(*(TMatrixTSym<float>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_157_0_72(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSym<float>& obj = ((TMatrixTSym<float>*) G__getstructoffset())->RandomizePD((float) G__double(libp->para[0]), (float) G__double(libp->para[1])
, *(Double_t*) G__Doubleref(&libp->para[2]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_157_0_73(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixT<float>* pobj;
         const TMatrixT<float> xobj = ((const TMatrixTSym<float>*) G__getstructoffset())->EigenVectors(*(TVectorT<float>*) libp->para[0].ref);
         pobj = new TMatrixT<float>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_157_0_74(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TMatrixTSym<float>::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_157_0_75(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTSym<float>::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_157_0_76(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TMatrixTSym<float>::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_157_0_77(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TMatrixTSym<float>::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_157_0_81(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTSym<float>*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_157_0_82(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTSym<float>::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_157_0_83(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMatrixTSym<float>::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_157_0_84(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTSym<float>::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_157_0_85(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMatrixTSym<float>::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_157_0_86(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTSym<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixTSym<float>(*(TMatrixTSym<double>*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TMatrixTSym<float>(*(TMatrixTSym<double>*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TMatrixTSym<float> G__TTMatrixTSymlEfloatgR;
static int G__G__Matrix_157_0_87(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TMatrixTSym<float>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMatrixTSym<float>*) (soff+(sizeof(TMatrixTSym<float>)*i)))->~G__TTMatrixTSymlEfloatgR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMatrixTSym<float>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMatrixTSym<float>*) (soff))->~G__TTMatrixTSymlEfloatgR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TMatrixTSymLazy<float> */
static int G__G__Matrix_161_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMatrixTSymLazy<float>*) G__getstructoffset())->GetRowLwb());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_161_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMatrixTSymLazy<float>*) G__getstructoffset())->GetRowUpb());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_161_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TMatrixTSymLazy<float>::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_161_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTSymLazy<float>::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_161_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TMatrixTSymLazy<float>::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_161_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TMatrixTSymLazy<float>::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_161_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTSymLazy<float>*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_161_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTSymLazy<float>::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_161_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMatrixTSymLazy<float>::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_161_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTSymLazy<float>::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_161_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMatrixTSymLazy<float>::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TMatrixTSymLazy<float> G__TTMatrixTSymLazylEfloatgR;
static int G__G__Matrix_161_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TMatrixTSymLazy<float>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMatrixTSymLazy<float>*) (soff+(sizeof(TMatrixTSymLazy<float>)*i)))->~G__TTMatrixTSymLazylEfloatgR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMatrixTSymLazy<float>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMatrixTSymLazy<float>*) (soff))->~G__TTMatrixTSymLazylEfloatgR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TMatrixTRow<float> */
static int G__G__Matrix_162_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTRow<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMatrixTRow<float>[n];
     } else {
       p = new((void*) gvp) TMatrixTRow<float>[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMatrixTRow<float>;
     } else {
       p = new((void*) gvp) TMatrixTRow<float>;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTRowlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_162_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTRow<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixTRow<float>(*(TMatrixT<float>*) libp->para[0].ref, (Int_t) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TMatrixTRow<float>(*(TMatrixT<float>*) libp->para[0].ref, (Int_t) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTRowlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_162_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTRow<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixTRow<float>(*(TMatrixTSym<float>*) libp->para[0].ref, (Int_t) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TMatrixTRow<float>(*(TMatrixTSym<float>*) libp->para[0].ref, (Int_t) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTRowlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_162_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTRow<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixTRow<float>(*(TMatrixTRow<float>*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TMatrixTRow<float>(*(TMatrixTRow<float>*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTRowlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_162_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 70, (long) ((const TMatrixTRow<float>*) G__getstructoffset())->GetPtr());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_162_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const float& obj = ((const TMatrixTRow<float>*) G__getstructoffset())->operator()((Int_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.d = (double) (obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_162_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const float& obj = ((TMatrixTRow<float>*) G__getstructoffset())->operator()((Int_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.d = (double) (obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_162_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const float& obj = ((const TMatrixTRow<float>*) G__getstructoffset())->operator[]((Int_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.d = (double) (obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_162_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const float& obj = ((TMatrixTRow<float>*) G__getstructoffset())->operator[]((Int_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.d = (double) (obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_162_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTRow<float>*) G__getstructoffset())->operator=((float) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_162_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTRow<float>*) G__getstructoffset())->operator+=((float) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_162_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTRow<float>*) G__getstructoffset())->operator*=((float) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_162_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTRow<float>*) G__getstructoffset())->operator=(*(TMatrixTRow_const<float>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_162_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTRow<float>& obj = ((TMatrixTRow<float>*) G__getstructoffset())->operator=(*(TMatrixTRow<float>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_162_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTRow<float>*) G__getstructoffset())->operator=(*(TVectorT<float>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_162_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTRow<float>*) G__getstructoffset())->operator+=(*(TMatrixTRow_const<float>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_162_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTRow<float>*) G__getstructoffset())->operator*=(*(TMatrixTRow_const<float>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_162_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TMatrixTRow<float>::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_162_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTRow<float>::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_162_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TMatrixTRow<float>::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_162_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TMatrixTRow<float>::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_162_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTRow<float>*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_162_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTRow<float>::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_162_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMatrixTRow<float>::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_162_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTRow<float>::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_162_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMatrixTRow<float>::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TMatrixTRow<float> G__TTMatrixTRowlEfloatgR;
static int G__G__Matrix_162_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TMatrixTRow<float>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMatrixTRow<float>*) (soff+(sizeof(TMatrixTRow<float>)*i)))->~G__TTMatrixTRowlEfloatgR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMatrixTRow<float>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMatrixTRow<float>*) (soff))->~G__TTMatrixTRowlEfloatgR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TMatrixTSparse<float> */
static int G__G__Matrix_163_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTSparse<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMatrixTSparse<float>[n];
     } else {
       p = new((void*) gvp) TMatrixTSparse<float>[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMatrixTSparse<float>;
     } else {
       p = new((void*) gvp) TMatrixTSparse<float>;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_163_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTSparse<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixTSparse<float>((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TMatrixTSparse<float>((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_163_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTSparse<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 4
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixTSparse<float>(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
   } else {
     p = new((void*) gvp) TMatrixTSparse<float>(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_163_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTSparse<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 8
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixTSparse<float>(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t*) G__int(libp->para[5])
, (Int_t*) G__int(libp->para[6]), (float*) G__int(libp->para[7]));
   } else {
     p = new((void*) gvp) TMatrixTSparse<float>(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t*) G__int(libp->para[5])
, (Int_t*) G__int(libp->para[6]), (float*) G__int(libp->para[7]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_163_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTSparse<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixTSparse<float>(*(TMatrixTSparse<float>*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TMatrixTSparse<float>(*(TMatrixTSparse<float>*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_163_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTSparse<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixTSparse<float>(*(TMatrixT<float>*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TMatrixTSparse<float>(*(TMatrixT<float>*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_163_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTSparse<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixTSparse<float>((TMatrixTSparse<float>::EMatrixCreatorsOp1) G__int(libp->para[0]), *(TMatrixTSparse<float>*) libp->para[1].ref);
   } else {
     p = new((void*) gvp) TMatrixTSparse<float>((TMatrixTSparse<float>::EMatrixCreatorsOp1) G__int(libp->para[0]), *(TMatrixTSparse<float>*) libp->para[1].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_163_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTSparse<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixTSparse<float>(
*(TMatrixTSparse<float>*) libp->para[0].ref, (TMatrixTSparse<float>::EMatrixCreatorsOp2) G__int(libp->para[1])
, *(TMatrixTSparse<float>*) libp->para[2].ref);
   } else {
     p = new((void*) gvp) TMatrixTSparse<float>(
*(TMatrixTSparse<float>*) libp->para[0].ref, (TMatrixTSparse<float>::EMatrixCreatorsOp2) G__int(libp->para[1])
, *(TMatrixTSparse<float>*) libp->para[2].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_163_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTSparse<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixTSparse<float>(
*(TMatrixTSparse<float>*) libp->para[0].ref, (TMatrixTSparse<float>::EMatrixCreatorsOp2) G__int(libp->para[1])
, *(TMatrixT<float>*) libp->para[2].ref);
   } else {
     p = new((void*) gvp) TMatrixTSparse<float>(
*(TMatrixTSparse<float>*) libp->para[0].ref, (TMatrixTSparse<float>::EMatrixCreatorsOp2) G__int(libp->para[1])
, *(TMatrixT<float>*) libp->para[2].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_163_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTSparse<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixTSparse<float>(
*(TMatrixT<float>*) libp->para[0].ref, (TMatrixTSparse<float>::EMatrixCreatorsOp2) G__int(libp->para[1])
, *(TMatrixTSparse<float>*) libp->para[2].ref);
   } else {
     p = new((void*) gvp) TMatrixTSparse<float>(
*(TMatrixT<float>*) libp->para[0].ref, (TMatrixTSparse<float>::EMatrixCreatorsOp2) G__int(libp->para[1])
, *(TMatrixTSparse<float>*) libp->para[2].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_163_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSparse<float>& obj = ((TMatrixTSparse<float>*) G__getstructoffset())->SetSparseIndex((Int_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_163_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSparse<float>& obj = ((TMatrixTSparse<float>*) G__getstructoffset())->SetSparseIndex(*(TMatrixTBase<float>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_163_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSparse<float>& obj = ((TMatrixTSparse<float>*) G__getstructoffset())->SetSparseIndexAB(*(TMatrixTSparse<float>*) libp->para[0].ref, *(TMatrixTSparse<float>*) libp->para[1].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_163_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSparse<float>& obj = ((TMatrixTSparse<float>*) G__getstructoffset())->SetSparseIndexAB(*(TMatrixT<float>*) libp->para[0].ref, *(TMatrixTSparse<float>*) libp->para[1].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_163_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSparse<float>& obj = ((TMatrixTSparse<float>*) G__getstructoffset())->SetSparseIndexAB(*(TMatrixTSparse<float>*) libp->para[0].ref, *(TMatrixT<float>*) libp->para[1].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_163_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTBase<float>& obj = ((TMatrixTSparse<float>*) G__getstructoffset())->SetMatrixArray((Int_t) G__int(libp->para[0]), (Int_t*) G__int(libp->para[1])
, (Int_t*) G__int(libp->para[2]), (float*) G__int(libp->para[3]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_163_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTBase<float>& obj = ((TMatrixTSparse<float>*) G__getstructoffset())->ResizeTo(*(TMatrixTSparse<float>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_163_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSparse<float>& obj = ((TMatrixTSparse<float>*) G__getstructoffset())->Use(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Int_t*) G__int(libp->para[5])
, (Int_t*) G__int(libp->para[6]), (float*) G__int(libp->para[7]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_163_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSparse<float>& obj = ((const TMatrixTSparse<float>*) G__getstructoffset())->Use(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (const Int_t*) G__int(libp->para[5])
, (const Int_t*) G__int(libp->para[6]), (float*) G__int(libp->para[7]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_163_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSparse<float>& obj = ((TMatrixTSparse<float>*) G__getstructoffset())->Use((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t*) G__int(libp->para[3])
, (Int_t*) G__int(libp->para[4]), (float*) G__int(libp->para[5]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_163_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSparse<float>& obj = ((const TMatrixTSparse<float>*) G__getstructoffset())->Use((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (const Int_t*) G__int(libp->para[3])
, (const Int_t*) G__int(libp->para[4]), (float*) G__int(libp->para[5]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_163_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSparse<float>& obj = ((TMatrixTSparse<float>*) G__getstructoffset())->Use(*(TMatrixTSparse<float>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_163_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSparse<float>& obj = ((const TMatrixTSparse<float>*) G__getstructoffset())->Use(*(TMatrixTSparse<float>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_163_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      {
         const TMatrixTSparse<float>* pobj;
         const TMatrixTSparse<float> xobj = ((const TMatrixTSparse<float>*) G__getstructoffset())->GetSub((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Option_t*) G__int(libp->para[4]));
         pobj = new TMatrixTSparse<float>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 4:
      {
         const TMatrixTSparse<float>* pobj;
         const TMatrixTSparse<float> xobj = ((const TMatrixTSparse<float>*) G__getstructoffset())->GetSub((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
         pobj = new TMatrixTSparse<float>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_163_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSparse<float>& obj = ((TMatrixTSparse<float>*) G__getstructoffset())->Transpose(*(TMatrixTSparse<float>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_163_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSparse<float>& obj = ((TMatrixTSparse<float>*) G__getstructoffset())->T();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_163_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTSparse<float>*) G__getstructoffset())->Mult(*(TMatrixTSparse<float>*) libp->para[0].ref, *(TMatrixTSparse<float>*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_163_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSparseRow_const<float>* pobj;
         const TMatrixTSparseRow_const<float> xobj = ((const TMatrixTSparse<float>*) G__getstructoffset())->operator[]((Int_t) G__int(libp->para[0]));
         pobj = new TMatrixTSparseRow_const<float>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_163_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixTSparseRow<float>* pobj;
         TMatrixTSparseRow<float> xobj = ((TMatrixTSparse<float>*) G__getstructoffset())->operator[]((Int_t) G__int(libp->para[0]));
         pobj = new TMatrixTSparseRow<float>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_163_0_69(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSparse<float>& obj = ((TMatrixTSparse<float>*) G__getstructoffset())->operator=(*(TMatrixT<float>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_163_0_70(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSparse<float>& obj = ((TMatrixTSparse<float>*) G__getstructoffset())->operator=(*(TMatrixTSparse<float>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_163_0_71(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSparse<float>& obj = ((TMatrixTSparse<float>*) G__getstructoffset())->operator=((float) G__double(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_163_0_72(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSparse<float>& obj = ((TMatrixTSparse<float>*) G__getstructoffset())->operator-=((float) G__double(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_163_0_73(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSparse<float>& obj = ((TMatrixTSparse<float>*) G__getstructoffset())->operator+=((float) G__double(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_163_0_74(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSparse<float>& obj = ((TMatrixTSparse<float>*) G__getstructoffset())->operator*=((float) G__double(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_163_0_75(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSparse<float>& obj = ((TMatrixTSparse<float>*) G__getstructoffset())->operator+=(*(TMatrixTSparse<float>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_163_0_76(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSparse<float>& obj = ((TMatrixTSparse<float>*) G__getstructoffset())->operator+=(*(TMatrixT<float>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_163_0_77(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSparse<float>& obj = ((TMatrixTSparse<float>*) G__getstructoffset())->operator-=(*(TMatrixTSparse<float>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_163_0_78(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSparse<float>& obj = ((TMatrixTSparse<float>*) G__getstructoffset())->operator-=(*(TMatrixT<float>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_163_0_79(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSparse<float>& obj = ((TMatrixTSparse<float>*) G__getstructoffset())->operator*=(*(TMatrixTSparse<float>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_163_0_80(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSparse<float>& obj = ((TMatrixTSparse<float>*) G__getstructoffset())->operator*=(*(TMatrixT<float>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_163_0_82(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSparse<float>& obj = ((TMatrixTSparse<float>*) G__getstructoffset())->RandomizePD((float) G__double(libp->para[0]), (float) G__double(libp->para[1])
, *(Double_t*) G__Doubleref(&libp->para[2]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_163_0_83(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TMatrixTSparse<float>::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_163_0_84(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTSparse<float>::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_163_0_85(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TMatrixTSparse<float>::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_163_0_86(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TMatrixTSparse<float>::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_163_0_90(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTSparse<float>*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_163_0_91(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTSparse<float>::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_163_0_92(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMatrixTSparse<float>::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_163_0_93(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTSparse<float>::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_163_0_94(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMatrixTSparse<float>::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TMatrixTSparse<float> G__TTMatrixTSparselEfloatgR;
static int G__G__Matrix_163_0_95(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TMatrixTSparse<float>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMatrixTSparse<float>*) (soff+(sizeof(TMatrixTSparse<float>)*i)))->~G__TTMatrixTSparselEfloatgR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMatrixTSparse<float>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMatrixTSparse<float>*) (soff))->~G__TTMatrixTSparselEfloatgR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TMatrixTSparseRow_const<float> */
static int G__G__Matrix_166_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTSparseRow_const<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMatrixTSparseRow_const<float>[n];
     } else {
       p = new((void*) gvp) TMatrixTSparseRow_const<float>[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMatrixTSparseRow_const<float>;
     } else {
       p = new((void*) gvp) TMatrixTSparseRow_const<float>;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparseRow_constlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_166_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTSparseRow_const<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixTSparseRow_const<float>(*(TMatrixTSparse<float>*) libp->para[0].ref, (Int_t) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TMatrixTSparseRow_const<float>(*(TMatrixTSparse<float>*) libp->para[0].ref, (Int_t) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparseRow_constlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_166_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTSparseRow_const<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixTSparseRow_const<float>(*(TMatrixTSparseRow_const<float>*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TMatrixTSparseRow_const<float>(*(TMatrixTSparseRow_const<float>*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparseRow_constlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_166_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSparseRow_const<float>& obj = ((TMatrixTSparseRow_const<float>*) G__getstructoffset())->operator=(*(TMatrixTSparseRow_const<float>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_166_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TMatrixTSparseRow_const<float>*) G__getstructoffset())->GetMatrix());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_166_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 70, (long) ((const TMatrixTSparseRow_const<float>*) G__getstructoffset())->GetDataPtr());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_166_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 73, (long) ((const TMatrixTSparseRow_const<float>*) G__getstructoffset())->GetColPtr());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_166_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMatrixTSparseRow_const<float>*) G__getstructoffset())->GetRowIndex());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_166_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMatrixTSparseRow_const<float>*) G__getstructoffset())->GetNindex());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_166_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TMatrixTSparseRow_const<float>*) G__getstructoffset())->operator()((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_166_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TMatrixTSparseRow_const<float>*) G__getstructoffset())->operator[]((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_166_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TMatrixTSparseRow_const<float>::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_166_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTSparseRow_const<float>::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_166_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TMatrixTSparseRow_const<float>::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_166_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TMatrixTSparseRow_const<float>::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_166_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TMatrixTSparseRow_const<float>*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_166_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTSparseRow_const<float>*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_166_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTSparseRow_const<float>*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_166_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTSparseRow_const<float>*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_166_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTSparseRow_const<float>::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_166_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMatrixTSparseRow_const<float>::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_166_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTSparseRow_const<float>::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_166_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMatrixTSparseRow_const<float>::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TMatrixTSparseRow_const<float> G__TTMatrixTSparseRow_constlEfloatgR;
static int G__G__Matrix_166_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TMatrixTSparseRow_const<float>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMatrixTSparseRow_const<float>*) (soff+(sizeof(TMatrixTSparseRow_const<float>)*i)))->~G__TTMatrixTSparseRow_constlEfloatgR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMatrixTSparseRow_const<float>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMatrixTSparseRow_const<float>*) (soff))->~G__TTMatrixTSparseRow_constlEfloatgR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TMatrixTSparseRow<float> */
static int G__G__Matrix_167_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTSparseRow<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMatrixTSparseRow<float>[n];
     } else {
       p = new((void*) gvp) TMatrixTSparseRow<float>[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMatrixTSparseRow<float>;
     } else {
       p = new((void*) gvp) TMatrixTSparseRow<float>;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparseRowlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_167_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTSparseRow<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixTSparseRow<float>(*(TMatrixTSparse<float>*) libp->para[0].ref, (Int_t) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TMatrixTSparseRow<float>(*(TMatrixTSparse<float>*) libp->para[0].ref, (Int_t) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparseRowlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_167_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTSparseRow<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixTSparseRow<float>(*(TMatrixTSparseRow<float>*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TMatrixTSparseRow<float>(*(TMatrixTSparseRow<float>*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparseRowlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_167_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 70, (long) ((const TMatrixTSparseRow<float>*) G__getstructoffset())->GetDataPtr());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_167_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TMatrixTSparseRow<float>*) G__getstructoffset())->operator()((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_167_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const float& obj = ((TMatrixTSparseRow<float>*) G__getstructoffset())->operator()((Int_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.d = (double) (obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_167_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TMatrixTSparseRow<float>*) G__getstructoffset())->operator[]((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_167_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const float& obj = ((TMatrixTSparseRow<float>*) G__getstructoffset())->operator[]((Int_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.d = (double) (obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_167_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTSparseRow<float>*) G__getstructoffset())->operator=((float) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_167_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTSparseRow<float>*) G__getstructoffset())->operator+=((float) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_167_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTSparseRow<float>*) G__getstructoffset())->operator*=((float) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_167_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTSparseRow<float>*) G__getstructoffset())->operator=(*(TMatrixTSparseRow_const<float>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_167_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSparseRow<float>& obj = ((TMatrixTSparseRow<float>*) G__getstructoffset())->operator=(*(TMatrixTSparseRow<float>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_167_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTSparseRow<float>*) G__getstructoffset())->operator=(*(TVectorT<float>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_167_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTSparseRow<float>*) G__getstructoffset())->operator+=(*(TMatrixTSparseRow_const<float>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_167_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTSparseRow<float>*) G__getstructoffset())->operator*=(*(TMatrixTSparseRow_const<float>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_167_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TMatrixTSparseRow<float>::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_167_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTSparseRow<float>::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_167_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TMatrixTSparseRow<float>::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_167_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TMatrixTSparseRow<float>::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_167_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTSparseRow<float>*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_167_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTSparseRow<float>::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_167_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMatrixTSparseRow<float>::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_167_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTSparseRow<float>::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_167_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMatrixTSparseRow<float>::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TMatrixTSparseRow<float> G__TTMatrixTSparseRowlEfloatgR;
static int G__G__Matrix_167_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TMatrixTSparseRow<float>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMatrixTSparseRow<float>*) (soff+(sizeof(TMatrixTSparseRow<float>)*i)))->~G__TTMatrixTSparseRowlEfloatgR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMatrixTSparseRow<float>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMatrixTSparseRow<float>*) (soff))->~G__TTMatrixTSparseRowlEfloatgR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TMatrixTLazy<float> */
static int G__G__Matrix_168_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMatrixTLazy<float>*) G__getstructoffset())->GetRowLwb());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_168_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMatrixTLazy<float>*) G__getstructoffset())->GetRowUpb());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_168_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMatrixTLazy<float>*) G__getstructoffset())->GetColLwb());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_168_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMatrixTLazy<float>*) G__getstructoffset())->GetColUpb());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_168_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TMatrixTLazy<float>::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_168_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTLazy<float>::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_168_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TMatrixTLazy<float>::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_168_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TMatrixTLazy<float>::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_168_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTLazy<float>*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_168_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTLazy<float>::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_168_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMatrixTLazy<float>::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_168_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTLazy<float>::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_168_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMatrixTLazy<float>::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TMatrixTLazy<float> G__TTMatrixTLazylEfloatgR;
static int G__G__Matrix_168_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TMatrixTLazy<float>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMatrixTLazy<float>*) (soff+(sizeof(TMatrixTLazy<float>)*i)))->~G__TTMatrixTLazylEfloatgR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMatrixTLazy<float>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMatrixTLazy<float>*) (soff))->~G__TTMatrixTLazylEfloatgR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TMatrixTDiag_const<float> */
static int G__G__Matrix_169_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTDiag_const<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMatrixTDiag_const<float>[n];
     } else {
       p = new((void*) gvp) TMatrixTDiag_const<float>[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMatrixTDiag_const<float>;
     } else {
       p = new((void*) gvp) TMatrixTDiag_const<float>;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTDiag_constlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_169_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTDiag_const<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixTDiag_const<float>(*(TMatrixT<float>*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TMatrixTDiag_const<float>(*(TMatrixT<float>*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTDiag_constlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_169_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTDiag_const<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixTDiag_const<float>(*(TMatrixTSym<float>*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TMatrixTDiag_const<float>(*(TMatrixTSym<float>*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTDiag_constlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_169_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTDiag_const<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixTDiag_const<float>(*(TMatrixTDiag_const<float>*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TMatrixTDiag_const<float>(*(TMatrixTDiag_const<float>*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTDiag_constlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_169_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTDiag_const<float>& obj = ((TMatrixTDiag_const<float>*) G__getstructoffset())->operator=(*(TMatrixTDiag_const<float>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_169_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TMatrixTDiag_const<float>*) G__getstructoffset())->GetMatrix());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_169_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 70, (long) ((const TMatrixTDiag_const<float>*) G__getstructoffset())->GetPtr());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_169_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMatrixTDiag_const<float>*) G__getstructoffset())->GetInc());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_169_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const float& obj = ((const TMatrixTDiag_const<float>*) G__getstructoffset())->operator()((Int_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.d = (double) (obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_169_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const float& obj = ((const TMatrixTDiag_const<float>*) G__getstructoffset())->operator[]((Int_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.d = (double) (obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_169_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMatrixTDiag_const<float>*) G__getstructoffset())->GetNdiags());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_169_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TMatrixTDiag_const<float>::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_169_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTDiag_const<float>::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_169_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TMatrixTDiag_const<float>::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_169_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TMatrixTDiag_const<float>::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_169_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TMatrixTDiag_const<float>*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_169_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTDiag_const<float>*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_169_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTDiag_const<float>*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_169_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTDiag_const<float>*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_169_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTDiag_const<float>::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_169_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMatrixTDiag_const<float>::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_169_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTDiag_const<float>::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_169_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMatrixTDiag_const<float>::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TMatrixTDiag_const<float> G__TTMatrixTDiag_constlEfloatgR;
static int G__G__Matrix_169_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TMatrixTDiag_const<float>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMatrixTDiag_const<float>*) (soff+(sizeof(TMatrixTDiag_const<float>)*i)))->~G__TTMatrixTDiag_constlEfloatgR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMatrixTDiag_const<float>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMatrixTDiag_const<float>*) (soff))->~G__TTMatrixTDiag_constlEfloatgR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TMatrixTColumn_const<float> */
static int G__G__Matrix_170_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTColumn_const<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMatrixTColumn_const<float>[n];
     } else {
       p = new((void*) gvp) TMatrixTColumn_const<float>[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMatrixTColumn_const<float>;
     } else {
       p = new((void*) gvp) TMatrixTColumn_const<float>;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTColumn_constlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_170_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTColumn_const<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixTColumn_const<float>(*(TMatrixT<float>*) libp->para[0].ref, (Int_t) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TMatrixTColumn_const<float>(*(TMatrixT<float>*) libp->para[0].ref, (Int_t) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTColumn_constlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_170_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTColumn_const<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixTColumn_const<float>(*(TMatrixTSym<float>*) libp->para[0].ref, (Int_t) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TMatrixTColumn_const<float>(*(TMatrixTSym<float>*) libp->para[0].ref, (Int_t) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTColumn_constlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_170_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTColumn_const<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixTColumn_const<float>(*(TMatrixTColumn_const<float>*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TMatrixTColumn_const<float>(*(TMatrixTColumn_const<float>*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTColumn_constlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_170_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTColumn_const<float>& obj = ((TMatrixTColumn_const<float>*) G__getstructoffset())->operator=(*(TMatrixTColumn_const<float>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_170_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TMatrixTColumn_const<float>*) G__getstructoffset())->GetMatrix());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_170_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMatrixTColumn_const<float>*) G__getstructoffset())->GetColIndex());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_170_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMatrixTColumn_const<float>*) G__getstructoffset())->GetInc());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_170_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 70, (long) ((const TMatrixTColumn_const<float>*) G__getstructoffset())->GetPtr());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_170_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const float& obj = ((const TMatrixTColumn_const<float>*) G__getstructoffset())->operator()((Int_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.d = (double) (obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_170_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const float& obj = ((const TMatrixTColumn_const<float>*) G__getstructoffset())->operator[]((Int_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.d = (double) (obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_170_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TMatrixTColumn_const<float>::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_170_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTColumn_const<float>::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_170_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TMatrixTColumn_const<float>::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_170_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TMatrixTColumn_const<float>::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_170_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TMatrixTColumn_const<float>*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_170_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTColumn_const<float>*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_170_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTColumn_const<float>*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_170_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTColumn_const<float>*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_170_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTColumn_const<float>::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_170_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMatrixTColumn_const<float>::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_170_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTColumn_const<float>::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_170_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMatrixTColumn_const<float>::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TMatrixTColumn_const<float> G__TTMatrixTColumn_constlEfloatgR;
static int G__G__Matrix_170_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TMatrixTColumn_const<float>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMatrixTColumn_const<float>*) (soff+(sizeof(TMatrixTColumn_const<float>)*i)))->~G__TTMatrixTColumn_constlEfloatgR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMatrixTColumn_const<float>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMatrixTColumn_const<float>*) (soff))->~G__TTMatrixTColumn_constlEfloatgR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TMatrixTSparseDiag_const<float> */
static int G__G__Matrix_171_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTSparseDiag_const<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMatrixTSparseDiag_const<float>[n];
     } else {
       p = new((void*) gvp) TMatrixTSparseDiag_const<float>[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMatrixTSparseDiag_const<float>;
     } else {
       p = new((void*) gvp) TMatrixTSparseDiag_const<float>;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparseDiag_constlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_171_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTSparseDiag_const<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixTSparseDiag_const<float>(*(TMatrixTSparse<float>*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TMatrixTSparseDiag_const<float>(*(TMatrixTSparse<float>*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparseDiag_constlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_171_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTSparseDiag_const<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixTSparseDiag_const<float>(*(TMatrixTSparseDiag_const<float>*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TMatrixTSparseDiag_const<float>(*(TMatrixTSparseDiag_const<float>*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparseDiag_constlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_171_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSparseDiag_const<float>& obj = ((TMatrixTSparseDiag_const<float>*) G__getstructoffset())->operator=(*(TMatrixTSparseDiag_const<float>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_171_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TMatrixTSparseDiag_const<float>*) G__getstructoffset())->GetMatrix());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_171_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 70, (long) ((const TMatrixTSparseDiag_const<float>*) G__getstructoffset())->GetDataPtr());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_171_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMatrixTSparseDiag_const<float>*) G__getstructoffset())->GetNdiags());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_171_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TMatrixTSparseDiag_const<float>*) G__getstructoffset())->operator()((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_171_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TMatrixTSparseDiag_const<float>*) G__getstructoffset())->operator[]((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_171_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TMatrixTSparseDiag_const<float>::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_171_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTSparseDiag_const<float>::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_171_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TMatrixTSparseDiag_const<float>::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_171_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TMatrixTSparseDiag_const<float>::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_171_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TMatrixTSparseDiag_const<float>*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_171_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTSparseDiag_const<float>*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_171_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTSparseDiag_const<float>*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_171_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTSparseDiag_const<float>*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_171_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTSparseDiag_const<float>::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_171_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMatrixTSparseDiag_const<float>::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_171_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTSparseDiag_const<float>::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_171_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMatrixTSparseDiag_const<float>::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TMatrixTSparseDiag_const<float> G__TTMatrixTSparseDiag_constlEfloatgR;
static int G__G__Matrix_171_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TMatrixTSparseDiag_const<float>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMatrixTSparseDiag_const<float>*) (soff+(sizeof(TMatrixTSparseDiag_const<float>)*i)))->~G__TTMatrixTSparseDiag_constlEfloatgR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMatrixTSparseDiag_const<float>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMatrixTSparseDiag_const<float>*) (soff))->~G__TTMatrixTSparseDiag_constlEfloatgR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TDecompBase */
static int G__G__Matrix_174_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TDecompBase*) G__getstructoffset())->GetTol());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_174_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TDecompBase*) G__getstructoffset())->GetDet1());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_174_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TDecompBase*) G__getstructoffset())->GetDet2());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_174_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TDecompBase*) G__getstructoffset())->GetCondition());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_174_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TDecompBase*) G__getstructoffset())->GetNrows());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_174_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TDecompBase*) G__getstructoffset())->GetNcols());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_174_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TDecompBase*) G__getstructoffset())->GetRowLwb());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_174_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TDecompBase*) G__getstructoffset())->GetColLwb());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_174_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((TDecompBase*) G__getstructoffset())->SetTol((Double_t) G__double(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_174_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((TDecompBase*) G__getstructoffset())->Condition());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_174_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TDecompBase*) G__getstructoffset())->Det(*(Double_t*) G__Doubleref(&libp->para[0]), *(Double_t*) G__Doubleref(&libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_174_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TDecompBase*) G__getstructoffset())->Decompose());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_174_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TDecompBase*) G__getstructoffset())->Solve(*(TVectorD*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_174_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TVectorD* pobj;
         TVectorD xobj = ((TDecompBase*) G__getstructoffset())->Solve(*(TVectorD*) libp->para[0].ref, *(Bool_t*) G__Boolref(&libp->para[1]));
         pobj = new TVectorD(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_174_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TDecompBase*) G__getstructoffset())->Solve(*(TMatrixDColumn*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_174_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TDecompBase*) G__getstructoffset())->TransSolve(*(TVectorD*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_174_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TVectorD* pobj;
         TVectorD xobj = ((TDecompBase*) G__getstructoffset())->TransSolve(*(TVectorD*) libp->para[0].ref, *(Bool_t*) G__Boolref(&libp->para[1]));
         pobj = new TVectorD(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_174_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TDecompBase*) G__getstructoffset())->TransSolve(*(TMatrixDColumn*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_174_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TDecompBase*) G__getstructoffset())->MultiSolve(*(TMatrixD*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_174_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TDecompBase& obj = ((TDecompBase*) G__getstructoffset())->operator=(*(TDecompBase*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_174_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TDecompBase::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_174_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TDecompBase::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_174_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TDecompBase::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_174_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TDecompBase::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_174_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TDecompBase*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_174_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TDecompBase::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_174_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TDecompBase::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_174_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TDecompBase::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_174_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TDecompBase::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TDecompBase G__TTDecompBase;
static int G__G__Matrix_174_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TDecompBase*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TDecompBase*) (soff+(sizeof(TDecompBase)*i)))->~G__TTDecompBase();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TDecompBase*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TDecompBase*) (soff))->~G__TTDecompBase();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TDecompBK */
static int G__G__Matrix_177_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TDecompBK* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TDecompBK[n];
     } else {
       p = new((void*) gvp) TDecompBK[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TDecompBK;
     } else {
       p = new((void*) gvp) TDecompBK;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TDecompBK));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_177_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TDecompBK* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TDecompBK((Int_t) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TDecompBK((Int_t) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TDecompBK));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_177_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TDecompBK* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TDecompBK((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TDecompBK((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TDecompBK));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_177_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TDecompBK* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TDecompBK(*(TMatrixDSym*) libp->para[0].ref, (Double_t) G__double(libp->para[1]));
     } else {
       p = new((void*) gvp) TDecompBK(*(TMatrixDSym*) libp->para[0].ref, (Double_t) G__double(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TDecompBK(*(TMatrixDSym*) libp->para[0].ref);
     } else {
       p = new((void*) gvp) TDecompBK(*(TMatrixDSym*) libp->para[0].ref);
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TDecompBK));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_177_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TDecompBK* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TDecompBK(*(TDecompBK*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TDecompBK(*(TDecompBK*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TDecompBK));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_177_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixD& obj = ((TDecompBK*) G__getstructoffset())->GetU();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_177_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TDecompBK*) G__getstructoffset())->SetMatrix(*(TMatrixDSym*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_177_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TDecompBK*) G__getstructoffset())->Invert(*(TMatrixDSym*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_177_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixDSym* pobj;
         TMatrixDSym xobj = ((TDecompBK*) G__getstructoffset())->Invert(*(Bool_t*) G__Boolref(&libp->para[0]));
         pobj = new TMatrixDSym(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_177_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixDSym* pobj;
         TMatrixDSym xobj = ((TDecompBK*) G__getstructoffset())->Invert();
         pobj = new TMatrixDSym(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_177_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TDecompBK& obj = ((TDecompBK*) G__getstructoffset())->operator=(*(TDecompBK*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_177_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TDecompBK::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_177_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TDecompBK::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_177_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TDecompBK::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_177_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TDecompBK::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_177_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TDecompBK*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_177_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TDecompBK::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_177_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TDecompBK::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_177_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TDecompBK::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_177_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TDecompBK::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TDecompBK G__TTDecompBK;
static int G__G__Matrix_177_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TDecompBK*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TDecompBK*) (soff+(sizeof(TDecompBK)*i)))->~G__TTDecompBK();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TDecompBK*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TDecompBK*) (soff))->~G__TTDecompBK();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TDecompChol */
static int G__G__Matrix_178_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TDecompChol* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TDecompChol[n];
     } else {
       p = new((void*) gvp) TDecompChol[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TDecompChol;
     } else {
       p = new((void*) gvp) TDecompChol;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TDecompChol));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_178_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TDecompChol* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TDecompChol((Int_t) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TDecompChol((Int_t) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TDecompChol));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_178_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TDecompChol* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TDecompChol((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TDecompChol((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TDecompChol));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_178_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TDecompChol* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TDecompChol(*(TMatrixDSym*) libp->para[0].ref, (Double_t) G__double(libp->para[1]));
     } else {
       p = new((void*) gvp) TDecompChol(*(TMatrixDSym*) libp->para[0].ref, (Double_t) G__double(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TDecompChol(*(TMatrixDSym*) libp->para[0].ref);
     } else {
       p = new((void*) gvp) TDecompChol(*(TMatrixDSym*) libp->para[0].ref);
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TDecompChol));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_178_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TDecompChol* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TDecompChol(*(TMatrixD*) libp->para[0].ref, (Double_t) G__double(libp->para[1]));
     } else {
       p = new((void*) gvp) TDecompChol(*(TMatrixD*) libp->para[0].ref, (Double_t) G__double(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TDecompChol(*(TMatrixD*) libp->para[0].ref);
     } else {
       p = new((void*) gvp) TDecompChol(*(TMatrixD*) libp->para[0].ref);
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TDecompChol));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_178_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TDecompChol* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TDecompChol(*(TDecompChol*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TDecompChol(*(TDecompChol*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TDecompChol));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_178_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixDSym* pobj;
         TMatrixDSym xobj = ((TDecompChol*) G__getstructoffset())->GetMatrix();
         pobj = new TMatrixDSym(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_178_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixD& obj = ((const TDecompChol*) G__getstructoffset())->GetU();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_178_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TDecompChol*) G__getstructoffset())->SetMatrix(*(TMatrixDSym*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_178_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TDecompChol*) G__getstructoffset())->Invert(*(TMatrixDSym*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_178_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixDSym* pobj;
         TMatrixDSym xobj = ((TDecompChol*) G__getstructoffset())->Invert(*(Bool_t*) G__Boolref(&libp->para[0]));
         pobj = new TMatrixDSym(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_178_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixDSym* pobj;
         TMatrixDSym xobj = ((TDecompChol*) G__getstructoffset())->Invert();
         pobj = new TMatrixDSym(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_178_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TDecompChol& obj = ((TDecompChol*) G__getstructoffset())->operator=(*(TDecompChol*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_178_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TDecompChol::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_178_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TDecompChol::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_178_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TDecompChol::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_178_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TDecompChol::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_178_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TDecompChol*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_178_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TDecompChol::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_178_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TDecompChol::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_178_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TDecompChol::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_178_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TDecompChol::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TDecompChol G__TTDecompChol;
static int G__G__Matrix_178_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TDecompChol*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TDecompChol*) (soff+(sizeof(TDecompChol)*i)))->~G__TTDecompChol();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TDecompChol*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TDecompChol*) (soff))->~G__TTDecompChol();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TDecompLU */
static int G__G__Matrix_179_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TDecompLU* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TDecompLU[n];
     } else {
       p = new((void*) gvp) TDecompLU[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TDecompLU;
     } else {
       p = new((void*) gvp) TDecompLU;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TDecompLU));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_179_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TDecompLU* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TDecompLU((Int_t) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TDecompLU((Int_t) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TDecompLU));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_179_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TDecompLU* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TDecompLU((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TDecompLU((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TDecompLU));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_179_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TDecompLU* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TDecompLU(
*(TMatrixD*) libp->para[0].ref, (Double_t) G__double(libp->para[1])
, (Int_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TDecompLU(
*(TMatrixD*) libp->para[0].ref, (Double_t) G__double(libp->para[1])
, (Int_t) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TDecompLU(*(TMatrixD*) libp->para[0].ref, (Double_t) G__double(libp->para[1]));
     } else {
       p = new((void*) gvp) TDecompLU(*(TMatrixD*) libp->para[0].ref, (Double_t) G__double(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TDecompLU(*(TMatrixD*) libp->para[0].ref);
     } else {
       p = new((void*) gvp) TDecompLU(*(TMatrixD*) libp->para[0].ref);
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TDecompLU));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_179_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TDecompLU* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TDecompLU(*(TDecompLU*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TDecompLU(*(TDecompLU*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TDecompLU));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_179_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixD* pobj;
         TMatrixD xobj = ((TDecompLU*) G__getstructoffset())->GetMatrix();
         pobj = new TMatrixD(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_179_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixD& obj = ((TDecompLU*) G__getstructoffset())->GetLU();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_179_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TDecompLU*) G__getstructoffset())->SetMatrix(*(TMatrixD*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_179_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 103, (long) TDecompLU::InvertLU(*(TMatrixD*) libp->para[0].ref, (Double_t) G__double(libp->para[1])
, (Double_t*) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 103, (long) TDecompLU::InvertLU(*(TMatrixD*) libp->para[0].ref, (Double_t) G__double(libp->para[1])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_179_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TDecompLU*) G__getstructoffset())->Invert(*(TMatrixD*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_179_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixD* pobj;
         TMatrixD xobj = ((TDecompLU*) G__getstructoffset())->Invert(*(Bool_t*) G__Boolref(&libp->para[0]));
         pobj = new TMatrixD(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_179_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixD* pobj;
         TMatrixD xobj = ((TDecompLU*) G__getstructoffset())->Invert();
         pobj = new TMatrixD(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_179_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TDecompLU& obj = ((TDecompLU*) G__getstructoffset())->operator=(*(TDecompLU*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_179_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TDecompLU::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_179_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TDecompLU::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_179_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TDecompLU::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_179_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TDecompLU::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_179_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TDecompLU*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_179_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TDecompLU::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_179_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TDecompLU::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_179_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TDecompLU::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_179_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TDecompLU::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TDecompLU G__TTDecompLU;
static int G__G__Matrix_179_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TDecompLU*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TDecompLU*) (soff+(sizeof(TDecompLU)*i)))->~G__TTDecompLU();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TDecompLU*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TDecompLU*) (soff))->~G__TTDecompLU();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TDecompQRH */
static int G__G__Matrix_180_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TDecompQRH* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TDecompQRH[n];
     } else {
       p = new((void*) gvp) TDecompQRH[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TDecompQRH;
     } else {
       p = new((void*) gvp) TDecompQRH;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TDecompQRH));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_180_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TDecompQRH* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TDecompQRH((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TDecompQRH((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TDecompQRH));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_180_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TDecompQRH* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 4
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TDecompQRH(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
   } else {
     p = new((void*) gvp) TDecompQRH(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TDecompQRH));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_180_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TDecompQRH* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TDecompQRH(*(TMatrixD*) libp->para[0].ref, (Double_t) G__double(libp->para[1]));
     } else {
       p = new((void*) gvp) TDecompQRH(*(TMatrixD*) libp->para[0].ref, (Double_t) G__double(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TDecompQRH(*(TMatrixD*) libp->para[0].ref);
     } else {
       p = new((void*) gvp) TDecompQRH(*(TMatrixD*) libp->para[0].ref);
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TDecompQRH));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_180_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TDecompQRH* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TDecompQRH(*(TDecompQRH*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TDecompQRH(*(TDecompQRH*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TDecompQRH));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_180_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixD& obj = ((TDecompQRH*) G__getstructoffset())->GetQ();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_180_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixD& obj = ((TDecompQRH*) G__getstructoffset())->GetR();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_180_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVectorD& obj = ((TDecompQRH*) G__getstructoffset())->GetUp();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_180_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVectorD& obj = ((TDecompQRH*) G__getstructoffset())->GetW();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_180_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TDecompQRH*) G__getstructoffset())->SetMatrix(*(TMatrixD*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_180_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TDecompQRH*) G__getstructoffset())->Invert(*(TMatrixD*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_180_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixD* pobj;
         TMatrixD xobj = ((TDecompQRH*) G__getstructoffset())->Invert(*(Bool_t*) G__Boolref(&libp->para[0]));
         pobj = new TMatrixD(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_180_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixD* pobj;
         TMatrixD xobj = ((TDecompQRH*) G__getstructoffset())->Invert();
         pobj = new TMatrixD(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_180_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TDecompQRH& obj = ((TDecompQRH*) G__getstructoffset())->operator=(*(TDecompQRH*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_180_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TDecompQRH::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_180_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TDecompQRH::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_180_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TDecompQRH::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_180_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TDecompQRH::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_180_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TDecompQRH*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_180_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TDecompQRH::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_180_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TDecompQRH::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_180_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TDecompQRH::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_180_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TDecompQRH::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TDecompQRH G__TTDecompQRH;
static int G__G__Matrix_180_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TDecompQRH*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TDecompQRH*) (soff+(sizeof(TDecompQRH)*i)))->~G__TTDecompQRH();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TDecompQRH*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TDecompQRH*) (soff))->~G__TTDecompQRH();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TDecompSparse */
static int G__G__Matrix_185_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TDecompSparse* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TDecompSparse[n];
     } else {
       p = new((void*) gvp) TDecompSparse[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TDecompSparse;
     } else {
       p = new((void*) gvp) TDecompSparse;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TDecompSparse));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_185_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TDecompSparse* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TDecompSparse(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
   } else {
     p = new((void*) gvp) TDecompSparse(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TDecompSparse));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_185_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TDecompSparse* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 4
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TDecompSparse(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
   } else {
     p = new((void*) gvp) TDecompSparse(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TDecompSparse));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_185_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TDecompSparse* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TDecompSparse(*(TMatrixDSparse*) libp->para[0].ref, (Int_t) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TDecompSparse(*(TMatrixDSparse*) libp->para[0].ref, (Int_t) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TDecompSparse));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_185_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TDecompSparse* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TDecompSparse(*(TDecompSparse*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TDecompSparse(*(TDecompSparse*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TDecompSparse));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_185_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TDecompSparse*) G__getstructoffset())->SetVerbose((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_185_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TDecompSparse*) G__getstructoffset())->SetMatrix(*(TMatrixDSparse*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_185_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TDecompSparse& obj = ((TDecompSparse*) G__getstructoffset())->operator=(*(TDecompSparse*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_185_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TDecompSparse::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_185_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TDecompSparse::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_185_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TDecompSparse::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_185_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TDecompSparse::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_185_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TDecompSparse*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_185_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TDecompSparse::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_185_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TDecompSparse::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_185_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TDecompSparse::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_185_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TDecompSparse::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TDecompSparse G__TTDecompSparse;
static int G__G__Matrix_185_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TDecompSparse*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TDecompSparse*) (soff+(sizeof(TDecompSparse)*i)))->~G__TTDecompSparse();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TDecompSparse*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TDecompSparse*) (soff))->~G__TTDecompSparse();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TDecompSVD */
static int G__G__Matrix_186_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TDecompSVD* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TDecompSVD[n];
     } else {
       p = new((void*) gvp) TDecompSVD[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TDecompSVD;
     } else {
       p = new((void*) gvp) TDecompSVD;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TDecompSVD));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_186_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TDecompSVD* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TDecompSVD((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TDecompSVD((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TDecompSVD));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_186_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TDecompSVD* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 4
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TDecompSVD(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
   } else {
     p = new((void*) gvp) TDecompSVD(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TDecompSVD));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_186_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TDecompSVD* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TDecompSVD(*(TMatrixD*) libp->para[0].ref, (Double_t) G__double(libp->para[1]));
     } else {
       p = new((void*) gvp) TDecompSVD(*(TMatrixD*) libp->para[0].ref, (Double_t) G__double(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TDecompSVD(*(TMatrixD*) libp->para[0].ref);
     } else {
       p = new((void*) gvp) TDecompSVD(*(TMatrixD*) libp->para[0].ref);
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TDecompSVD));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_186_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TDecompSVD* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TDecompSVD(*(TDecompSVD*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TDecompSVD(*(TDecompSVD*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TDecompSVD));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_186_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixD* pobj;
         TMatrixD xobj = ((TDecompSVD*) G__getstructoffset())->GetMatrix();
         pobj = new TMatrixD(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_186_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixD& obj = ((TDecompSVD*) G__getstructoffset())->GetU();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_186_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixD& obj = ((TDecompSVD*) G__getstructoffset())->GetV();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_186_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVectorD& obj = ((TDecompSVD*) G__getstructoffset())->GetSig();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_186_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TDecompSVD*) G__getstructoffset())->SetMatrix(*(TMatrixD*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_186_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TDecompSVD*) G__getstructoffset())->Invert(*(TMatrixD*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_186_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixD* pobj;
         TMatrixD xobj = ((TDecompSVD*) G__getstructoffset())->Invert(*(Bool_t*) G__Boolref(&libp->para[0]));
         pobj = new TMatrixD(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_186_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixD* pobj;
         TMatrixD xobj = ((TDecompSVD*) G__getstructoffset())->Invert();
         pobj = new TMatrixD(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_186_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TDecompSVD& obj = ((TDecompSVD*) G__getstructoffset())->operator=(*(TDecompSVD*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_186_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TDecompSVD::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_186_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TDecompSVD::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_186_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TDecompSVD::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_186_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TDecompSVD::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_186_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TDecompSVD*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_186_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TDecompSVD::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_186_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TDecompSVD::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_186_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TDecompSVD::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_186_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TDecompSVD::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TDecompSVD G__TTDecompSVD;
static int G__G__Matrix_186_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TDecompSVD*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TDecompSVD*) (soff+(sizeof(TDecompSVD)*i)))->~G__TTDecompSVD();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TDecompSVD*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TDecompSVD*) (soff))->~G__TTDecompSVD();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TMatrixDEigen */
static int G__G__Matrix_188_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixDEigen* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMatrixDEigen[n];
     } else {
       p = new((void*) gvp) TMatrixDEigen[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMatrixDEigen;
     } else {
       p = new((void*) gvp) TMatrixDEigen;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixDEigen));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_188_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixDEigen* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixDEigen(*(TMatrixD*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TMatrixDEigen(*(TMatrixD*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixDEigen));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_188_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixDEigen* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixDEigen(*(TMatrixDEigen*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TMatrixDEigen(*(TMatrixDEigen*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixDEigen));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_188_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixD& obj = ((const TMatrixDEigen*) G__getstructoffset())->GetEigenVectors();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_188_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVectorD& obj = ((const TMatrixDEigen*) G__getstructoffset())->GetEigenValuesRe();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_188_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVectorD& obj = ((const TMatrixDEigen*) G__getstructoffset())->GetEigenValuesIm();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_188_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixD* pobj;
         const TMatrixD xobj = ((const TMatrixDEigen*) G__getstructoffset())->GetEigenValues();
         pobj = new TMatrixD(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_188_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixDEigen& obj = ((TMatrixDEigen*) G__getstructoffset())->operator=(*(TMatrixDEigen*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_188_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TMatrixDEigen::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_188_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixDEigen::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_188_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TMatrixDEigen::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_188_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TMatrixDEigen::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_188_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TMatrixDEigen*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_188_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixDEigen*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_188_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixDEigen*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_188_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixDEigen*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_188_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixDEigen::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_188_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMatrixDEigen::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_188_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixDEigen::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_188_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMatrixDEigen::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TMatrixDEigen G__TTMatrixDEigen;
static int G__G__Matrix_188_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TMatrixDEigen*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMatrixDEigen*) (soff+(sizeof(TMatrixDEigen)*i)))->~G__TTMatrixDEigen();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMatrixDEigen*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMatrixDEigen*) (soff))->~G__TTMatrixDEigen();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* THaarMatrixT<double> */
static int G__G__Matrix_190_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   THaarMatrixT<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THaarMatrixT<double>[n];
     } else {
       p = new((void*) gvp) THaarMatrixT<double>[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THaarMatrixT<double>;
     } else {
       p = new((void*) gvp) THaarMatrixT<double>;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_THaarMatrixTlEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_190_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   THaarMatrixT<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THaarMatrixT<double>((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) THaarMatrixT<double>((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THaarMatrixT<double>((Int_t) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) THaarMatrixT<double>((Int_t) G__int(libp->para[0]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_THaarMatrixTlEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_190_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) THaarMatrixT<double>::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_190_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) THaarMatrixT<double>::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_190_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) THaarMatrixT<double>::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_190_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      THaarMatrixT<double>::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_190_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((THaarMatrixT<double>*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_190_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) THaarMatrixT<double>::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_190_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) THaarMatrixT<double>::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_190_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) THaarMatrixT<double>::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_190_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) THaarMatrixT<double>::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Matrix_190_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   THaarMatrixT<double>* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new THaarMatrixT<double>(*(THaarMatrixT<double>*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_THaarMatrixTlEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef THaarMatrixT<double> G__TTHaarMatrixTlEdoublegR;
static int G__G__Matrix_190_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (THaarMatrixT<double>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((THaarMatrixT<double>*) (soff+(sizeof(THaarMatrixT<double>)*i)))->~G__TTHaarMatrixTlEdoublegR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (THaarMatrixT<double>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((THaarMatrixT<double>*) (soff))->~G__TTHaarMatrixTlEdoublegR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* THilbertMatrixT<double> */
static int G__G__Matrix_191_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   THilbertMatrixT<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THilbertMatrixT<double>[n];
     } else {
       p = new((void*) gvp) THilbertMatrixT<double>[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THilbertMatrixT<double>;
     } else {
       p = new((void*) gvp) THilbertMatrixT<double>;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_THilbertMatrixTlEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_191_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   THilbertMatrixT<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new THilbertMatrixT<double>((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) THilbertMatrixT<double>((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_THilbertMatrixTlEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_191_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   THilbertMatrixT<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 4
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new THilbertMatrixT<double>(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
   } else {
     p = new((void*) gvp) THilbertMatrixT<double>(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_THilbertMatrixTlEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_191_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) THilbertMatrixT<double>::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_191_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) THilbertMatrixT<double>::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_191_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) THilbertMatrixT<double>::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_191_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      THilbertMatrixT<double>::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_191_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((THilbertMatrixT<double>*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_191_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) THilbertMatrixT<double>::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_191_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) THilbertMatrixT<double>::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_191_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) THilbertMatrixT<double>::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_191_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) THilbertMatrixT<double>::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Matrix_191_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   THilbertMatrixT<double>* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new THilbertMatrixT<double>(*(THilbertMatrixT<double>*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_THilbertMatrixTlEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef THilbertMatrixT<double> G__TTHilbertMatrixTlEdoublegR;
static int G__G__Matrix_191_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (THilbertMatrixT<double>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((THilbertMatrixT<double>*) (soff+(sizeof(THilbertMatrixT<double>)*i)))->~G__TTHilbertMatrixTlEdoublegR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (THilbertMatrixT<double>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((THilbertMatrixT<double>*) (soff))->~G__TTHilbertMatrixTlEdoublegR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* THilbertMatrixTSym<double> */
static int G__G__Matrix_192_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   THilbertMatrixTSym<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THilbertMatrixTSym<double>[n];
     } else {
       p = new((void*) gvp) THilbertMatrixTSym<double>[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THilbertMatrixTSym<double>;
     } else {
       p = new((void*) gvp) THilbertMatrixTSym<double>;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_THilbertMatrixTSymlEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_192_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   THilbertMatrixTSym<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new THilbertMatrixTSym<double>((Int_t) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) THilbertMatrixTSym<double>((Int_t) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_THilbertMatrixTSymlEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_192_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   THilbertMatrixTSym<double>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new THilbertMatrixTSym<double>((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) THilbertMatrixTSym<double>((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_THilbertMatrixTSymlEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_192_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) THilbertMatrixTSym<double>::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_192_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) THilbertMatrixTSym<double>::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_192_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) THilbertMatrixTSym<double>::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_192_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      THilbertMatrixTSym<double>::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_192_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((THilbertMatrixTSym<double>*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_192_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) THilbertMatrixTSym<double>::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_192_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) THilbertMatrixTSym<double>::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_192_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) THilbertMatrixTSym<double>::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_192_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) THilbertMatrixTSym<double>::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Matrix_192_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   THilbertMatrixTSym<double>* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new THilbertMatrixTSym<double>(*(THilbertMatrixTSym<double>*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_THilbertMatrixTSymlEdoublegR));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef THilbertMatrixTSym<double> G__TTHilbertMatrixTSymlEdoublegR;
static int G__G__Matrix_192_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (THilbertMatrixTSym<double>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((THilbertMatrixTSym<double>*) (soff+(sizeof(THilbertMatrixTSym<double>)*i)))->~G__TTHilbertMatrixTSymlEdoublegR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (THilbertMatrixTSym<double>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((THilbertMatrixTSym<double>*) (soff))->~G__TTHilbertMatrixTSymlEdoublegR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TMatrixDSymEigen */
static int G__G__Matrix_193_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixDSymEigen* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMatrixDSymEigen[n];
     } else {
       p = new((void*) gvp) TMatrixDSymEigen[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMatrixDSymEigen;
     } else {
       p = new((void*) gvp) TMatrixDSymEigen;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixDSymEigen));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_193_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixDSymEigen* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixDSymEigen(*(TMatrixDSym*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TMatrixDSymEigen(*(TMatrixDSym*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixDSymEigen));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_193_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixDSymEigen* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixDSymEigen(*(TMatrixDSymEigen*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TMatrixDSymEigen(*(TMatrixDSymEigen*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixDSymEigen));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_193_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixD& obj = ((const TMatrixDSymEigen*) G__getstructoffset())->GetEigenVectors();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_193_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVectorD& obj = ((const TMatrixDSymEigen*) G__getstructoffset())->GetEigenValues();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_193_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixDSymEigen& obj = ((TMatrixDSymEigen*) G__getstructoffset())->operator=(*(TMatrixDSymEigen*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_193_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TMatrixDSymEigen::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_193_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixDSymEigen::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_193_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TMatrixDSymEigen::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_193_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TMatrixDSymEigen::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_193_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TMatrixDSymEigen*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_193_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixDSymEigen*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_193_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixDSymEigen*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_193_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixDSymEigen*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_193_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixDSymEigen::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_193_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMatrixDSymEigen::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_193_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixDSymEigen::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_193_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMatrixDSymEigen::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TMatrixDSymEigen G__TTMatrixDSymEigen;
static int G__G__Matrix_193_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TMatrixDSymEigen*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMatrixDSymEigen*) (soff+(sizeof(TMatrixDSymEigen)*i)))->~G__TTMatrixDSymEigen();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMatrixDSymEigen*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMatrixDSymEigen*) (soff))->~G__TTMatrixDSymEigen();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TMatrixTFlat_const<float> */
static int G__G__Matrix_195_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTFlat_const<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMatrixTFlat_const<float>[n];
     } else {
       p = new((void*) gvp) TMatrixTFlat_const<float>[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMatrixTFlat_const<float>;
     } else {
       p = new((void*) gvp) TMatrixTFlat_const<float>;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTFlat_constlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_195_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTFlat_const<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixTFlat_const<float>(*(TMatrixT<float>*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TMatrixTFlat_const<float>(*(TMatrixT<float>*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTFlat_constlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_195_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTFlat_const<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixTFlat_const<float>(*(TMatrixTSym<float>*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TMatrixTFlat_const<float>(*(TMatrixTSym<float>*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTFlat_constlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_195_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTFlat_const<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixTFlat_const<float>(*(TMatrixTFlat_const<float>*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TMatrixTFlat_const<float>(*(TMatrixTFlat_const<float>*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTFlat_constlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_195_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTFlat_const<float>& obj = ((TMatrixTFlat_const<float>*) G__getstructoffset())->operator=(*(TMatrixTFlat_const<float>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_195_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TMatrixTFlat_const<float>*) G__getstructoffset())->GetMatrix());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_195_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 70, (long) ((const TMatrixTFlat_const<float>*) G__getstructoffset())->GetPtr());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_195_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const float& obj = ((const TMatrixTFlat_const<float>*) G__getstructoffset())->operator()((Int_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.d = (double) (obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_195_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const float& obj = ((const TMatrixTFlat_const<float>*) G__getstructoffset())->operator[]((Int_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.d = (double) (obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_195_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TMatrixTFlat_const<float>::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_195_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTFlat_const<float>::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_195_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TMatrixTFlat_const<float>::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_195_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TMatrixTFlat_const<float>::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_195_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TMatrixTFlat_const<float>*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_195_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTFlat_const<float>*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_195_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTFlat_const<float>*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_195_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTFlat_const<float>*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_195_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTFlat_const<float>::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_195_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMatrixTFlat_const<float>::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_195_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTFlat_const<float>::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_195_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMatrixTFlat_const<float>::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TMatrixTFlat_const<float> G__TTMatrixTFlat_constlEfloatgR;
static int G__G__Matrix_195_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TMatrixTFlat_const<float>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMatrixTFlat_const<float>*) (soff+(sizeof(TMatrixTFlat_const<float>)*i)))->~G__TTMatrixTFlat_constlEfloatgR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMatrixTFlat_const<float>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMatrixTFlat_const<float>*) (soff))->~G__TTMatrixTFlat_constlEfloatgR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TMatrixTSub_const<float> */
static int G__G__Matrix_196_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTSub_const<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMatrixTSub_const<float>[n];
     } else {
       p = new((void*) gvp) TMatrixTSub_const<float>[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMatrixTSub_const<float>;
     } else {
       p = new((void*) gvp) TMatrixTSub_const<float>;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSub_constlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_196_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTSub_const<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 5
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixTSub_const<float>(
*(TMatrixT<float>*) libp->para[0].ref, (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
   } else {
     p = new((void*) gvp) TMatrixTSub_const<float>(
*(TMatrixT<float>*) libp->para[0].ref, (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSub_constlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_196_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTSub_const<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 5
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixTSub_const<float>(
*(TMatrixTSym<float>*) libp->para[0].ref, (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
   } else {
     p = new((void*) gvp) TMatrixTSub_const<float>(
*(TMatrixTSym<float>*) libp->para[0].ref, (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSub_constlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_196_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TMatrixTSub_const<float>*) G__getstructoffset())->GetMatrix());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_196_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMatrixTSub_const<float>*) G__getstructoffset())->GetRowOff());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_196_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMatrixTSub_const<float>*) G__getstructoffset())->GetColOff());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_196_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMatrixTSub_const<float>*) G__getstructoffset())->GetNrows());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_196_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMatrixTSub_const<float>*) G__getstructoffset())->GetNcols());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_196_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const float& obj = ((const TMatrixTSub_const<float>*) G__getstructoffset())->operator()((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
         result7->ref = (long) (&obj);
         result7->obj.d = (double) (obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_196_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TMatrixTSub_const<float>::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_196_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTSub_const<float>::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_196_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TMatrixTSub_const<float>::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_196_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TMatrixTSub_const<float>::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_196_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TMatrixTSub_const<float>*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_196_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTSub_const<float>*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_196_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTSub_const<float>*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_196_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTSub_const<float>*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_196_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTSub_const<float>::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_196_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMatrixTSub_const<float>::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_196_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTSub_const<float>::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_196_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMatrixTSub_const<float>::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Matrix_196_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TMatrixTSub_const<float>* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TMatrixTSub_const<float>(*(TMatrixTSub_const<float>*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSub_constlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TMatrixTSub_const<float> G__TTMatrixTSub_constlEfloatgR;
static int G__G__Matrix_196_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TMatrixTSub_const<float>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMatrixTSub_const<float>*) (soff+(sizeof(TMatrixTSub_const<float>)*i)))->~G__TTMatrixTSub_constlEfloatgR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMatrixTSub_const<float>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMatrixTSub_const<float>*) (soff))->~G__TTMatrixTSub_constlEfloatgR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TMatrixTColumn<float> */
static int G__G__Matrix_197_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTColumn<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMatrixTColumn<float>[n];
     } else {
       p = new((void*) gvp) TMatrixTColumn<float>[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMatrixTColumn<float>;
     } else {
       p = new((void*) gvp) TMatrixTColumn<float>;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTColumnlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_197_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTColumn<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixTColumn<float>(*(TMatrixT<float>*) libp->para[0].ref, (Int_t) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TMatrixTColumn<float>(*(TMatrixT<float>*) libp->para[0].ref, (Int_t) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTColumnlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_197_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTColumn<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixTColumn<float>(*(TMatrixTSym<float>*) libp->para[0].ref, (Int_t) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TMatrixTColumn<float>(*(TMatrixTSym<float>*) libp->para[0].ref, (Int_t) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTColumnlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_197_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTColumn<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixTColumn<float>(*(TMatrixTColumn<float>*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TMatrixTColumn<float>(*(TMatrixTColumn<float>*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTColumnlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_197_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 70, (long) ((const TMatrixTColumn<float>*) G__getstructoffset())->GetPtr());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_197_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const float& obj = ((const TMatrixTColumn<float>*) G__getstructoffset())->operator()((Int_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.d = (double) (obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_197_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const float& obj = ((TMatrixTColumn<float>*) G__getstructoffset())->operator()((Int_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.d = (double) (obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_197_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const float& obj = ((const TMatrixTColumn<float>*) G__getstructoffset())->operator[]((Int_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.d = (double) (obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_197_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const float& obj = ((TMatrixTColumn<float>*) G__getstructoffset())->operator[]((Int_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.d = (double) (obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_197_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTColumn<float>*) G__getstructoffset())->operator=((float) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_197_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTColumn<float>*) G__getstructoffset())->operator+=((float) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_197_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTColumn<float>*) G__getstructoffset())->operator*=((float) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_197_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTColumn<float>*) G__getstructoffset())->operator=(*(TMatrixTColumn_const<float>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_197_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTColumn<float>& obj = ((TMatrixTColumn<float>*) G__getstructoffset())->operator=(*(TMatrixTColumn<float>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_197_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTColumn<float>*) G__getstructoffset())->operator=(*(TVectorT<float>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_197_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTColumn<float>*) G__getstructoffset())->operator+=(*(TMatrixTColumn_const<float>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_197_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTColumn<float>*) G__getstructoffset())->operator*=(*(TMatrixTColumn_const<float>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_197_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TMatrixTColumn<float>::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_197_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTColumn<float>::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_197_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TMatrixTColumn<float>::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_197_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TMatrixTColumn<float>::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_197_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTColumn<float>*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_197_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTColumn<float>::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_197_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMatrixTColumn<float>::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_197_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTColumn<float>::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_197_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMatrixTColumn<float>::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TMatrixTColumn<float> G__TTMatrixTColumnlEfloatgR;
static int G__G__Matrix_197_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TMatrixTColumn<float>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMatrixTColumn<float>*) (soff+(sizeof(TMatrixTColumn<float>)*i)))->~G__TTMatrixTColumnlEfloatgR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMatrixTColumn<float>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMatrixTColumn<float>*) (soff))->~G__TTMatrixTColumnlEfloatgR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TMatrixTDiag<float> */
static int G__G__Matrix_198_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTDiag<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMatrixTDiag<float>[n];
     } else {
       p = new((void*) gvp) TMatrixTDiag<float>[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMatrixTDiag<float>;
     } else {
       p = new((void*) gvp) TMatrixTDiag<float>;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTDiaglEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_198_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTDiag<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixTDiag<float>(*(TMatrixT<float>*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TMatrixTDiag<float>(*(TMatrixT<float>*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTDiaglEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_198_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTDiag<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixTDiag<float>(*(TMatrixTSym<float>*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TMatrixTDiag<float>(*(TMatrixTSym<float>*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTDiaglEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_198_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTDiag<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixTDiag<float>(*(TMatrixTDiag<float>*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TMatrixTDiag<float>(*(TMatrixTDiag<float>*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTDiaglEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_198_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 70, (long) ((const TMatrixTDiag<float>*) G__getstructoffset())->GetPtr());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_198_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const float& obj = ((const TMatrixTDiag<float>*) G__getstructoffset())->operator()((Int_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.d = (double) (obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_198_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const float& obj = ((TMatrixTDiag<float>*) G__getstructoffset())->operator()((Int_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.d = (double) (obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_198_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const float& obj = ((const TMatrixTDiag<float>*) G__getstructoffset())->operator[]((Int_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.d = (double) (obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_198_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const float& obj = ((TMatrixTDiag<float>*) G__getstructoffset())->operator[]((Int_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.d = (double) (obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_198_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTDiag<float>*) G__getstructoffset())->operator=((float) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_198_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTDiag<float>*) G__getstructoffset())->operator+=((float) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_198_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTDiag<float>*) G__getstructoffset())->operator*=((float) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_198_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTDiag<float>*) G__getstructoffset())->operator=(*(TMatrixTDiag_const<float>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_198_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTDiag<float>& obj = ((TMatrixTDiag<float>*) G__getstructoffset())->operator=(*(TMatrixTDiag<float>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_198_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTDiag<float>*) G__getstructoffset())->operator=(*(TVectorT<float>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_198_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTDiag<float>*) G__getstructoffset())->operator+=(*(TMatrixTDiag_const<float>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_198_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTDiag<float>*) G__getstructoffset())->operator*=(*(TMatrixTDiag_const<float>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_198_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TMatrixTDiag<float>::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_198_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTDiag<float>::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_198_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TMatrixTDiag<float>::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_198_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TMatrixTDiag<float>::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_198_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTDiag<float>*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_198_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTDiag<float>::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_198_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMatrixTDiag<float>::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_198_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTDiag<float>::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_198_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMatrixTDiag<float>::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TMatrixTDiag<float> G__TTMatrixTDiaglEfloatgR;
static int G__G__Matrix_198_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TMatrixTDiag<float>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMatrixTDiag<float>*) (soff+(sizeof(TMatrixTDiag<float>)*i)))->~G__TTMatrixTDiaglEfloatgR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMatrixTDiag<float>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMatrixTDiag<float>*) (soff))->~G__TTMatrixTDiaglEfloatgR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TMatrixTFlat<float> */
static int G__G__Matrix_199_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTFlat<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMatrixTFlat<float>[n];
     } else {
       p = new((void*) gvp) TMatrixTFlat<float>[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMatrixTFlat<float>;
     } else {
       p = new((void*) gvp) TMatrixTFlat<float>;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTFlatlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_199_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTFlat<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixTFlat<float>(*(TMatrixT<float>*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TMatrixTFlat<float>(*(TMatrixT<float>*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTFlatlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_199_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTFlat<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixTFlat<float>(*(TMatrixTSym<float>*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TMatrixTFlat<float>(*(TMatrixTSym<float>*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTFlatlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_199_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTFlat<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixTFlat<float>(*(TMatrixTFlat<float>*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TMatrixTFlat<float>(*(TMatrixTFlat<float>*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTFlatlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_199_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 70, (long) ((const TMatrixTFlat<float>*) G__getstructoffset())->GetPtr());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_199_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const float& obj = ((const TMatrixTFlat<float>*) G__getstructoffset())->operator()((Int_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.d = (double) (obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_199_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const float& obj = ((TMatrixTFlat<float>*) G__getstructoffset())->operator()((Int_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.d = (double) (obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_199_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const float& obj = ((const TMatrixTFlat<float>*) G__getstructoffset())->operator[]((Int_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.d = (double) (obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_199_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const float& obj = ((TMatrixTFlat<float>*) G__getstructoffset())->operator[]((Int_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.d = (double) (obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_199_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTFlat<float>*) G__getstructoffset())->operator=((float) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_199_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTFlat<float>*) G__getstructoffset())->operator+=((float) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_199_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTFlat<float>*) G__getstructoffset())->operator*=((float) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_199_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTFlat<float>*) G__getstructoffset())->operator=(*(TMatrixTFlat_const<float>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_199_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTFlat<float>& obj = ((TMatrixTFlat<float>*) G__getstructoffset())->operator=(*(TMatrixTFlat<float>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_199_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTFlat<float>*) G__getstructoffset())->operator=(*(TVectorT<float>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_199_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTFlat<float>*) G__getstructoffset())->operator+=(*(TMatrixTFlat_const<float>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_199_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTFlat<float>*) G__getstructoffset())->operator*=(*(TMatrixTFlat_const<float>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_199_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TMatrixTFlat<float>::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_199_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTFlat<float>::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_199_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TMatrixTFlat<float>::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_199_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TMatrixTFlat<float>::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_199_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTFlat<float>*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_199_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTFlat<float>::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_199_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMatrixTFlat<float>::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_199_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTFlat<float>::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_199_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMatrixTFlat<float>::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TMatrixTFlat<float> G__TTMatrixTFlatlEfloatgR;
static int G__G__Matrix_199_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TMatrixTFlat<float>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMatrixTFlat<float>*) (soff+(sizeof(TMatrixTFlat<float>)*i)))->~G__TTMatrixTFlatlEfloatgR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMatrixTFlat<float>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMatrixTFlat<float>*) (soff))->~G__TTMatrixTFlatlEfloatgR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TMatrixTSub<float> */
static int G__G__Matrix_200_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTSub<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMatrixTSub<float>[n];
     } else {
       p = new((void*) gvp) TMatrixTSub<float>[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMatrixTSub<float>;
     } else {
       p = new((void*) gvp) TMatrixTSub<float>;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSublEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_200_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTSub<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 5
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixTSub<float>(
*(TMatrixT<float>*) libp->para[0].ref, (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
   } else {
     p = new((void*) gvp) TMatrixTSub<float>(
*(TMatrixT<float>*) libp->para[0].ref, (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSublEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_200_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTSub<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 5
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixTSub<float>(
*(TMatrixTSym<float>*) libp->para[0].ref, (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
   } else {
     p = new((void*) gvp) TMatrixTSub<float>(
*(TMatrixTSym<float>*) libp->para[0].ref, (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSublEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_200_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTSub<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixTSub<float>(*(TMatrixTSub<float>*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TMatrixTSub<float>(*(TMatrixTSub<float>*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSublEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_200_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const float& obj = ((TMatrixTSub<float>*) G__getstructoffset())->operator()((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
         result7->ref = (long) (&obj);
         result7->obj.d = (double) (obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_200_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TMatrixTSub<float>*) G__getstructoffset())->Rank1Update(*(TVectorT<float>*) libp->para[0].ref, (float) G__double(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TMatrixTSub<float>*) G__getstructoffset())->Rank1Update(*(TVectorT<float>*) libp->para[0].ref);
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_200_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTSub<float>*) G__getstructoffset())->operator=((float) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_200_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTSub<float>*) G__getstructoffset())->operator+=((float) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_200_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTSub<float>*) G__getstructoffset())->operator*=((float) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_200_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTSub<float>*) G__getstructoffset())->operator=(*(TMatrixTSub_const<float>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_200_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSub<float>& obj = ((TMatrixTSub<float>*) G__getstructoffset())->operator=(*(TMatrixTSub<float>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_200_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTSub<float>*) G__getstructoffset())->operator=(*(TMatrixTBase<float>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_200_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTSub<float>*) G__getstructoffset())->operator+=(*(TMatrixTSub_const<float>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_200_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTSub<float>*) G__getstructoffset())->operator*=(*(TMatrixTSub_const<float>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_200_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTSub<float>*) G__getstructoffset())->operator+=(*(TMatrixTBase<float>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_200_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTSub<float>*) G__getstructoffset())->operator*=(*(TMatrixT<float>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_200_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTSub<float>*) G__getstructoffset())->operator*=(*(TMatrixTSym<float>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_200_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TMatrixTSub<float>::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_200_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTSub<float>::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_200_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TMatrixTSub<float>::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_200_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TMatrixTSub<float>::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_200_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTSub<float>*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_200_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTSub<float>::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_200_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMatrixTSub<float>::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_200_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTSub<float>::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_200_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMatrixTSub<float>::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TMatrixTSub<float> G__TTMatrixTSublEfloatgR;
static int G__G__Matrix_200_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TMatrixTSub<float>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMatrixTSub<float>*) (soff+(sizeof(TMatrixTSub<float>)*i)))->~G__TTMatrixTSublEfloatgR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMatrixTSub<float>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMatrixTSub<float>*) (soff))->~G__TTMatrixTSublEfloatgR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TMatrixTSparseDiag<float> */
static int G__G__Matrix_202_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTSparseDiag<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMatrixTSparseDiag<float>[n];
     } else {
       p = new((void*) gvp) TMatrixTSparseDiag<float>[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMatrixTSparseDiag<float>;
     } else {
       p = new((void*) gvp) TMatrixTSparseDiag<float>;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparseDiaglEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_202_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTSparseDiag<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixTSparseDiag<float>(*(TMatrixTSparse<float>*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TMatrixTSparseDiag<float>(*(TMatrixTSparse<float>*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparseDiaglEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_202_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMatrixTSparseDiag<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMatrixTSparseDiag<float>(*(TMatrixTSparseDiag<float>*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TMatrixTSparseDiag<float>(*(TMatrixTSparseDiag<float>*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparseDiaglEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_202_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 70, (long) ((const TMatrixTSparseDiag<float>*) G__getstructoffset())->GetDataPtr());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_202_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TMatrixTSparseDiag<float>*) G__getstructoffset())->operator()((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_202_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const float& obj = ((TMatrixTSparseDiag<float>*) G__getstructoffset())->operator()((Int_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.d = (double) (obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_202_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TMatrixTSparseDiag<float>*) G__getstructoffset())->operator[]((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_202_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const float& obj = ((TMatrixTSparseDiag<float>*) G__getstructoffset())->operator[]((Int_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.d = (double) (obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_202_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTSparseDiag<float>*) G__getstructoffset())->operator=((float) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_202_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTSparseDiag<float>*) G__getstructoffset())->operator+=((float) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_202_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTSparseDiag<float>*) G__getstructoffset())->operator*=((float) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_202_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTSparseDiag<float>*) G__getstructoffset())->operator=(*(TMatrixTSparseDiag_const<float>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_202_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSparseDiag<float>& obj = ((TMatrixTSparseDiag<float>*) G__getstructoffset())->operator=(*(TMatrixTSparseDiag<float>*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_202_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTSparseDiag<float>*) G__getstructoffset())->operator=(*(TVectorT<float>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_202_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTSparseDiag<float>*) G__getstructoffset())->operator+=(*(TMatrixTSparseDiag_const<float>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_202_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTSparseDiag<float>*) G__getstructoffset())->operator*=(*(TMatrixTSparseDiag_const<float>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_202_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TMatrixTSparseDiag<float>::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_202_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTSparseDiag<float>::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_202_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TMatrixTSparseDiag<float>::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_202_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TMatrixTSparseDiag<float>::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_202_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMatrixTSparseDiag<float>*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_202_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTSparseDiag<float>::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_202_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMatrixTSparseDiag<float>::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_202_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMatrixTSparseDiag<float>::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_202_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMatrixTSparseDiag<float>::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TMatrixTSparseDiag<float> G__TTMatrixTSparseDiaglEfloatgR;
static int G__G__Matrix_202_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TMatrixTSparseDiag<float>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMatrixTSparseDiag<float>*) (soff+(sizeof(TMatrixTSparseDiag<float>)*i)))->~G__TTMatrixTSparseDiaglEfloatgR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMatrixTSparseDiag<float>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMatrixTSparseDiag<float>*) (soff))->~G__TTMatrixTSparseDiaglEfloatgR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* THaarMatrixT<float> */
static int G__G__Matrix_203_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   THaarMatrixT<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THaarMatrixT<float>[n];
     } else {
       p = new((void*) gvp) THaarMatrixT<float>[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THaarMatrixT<float>;
     } else {
       p = new((void*) gvp) THaarMatrixT<float>;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_THaarMatrixTlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_203_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   THaarMatrixT<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THaarMatrixT<float>((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) THaarMatrixT<float>((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THaarMatrixT<float>((Int_t) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) THaarMatrixT<float>((Int_t) G__int(libp->para[0]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_THaarMatrixTlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_203_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) THaarMatrixT<float>::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_203_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) THaarMatrixT<float>::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_203_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) THaarMatrixT<float>::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_203_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      THaarMatrixT<float>::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_203_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((THaarMatrixT<float>*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_203_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) THaarMatrixT<float>::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_203_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) THaarMatrixT<float>::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_203_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) THaarMatrixT<float>::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_203_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) THaarMatrixT<float>::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Matrix_203_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   THaarMatrixT<float>* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new THaarMatrixT<float>(*(THaarMatrixT<float>*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_THaarMatrixTlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef THaarMatrixT<float> G__TTHaarMatrixTlEfloatgR;
static int G__G__Matrix_203_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (THaarMatrixT<float>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((THaarMatrixT<float>*) (soff+(sizeof(THaarMatrixT<float>)*i)))->~G__TTHaarMatrixTlEfloatgR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (THaarMatrixT<float>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((THaarMatrixT<float>*) (soff))->~G__TTHaarMatrixTlEfloatgR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* THilbertMatrixT<float> */
static int G__G__Matrix_204_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   THilbertMatrixT<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THilbertMatrixT<float>[n];
     } else {
       p = new((void*) gvp) THilbertMatrixT<float>[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THilbertMatrixT<float>;
     } else {
       p = new((void*) gvp) THilbertMatrixT<float>;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_THilbertMatrixTlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_204_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   THilbertMatrixT<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new THilbertMatrixT<float>((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) THilbertMatrixT<float>((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_THilbertMatrixTlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_204_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   THilbertMatrixT<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 4
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new THilbertMatrixT<float>(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
   } else {
     p = new((void*) gvp) THilbertMatrixT<float>(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_THilbertMatrixTlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_204_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) THilbertMatrixT<float>::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_204_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) THilbertMatrixT<float>::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_204_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) THilbertMatrixT<float>::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_204_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      THilbertMatrixT<float>::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_204_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((THilbertMatrixT<float>*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_204_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) THilbertMatrixT<float>::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_204_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) THilbertMatrixT<float>::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_204_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) THilbertMatrixT<float>::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_204_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) THilbertMatrixT<float>::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Matrix_204_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   THilbertMatrixT<float>* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new THilbertMatrixT<float>(*(THilbertMatrixT<float>*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_THilbertMatrixTlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef THilbertMatrixT<float> G__TTHilbertMatrixTlEfloatgR;
static int G__G__Matrix_204_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (THilbertMatrixT<float>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((THilbertMatrixT<float>*) (soff+(sizeof(THilbertMatrixT<float>)*i)))->~G__TTHilbertMatrixTlEfloatgR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (THilbertMatrixT<float>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((THilbertMatrixT<float>*) (soff))->~G__TTHilbertMatrixTlEfloatgR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* THilbertMatrixTSym<float> */
static int G__G__Matrix_205_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   THilbertMatrixTSym<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THilbertMatrixTSym<float>[n];
     } else {
       p = new((void*) gvp) THilbertMatrixTSym<float>[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new THilbertMatrixTSym<float>;
     } else {
       p = new((void*) gvp) THilbertMatrixTSym<float>;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_THilbertMatrixTSymlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_205_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   THilbertMatrixTSym<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new THilbertMatrixTSym<float>((Int_t) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) THilbertMatrixTSym<float>((Int_t) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_THilbertMatrixTSymlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_205_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   THilbertMatrixTSym<float>* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new THilbertMatrixTSym<float>((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) THilbertMatrixTSym<float>((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_THilbertMatrixTSymlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_205_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) THilbertMatrixTSym<float>::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_205_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) THilbertMatrixTSym<float>::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_205_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) THilbertMatrixTSym<float>::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_205_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      THilbertMatrixTSym<float>::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_205_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((THilbertMatrixTSym<float>*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_205_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) THilbertMatrixTSym<float>::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_205_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) THilbertMatrixTSym<float>::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_205_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) THilbertMatrixTSym<float>::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_205_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) THilbertMatrixTSym<float>::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__Matrix_205_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   THilbertMatrixTSym<float>* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new THilbertMatrixTSym<float>(*(THilbertMatrixTSym<float>*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MatrixLN_THilbertMatrixTSymlEfloatgR));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef THilbertMatrixTSym<float> G__TTHilbertMatrixTSymlEfloatgR;
static int G__G__Matrix_205_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (THilbertMatrixTSym<float>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((THilbertMatrixTSym<float>*) (soff+(sizeof(THilbertMatrixTSym<float>)*i)))->~G__TTHilbertMatrixTSymlEfloatgR();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (THilbertMatrixTSym<float>*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((THilbertMatrixTSym<float>*) (soff))->~G__TTHilbertMatrixTSymlEfloatgR();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TMatrixTCramerInv */
static int G__G__Matrix_206_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) TMatrixTCramerInv::Inv2x2(*(TMatrixT<float>*) libp->para[0].ref, (Double_t*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_206_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) TMatrixTCramerInv::Inv2x2(*(TMatrixT<double>*) libp->para[0].ref, (Double_t*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_206_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) TMatrixTCramerInv::Inv3x3(*(TMatrixT<float>*) libp->para[0].ref, (Double_t*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_206_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) TMatrixTCramerInv::Inv3x3(*(TMatrixT<double>*) libp->para[0].ref, (Double_t*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_206_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) TMatrixTCramerInv::Inv4x4(*(TMatrixT<float>*) libp->para[0].ref, (Double_t*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_206_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) TMatrixTCramerInv::Inv4x4(*(TMatrixT<double>*) libp->para[0].ref, (Double_t*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_206_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) TMatrixTCramerInv::Inv5x5(*(TMatrixT<float>*) libp->para[0].ref, (Double_t*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_206_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) TMatrixTCramerInv::Inv5x5(*(TMatrixT<double>*) libp->para[0].ref, (Double_t*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_206_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) TMatrixTCramerInv::Inv6x6(*(TMatrixT<float>*) libp->para[0].ref, (Double_t*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_206_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) TMatrixTCramerInv::Inv6x6(*(TMatrixT<double>*) libp->para[0].ref, (Double_t*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}


/* TMatrixTSymCramerInv */
static int G__G__Matrix_207_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) TMatrixTSymCramerInv::Inv2x2(*(TMatrixTSym<float>*) libp->para[0].ref, (Double_t*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_207_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) TMatrixTSymCramerInv::Inv2x2(*(TMatrixTSym<double>*) libp->para[0].ref, (Double_t*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_207_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) TMatrixTSymCramerInv::Inv3x3(*(TMatrixTSym<float>*) libp->para[0].ref, (Double_t*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_207_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) TMatrixTSymCramerInv::Inv3x3(*(TMatrixTSym<double>*) libp->para[0].ref, (Double_t*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_207_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) TMatrixTSymCramerInv::Inv4x4(*(TMatrixTSym<float>*) libp->para[0].ref, (Double_t*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_207_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) TMatrixTSymCramerInv::Inv4x4(*(TMatrixTSym<double>*) libp->para[0].ref, (Double_t*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_207_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) TMatrixTSymCramerInv::Inv5x5(*(TMatrixTSym<float>*) libp->para[0].ref, (Double_t*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_207_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) TMatrixTSymCramerInv::Inv5x5(*(TMatrixTSym<double>*) libp->para[0].ref, (Double_t*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_207_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) TMatrixTSymCramerInv::Inv6x6(*(TMatrixTSym<float>*) libp->para[0].ref, (Double_t*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix_207_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) TMatrixTSymCramerInv::Inv6x6(*(TMatrixTSym<double>*) libp->para[0].ref, (Double_t*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}


/* Setting up global function */
static int G__G__Matrix__0_359(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TVectorD* pobj;
         TVectorD xobj = NormalEqn(*(TMatrixD*) libp->para[0].ref, *(TVectorD*) libp->para[1].ref);
         pobj = new TVectorD(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_360(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TVectorD* pobj;
         TVectorD xobj = NormalEqn(*(TMatrixD*) libp->para[0].ref, *(TVectorD*) libp->para[1].ref
, *(TVectorD*) libp->para[2].ref);
         pobj = new TVectorD(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_361(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixD* pobj;
         TMatrixD xobj = NormalEqn(*(TMatrixD*) libp->para[0].ref, *(TMatrixD*) libp->para[1].ref);
         pobj = new TMatrixD(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_362(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixD* pobj;
         TMatrixD xobj = NormalEqn(*(TMatrixD*) libp->para[0].ref, *(TMatrixD*) libp->para[1].ref
, *(TVectorD*) libp->para[2].ref);
         pobj = new TMatrixD(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_369(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) operator==(*(TVectorT<float>*) libp->para[0].ref, *(TVectorT<float>*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_370(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TVectorT<float>* pobj;
         TVectorT<float> xobj = operator+(*(TVectorT<float>*) libp->para[0].ref, *(TVectorT<float>*) libp->para[1].ref);
         pobj = new TVectorT<float>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_371(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TVectorT<float>* pobj;
         TVectorT<float> xobj = operator-(*(TVectorT<float>*) libp->para[0].ref, *(TVectorT<float>*) libp->para[1].ref);
         pobj = new TVectorT<float>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_372(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) operator*(*(TVectorT<float>*) libp->para[0].ref, *(TVectorT<float>*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_373(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TVectorT<float>* pobj;
         TVectorT<float> xobj = operator*(*(TMatrixT<float>*) libp->para[0].ref, *(TVectorT<float>*) libp->para[1].ref);
         pobj = new TVectorT<float>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_374(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TVectorT<float>* pobj;
         TVectorT<float> xobj = operator*(*(TMatrixTSym<float>*) libp->para[0].ref, *(TVectorT<float>*) libp->para[1].ref);
         pobj = new TVectorT<float>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_375(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TVectorT<float>* pobj;
         TVectorT<float> xobj = operator*(*(TMatrixTSparse<float>*) libp->para[0].ref, *(TVectorT<float>*) libp->para[1].ref);
         pobj = new TVectorT<float>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_376(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TVectorT<float>* pobj;
         TVectorT<float> xobj = operator*((float) G__double(libp->para[0]), *(TVectorT<float>*) libp->para[1].ref);
         pobj = new TVectorT<float>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_377(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) Dot(*(TVectorT<float>*) libp->para[0].ref, *(TVectorT<float>*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_378(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixT<float>* pobj;
         TMatrixT<float> xobj = OuterProduct(*(TVectorT<float>*) libp->para[0].ref, *(TVectorT<float>*) libp->para[1].ref);
         pobj = new TMatrixT<float>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_379(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixT<float>& obj = OuterProduct(*(TMatrixT<float>*) libp->para[0].ref, *(TVectorT<float>*) libp->para[1].ref
, *(TVectorT<float>*) libp->para[2].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_380(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) Mult(*(TVectorT<float>*) libp->para[0].ref, *(TMatrixT<float>*) libp->para[1].ref
, *(TVectorT<float>*) libp->para[2].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_381(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVectorT<float>& obj = Add(*(TVectorT<float>*) libp->para[0].ref, (float) G__double(libp->para[1])
, *(TVectorT<float>*) libp->para[2].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_382(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVectorT<float>& obj = Add(*(TVectorT<float>*) libp->para[0].ref, (float) G__double(libp->para[1])
, *(TMatrixT<float>*) libp->para[2].ref, *(TVectorT<float>*) libp->para[3].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_383(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVectorT<float>& obj = Add(*(TVectorT<float>*) libp->para[0].ref, (float) G__double(libp->para[1])
, *(TMatrixTSym<float>*) libp->para[2].ref, *(TVectorT<float>*) libp->para[3].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_384(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVectorT<float>& obj = Add(*(TVectorT<float>*) libp->para[0].ref, (float) G__double(libp->para[1])
, *(TMatrixTSparse<float>*) libp->para[2].ref, *(TVectorT<float>*) libp->para[3].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_385(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVectorT<float>& obj = AddElemMult(*(TVectorT<float>*) libp->para[0].ref, (float) G__double(libp->para[1])
, *(TVectorT<float>*) libp->para[2].ref, *(TVectorT<float>*) libp->para[3].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_386(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVectorT<float>& obj = AddElemMult(*(TVectorT<float>*) libp->para[0].ref, (float) G__double(libp->para[1])
, *(TVectorT<float>*) libp->para[2].ref, *(TVectorT<float>*) libp->para[3].ref
, *(TVectorT<float>*) libp->para[4].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_387(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVectorT<float>& obj = AddElemDiv(*(TVectorT<float>*) libp->para[0].ref, (float) G__double(libp->para[1])
, *(TVectorT<float>*) libp->para[2].ref, *(TVectorT<float>*) libp->para[3].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_388(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVectorT<float>& obj = AddElemDiv(*(TVectorT<float>*) libp->para[0].ref, (float) G__double(libp->para[1])
, *(TVectorT<float>*) libp->para[2].ref, *(TVectorT<float>*) libp->para[3].ref
, *(TVectorT<float>*) libp->para[4].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_389(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVectorT<float>& obj = ElementMult(*(TVectorT<float>*) libp->para[0].ref, *(TVectorT<float>*) libp->para[1].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_390(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVectorT<float>& obj = ElementMult(*(TVectorT<float>*) libp->para[0].ref, *(TVectorT<float>*) libp->para[1].ref
, *(TVectorT<float>*) libp->para[2].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_391(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVectorT<float>& obj = ElementDiv(*(TVectorT<float>*) libp->para[0].ref, *(TVectorT<float>*) libp->para[1].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_392(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVectorT<float>& obj = ElementDiv(*(TVectorT<float>*) libp->para[0].ref, *(TVectorT<float>*) libp->para[1].ref
, *(TVectorT<float>*) libp->para[2].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_393(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 103, (long) AreCompatible(*(TVectorT<float>*) libp->para[0].ref, *(TVectorT<float>*) libp->para[1].ref
, (Int_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 103, (long) AreCompatible(*(TVectorT<float>*) libp->para[0].ref, *(TVectorT<float>*) libp->para[1].ref));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_394(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 103, (long) AreCompatible(*(TVectorT<float>*) libp->para[0].ref, *(TVectorT<double>*) libp->para[1].ref
, (Int_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 103, (long) AreCompatible(*(TVectorT<float>*) libp->para[0].ref, *(TVectorT<double>*) libp->para[1].ref));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_395(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 103, (long) AreCompatible(*(TMatrixT<float>*) libp->para[0].ref, *(TVectorT<float>*) libp->para[1].ref
, (Int_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 103, (long) AreCompatible(*(TMatrixT<float>*) libp->para[0].ref, *(TVectorT<float>*) libp->para[1].ref));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_396(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 103, (long) AreCompatible(*(TVectorT<float>*) libp->para[0].ref, *(TMatrixT<float>*) libp->para[1].ref
, (Int_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 103, (long) AreCompatible(*(TVectorT<float>*) libp->para[0].ref, *(TMatrixT<float>*) libp->para[1].ref));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_397(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      Compare(*(TVectorT<float>*) libp->para[0].ref, *(TVectorT<float>*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_398(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) VerifyVectorValue(*(TVectorT<float>*) libp->para[0].ref, (float) G__double(libp->para[1])
, (Int_t) G__int(libp->para[2]), (float) G__double(libp->para[3])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_399(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) VerifyVectorIdentity(*(TVectorT<float>*) libp->para[0].ref, *(TVectorT<float>*) libp->para[1].ref
, (Int_t) G__int(libp->para[2]), (float) G__double(libp->para[3])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_400(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) operator==(*(TMatrixTBase<float>*) libp->para[0].ref, *(TMatrixTBase<float>*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_401(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) E2Norm(*(TMatrixTBase<float>*) libp->para[0].ref, *(TMatrixTBase<float>*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_402(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 103, (long) AreCompatible(*(TMatrixTBase<float>*) libp->para[0].ref, *(TMatrixTBase<float>*) libp->para[1].ref
, (Int_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 103, (long) AreCompatible(*(TMatrixTBase<float>*) libp->para[0].ref, *(TMatrixTBase<float>*) libp->para[1].ref));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_403(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 103, (long) AreCompatible(*(TMatrixTBase<float>*) libp->para[0].ref, *(TMatrixTBase<double>*) libp->para[1].ref
, (Int_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 103, (long) AreCompatible(*(TMatrixTBase<float>*) libp->para[0].ref, *(TMatrixTBase<double>*) libp->para[1].ref));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_404(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      Compare(*(TMatrixTBase<float>*) libp->para[0].ref, *(TMatrixTBase<float>*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_405(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) VerifyMatrixValue(*(TMatrixTBase<float>*) libp->para[0].ref, (float) G__double(libp->para[1])
, (Int_t) G__int(libp->para[2]), (float) G__double(libp->para[3])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_406(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) VerifyMatrixIdentity(*(TMatrixTBase<float>*) libp->para[0].ref, *(TMatrixTBase<float>*) libp->para[1].ref
, (Int_t) G__int(libp->para[2]), (float) G__double(libp->para[3])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_407(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixT<float>* pobj;
         TMatrixT<float> xobj = operator+(*(TMatrixT<float>*) libp->para[0].ref, *(TMatrixT<float>*) libp->para[1].ref);
         pobj = new TMatrixT<float>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_408(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixT<float>* pobj;
         TMatrixT<float> xobj = operator+(*(TMatrixT<float>*) libp->para[0].ref, *(TMatrixTSym<float>*) libp->para[1].ref);
         pobj = new TMatrixT<float>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_409(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixT<float>* pobj;
         TMatrixT<float> xobj = operator+(*(TMatrixTSym<float>*) libp->para[0].ref, *(TMatrixT<float>*) libp->para[1].ref);
         pobj = new TMatrixT<float>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_410(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixT<float>* pobj;
         TMatrixT<float> xobj = operator+(*(TMatrixT<float>*) libp->para[0].ref, (float) G__double(libp->para[1]));
         pobj = new TMatrixT<float>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_411(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixT<float>* pobj;
         TMatrixT<float> xobj = operator+((float) G__double(libp->para[0]), *(TMatrixT<float>*) libp->para[1].ref);
         pobj = new TMatrixT<float>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_412(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixT<float>* pobj;
         TMatrixT<float> xobj = operator-(*(TMatrixT<float>*) libp->para[0].ref, *(TMatrixT<float>*) libp->para[1].ref);
         pobj = new TMatrixT<float>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_413(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixT<float>* pobj;
         TMatrixT<float> xobj = operator-(*(TMatrixT<float>*) libp->para[0].ref, *(TMatrixTSym<float>*) libp->para[1].ref);
         pobj = new TMatrixT<float>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_414(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixT<float>* pobj;
         TMatrixT<float> xobj = operator-(*(TMatrixTSym<float>*) libp->para[0].ref, *(TMatrixT<float>*) libp->para[1].ref);
         pobj = new TMatrixT<float>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_415(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixT<float>* pobj;
         TMatrixT<float> xobj = operator-(*(TMatrixT<float>*) libp->para[0].ref, (float) G__double(libp->para[1]));
         pobj = new TMatrixT<float>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_416(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixT<float>* pobj;
         TMatrixT<float> xobj = operator-((float) G__double(libp->para[0]), *(TMatrixT<float>*) libp->para[1].ref);
         pobj = new TMatrixT<float>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_417(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixT<float>* pobj;
         TMatrixT<float> xobj = operator*((float) G__double(libp->para[0]), *(TMatrixT<float>*) libp->para[1].ref);
         pobj = new TMatrixT<float>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_418(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixT<float>* pobj;
         TMatrixT<float> xobj = operator*(*(TMatrixT<float>*) libp->para[0].ref, (float) G__double(libp->para[1]));
         pobj = new TMatrixT<float>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_419(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixT<float>* pobj;
         TMatrixT<float> xobj = operator*(*(TMatrixT<float>*) libp->para[0].ref, *(TMatrixT<float>*) libp->para[1].ref);
         pobj = new TMatrixT<float>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_420(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixT<float>* pobj;
         TMatrixT<float> xobj = operator*(*(TMatrixT<float>*) libp->para[0].ref, *(TMatrixTSym<float>*) libp->para[1].ref);
         pobj = new TMatrixT<float>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_421(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixT<float>* pobj;
         TMatrixT<float> xobj = operator*(*(TMatrixTSym<float>*) libp->para[0].ref, *(TMatrixT<float>*) libp->para[1].ref);
         pobj = new TMatrixT<float>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_422(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixT<float>* pobj;
         TMatrixT<float> xobj = operator*(*(TMatrixTSym<float>*) libp->para[0].ref, *(TMatrixTSym<float>*) libp->para[1].ref);
         pobj = new TMatrixT<float>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_423(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixT<float>* pobj;
         TMatrixT<float> xobj = operator&&(*(TMatrixT<float>*) libp->para[0].ref, *(TMatrixT<float>*) libp->para[1].ref);
         pobj = new TMatrixT<float>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_424(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixT<float>* pobj;
         TMatrixT<float> xobj = operator&&(*(TMatrixT<float>*) libp->para[0].ref, *(TMatrixTSym<float>*) libp->para[1].ref);
         pobj = new TMatrixT<float>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_425(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixT<float>* pobj;
         TMatrixT<float> xobj = operator&&(*(TMatrixTSym<float>*) libp->para[0].ref, *(TMatrixT<float>*) libp->para[1].ref);
         pobj = new TMatrixT<float>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_426(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixT<float>* pobj;
         TMatrixT<float> xobj = operator||(*(TMatrixT<float>*) libp->para[0].ref, *(TMatrixT<float>*) libp->para[1].ref);
         pobj = new TMatrixT<float>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_427(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixT<float>* pobj;
         TMatrixT<float> xobj = operator||(*(TMatrixT<float>*) libp->para[0].ref, *(TMatrixTSym<float>*) libp->para[1].ref);
         pobj = new TMatrixT<float>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_428(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixT<float>* pobj;
         TMatrixT<float> xobj = operator||(*(TMatrixTSym<float>*) libp->para[0].ref, *(TMatrixT<float>*) libp->para[1].ref);
         pobj = new TMatrixT<float>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_429(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixT<float>* pobj;
         TMatrixT<float> xobj = operator>(*(TMatrixT<float>*) libp->para[0].ref, *(TMatrixT<float>*) libp->para[1].ref);
         pobj = new TMatrixT<float>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_430(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixT<float>* pobj;
         TMatrixT<float> xobj = operator>(*(TMatrixT<float>*) libp->para[0].ref, *(TMatrixTSym<float>*) libp->para[1].ref);
         pobj = new TMatrixT<float>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_431(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixT<float>* pobj;
         TMatrixT<float> xobj = operator>(*(TMatrixTSym<float>*) libp->para[0].ref, *(TMatrixT<float>*) libp->para[1].ref);
         pobj = new TMatrixT<float>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_432(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixT<float>* pobj;
         TMatrixT<float> xobj = operator>=(*(TMatrixT<float>*) libp->para[0].ref, *(TMatrixT<float>*) libp->para[1].ref);
         pobj = new TMatrixT<float>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_433(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixT<float>* pobj;
         TMatrixT<float> xobj = operator>=(*(TMatrixT<float>*) libp->para[0].ref, *(TMatrixTSym<float>*) libp->para[1].ref);
         pobj = new TMatrixT<float>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_434(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixT<float>* pobj;
         TMatrixT<float> xobj = operator>=(*(TMatrixTSym<float>*) libp->para[0].ref, *(TMatrixT<float>*) libp->para[1].ref);
         pobj = new TMatrixT<float>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_435(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixT<float>* pobj;
         TMatrixT<float> xobj = operator<=(*(TMatrixT<float>*) libp->para[0].ref, *(TMatrixT<float>*) libp->para[1].ref);
         pobj = new TMatrixT<float>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_436(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixT<float>* pobj;
         TMatrixT<float> xobj = operator<=(*(TMatrixT<float>*) libp->para[0].ref, *(TMatrixTSym<float>*) libp->para[1].ref);
         pobj = new TMatrixT<float>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_437(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixT<float>* pobj;
         TMatrixT<float> xobj = operator<=(*(TMatrixTSym<float>*) libp->para[0].ref, *(TMatrixT<float>*) libp->para[1].ref);
         pobj = new TMatrixT<float>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_438(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixT<float>* pobj;
         TMatrixT<float> xobj = operator<(*(TMatrixT<float>*) libp->para[0].ref, *(TMatrixT<float>*) libp->para[1].ref);
         pobj = new TMatrixT<float>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_439(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixT<float>* pobj;
         TMatrixT<float> xobj = operator<(*(TMatrixT<float>*) libp->para[0].ref, *(TMatrixTSym<float>*) libp->para[1].ref);
         pobj = new TMatrixT<float>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_440(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixT<float>* pobj;
         TMatrixT<float> xobj = operator<(*(TMatrixTSym<float>*) libp->para[0].ref, *(TMatrixT<float>*) libp->para[1].ref);
         pobj = new TMatrixT<float>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_441(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixT<float>* pobj;
         TMatrixT<float> xobj = operator!=(*(TMatrixT<float>*) libp->para[0].ref, *(TMatrixT<float>*) libp->para[1].ref);
         pobj = new TMatrixT<float>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_442(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixT<float>* pobj;
         TMatrixT<float> xobj = operator!=(*(TMatrixT<float>*) libp->para[0].ref, *(TMatrixTSym<float>*) libp->para[1].ref);
         pobj = new TMatrixT<float>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_443(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixT<float>* pobj;
         TMatrixT<float> xobj = operator!=(*(TMatrixTSym<float>*) libp->para[0].ref, *(TMatrixT<float>*) libp->para[1].ref);
         pobj = new TMatrixT<float>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_444(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixT<float>& obj = Add(*(TMatrixT<float>*) libp->para[0].ref, (float) G__double(libp->para[1])
, *(TMatrixT<float>*) libp->para[2].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_445(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixT<float>& obj = Add(*(TMatrixT<float>*) libp->para[0].ref, (float) G__double(libp->para[1])
, *(TMatrixTSym<float>*) libp->para[2].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_446(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixT<float>& obj = ElementMult(*(TMatrixT<float>*) libp->para[0].ref, *(TMatrixT<float>*) libp->para[1].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_447(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixT<float>& obj = ElementMult(*(TMatrixT<float>*) libp->para[0].ref, *(TMatrixTSym<float>*) libp->para[1].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_448(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixT<float>& obj = ElementDiv(*(TMatrixT<float>*) libp->para[0].ref, *(TMatrixT<float>*) libp->para[1].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_449(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixT<float>& obj = ElementDiv(*(TMatrixT<float>*) libp->para[0].ref, *(TMatrixTSym<float>*) libp->para[1].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_450(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) operator==(*(TMatrixTSym<float>*) libp->para[0].ref, *(TMatrixTSym<float>*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_451(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixTSym<float>* pobj;
         TMatrixTSym<float> xobj = operator+(*(TMatrixTSym<float>*) libp->para[0].ref, *(TMatrixTSym<float>*) libp->para[1].ref);
         pobj = new TMatrixTSym<float>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_452(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixTSym<float>* pobj;
         TMatrixTSym<float> xobj = operator+(*(TMatrixTSym<float>*) libp->para[0].ref, (float) G__double(libp->para[1]));
         pobj = new TMatrixTSym<float>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_453(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixTSym<float>* pobj;
         TMatrixTSym<float> xobj = operator+((float) G__double(libp->para[0]), *(TMatrixTSym<float>*) libp->para[1].ref);
         pobj = new TMatrixTSym<float>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_454(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixTSym<float>* pobj;
         TMatrixTSym<float> xobj = operator-(*(TMatrixTSym<float>*) libp->para[0].ref, *(TMatrixTSym<float>*) libp->para[1].ref);
         pobj = new TMatrixTSym<float>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_455(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixTSym<float>* pobj;
         TMatrixTSym<float> xobj = operator-(*(TMatrixTSym<float>*) libp->para[0].ref, (float) G__double(libp->para[1]));
         pobj = new TMatrixTSym<float>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_456(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixTSym<float>* pobj;
         TMatrixTSym<float> xobj = operator-((float) G__double(libp->para[0]), *(TMatrixTSym<float>*) libp->para[1].ref);
         pobj = new TMatrixTSym<float>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_457(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixTSym<float>* pobj;
         TMatrixTSym<float> xobj = operator*(*(TMatrixTSym<float>*) libp->para[0].ref, (float) G__double(libp->para[1]));
         pobj = new TMatrixTSym<float>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_458(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixTSym<float>* pobj;
         TMatrixTSym<float> xobj = operator*((float) G__double(libp->para[0]), *(TMatrixTSym<float>*) libp->para[1].ref);
         pobj = new TMatrixTSym<float>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_459(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixTSym<float>* pobj;
         TMatrixTSym<float> xobj = operator&&(*(TMatrixTSym<float>*) libp->para[0].ref, *(TMatrixTSym<float>*) libp->para[1].ref);
         pobj = new TMatrixTSym<float>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_460(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixTSym<float>* pobj;
         TMatrixTSym<float> xobj = operator||(*(TMatrixTSym<float>*) libp->para[0].ref, *(TMatrixTSym<float>*) libp->para[1].ref);
         pobj = new TMatrixTSym<float>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_461(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixTSym<float>* pobj;
         TMatrixTSym<float> xobj = operator>(*(TMatrixTSym<float>*) libp->para[0].ref, *(TMatrixTSym<float>*) libp->para[1].ref);
         pobj = new TMatrixTSym<float>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_462(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixTSym<float>* pobj;
         TMatrixTSym<float> xobj = operator>=(*(TMatrixTSym<float>*) libp->para[0].ref, *(TMatrixTSym<float>*) libp->para[1].ref);
         pobj = new TMatrixTSym<float>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_463(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixTSym<float>* pobj;
         TMatrixTSym<float> xobj = operator<=(*(TMatrixTSym<float>*) libp->para[0].ref, *(TMatrixTSym<float>*) libp->para[1].ref);
         pobj = new TMatrixTSym<float>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_464(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixTSym<float>* pobj;
         TMatrixTSym<float> xobj = operator<(*(TMatrixTSym<float>*) libp->para[0].ref, *(TMatrixTSym<float>*) libp->para[1].ref);
         pobj = new TMatrixTSym<float>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_465(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSym<float>& obj = Add(*(TMatrixTSym<float>*) libp->para[0].ref, (float) G__double(libp->para[1])
, *(TMatrixTSym<float>*) libp->para[2].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_466(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSym<float>& obj = ElementMult(*(TMatrixTSym<float>*) libp->para[0].ref, *(TMatrixTSym<float>*) libp->para[1].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_467(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSym<float>& obj = ElementDiv(*(TMatrixTSym<float>*) libp->para[0].ref, *(TMatrixTSym<float>*) libp->para[1].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_468(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixTSparse<float>* pobj;
         TMatrixTSparse<float> xobj = operator+(*(TMatrixTSparse<float>*) libp->para[0].ref, *(TMatrixTSparse<float>*) libp->para[1].ref);
         pobj = new TMatrixTSparse<float>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_469(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixTSparse<float>* pobj;
         TMatrixTSparse<float> xobj = operator+(*(TMatrixTSparse<float>*) libp->para[0].ref, *(TMatrixT<float>*) libp->para[1].ref);
         pobj = new TMatrixTSparse<float>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_470(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixTSparse<float>* pobj;
         TMatrixTSparse<float> xobj = operator+(*(TMatrixT<float>*) libp->para[0].ref, *(TMatrixTSparse<float>*) libp->para[1].ref);
         pobj = new TMatrixTSparse<float>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_471(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixTSparse<float>* pobj;
         TMatrixTSparse<float> xobj = operator+(*(TMatrixTSparse<float>*) libp->para[0].ref, (float) G__double(libp->para[1]));
         pobj = new TMatrixTSparse<float>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_472(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixTSparse<float>* pobj;
         TMatrixTSparse<float> xobj = operator+((float) G__double(libp->para[0]), *(TMatrixTSparse<float>*) libp->para[1].ref);
         pobj = new TMatrixTSparse<float>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_473(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixTSparse<float>* pobj;
         TMatrixTSparse<float> xobj = operator-(*(TMatrixTSparse<float>*) libp->para[0].ref, *(TMatrixTSparse<float>*) libp->para[1].ref);
         pobj = new TMatrixTSparse<float>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_474(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixTSparse<float>* pobj;
         TMatrixTSparse<float> xobj = operator-(*(TMatrixTSparse<float>*) libp->para[0].ref, *(TMatrixT<float>*) libp->para[1].ref);
         pobj = new TMatrixTSparse<float>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_475(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixTSparse<float>* pobj;
         TMatrixTSparse<float> xobj = operator-(*(TMatrixT<float>*) libp->para[0].ref, *(TMatrixTSparse<float>*) libp->para[1].ref);
         pobj = new TMatrixTSparse<float>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_476(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixTSparse<float>* pobj;
         TMatrixTSparse<float> xobj = operator-(*(TMatrixTSparse<float>*) libp->para[0].ref, (float) G__double(libp->para[1]));
         pobj = new TMatrixTSparse<float>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_477(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixTSparse<float>* pobj;
         TMatrixTSparse<float> xobj = operator-((float) G__double(libp->para[0]), *(TMatrixTSparse<float>*) libp->para[1].ref);
         pobj = new TMatrixTSparse<float>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_478(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixTSparse<float>* pobj;
         TMatrixTSparse<float> xobj = operator*(*(TMatrixTSparse<float>*) libp->para[0].ref, *(TMatrixTSparse<float>*) libp->para[1].ref);
         pobj = new TMatrixTSparse<float>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_479(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixTSparse<float>* pobj;
         TMatrixTSparse<float> xobj = operator*(*(TMatrixTSparse<float>*) libp->para[0].ref, *(TMatrixT<float>*) libp->para[1].ref);
         pobj = new TMatrixTSparse<float>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_480(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixTSparse<float>* pobj;
         TMatrixTSparse<float> xobj = operator*(*(TMatrixT<float>*) libp->para[0].ref, *(TMatrixTSparse<float>*) libp->para[1].ref);
         pobj = new TMatrixTSparse<float>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_481(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixTSparse<float>* pobj;
         TMatrixTSparse<float> xobj = operator*((float) G__double(libp->para[0]), *(TMatrixTSparse<float>*) libp->para[1].ref);
         pobj = new TMatrixTSparse<float>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_482(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixTSparse<float>* pobj;
         TMatrixTSparse<float> xobj = operator*(*(TMatrixTSparse<float>*) libp->para[0].ref, (float) G__double(libp->para[1]));
         pobj = new TMatrixTSparse<float>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_483(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSparse<float>& obj = Add(*(TMatrixTSparse<float>*) libp->para[0].ref, (float) G__double(libp->para[1])
, *(TMatrixTSparse<float>*) libp->para[2].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_484(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSparse<float>& obj = ElementMult(*(TMatrixTSparse<float>*) libp->para[0].ref, *(TMatrixTSparse<float>*) libp->para[1].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_485(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSparse<float>& obj = ElementDiv(*(TMatrixTSparse<float>*) libp->para[0].ref, *(TMatrixTSparse<float>*) libp->para[1].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_486(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 103, (long) AreCompatible(*(TMatrixTSparse<float>*) libp->para[0].ref, *(TMatrixTSparse<float>*) libp->para[1].ref
, (Int_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 103, (long) AreCompatible(*(TMatrixTSparse<float>*) libp->para[0].ref, *(TMatrixTSparse<float>*) libp->para[1].ref));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_487(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) operator==(*(TVectorT<double>*) libp->para[0].ref, *(TVectorT<double>*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_488(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TVectorT<double>* pobj;
         TVectorT<double> xobj = operator+(*(TVectorT<double>*) libp->para[0].ref, *(TVectorT<double>*) libp->para[1].ref);
         pobj = new TVectorT<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_489(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TVectorT<double>* pobj;
         TVectorT<double> xobj = operator-(*(TVectorT<double>*) libp->para[0].ref, *(TVectorT<double>*) libp->para[1].ref);
         pobj = new TVectorT<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_490(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) operator*(*(TVectorT<double>*) libp->para[0].ref, *(TVectorT<double>*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_491(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TVectorT<double>* pobj;
         TVectorT<double> xobj = operator*(*(TMatrixT<double>*) libp->para[0].ref, *(TVectorT<double>*) libp->para[1].ref);
         pobj = new TVectorT<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_492(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TVectorT<double>* pobj;
         TVectorT<double> xobj = operator*(*(TMatrixTSym<double>*) libp->para[0].ref, *(TVectorT<double>*) libp->para[1].ref);
         pobj = new TVectorT<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_493(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TVectorT<double>* pobj;
         TVectorT<double> xobj = operator*(*(TMatrixTSparse<double>*) libp->para[0].ref, *(TVectorT<double>*) libp->para[1].ref);
         pobj = new TVectorT<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_494(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TVectorT<double>* pobj;
         TVectorT<double> xobj = operator*((double) G__double(libp->para[0]), *(TVectorT<double>*) libp->para[1].ref);
         pobj = new TVectorT<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_495(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) Dot(*(TVectorT<double>*) libp->para[0].ref, *(TVectorT<double>*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_496(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixT<double>* pobj;
         TMatrixT<double> xobj = OuterProduct(*(TVectorT<double>*) libp->para[0].ref, *(TVectorT<double>*) libp->para[1].ref);
         pobj = new TMatrixT<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_497(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixT<double>& obj = OuterProduct(*(TMatrixT<double>*) libp->para[0].ref, *(TVectorT<double>*) libp->para[1].ref
, *(TVectorT<double>*) libp->para[2].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_498(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) Mult(*(TVectorT<double>*) libp->para[0].ref, *(TMatrixT<double>*) libp->para[1].ref
, *(TVectorT<double>*) libp->para[2].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_499(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVectorT<double>& obj = Add(*(TVectorT<double>*) libp->para[0].ref, (double) G__double(libp->para[1])
, *(TVectorT<double>*) libp->para[2].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_500(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVectorT<double>& obj = Add(*(TVectorT<double>*) libp->para[0].ref, (double) G__double(libp->para[1])
, *(TMatrixT<double>*) libp->para[2].ref, *(TVectorT<double>*) libp->para[3].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_501(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVectorT<double>& obj = Add(*(TVectorT<double>*) libp->para[0].ref, (double) G__double(libp->para[1])
, *(TMatrixTSym<double>*) libp->para[2].ref, *(TVectorT<double>*) libp->para[3].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_502(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVectorT<double>& obj = Add(*(TVectorT<double>*) libp->para[0].ref, (double) G__double(libp->para[1])
, *(TMatrixTSparse<double>*) libp->para[2].ref, *(TVectorT<double>*) libp->para[3].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_503(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVectorT<double>& obj = AddElemMult(*(TVectorT<double>*) libp->para[0].ref, (double) G__double(libp->para[1])
, *(TVectorT<double>*) libp->para[2].ref, *(TVectorT<double>*) libp->para[3].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_504(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVectorT<double>& obj = AddElemMult(*(TVectorT<double>*) libp->para[0].ref, (double) G__double(libp->para[1])
, *(TVectorT<double>*) libp->para[2].ref, *(TVectorT<double>*) libp->para[3].ref
, *(TVectorT<double>*) libp->para[4].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_505(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVectorT<double>& obj = AddElemDiv(*(TVectorT<double>*) libp->para[0].ref, (double) G__double(libp->para[1])
, *(TVectorT<double>*) libp->para[2].ref, *(TVectorT<double>*) libp->para[3].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_506(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVectorT<double>& obj = AddElemDiv(*(TVectorT<double>*) libp->para[0].ref, (double) G__double(libp->para[1])
, *(TVectorT<double>*) libp->para[2].ref, *(TVectorT<double>*) libp->para[3].ref
, *(TVectorT<double>*) libp->para[4].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_507(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVectorT<double>& obj = ElementMult(*(TVectorT<double>*) libp->para[0].ref, *(TVectorT<double>*) libp->para[1].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_508(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVectorT<double>& obj = ElementMult(*(TVectorT<double>*) libp->para[0].ref, *(TVectorT<double>*) libp->para[1].ref
, *(TVectorT<double>*) libp->para[2].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_509(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVectorT<double>& obj = ElementDiv(*(TVectorT<double>*) libp->para[0].ref, *(TVectorT<double>*) libp->para[1].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_510(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TVectorT<double>& obj = ElementDiv(*(TVectorT<double>*) libp->para[0].ref, *(TVectorT<double>*) libp->para[1].ref
, *(TVectorT<double>*) libp->para[2].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_511(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 103, (long) AreCompatible(*(TVectorT<double>*) libp->para[0].ref, *(TVectorT<double>*) libp->para[1].ref
, (Int_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 103, (long) AreCompatible(*(TVectorT<double>*) libp->para[0].ref, *(TVectorT<double>*) libp->para[1].ref));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_512(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 103, (long) AreCompatible(*(TVectorT<double>*) libp->para[0].ref, *(TVectorT<float>*) libp->para[1].ref
, (Int_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 103, (long) AreCompatible(*(TVectorT<double>*) libp->para[0].ref, *(TVectorT<float>*) libp->para[1].ref));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_513(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 103, (long) AreCompatible(*(TMatrixT<double>*) libp->para[0].ref, *(TVectorT<double>*) libp->para[1].ref
, (Int_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 103, (long) AreCompatible(*(TMatrixT<double>*) libp->para[0].ref, *(TVectorT<double>*) libp->para[1].ref));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_514(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 103, (long) AreCompatible(*(TVectorT<double>*) libp->para[0].ref, *(TMatrixT<double>*) libp->para[1].ref
, (Int_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 103, (long) AreCompatible(*(TVectorT<double>*) libp->para[0].ref, *(TMatrixT<double>*) libp->para[1].ref));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_515(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      Compare(*(TVectorT<double>*) libp->para[0].ref, *(TVectorT<double>*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_516(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) VerifyVectorValue(*(TVectorT<double>*) libp->para[0].ref, (double) G__double(libp->para[1])
, (Int_t) G__int(libp->para[2]), (double) G__double(libp->para[3])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_517(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) VerifyVectorIdentity(*(TVectorT<double>*) libp->para[0].ref, *(TVectorT<double>*) libp->para[1].ref
, (Int_t) G__int(libp->para[2]), (double) G__double(libp->para[3])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_518(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) operator==(*(TMatrixTBase<double>*) libp->para[0].ref, *(TMatrixTBase<double>*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_519(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) E2Norm(*(TMatrixTBase<double>*) libp->para[0].ref, *(TMatrixTBase<double>*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_520(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 103, (long) AreCompatible(*(TMatrixTBase<double>*) libp->para[0].ref, *(TMatrixTBase<double>*) libp->para[1].ref
, (Int_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 103, (long) AreCompatible(*(TMatrixTBase<double>*) libp->para[0].ref, *(TMatrixTBase<double>*) libp->para[1].ref));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_521(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 103, (long) AreCompatible(*(TMatrixTBase<double>*) libp->para[0].ref, *(TMatrixTBase<float>*) libp->para[1].ref
, (Int_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 103, (long) AreCompatible(*(TMatrixTBase<double>*) libp->para[0].ref, *(TMatrixTBase<float>*) libp->para[1].ref));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_522(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      Compare(*(TMatrixTBase<double>*) libp->para[0].ref, *(TMatrixTBase<double>*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_523(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) VerifyMatrixValue(*(TMatrixTBase<double>*) libp->para[0].ref, (double) G__double(libp->para[1])
, (Int_t) G__int(libp->para[2]), (double) G__double(libp->para[3])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_524(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) VerifyMatrixIdentity(*(TMatrixTBase<double>*) libp->para[0].ref, *(TMatrixTBase<double>*) libp->para[1].ref
, (Int_t) G__int(libp->para[2]), (double) G__double(libp->para[3])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_525(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixT<double>* pobj;
         TMatrixT<double> xobj = operator+(*(TMatrixT<double>*) libp->para[0].ref, *(TMatrixT<double>*) libp->para[1].ref);
         pobj = new TMatrixT<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_526(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixT<double>* pobj;
         TMatrixT<double> xobj = operator+(*(TMatrixT<double>*) libp->para[0].ref, *(TMatrixTSym<double>*) libp->para[1].ref);
         pobj = new TMatrixT<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_527(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixT<double>* pobj;
         TMatrixT<double> xobj = operator+(*(TMatrixTSym<double>*) libp->para[0].ref, *(TMatrixT<double>*) libp->para[1].ref);
         pobj = new TMatrixT<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_528(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixT<double>* pobj;
         TMatrixT<double> xobj = operator+(*(TMatrixT<double>*) libp->para[0].ref, (double) G__double(libp->para[1]));
         pobj = new TMatrixT<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_529(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixT<double>* pobj;
         TMatrixT<double> xobj = operator+((double) G__double(libp->para[0]), *(TMatrixT<double>*) libp->para[1].ref);
         pobj = new TMatrixT<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_530(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixT<double>* pobj;
         TMatrixT<double> xobj = operator-(*(TMatrixT<double>*) libp->para[0].ref, *(TMatrixT<double>*) libp->para[1].ref);
         pobj = new TMatrixT<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_531(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixT<double>* pobj;
         TMatrixT<double> xobj = operator-(*(TMatrixT<double>*) libp->para[0].ref, *(TMatrixTSym<double>*) libp->para[1].ref);
         pobj = new TMatrixT<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_532(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixT<double>* pobj;
         TMatrixT<double> xobj = operator-(*(TMatrixTSym<double>*) libp->para[0].ref, *(TMatrixT<double>*) libp->para[1].ref);
         pobj = new TMatrixT<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_533(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixT<double>* pobj;
         TMatrixT<double> xobj = operator-(*(TMatrixT<double>*) libp->para[0].ref, (double) G__double(libp->para[1]));
         pobj = new TMatrixT<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_534(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixT<double>* pobj;
         TMatrixT<double> xobj = operator-((double) G__double(libp->para[0]), *(TMatrixT<double>*) libp->para[1].ref);
         pobj = new TMatrixT<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_535(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixT<double>* pobj;
         TMatrixT<double> xobj = operator*((double) G__double(libp->para[0]), *(TMatrixT<double>*) libp->para[1].ref);
         pobj = new TMatrixT<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_536(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixT<double>* pobj;
         TMatrixT<double> xobj = operator*(*(TMatrixT<double>*) libp->para[0].ref, (double) G__double(libp->para[1]));
         pobj = new TMatrixT<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_537(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixT<double>* pobj;
         TMatrixT<double> xobj = operator*(*(TMatrixT<double>*) libp->para[0].ref, *(TMatrixT<double>*) libp->para[1].ref);
         pobj = new TMatrixT<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_538(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixT<double>* pobj;
         TMatrixT<double> xobj = operator*(*(TMatrixT<double>*) libp->para[0].ref, *(TMatrixTSym<double>*) libp->para[1].ref);
         pobj = new TMatrixT<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_539(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixT<double>* pobj;
         TMatrixT<double> xobj = operator*(*(TMatrixTSym<double>*) libp->para[0].ref, *(TMatrixT<double>*) libp->para[1].ref);
         pobj = new TMatrixT<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_540(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixT<double>* pobj;
         TMatrixT<double> xobj = operator*(*(TMatrixTSym<double>*) libp->para[0].ref, *(TMatrixTSym<double>*) libp->para[1].ref);
         pobj = new TMatrixT<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_541(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixT<double>* pobj;
         TMatrixT<double> xobj = operator&&(*(TMatrixT<double>*) libp->para[0].ref, *(TMatrixT<double>*) libp->para[1].ref);
         pobj = new TMatrixT<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_542(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixT<double>* pobj;
         TMatrixT<double> xobj = operator&&(*(TMatrixT<double>*) libp->para[0].ref, *(TMatrixTSym<double>*) libp->para[1].ref);
         pobj = new TMatrixT<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_543(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixT<double>* pobj;
         TMatrixT<double> xobj = operator&&(*(TMatrixTSym<double>*) libp->para[0].ref, *(TMatrixT<double>*) libp->para[1].ref);
         pobj = new TMatrixT<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_544(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixT<double>* pobj;
         TMatrixT<double> xobj = operator||(*(TMatrixT<double>*) libp->para[0].ref, *(TMatrixT<double>*) libp->para[1].ref);
         pobj = new TMatrixT<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_545(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixT<double>* pobj;
         TMatrixT<double> xobj = operator||(*(TMatrixT<double>*) libp->para[0].ref, *(TMatrixTSym<double>*) libp->para[1].ref);
         pobj = new TMatrixT<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_546(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixT<double>* pobj;
         TMatrixT<double> xobj = operator||(*(TMatrixTSym<double>*) libp->para[0].ref, *(TMatrixT<double>*) libp->para[1].ref);
         pobj = new TMatrixT<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_547(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixT<double>* pobj;
         TMatrixT<double> xobj = operator>(*(TMatrixT<double>*) libp->para[0].ref, *(TMatrixT<double>*) libp->para[1].ref);
         pobj = new TMatrixT<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_548(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixT<double>* pobj;
         TMatrixT<double> xobj = operator>(*(TMatrixT<double>*) libp->para[0].ref, *(TMatrixTSym<double>*) libp->para[1].ref);
         pobj = new TMatrixT<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_549(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixT<double>* pobj;
         TMatrixT<double> xobj = operator>(*(TMatrixTSym<double>*) libp->para[0].ref, *(TMatrixT<double>*) libp->para[1].ref);
         pobj = new TMatrixT<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_550(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixT<double>* pobj;
         TMatrixT<double> xobj = operator>=(*(TMatrixT<double>*) libp->para[0].ref, *(TMatrixT<double>*) libp->para[1].ref);
         pobj = new TMatrixT<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_551(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixT<double>* pobj;
         TMatrixT<double> xobj = operator>=(*(TMatrixT<double>*) libp->para[0].ref, *(TMatrixTSym<double>*) libp->para[1].ref);
         pobj = new TMatrixT<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_552(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixT<double>* pobj;
         TMatrixT<double> xobj = operator>=(*(TMatrixTSym<double>*) libp->para[0].ref, *(TMatrixT<double>*) libp->para[1].ref);
         pobj = new TMatrixT<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_553(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixT<double>* pobj;
         TMatrixT<double> xobj = operator<=(*(TMatrixT<double>*) libp->para[0].ref, *(TMatrixT<double>*) libp->para[1].ref);
         pobj = new TMatrixT<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_554(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixT<double>* pobj;
         TMatrixT<double> xobj = operator<=(*(TMatrixT<double>*) libp->para[0].ref, *(TMatrixTSym<double>*) libp->para[1].ref);
         pobj = new TMatrixT<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_555(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixT<double>* pobj;
         TMatrixT<double> xobj = operator<=(*(TMatrixTSym<double>*) libp->para[0].ref, *(TMatrixT<double>*) libp->para[1].ref);
         pobj = new TMatrixT<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_556(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixT<double>* pobj;
         TMatrixT<double> xobj = operator<(*(TMatrixT<double>*) libp->para[0].ref, *(TMatrixT<double>*) libp->para[1].ref);
         pobj = new TMatrixT<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_557(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixT<double>* pobj;
         TMatrixT<double> xobj = operator<(*(TMatrixT<double>*) libp->para[0].ref, *(TMatrixTSym<double>*) libp->para[1].ref);
         pobj = new TMatrixT<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_558(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixT<double>* pobj;
         TMatrixT<double> xobj = operator<(*(TMatrixTSym<double>*) libp->para[0].ref, *(TMatrixT<double>*) libp->para[1].ref);
         pobj = new TMatrixT<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_559(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixT<double>* pobj;
         TMatrixT<double> xobj = operator!=(*(TMatrixT<double>*) libp->para[0].ref, *(TMatrixT<double>*) libp->para[1].ref);
         pobj = new TMatrixT<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_560(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixT<double>* pobj;
         TMatrixT<double> xobj = operator!=(*(TMatrixT<double>*) libp->para[0].ref, *(TMatrixTSym<double>*) libp->para[1].ref);
         pobj = new TMatrixT<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_561(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixT<double>* pobj;
         TMatrixT<double> xobj = operator!=(*(TMatrixTSym<double>*) libp->para[0].ref, *(TMatrixT<double>*) libp->para[1].ref);
         pobj = new TMatrixT<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_562(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixT<double>& obj = Add(*(TMatrixT<double>*) libp->para[0].ref, (double) G__double(libp->para[1])
, *(TMatrixT<double>*) libp->para[2].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_563(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixT<double>& obj = Add(*(TMatrixT<double>*) libp->para[0].ref, (double) G__double(libp->para[1])
, *(TMatrixTSym<double>*) libp->para[2].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_564(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixT<double>& obj = ElementMult(*(TMatrixT<double>*) libp->para[0].ref, *(TMatrixT<double>*) libp->para[1].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_565(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixT<double>& obj = ElementMult(*(TMatrixT<double>*) libp->para[0].ref, *(TMatrixTSym<double>*) libp->para[1].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_566(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixT<double>& obj = ElementDiv(*(TMatrixT<double>*) libp->para[0].ref, *(TMatrixT<double>*) libp->para[1].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_567(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixT<double>& obj = ElementDiv(*(TMatrixT<double>*) libp->para[0].ref, *(TMatrixTSym<double>*) libp->para[1].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_568(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) operator==(*(TMatrixTSym<double>*) libp->para[0].ref, *(TMatrixTSym<double>*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_569(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixTSym<double>* pobj;
         TMatrixTSym<double> xobj = operator+(*(TMatrixTSym<double>*) libp->para[0].ref, *(TMatrixTSym<double>*) libp->para[1].ref);
         pobj = new TMatrixTSym<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_570(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixTSym<double>* pobj;
         TMatrixTSym<double> xobj = operator+(*(TMatrixTSym<double>*) libp->para[0].ref, (double) G__double(libp->para[1]));
         pobj = new TMatrixTSym<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_571(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixTSym<double>* pobj;
         TMatrixTSym<double> xobj = operator+((double) G__double(libp->para[0]), *(TMatrixTSym<double>*) libp->para[1].ref);
         pobj = new TMatrixTSym<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_572(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixTSym<double>* pobj;
         TMatrixTSym<double> xobj = operator-(*(TMatrixTSym<double>*) libp->para[0].ref, *(TMatrixTSym<double>*) libp->para[1].ref);
         pobj = new TMatrixTSym<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_573(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixTSym<double>* pobj;
         TMatrixTSym<double> xobj = operator-(*(TMatrixTSym<double>*) libp->para[0].ref, (double) G__double(libp->para[1]));
         pobj = new TMatrixTSym<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_574(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixTSym<double>* pobj;
         TMatrixTSym<double> xobj = operator-((double) G__double(libp->para[0]), *(TMatrixTSym<double>*) libp->para[1].ref);
         pobj = new TMatrixTSym<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_575(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixTSym<double>* pobj;
         TMatrixTSym<double> xobj = operator*(*(TMatrixTSym<double>*) libp->para[0].ref, (double) G__double(libp->para[1]));
         pobj = new TMatrixTSym<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_576(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixTSym<double>* pobj;
         TMatrixTSym<double> xobj = operator*((double) G__double(libp->para[0]), *(TMatrixTSym<double>*) libp->para[1].ref);
         pobj = new TMatrixTSym<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_577(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixTSym<double>* pobj;
         TMatrixTSym<double> xobj = operator&&(*(TMatrixTSym<double>*) libp->para[0].ref, *(TMatrixTSym<double>*) libp->para[1].ref);
         pobj = new TMatrixTSym<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_578(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixTSym<double>* pobj;
         TMatrixTSym<double> xobj = operator||(*(TMatrixTSym<double>*) libp->para[0].ref, *(TMatrixTSym<double>*) libp->para[1].ref);
         pobj = new TMatrixTSym<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_579(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixTSym<double>* pobj;
         TMatrixTSym<double> xobj = operator>(*(TMatrixTSym<double>*) libp->para[0].ref, *(TMatrixTSym<double>*) libp->para[1].ref);
         pobj = new TMatrixTSym<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_580(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixTSym<double>* pobj;
         TMatrixTSym<double> xobj = operator>=(*(TMatrixTSym<double>*) libp->para[0].ref, *(TMatrixTSym<double>*) libp->para[1].ref);
         pobj = new TMatrixTSym<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_581(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixTSym<double>* pobj;
         TMatrixTSym<double> xobj = operator<=(*(TMatrixTSym<double>*) libp->para[0].ref, *(TMatrixTSym<double>*) libp->para[1].ref);
         pobj = new TMatrixTSym<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_582(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixTSym<double>* pobj;
         TMatrixTSym<double> xobj = operator<(*(TMatrixTSym<double>*) libp->para[0].ref, *(TMatrixTSym<double>*) libp->para[1].ref);
         pobj = new TMatrixTSym<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_583(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSym<double>& obj = Add(*(TMatrixTSym<double>*) libp->para[0].ref, (double) G__double(libp->para[1])
, *(TMatrixTSym<double>*) libp->para[2].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_584(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSym<double>& obj = ElementMult(*(TMatrixTSym<double>*) libp->para[0].ref, *(TMatrixTSym<double>*) libp->para[1].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_585(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSym<double>& obj = ElementDiv(*(TMatrixTSym<double>*) libp->para[0].ref, *(TMatrixTSym<double>*) libp->para[1].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_586(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixTSparse<double>* pobj;
         TMatrixTSparse<double> xobj = operator+(*(TMatrixTSparse<double>*) libp->para[0].ref, *(TMatrixTSparse<double>*) libp->para[1].ref);
         pobj = new TMatrixTSparse<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_587(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixTSparse<double>* pobj;
         TMatrixTSparse<double> xobj = operator+(*(TMatrixTSparse<double>*) libp->para[0].ref, *(TMatrixT<double>*) libp->para[1].ref);
         pobj = new TMatrixTSparse<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_588(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixTSparse<double>* pobj;
         TMatrixTSparse<double> xobj = operator+(*(TMatrixT<double>*) libp->para[0].ref, *(TMatrixTSparse<double>*) libp->para[1].ref);
         pobj = new TMatrixTSparse<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_589(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixTSparse<double>* pobj;
         TMatrixTSparse<double> xobj = operator+(*(TMatrixTSparse<double>*) libp->para[0].ref, (double) G__double(libp->para[1]));
         pobj = new TMatrixTSparse<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_590(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixTSparse<double>* pobj;
         TMatrixTSparse<double> xobj = operator+((double) G__double(libp->para[0]), *(TMatrixTSparse<double>*) libp->para[1].ref);
         pobj = new TMatrixTSparse<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_591(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixTSparse<double>* pobj;
         TMatrixTSparse<double> xobj = operator-(*(TMatrixTSparse<double>*) libp->para[0].ref, *(TMatrixTSparse<double>*) libp->para[1].ref);
         pobj = new TMatrixTSparse<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_592(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixTSparse<double>* pobj;
         TMatrixTSparse<double> xobj = operator-(*(TMatrixTSparse<double>*) libp->para[0].ref, *(TMatrixT<double>*) libp->para[1].ref);
         pobj = new TMatrixTSparse<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_593(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixTSparse<double>* pobj;
         TMatrixTSparse<double> xobj = operator-(*(TMatrixT<double>*) libp->para[0].ref, *(TMatrixTSparse<double>*) libp->para[1].ref);
         pobj = new TMatrixTSparse<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_594(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixTSparse<double>* pobj;
         TMatrixTSparse<double> xobj = operator-(*(TMatrixTSparse<double>*) libp->para[0].ref, (double) G__double(libp->para[1]));
         pobj = new TMatrixTSparse<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_595(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixTSparse<double>* pobj;
         TMatrixTSparse<double> xobj = operator-((double) G__double(libp->para[0]), *(TMatrixTSparse<double>*) libp->para[1].ref);
         pobj = new TMatrixTSparse<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_596(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixTSparse<double>* pobj;
         TMatrixTSparse<double> xobj = operator*(*(TMatrixTSparse<double>*) libp->para[0].ref, *(TMatrixTSparse<double>*) libp->para[1].ref);
         pobj = new TMatrixTSparse<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_597(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixTSparse<double>* pobj;
         TMatrixTSparse<double> xobj = operator*(*(TMatrixTSparse<double>*) libp->para[0].ref, *(TMatrixT<double>*) libp->para[1].ref);
         pobj = new TMatrixTSparse<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_598(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixTSparse<double>* pobj;
         TMatrixTSparse<double> xobj = operator*(*(TMatrixT<double>*) libp->para[0].ref, *(TMatrixTSparse<double>*) libp->para[1].ref);
         pobj = new TMatrixTSparse<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_599(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixTSparse<double>* pobj;
         TMatrixTSparse<double> xobj = operator*((double) G__double(libp->para[0]), *(TMatrixTSparse<double>*) libp->para[1].ref);
         pobj = new TMatrixTSparse<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_600(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMatrixTSparse<double>* pobj;
         TMatrixTSparse<double> xobj = operator*(*(TMatrixTSparse<double>*) libp->para[0].ref, (double) G__double(libp->para[1]));
         pobj = new TMatrixTSparse<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_601(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSparse<double>& obj = Add(*(TMatrixTSparse<double>*) libp->para[0].ref, (double) G__double(libp->para[1])
, *(TMatrixTSparse<double>*) libp->para[2].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_602(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSparse<double>& obj = ElementMult(*(TMatrixTSparse<double>*) libp->para[0].ref, *(TMatrixTSparse<double>*) libp->para[1].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_603(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMatrixTSparse<double>& obj = ElementDiv(*(TMatrixTSparse<double>*) libp->para[0].ref, *(TMatrixTSparse<double>*) libp->para[1].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Matrix__0_604(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 103, (long) AreCompatible(*(TMatrixTSparse<double>*) libp->para[0].ref, *(TMatrixTSparse<double>*) libp->para[1].ref
, (Int_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 103, (long) AreCompatible(*(TMatrixTSparse<double>*) libp->para[0].ref, *(TMatrixTSparse<double>*) libp->para[1].ref));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}


/*********************************************************
* Member function Stub
*********************************************************/

/* TMatrixTBase<float> */

/* TMatrixTBase<double> */

/* TVectorT<float> */

/* TVectorT<double> */

/* TMatrixT<double> */

/* TMatrixTSym<double> */

/* TMatrixTSparse<double> */

/* TMatrixTLazy<double> */

/* TMatrixTRow_const<double> */

/* TMatrixTRow<double> */

/* TMatrixTDiag_const<double> */

/* TMatrixTColumn_const<double> */

/* TMatrixTFlat_const<double> */

/* TMatrixTSub_const<double> */

/* TMatrixTSparseRow_const<double> */

/* TMatrixTSparseDiag_const<double> */

/* TMatrixTColumn<double> */

/* TMatrixTDiag<double> */

/* TMatrixTFlat<double> */

/* TMatrixTSub<double> */

/* TMatrixTSparseRow<double> */

/* TMatrixTSparseDiag<double> */

/* TMatrixTSymLazy<double> */

/* TMatrixTRow_const<float> */

/* TMatrixT<float> */

/* TMatrixTSym<float> */

/* TMatrixTSymLazy<float> */

/* TMatrixTRow<float> */

/* TMatrixTSparse<float> */

/* TMatrixTSparseRow_const<float> */

/* TMatrixTSparseRow<float> */

/* TMatrixTLazy<float> */

/* TMatrixTDiag_const<float> */

/* TMatrixTColumn_const<float> */

/* TMatrixTSparseDiag_const<float> */

/* TDecompBase */

/* TDecompBK */

/* TDecompChol */

/* TDecompLU */

/* TDecompQRH */

/* TDecompSparse */

/* TDecompSVD */

/* TMatrixDEigen */

/* THaarMatrixT<double> */

/* THilbertMatrixT<double> */

/* THilbertMatrixTSym<double> */

/* TMatrixDSymEigen */

/* TMatrixTFlat_const<float> */

/* TMatrixTSub_const<float> */

/* TMatrixTColumn<float> */

/* TMatrixTDiag<float> */

/* TMatrixTFlat<float> */

/* TMatrixTSub<float> */

/* TMatrixTSparseDiag<float> */

/* THaarMatrixT<float> */

/* THilbertMatrixT<float> */

/* THilbertMatrixTSym<float> */

/* TMatrixTCramerInv */

/* TMatrixTSymCramerInv */

/*********************************************************
* Global function Stub
*********************************************************/

/*********************************************************
* Get size of pointer to member function
*********************************************************/
class G__Sizep2memfuncG__Matrix {
 public:
  G__Sizep2memfuncG__Matrix(): p(&G__Sizep2memfuncG__Matrix::sizep2memfunc) {}
    size_t sizep2memfunc() { return(sizeof(p)); }
  private:
    size_t (G__Sizep2memfuncG__Matrix::*p)();
};

size_t G__get_sizep2memfuncG__Matrix()
{
  G__Sizep2memfuncG__Matrix a;
  G__setsizep2memfunc((int)a.sizep2memfunc());
  return((size_t)a.sizep2memfunc());
}


/*********************************************************
* virtual base class offset calculation interface
*********************************************************/

   /* Setting up class inheritance */

/*********************************************************
* Inheritance information setup/
*********************************************************/
extern "C" void G__cpp_setup_inheritanceG__Matrix() {

   /* Setting up class inheritance */
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEfloatgR))) {
     TMatrixTBase<float> *G__Lderived;
     G__Lderived=(TMatrixTBase<float>*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEfloatgR),G__get_linked_tagnum(&G__G__MatrixLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEdoublegR))) {
     TMatrixTBase<double> *G__Lderived;
     G__Lderived=(TMatrixTBase<double>*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEdoublegR),G__get_linked_tagnum(&G__G__MatrixLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEfloatgR))) {
     TVectorT<float> *G__Lderived;
     G__Lderived=(TVectorT<float>*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEfloatgR),G__get_linked_tagnum(&G__G__MatrixLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR))) {
     TVectorT<double> *G__Lderived;
     G__Lderived=(TVectorT<double>*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR),G__get_linked_tagnum(&G__G__MatrixLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR))) {
     TMatrixT<double> *G__Lderived;
     G__Lderived=(TMatrixT<double>*)0x1000;
     {
       TMatrixTBase<double> *G__Lpbase=(TMatrixTBase<double>*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR),G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEdoublegR),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR),G__get_linked_tagnum(&G__G__MatrixLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEdoublegR))) {
     TMatrixTSym<double> *G__Lderived;
     G__Lderived=(TMatrixTSym<double>*)0x1000;
     {
       TMatrixTBase<double> *G__Lpbase=(TMatrixTBase<double>*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEdoublegR),G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEdoublegR),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEdoublegR),G__get_linked_tagnum(&G__G__MatrixLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEdoublegR))) {
     TMatrixTSparse<double> *G__Lderived;
     G__Lderived=(TMatrixTSparse<double>*)0x1000;
     {
       TMatrixTBase<double> *G__Lpbase=(TMatrixTBase<double>*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEdoublegR),G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEdoublegR),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEdoublegR),G__get_linked_tagnum(&G__G__MatrixLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTLazylEdoublegR))) {
     TMatrixTLazy<double> *G__Lderived;
     G__Lderived=(TMatrixTLazy<double>*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTLazylEdoublegR),G__get_linked_tagnum(&G__G__MatrixLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTRowlEdoublegR))) {
     TMatrixTRow<double> *G__Lderived;
     G__Lderived=(TMatrixTRow<double>*)0x1000;
     {
       TMatrixTRow_const<double> *G__Lpbase=(TMatrixTRow_const<double>*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTRowlEdoublegR),G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTRow_constlEdoublegR),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTColumnlEdoublegR))) {
     TMatrixTColumn<double> *G__Lderived;
     G__Lderived=(TMatrixTColumn<double>*)0x1000;
     {
       TMatrixTColumn_const<double> *G__Lpbase=(TMatrixTColumn_const<double>*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTColumnlEdoublegR),G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTColumn_constlEdoublegR),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTDiaglEdoublegR))) {
     TMatrixTDiag<double> *G__Lderived;
     G__Lderived=(TMatrixTDiag<double>*)0x1000;
     {
       TMatrixTDiag_const<double> *G__Lpbase=(TMatrixTDiag_const<double>*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTDiaglEdoublegR),G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTDiag_constlEdoublegR),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTFlatlEdoublegR))) {
     TMatrixTFlat<double> *G__Lderived;
     G__Lderived=(TMatrixTFlat<double>*)0x1000;
     {
       TMatrixTFlat_const<double> *G__Lpbase=(TMatrixTFlat_const<double>*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTFlatlEdoublegR),G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTFlat_constlEdoublegR),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSublEdoublegR))) {
     TMatrixTSub<double> *G__Lderived;
     G__Lderived=(TMatrixTSub<double>*)0x1000;
     {
       TMatrixTSub_const<double> *G__Lpbase=(TMatrixTSub_const<double>*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSublEdoublegR),G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSub_constlEdoublegR),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparseRowlEdoublegR))) {
     TMatrixTSparseRow<double> *G__Lderived;
     G__Lderived=(TMatrixTSparseRow<double>*)0x1000;
     {
       TMatrixTSparseRow_const<double> *G__Lpbase=(TMatrixTSparseRow_const<double>*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparseRowlEdoublegR),G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparseRow_constlEdoublegR),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparseDiaglEdoublegR))) {
     TMatrixTSparseDiag<double> *G__Lderived;
     G__Lderived=(TMatrixTSparseDiag<double>*)0x1000;
     {
       TMatrixTSparseDiag_const<double> *G__Lpbase=(TMatrixTSparseDiag_const<double>*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparseDiaglEdoublegR),G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparseDiag_constlEdoublegR),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymLazylEdoublegR))) {
     TMatrixTSymLazy<double> *G__Lderived;
     G__Lderived=(TMatrixTSymLazy<double>*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymLazylEdoublegR),G__get_linked_tagnum(&G__G__MatrixLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR))) {
     TMatrixT<float> *G__Lderived;
     G__Lderived=(TMatrixT<float>*)0x1000;
     {
       TMatrixTBase<float> *G__Lpbase=(TMatrixTBase<float>*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR),G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEfloatgR),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR),G__get_linked_tagnum(&G__G__MatrixLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEfloatgR))) {
     TMatrixTSym<float> *G__Lderived;
     G__Lderived=(TMatrixTSym<float>*)0x1000;
     {
       TMatrixTBase<float> *G__Lpbase=(TMatrixTBase<float>*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEfloatgR),G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEfloatgR),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEfloatgR),G__get_linked_tagnum(&G__G__MatrixLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymLazylEfloatgR))) {
     TMatrixTSymLazy<float> *G__Lderived;
     G__Lderived=(TMatrixTSymLazy<float>*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymLazylEfloatgR),G__get_linked_tagnum(&G__G__MatrixLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTRowlEfloatgR))) {
     TMatrixTRow<float> *G__Lderived;
     G__Lderived=(TMatrixTRow<float>*)0x1000;
     {
       TMatrixTRow_const<float> *G__Lpbase=(TMatrixTRow_const<float>*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTRowlEfloatgR),G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTRow_constlEfloatgR),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEfloatgR))) {
     TMatrixTSparse<float> *G__Lderived;
     G__Lderived=(TMatrixTSparse<float>*)0x1000;
     {
       TMatrixTBase<float> *G__Lpbase=(TMatrixTBase<float>*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEfloatgR),G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEfloatgR),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEfloatgR),G__get_linked_tagnum(&G__G__MatrixLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparseRowlEfloatgR))) {
     TMatrixTSparseRow<float> *G__Lderived;
     G__Lderived=(TMatrixTSparseRow<float>*)0x1000;
     {
       TMatrixTSparseRow_const<float> *G__Lpbase=(TMatrixTSparseRow_const<float>*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparseRowlEfloatgR),G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparseRow_constlEfloatgR),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTLazylEfloatgR))) {
     TMatrixTLazy<float> *G__Lderived;
     G__Lderived=(TMatrixTLazy<float>*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTLazylEfloatgR),G__get_linked_tagnum(&G__G__MatrixLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MatrixLN_TDecompBase))) {
     TDecompBase *G__Lderived;
     G__Lderived=(TDecompBase*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MatrixLN_TDecompBase),G__get_linked_tagnum(&G__G__MatrixLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MatrixLN_TDecompBK))) {
     TDecompBK *G__Lderived;
     G__Lderived=(TDecompBK*)0x1000;
     {
       TDecompBase *G__Lpbase=(TDecompBase*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MatrixLN_TDecompBK),G__get_linked_tagnum(&G__G__MatrixLN_TDecompBase),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MatrixLN_TDecompBK),G__get_linked_tagnum(&G__G__MatrixLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MatrixLN_TDecompChol))) {
     TDecompChol *G__Lderived;
     G__Lderived=(TDecompChol*)0x1000;
     {
       TDecompBase *G__Lpbase=(TDecompBase*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MatrixLN_TDecompChol),G__get_linked_tagnum(&G__G__MatrixLN_TDecompBase),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MatrixLN_TDecompChol),G__get_linked_tagnum(&G__G__MatrixLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MatrixLN_TDecompLU))) {
     TDecompLU *G__Lderived;
     G__Lderived=(TDecompLU*)0x1000;
     {
       TDecompBase *G__Lpbase=(TDecompBase*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MatrixLN_TDecompLU),G__get_linked_tagnum(&G__G__MatrixLN_TDecompBase),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MatrixLN_TDecompLU),G__get_linked_tagnum(&G__G__MatrixLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MatrixLN_TDecompQRH))) {
     TDecompQRH *G__Lderived;
     G__Lderived=(TDecompQRH*)0x1000;
     {
       TDecompBase *G__Lpbase=(TDecompBase*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MatrixLN_TDecompQRH),G__get_linked_tagnum(&G__G__MatrixLN_TDecompBase),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MatrixLN_TDecompQRH),G__get_linked_tagnum(&G__G__MatrixLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MatrixLN_TDecompSparse))) {
     TDecompSparse *G__Lderived;
     G__Lderived=(TDecompSparse*)0x1000;
     {
       TDecompBase *G__Lpbase=(TDecompBase*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MatrixLN_TDecompSparse),G__get_linked_tagnum(&G__G__MatrixLN_TDecompBase),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MatrixLN_TDecompSparse),G__get_linked_tagnum(&G__G__MatrixLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MatrixLN_TDecompSVD))) {
     TDecompSVD *G__Lderived;
     G__Lderived=(TDecompSVD*)0x1000;
     {
       TDecompBase *G__Lpbase=(TDecompBase*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MatrixLN_TDecompSVD),G__get_linked_tagnum(&G__G__MatrixLN_TDecompBase),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MatrixLN_TDecompSVD),G__get_linked_tagnum(&G__G__MatrixLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MatrixLN_THaarMatrixTlEdoublegR))) {
     THaarMatrixT<double> *G__Lderived;
     G__Lderived=(THaarMatrixT<double>*)0x1000;
     {
       TMatrixTLazy<double> *G__Lpbase=(TMatrixTLazy<double>*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MatrixLN_THaarMatrixTlEdoublegR),G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTLazylEdoublegR),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MatrixLN_THaarMatrixTlEdoublegR),G__get_linked_tagnum(&G__G__MatrixLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MatrixLN_THilbertMatrixTlEdoublegR))) {
     THilbertMatrixT<double> *G__Lderived;
     G__Lderived=(THilbertMatrixT<double>*)0x1000;
     {
       TMatrixTLazy<double> *G__Lpbase=(TMatrixTLazy<double>*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MatrixLN_THilbertMatrixTlEdoublegR),G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTLazylEdoublegR),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MatrixLN_THilbertMatrixTlEdoublegR),G__get_linked_tagnum(&G__G__MatrixLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MatrixLN_THilbertMatrixTSymlEdoublegR))) {
     THilbertMatrixTSym<double> *G__Lderived;
     G__Lderived=(THilbertMatrixTSym<double>*)0x1000;
     {
       TMatrixTSymLazy<double> *G__Lpbase=(TMatrixTSymLazy<double>*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MatrixLN_THilbertMatrixTSymlEdoublegR),G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymLazylEdoublegR),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MatrixLN_THilbertMatrixTSymlEdoublegR),G__get_linked_tagnum(&G__G__MatrixLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTColumnlEfloatgR))) {
     TMatrixTColumn<float> *G__Lderived;
     G__Lderived=(TMatrixTColumn<float>*)0x1000;
     {
       TMatrixTColumn_const<float> *G__Lpbase=(TMatrixTColumn_const<float>*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTColumnlEfloatgR),G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTColumn_constlEfloatgR),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTDiaglEfloatgR))) {
     TMatrixTDiag<float> *G__Lderived;
     G__Lderived=(TMatrixTDiag<float>*)0x1000;
     {
       TMatrixTDiag_const<float> *G__Lpbase=(TMatrixTDiag_const<float>*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTDiaglEfloatgR),G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTDiag_constlEfloatgR),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTFlatlEfloatgR))) {
     TMatrixTFlat<float> *G__Lderived;
     G__Lderived=(TMatrixTFlat<float>*)0x1000;
     {
       TMatrixTFlat_const<float> *G__Lpbase=(TMatrixTFlat_const<float>*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTFlatlEfloatgR),G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTFlat_constlEfloatgR),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSublEfloatgR))) {
     TMatrixTSub<float> *G__Lderived;
     G__Lderived=(TMatrixTSub<float>*)0x1000;
     {
       TMatrixTSub_const<float> *G__Lpbase=(TMatrixTSub_const<float>*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSublEfloatgR),G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSub_constlEfloatgR),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparseDiaglEfloatgR))) {
     TMatrixTSparseDiag<float> *G__Lderived;
     G__Lderived=(TMatrixTSparseDiag<float>*)0x1000;
     {
       TMatrixTSparseDiag_const<float> *G__Lpbase=(TMatrixTSparseDiag_const<float>*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparseDiaglEfloatgR),G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparseDiag_constlEfloatgR),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MatrixLN_THaarMatrixTlEfloatgR))) {
     THaarMatrixT<float> *G__Lderived;
     G__Lderived=(THaarMatrixT<float>*)0x1000;
     {
       TMatrixTLazy<float> *G__Lpbase=(TMatrixTLazy<float>*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MatrixLN_THaarMatrixTlEfloatgR),G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTLazylEfloatgR),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MatrixLN_THaarMatrixTlEfloatgR),G__get_linked_tagnum(&G__G__MatrixLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MatrixLN_THilbertMatrixTlEfloatgR))) {
     THilbertMatrixT<float> *G__Lderived;
     G__Lderived=(THilbertMatrixT<float>*)0x1000;
     {
       TMatrixTLazy<float> *G__Lpbase=(TMatrixTLazy<float>*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MatrixLN_THilbertMatrixTlEfloatgR),G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTLazylEfloatgR),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MatrixLN_THilbertMatrixTlEfloatgR),G__get_linked_tagnum(&G__G__MatrixLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MatrixLN_THilbertMatrixTSymlEfloatgR))) {
     THilbertMatrixTSym<float> *G__Lderived;
     G__Lderived=(THilbertMatrixTSym<float>*)0x1000;
     {
       TMatrixTSymLazy<float> *G__Lpbase=(TMatrixTSymLazy<float>*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MatrixLN_THilbertMatrixTSymlEfloatgR),G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymLazylEfloatgR),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MatrixLN_THilbertMatrixTSymlEfloatgR),G__get_linked_tagnum(&G__G__MatrixLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
}

/*********************************************************
* typedef information setup/
*********************************************************/
extern "C" void G__cpp_setup_typetableG__Matrix() {

   /* Setting up typedef entry */
   G__search_typename2("Int_t",105,-1,0,-1);
   G__setnewtype(-1,"Signed integer 4 bytes (int)",0);
   G__search_typename2("Double_t",100,-1,0,-1);
   G__setnewtype(-1,"Double 8 bytes",0);
   G__search_typename2("Bool_t",103,-1,0,-1);
   G__setnewtype(-1,"Boolean (0=false, 1=true) (bool)",0);
   G__search_typename2("Version_t",115,-1,0,-1);
   G__setnewtype(-1,"Class version identifier (short)",0);
   G__search_typename2("Option_t",99,-1,256,-1);
   G__setnewtype(-1,"Option string (const char)",0);
   G__search_typename2("vector<ROOT::TSchemaHelper>",117,G__get_linked_tagnum(&G__G__MatrixLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__MatrixLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__MatrixLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__MatrixLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__MatrixLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TVirtualArray*>",117,G__get_linked_tagnum(&G__G__MatrixLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__MatrixLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__MatrixLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__MatrixLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__MatrixLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTBase<Float_t>",117,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTBase<Double_t>",117,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TVectorT<Float_t>",117,G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TVectorF",117,G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TVectorT<Double_t>",117,G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TVectorD",117,G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixT<Double_t>",117,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixD",117,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTRow_const<Double_t>",117,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTRow_constlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixDRow_const",117,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTRow_constlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTColumn_const<Double_t>",117,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTColumn_constlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixDColumn_const",117,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTColumn_constlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTDiag_const<Double_t>",117,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTDiag_constlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixDDiag_const",117,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTDiag_constlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTFlat_const<Double_t>",117,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTFlat_constlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixDFlat_const",117,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTFlat_constlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSub_const<Double_t>",117,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSub_constlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixDSub_const",117,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSub_constlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSparseRow_const<Double_t>",117,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparseRow_constlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixDSparseRow_const",117,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparseRow_constlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSparseDiag_const<Double_t>",117,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparseDiag_constlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixDSparseDiag_const",117,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparseDiag_constlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTRow<Double_t>",117,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTRowlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixDRow",117,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTRowlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTColumn<Double_t>",117,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTColumnlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixDColumn",117,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTColumnlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTDiag<Double_t>",117,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTDiaglEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixDDiag",117,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTDiaglEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTFlat<Double_t>",117,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTFlatlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixDFlat",117,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTFlatlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSub<Double_t>",117,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSublEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixDSub",117,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSublEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSparseRow<Double_t>",117,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparseRowlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixDSparseRow",117,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparseRowlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSparseDiag<Double_t>",117,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparseDiaglEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixDSparseDiag",117,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparseDiaglEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TElementActionT<Double_t>",117,G__get_linked_tagnum(&G__G__MatrixLN_TElementActionTlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TElementPosActionT<Double_t>",117,G__get_linked_tagnum(&G__G__MatrixLN_TElementPosActionTlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSym<Double_t>",117,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixDSym",117,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSparse<Double_t>",117,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixDSparse",117,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTLazy<Double_t>",117,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTLazylEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixDLazy",117,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTLazylEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSymLazy<Double_t>",117,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymLazylEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixDSymLazy",117,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymLazylEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("THaarMatrixT<Double_t>",117,G__get_linked_tagnum(&G__G__MatrixLN_THaarMatrixTlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("THaarMatrixD",117,G__get_linked_tagnum(&G__G__MatrixLN_THaarMatrixTlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("THilbertMatrixT<Double_t>",117,G__get_linked_tagnum(&G__G__MatrixLN_THilbertMatrixTlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("THilbertMatrixD",117,G__get_linked_tagnum(&G__G__MatrixLN_THilbertMatrixTlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("THilbertMatrixTSym<Double_t>",117,G__get_linked_tagnum(&G__G__MatrixLN_THilbertMatrixTSymlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("THilbertMatrixDSym",117,G__get_linked_tagnum(&G__G__MatrixLN_THilbertMatrixTSymlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixT<Float_t>",117,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixF",117,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTRow_const<Float_t>",117,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTRow_constlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixFRow_const",117,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTRow_constlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTColumn_const<Float_t>",117,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTColumn_constlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixFColumn_const",117,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTColumn_constlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTDiag_const<Float_t>",117,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTDiag_constlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixFDiag_const",117,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTDiag_constlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTFlat_const<Float_t>",117,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTFlat_constlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixFFlat_const",117,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTFlat_constlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSub_const<Float_t>",117,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSub_constlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixFSub_const",117,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSub_constlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSparseRow_const<Float_t>",117,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparseRow_constlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixFSparseRow_const",117,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparseRow_constlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSparseDiag_const<Float_t>",117,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparseDiag_constlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixFSparseDiag_const",117,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparseDiag_constlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTRow<Float_t>",117,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTRowlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixFRow",117,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTRowlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTColumn<Float_t>",117,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTColumnlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixFColumn",117,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTColumnlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTDiag<Float_t>",117,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTDiaglEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixFDiag",117,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTDiaglEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTFlat<Float_t>",117,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTFlatlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixFFlat",117,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTFlatlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSub<Float_t>",117,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSublEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixFSub",117,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSublEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSparseRow<Float_t>",117,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparseRowlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixFSparseRow",117,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparseRowlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSparseDiag<Float_t>",117,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparseDiaglEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixFSparseDiag",117,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparseDiaglEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TElementActionT<Float_t>",117,G__get_linked_tagnum(&G__G__MatrixLN_TElementActionTlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TElementPosActionT<Float_t>",117,G__get_linked_tagnum(&G__G__MatrixLN_TElementPosActionTlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTLazy<Float_t>",117,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTLazylEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixFLazy",117,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTLazylEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSymLazy<Float_t>",117,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymLazylEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixFSymLazy",117,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymLazylEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("THaarMatrixT<Float_t>",117,G__get_linked_tagnum(&G__G__MatrixLN_THaarMatrixTlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("THaarMatrixF",117,G__get_linked_tagnum(&G__G__MatrixLN_THaarMatrixTlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("THilbertMatrixT<Float_t>",117,G__get_linked_tagnum(&G__G__MatrixLN_THilbertMatrixTlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("THilbertMatrixF",117,G__get_linked_tagnum(&G__G__MatrixLN_THilbertMatrixTlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("THilbertMatrixTSym<Float_t>",117,G__get_linked_tagnum(&G__G__MatrixLN_THilbertMatrixTSymlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("THilbertMatrixFSym",117,G__get_linked_tagnum(&G__G__MatrixLN_THilbertMatrixTSymlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSparse<Float_t>",117,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixFSparse",117,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSym<Float_t>",117,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixFSym",117,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrix",117,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TVector",117,G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
}

/*********************************************************
* Data Member information setup/
*********************************************************/

   /* Setting up class,struct,union tag member variable */

   /* TMatrixTBase<float> */
static void G__setup_memvarTMatrixTBaselEfloatgR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEfloatgR));
   { TMatrixTBase<float> *p; p=(TMatrixTBase<float>*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNrows=",0,"number of rows");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNcols=",0,"number of columns");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fRowLwb=",0,"lower bound of the row index");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fColLwb=",0,"lower bound of the col index");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNelems=",0,"number of elements in matrix");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNrowIndex=",0,"length of row index array (= fNrows+1) wich is only used for sparse matrices");
   G__memvar_setup((void*)0,102,0,0,-1,-1,-1,2,"fTol=",0,"sqrt(epsilon); epsilon is smallest number number so that  1+epsilon > 1");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsOwner=",0,"!default kTRUE, when Use array kFALSE");
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEfloatgRcLcLdA),-1,-2,2,"kSizeMax=25LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEfloatgRcLcLdA),-1,-2,2,"kWorkMax=100LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEfloatgRcLcLEMatrixStatusBits),-1,-2,2,"kStatus=16384LL",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MatrixLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMatrixTBase<double> */
static void G__setup_memvarTMatrixTBaselEdoublegR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEdoublegR));
   { TMatrixTBase<double> *p; p=(TMatrixTBase<double>*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNrows=",0,"number of rows");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNcols=",0,"number of columns");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fRowLwb=",0,"lower bound of the row index");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fColLwb=",0,"lower bound of the col index");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNelems=",0,"number of elements in matrix");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNrowIndex=",0,"length of row index array (= fNrows+1) wich is only used for sparse matrices");
   G__memvar_setup((void*)0,100,0,0,-1,-1,-1,2,"fTol=",0,"sqrt(epsilon); epsilon is smallest number number so that  1+epsilon > 1");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsOwner=",0,"!default kTRUE, when Use array kFALSE");
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEdoublegRcLcLdA),-1,-2,2,"kSizeMax=25LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEdoublegRcLcLdA),-1,-2,2,"kWorkMax=100LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEdoublegRcLcLEMatrixStatusBits),-1,-2,2,"kStatus=16384LL",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MatrixLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TVectorT<float> */
static void G__setup_memvarTVectorTlEfloatgR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEfloatgR));
   { TVectorT<float> *p; p=(TVectorT<float>*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNrows=",0,"number of rows");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fRowLwb=",0,"lower bound of the row index");
   G__memvar_setup((void*)0,70,0,0,-1,-1,-1,2,"fElements=",0,"[fNrows] elements themselves");
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEfloatgRcLcLdA),-1,-2,2,"kSizeMax=5LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEfloatgRcLcLdA),-1,-2,2,"kWorkMax=100LL",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,-1,-1,2,"fDataStack[5]=",0,"! data container");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsOwner=",0,"!default kTRUE, when Use array kFALSE");
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEfloatgRcLcLEVectorStatusBits),-1,-2,2,"kStatus=16384LL",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MatrixLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TVectorT<double> */
static void G__setup_memvarTVectorTlEdoublegR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR));
   { TVectorT<double> *p; p=(TVectorT<double>*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNrows=",0,"number of rows");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fRowLwb=",0,"lower bound of the row index");
   G__memvar_setup((void*)0,68,0,0,-1,-1,-1,2,"fElements=",0,"[fNrows] elements themselves");
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegRcLcLdA),-1,-2,2,"kSizeMax=5LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegRcLcLdA),-1,-2,2,"kWorkMax=100LL",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,-1,-1,2,"fDataStack[5]=",0,"! data container");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsOwner=",0,"!default kTRUE, when Use array kFALSE");
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegRcLcLEVectorStatusBits),-1,-2,2,"kStatus=16384LL",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MatrixLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMatrixT<double> */
static void G__setup_memvarTMatrixTlEdoublegR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR));
   { TMatrixT<double> *p; p=(TMatrixT<double>*)0x1000; if (p) { }
   G__memvar_setup((void*)0,100,0,0,-1,-1,-1,2,"fDataStack[25]=",0,"! data container");
   G__memvar_setup((void*)0,68,0,0,-1,-1,-1,2,"fElements=",0,"[fNelems] elements themselves");
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegRcLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kWorkMax=%lldLL",(long long)TMatrixT<double>::kWorkMax).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegRcLcLEMatrixCreatorsOp1),-1,-2,1,G__FastAllocString(2048).Format("kZero=%lldLL",(long long)TMatrixT<double>::kZero).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegRcLcLEMatrixCreatorsOp1),-1,-2,1,G__FastAllocString(2048).Format("kUnit=%lldLL",(long long)TMatrixT<double>::kUnit).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegRcLcLEMatrixCreatorsOp1),-1,-2,1,G__FastAllocString(2048).Format("kTransposed=%lldLL",(long long)TMatrixT<double>::kTransposed).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegRcLcLEMatrixCreatorsOp1),-1,-2,1,G__FastAllocString(2048).Format("kInverted=%lldLL",(long long)TMatrixT<double>::kInverted).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegRcLcLEMatrixCreatorsOp1),-1,-2,1,G__FastAllocString(2048).Format("kAtA=%lldLL",(long long)TMatrixT<double>::kAtA).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegRcLcLEMatrixCreatorsOp2),-1,-2,1,G__FastAllocString(2048).Format("kMult=%lldLL",(long long)TMatrixT<double>::kMult).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegRcLcLEMatrixCreatorsOp2),-1,-2,1,G__FastAllocString(2048).Format("kTransposeMult=%lldLL",(long long)TMatrixT<double>::kTransposeMult).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegRcLcLEMatrixCreatorsOp2),-1,-2,1,G__FastAllocString(2048).Format("kInvMult=%lldLL",(long long)TMatrixT<double>::kInvMult).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegRcLcLEMatrixCreatorsOp2),-1,-2,1,G__FastAllocString(2048).Format("kMultTranspose=%lldLL",(long long)TMatrixT<double>::kMultTranspose).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegRcLcLEMatrixCreatorsOp2),-1,-2,1,G__FastAllocString(2048).Format("kPlus=%lldLL",(long long)TMatrixT<double>::kPlus).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegRcLcLEMatrixCreatorsOp2),-1,-2,1,G__FastAllocString(2048).Format("kMinus=%lldLL",(long long)TMatrixT<double>::kMinus).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MatrixLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMatrixTSym<double> */
static void G__setup_memvarTMatrixTSymlEdoublegR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEdoublegR));
   { TMatrixTSym<double> *p; p=(TMatrixTSym<double>*)0x1000; if (p) { }
   G__memvar_setup((void*)0,100,0,0,-1,-1,-1,2,"fDataStack[25]=",0,"! data container");
   G__memvar_setup((void*)0,68,0,0,-1,-1,-1,2,"fElements=",0,"[fNelems] elements themselves");
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEdoublegRcLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kWorkMax=%lldLL",(long long)TMatrixTSym<double>::kWorkMax).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEdoublegRcLcLEMatrixCreatorsOp1),-1,-2,1,G__FastAllocString(2048).Format("kZero=%lldLL",(long long)TMatrixTSym<double>::kZero).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEdoublegRcLcLEMatrixCreatorsOp1),-1,-2,1,G__FastAllocString(2048).Format("kUnit=%lldLL",(long long)TMatrixTSym<double>::kUnit).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEdoublegRcLcLEMatrixCreatorsOp1),-1,-2,1,G__FastAllocString(2048).Format("kTransposed=%lldLL",(long long)TMatrixTSym<double>::kTransposed).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEdoublegRcLcLEMatrixCreatorsOp1),-1,-2,1,G__FastAllocString(2048).Format("kInverted=%lldLL",(long long)TMatrixTSym<double>::kInverted).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEdoublegRcLcLEMatrixCreatorsOp1),-1,-2,1,G__FastAllocString(2048).Format("kAtA=%lldLL",(long long)TMatrixTSym<double>::kAtA).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEdoublegRcLcLEMatrixCreatorsOp2),-1,-2,1,G__FastAllocString(2048).Format("kPlus=%lldLL",(long long)TMatrixTSym<double>::kPlus).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEdoublegRcLcLEMatrixCreatorsOp2),-1,-2,1,G__FastAllocString(2048).Format("kMinus=%lldLL",(long long)TMatrixTSym<double>::kMinus).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MatrixLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMatrixTSparse<double> */
static void G__setup_memvarTMatrixTSparselEdoublegR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEdoublegR));
   { TMatrixTSparse<double> *p; p=(TMatrixTSparse<double>*)0x1000; if (p) { }
   G__memvar_setup((void*)0,73,0,0,-1,G__defined_typename("Int_t"),-1,2,"fRowIndex=",0,"[fNrowIndex] row index");
   G__memvar_setup((void*)0,73,0,0,-1,G__defined_typename("Int_t"),-1,2,"fColIndex=",0,"[fNelems]    column index");
   G__memvar_setup((void*)0,68,0,0,-1,-1,-1,2,"fElements=",0,"[fNelems]");
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEdoublegRcLcLEMatrixCreatorsOp1),-1,-2,1,G__FastAllocString(2048).Format("kZero=%lldLL",(long long)TMatrixTSparse<double>::kZero).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEdoublegRcLcLEMatrixCreatorsOp1),-1,-2,1,G__FastAllocString(2048).Format("kUnit=%lldLL",(long long)TMatrixTSparse<double>::kUnit).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEdoublegRcLcLEMatrixCreatorsOp1),-1,-2,1,G__FastAllocString(2048).Format("kTransposed=%lldLL",(long long)TMatrixTSparse<double>::kTransposed).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEdoublegRcLcLEMatrixCreatorsOp1),-1,-2,1,G__FastAllocString(2048).Format("kAtA=%lldLL",(long long)TMatrixTSparse<double>::kAtA).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEdoublegRcLcLEMatrixCreatorsOp2),-1,-2,1,G__FastAllocString(2048).Format("kMult=%lldLL",(long long)TMatrixTSparse<double>::kMult).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEdoublegRcLcLEMatrixCreatorsOp2),-1,-2,1,G__FastAllocString(2048).Format("kMultTranspose=%lldLL",(long long)TMatrixTSparse<double>::kMultTranspose).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEdoublegRcLcLEMatrixCreatorsOp2),-1,-2,1,G__FastAllocString(2048).Format("kPlus=%lldLL",(long long)TMatrixTSparse<double>::kPlus).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEdoublegRcLcLEMatrixCreatorsOp2),-1,-2,1,G__FastAllocString(2048).Format("kMinus=%lldLL",(long long)TMatrixTSparse<double>::kMinus).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MatrixLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMatrixTLazy<double> */
static void G__setup_memvarTMatrixTLazylEdoublegR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTLazylEdoublegR));
   { TMatrixTLazy<double> *p; p=(TMatrixTLazy<double>*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fRowUpb=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fRowLwb=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fColUpb=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fColLwb=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MatrixLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMatrixTRow_const<double> */
static void G__setup_memvarTMatrixTRow_constlEdoublegR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTRow_constlEdoublegR));
   { TMatrixTRow_const<double> *p; p=(TMatrixTRow_const<double>*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEdoublegR),-1,-1,2,"fMatrix=",0,"the matrix I am a row of");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fRowInd=",0,"effective row index");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fInc=",0,"if ptr = @a[row,i], then ptr+inc = @a[row,i+1]");
   G__memvar_setup((void*)0,68,0,1,-1,-1,-1,2,"fPtr=",0,"pointer to the a[row,0]");
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MatrixLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMatrixTRow<double> */
static void G__setup_memvarTMatrixTRowlEdoublegR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTRowlEdoublegR));
   { TMatrixTRow<double> *p; p=(TMatrixTRow<double>*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MatrixLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMatrixTDiag_const<double> */
static void G__setup_memvarTMatrixTDiag_constlEdoublegR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTDiag_constlEdoublegR));
   { TMatrixTDiag_const<double> *p; p=(TMatrixTDiag_const<double>*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEdoublegR),-1,-1,2,"fMatrix=",0,"the matrix I am the diagonal of");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fInc=",0,"if ptr=@a[i,i], then ptr+inc = @a[i+1,i+1]");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNdiag=",0,"number of diag elems, min(nrows,ncols)");
   G__memvar_setup((void*)0,68,0,1,-1,-1,-1,2,"fPtr=",0,"pointer to the a[0,0]");
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MatrixLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMatrixTColumn_const<double> */
static void G__setup_memvarTMatrixTColumn_constlEdoublegR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTColumn_constlEdoublegR));
   { TMatrixTColumn_const<double> *p; p=(TMatrixTColumn_const<double>*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEdoublegR),-1,-1,2,"fMatrix=",0,"the matrix I am a column of");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fColInd=",0,"effective column index");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fInc=",0,"if ptr = @a[i,col], then ptr+inc = @a[i+1,col]");
   G__memvar_setup((void*)0,68,0,1,-1,-1,-1,2,"fPtr=",0,"pointer to the a[0,col] column");
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MatrixLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMatrixTFlat_const<double> */
static void G__setup_memvarTMatrixTFlat_constlEdoublegR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTFlat_constlEdoublegR));
   { TMatrixTFlat_const<double> *p; p=(TMatrixTFlat_const<double>*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEdoublegR),-1,-1,2,"fMatrix=",0,"the matrix I am the diagonal of");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNelems=",0,(char*)NULL);
   G__memvar_setup((void*)0,68,0,1,-1,-1,-1,2,"fPtr=",0,"pointer to the a[0,0]");
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MatrixLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMatrixTSub_const<double> */
static void G__setup_memvarTMatrixTSub_constlEdoublegR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSub_constlEdoublegR));
   { TMatrixTSub_const<double> *p; p=(TMatrixTSub_const<double>*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEdoublegR),-1,-1,2,"fMatrix=",0,"the matrix I am a submatrix of");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fRowOff=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fColOff=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNrowsSub=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNcolsSub=",0,(char*)NULL);
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MatrixLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMatrixTSparseRow_const<double> */
static void G__setup_memvarTMatrixTSparseRow_constlEdoublegR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparseRow_constlEdoublegR));
   { TMatrixTSparseRow_const<double> *p; p=(TMatrixTSparseRow_const<double>*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEdoublegR),-1,-1,2,"fMatrix=",0,"the matrix I am a row of");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fRowInd=",0,"effective row index");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNindex=",0,"index range");
   G__memvar_setup((void*)0,73,0,1,-1,G__defined_typename("Int_t"),-1,2,"fColPtr=",0,"column index pointer");
   G__memvar_setup((void*)0,68,0,1,-1,-1,-1,2,"fDataPtr=",0,"data pointer");
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MatrixLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMatrixTSparseDiag_const<double> */
static void G__setup_memvarTMatrixTSparseDiag_constlEdoublegR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparseDiag_constlEdoublegR));
   { TMatrixTSparseDiag_const<double> *p; p=(TMatrixTSparseDiag_const<double>*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEdoublegR),-1,-1,2,"fMatrix=",0,"the matrix I am the diagonal of");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNdiag=",0,"number of diag elems, min(nrows,ncols)");
   G__memvar_setup((void*)0,68,0,1,-1,-1,-1,2,"fDataPtr=",0,"data pointer");
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MatrixLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMatrixTColumn<double> */
static void G__setup_memvarTMatrixTColumnlEdoublegR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTColumnlEdoublegR));
   { TMatrixTColumn<double> *p; p=(TMatrixTColumn<double>*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MatrixLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMatrixTDiag<double> */
static void G__setup_memvarTMatrixTDiaglEdoublegR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTDiaglEdoublegR));
   { TMatrixTDiag<double> *p; p=(TMatrixTDiag<double>*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MatrixLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMatrixTFlat<double> */
static void G__setup_memvarTMatrixTFlatlEdoublegR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTFlatlEdoublegR));
   { TMatrixTFlat<double> *p; p=(TMatrixTFlat<double>*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MatrixLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMatrixTSub<double> */
static void G__setup_memvarTMatrixTSublEdoublegR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSublEdoublegR));
   { TMatrixTSub<double> *p; p=(TMatrixTSub<double>*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSublEdoublegRcLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kWorkMax=%lldLL",(long long)TMatrixTSub<double>::kWorkMax).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MatrixLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMatrixTSparseRow<double> */
static void G__setup_memvarTMatrixTSparseRowlEdoublegR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparseRowlEdoublegR));
   { TMatrixTSparseRow<double> *p; p=(TMatrixTSparseRow<double>*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MatrixLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMatrixTSparseDiag<double> */
static void G__setup_memvarTMatrixTSparseDiaglEdoublegR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparseDiaglEdoublegR));
   { TMatrixTSparseDiag<double> *p; p=(TMatrixTSparseDiag<double>*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MatrixLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMatrixTSymLazy<double> */
static void G__setup_memvarTMatrixTSymLazylEdoublegR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymLazylEdoublegR));
   { TMatrixTSymLazy<double> *p; p=(TMatrixTSymLazy<double>*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fRowUpb=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fRowLwb=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MatrixLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMatrixTRow_const<float> */
static void G__setup_memvarTMatrixTRow_constlEfloatgR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTRow_constlEfloatgR));
   { TMatrixTRow_const<float> *p; p=(TMatrixTRow_const<float>*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEfloatgR),-1,-1,2,"fMatrix=",0,"the matrix I am a row of");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fRowInd=",0,"effective row index");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fInc=",0,"if ptr = @a[row,i], then ptr+inc = @a[row,i+1]");
   G__memvar_setup((void*)0,70,0,1,-1,-1,-1,2,"fPtr=",0,"pointer to the a[row,0]");
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MatrixLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMatrixT<float> */
static void G__setup_memvarTMatrixTlEfloatgR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR));
   { TMatrixT<float> *p; p=(TMatrixT<float>*)0x1000; if (p) { }
   G__memvar_setup((void*)0,102,0,0,-1,-1,-1,2,"fDataStack[25]=",0,"! data container");
   G__memvar_setup((void*)0,70,0,0,-1,-1,-1,2,"fElements=",0,"[fNelems] elements themselves");
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgRcLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kWorkMax=%lldLL",(long long)TMatrixT<float>::kWorkMax).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgRcLcLEMatrixCreatorsOp1),-1,-2,1,G__FastAllocString(2048).Format("kZero=%lldLL",(long long)TMatrixT<float>::kZero).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgRcLcLEMatrixCreatorsOp1),-1,-2,1,G__FastAllocString(2048).Format("kUnit=%lldLL",(long long)TMatrixT<float>::kUnit).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgRcLcLEMatrixCreatorsOp1),-1,-2,1,G__FastAllocString(2048).Format("kTransposed=%lldLL",(long long)TMatrixT<float>::kTransposed).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgRcLcLEMatrixCreatorsOp1),-1,-2,1,G__FastAllocString(2048).Format("kInverted=%lldLL",(long long)TMatrixT<float>::kInverted).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgRcLcLEMatrixCreatorsOp1),-1,-2,1,G__FastAllocString(2048).Format("kAtA=%lldLL",(long long)TMatrixT<float>::kAtA).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgRcLcLEMatrixCreatorsOp2),-1,-2,1,G__FastAllocString(2048).Format("kMult=%lldLL",(long long)TMatrixT<float>::kMult).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgRcLcLEMatrixCreatorsOp2),-1,-2,1,G__FastAllocString(2048).Format("kTransposeMult=%lldLL",(long long)TMatrixT<float>::kTransposeMult).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgRcLcLEMatrixCreatorsOp2),-1,-2,1,G__FastAllocString(2048).Format("kInvMult=%lldLL",(long long)TMatrixT<float>::kInvMult).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgRcLcLEMatrixCreatorsOp2),-1,-2,1,G__FastAllocString(2048).Format("kMultTranspose=%lldLL",(long long)TMatrixT<float>::kMultTranspose).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgRcLcLEMatrixCreatorsOp2),-1,-2,1,G__FastAllocString(2048).Format("kPlus=%lldLL",(long long)TMatrixT<float>::kPlus).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgRcLcLEMatrixCreatorsOp2),-1,-2,1,G__FastAllocString(2048).Format("kMinus=%lldLL",(long long)TMatrixT<float>::kMinus).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MatrixLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMatrixTSym<float> */
static void G__setup_memvarTMatrixTSymlEfloatgR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEfloatgR));
   { TMatrixTSym<float> *p; p=(TMatrixTSym<float>*)0x1000; if (p) { }
   G__memvar_setup((void*)0,102,0,0,-1,-1,-1,2,"fDataStack[25]=",0,"! data container");
   G__memvar_setup((void*)0,70,0,0,-1,-1,-1,2,"fElements=",0,"[fNelems] elements themselves");
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEfloatgRcLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kWorkMax=%lldLL",(long long)TMatrixTSym<float>::kWorkMax).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEfloatgRcLcLEMatrixCreatorsOp1),-1,-2,1,G__FastAllocString(2048).Format("kZero=%lldLL",(long long)TMatrixTSym<float>::kZero).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEfloatgRcLcLEMatrixCreatorsOp1),-1,-2,1,G__FastAllocString(2048).Format("kUnit=%lldLL",(long long)TMatrixTSym<float>::kUnit).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEfloatgRcLcLEMatrixCreatorsOp1),-1,-2,1,G__FastAllocString(2048).Format("kTransposed=%lldLL",(long long)TMatrixTSym<float>::kTransposed).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEfloatgRcLcLEMatrixCreatorsOp1),-1,-2,1,G__FastAllocString(2048).Format("kInverted=%lldLL",(long long)TMatrixTSym<float>::kInverted).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEfloatgRcLcLEMatrixCreatorsOp1),-1,-2,1,G__FastAllocString(2048).Format("kAtA=%lldLL",(long long)TMatrixTSym<float>::kAtA).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEfloatgRcLcLEMatrixCreatorsOp2),-1,-2,1,G__FastAllocString(2048).Format("kPlus=%lldLL",(long long)TMatrixTSym<float>::kPlus).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEfloatgRcLcLEMatrixCreatorsOp2),-1,-2,1,G__FastAllocString(2048).Format("kMinus=%lldLL",(long long)TMatrixTSym<float>::kMinus).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MatrixLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMatrixTSymLazy<float> */
static void G__setup_memvarTMatrixTSymLazylEfloatgR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymLazylEfloatgR));
   { TMatrixTSymLazy<float> *p; p=(TMatrixTSymLazy<float>*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fRowUpb=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fRowLwb=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MatrixLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMatrixTRow<float> */
static void G__setup_memvarTMatrixTRowlEfloatgR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTRowlEfloatgR));
   { TMatrixTRow<float> *p; p=(TMatrixTRow<float>*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MatrixLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMatrixTSparse<float> */
static void G__setup_memvarTMatrixTSparselEfloatgR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEfloatgR));
   { TMatrixTSparse<float> *p; p=(TMatrixTSparse<float>*)0x1000; if (p) { }
   G__memvar_setup((void*)0,73,0,0,-1,G__defined_typename("Int_t"),-1,2,"fRowIndex=",0,"[fNrowIndex] row index");
   G__memvar_setup((void*)0,73,0,0,-1,G__defined_typename("Int_t"),-1,2,"fColIndex=",0,"[fNelems]    column index");
   G__memvar_setup((void*)0,70,0,0,-1,-1,-1,2,"fElements=",0,"[fNelems]");
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEfloatgRcLcLEMatrixCreatorsOp1),-1,-2,1,G__FastAllocString(2048).Format("kZero=%lldLL",(long long)TMatrixTSparse<float>::kZero).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEfloatgRcLcLEMatrixCreatorsOp1),-1,-2,1,G__FastAllocString(2048).Format("kUnit=%lldLL",(long long)TMatrixTSparse<float>::kUnit).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEfloatgRcLcLEMatrixCreatorsOp1),-1,-2,1,G__FastAllocString(2048).Format("kTransposed=%lldLL",(long long)TMatrixTSparse<float>::kTransposed).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEfloatgRcLcLEMatrixCreatorsOp1),-1,-2,1,G__FastAllocString(2048).Format("kAtA=%lldLL",(long long)TMatrixTSparse<float>::kAtA).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEfloatgRcLcLEMatrixCreatorsOp2),-1,-2,1,G__FastAllocString(2048).Format("kMult=%lldLL",(long long)TMatrixTSparse<float>::kMult).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEfloatgRcLcLEMatrixCreatorsOp2),-1,-2,1,G__FastAllocString(2048).Format("kMultTranspose=%lldLL",(long long)TMatrixTSparse<float>::kMultTranspose).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEfloatgRcLcLEMatrixCreatorsOp2),-1,-2,1,G__FastAllocString(2048).Format("kPlus=%lldLL",(long long)TMatrixTSparse<float>::kPlus).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEfloatgRcLcLEMatrixCreatorsOp2),-1,-2,1,G__FastAllocString(2048).Format("kMinus=%lldLL",(long long)TMatrixTSparse<float>::kMinus).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MatrixLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMatrixTSparseRow_const<float> */
static void G__setup_memvarTMatrixTSparseRow_constlEfloatgR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparseRow_constlEfloatgR));
   { TMatrixTSparseRow_const<float> *p; p=(TMatrixTSparseRow_const<float>*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEfloatgR),-1,-1,2,"fMatrix=",0,"the matrix I am a row of");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fRowInd=",0,"effective row index");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNindex=",0,"index range");
   G__memvar_setup((void*)0,73,0,1,-1,G__defined_typename("Int_t"),-1,2,"fColPtr=",0,"column index pointer");
   G__memvar_setup((void*)0,70,0,1,-1,-1,-1,2,"fDataPtr=",0,"data pointer");
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MatrixLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMatrixTSparseRow<float> */
static void G__setup_memvarTMatrixTSparseRowlEfloatgR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparseRowlEfloatgR));
   { TMatrixTSparseRow<float> *p; p=(TMatrixTSparseRow<float>*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MatrixLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMatrixTLazy<float> */
static void G__setup_memvarTMatrixTLazylEfloatgR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTLazylEfloatgR));
   { TMatrixTLazy<float> *p; p=(TMatrixTLazy<float>*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fRowUpb=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fRowLwb=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fColUpb=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fColLwb=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MatrixLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMatrixTDiag_const<float> */
static void G__setup_memvarTMatrixTDiag_constlEfloatgR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTDiag_constlEfloatgR));
   { TMatrixTDiag_const<float> *p; p=(TMatrixTDiag_const<float>*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEfloatgR),-1,-1,2,"fMatrix=",0,"the matrix I am the diagonal of");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fInc=",0,"if ptr=@a[i,i], then ptr+inc = @a[i+1,i+1]");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNdiag=",0,"number of diag elems, min(nrows,ncols)");
   G__memvar_setup((void*)0,70,0,1,-1,-1,-1,2,"fPtr=",0,"pointer to the a[0,0]");
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MatrixLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMatrixTColumn_const<float> */
static void G__setup_memvarTMatrixTColumn_constlEfloatgR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTColumn_constlEfloatgR));
   { TMatrixTColumn_const<float> *p; p=(TMatrixTColumn_const<float>*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEfloatgR),-1,-1,2,"fMatrix=",0,"the matrix I am a column of");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fColInd=",0,"effective column index");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fInc=",0,"if ptr = @a[i,col], then ptr+inc = @a[i+1,col]");
   G__memvar_setup((void*)0,70,0,1,-1,-1,-1,2,"fPtr=",0,"pointer to the a[0,col] column");
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MatrixLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMatrixTSparseDiag_const<float> */
static void G__setup_memvarTMatrixTSparseDiag_constlEfloatgR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparseDiag_constlEfloatgR));
   { TMatrixTSparseDiag_const<float> *p; p=(TMatrixTSparseDiag_const<float>*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEfloatgR),-1,-1,2,"fMatrix=",0,"the matrix I am the diagonal of");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNdiag=",0,"number of diag elems, min(nrows,ncols)");
   G__memvar_setup((void*)0,70,0,1,-1,-1,-1,2,"fDataPtr=",0,"data pointer");
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MatrixLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TDecompBase */
static void G__setup_memvarTDecompBase(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MatrixLN_TDecompBase));
   { TDecompBase *p; p=(TDecompBase*)0x1000; if (p) { }
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fTol=",0,"sqrt(epsilon); epsilon is smallest number number so that  1+epsilon > 1");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fDet1=",0,"determinant mantissa");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fDet2=",0,"determinant exponent for powers of 2");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fCondition=",0,"matrix condition number");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fRowLwb=",0,"Row    lower bound of decomposed matrix");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fColLwb=",0,"Column lower bound of decomposed matrix");
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MatrixLN_TDecompBasecLcLEMatrixDecompStat),-1,-2,2,"kInit=16384LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MatrixLN_TDecompBasecLcLEMatrixDecompStat),-1,-2,2,"kPatternSet=32768LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MatrixLN_TDecompBasecLcLEMatrixDecompStat),-1,-2,2,"kValuesSet=65536LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MatrixLN_TDecompBasecLcLEMatrixDecompStat),-1,-2,2,"kMatrixSet=131072LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MatrixLN_TDecompBasecLcLEMatrixDecompStat),-1,-2,2,"kDecomposed=262144LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MatrixLN_TDecompBasecLcLEMatrixDecompStat),-1,-2,2,"kDetermined=524288LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MatrixLN_TDecompBasecLcLEMatrixDecompStat),-1,-2,2,"kCondition=1048576LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MatrixLN_TDecompBasecLcLEMatrixDecompStat),-1,-2,2,"kSingular=2097152LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MatrixLN_TDecompBasecLcLdA),-1,-2,2,"kWorkMax=100LL",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MatrixLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TDecompBK */
static void G__setup_memvarTDecompBK(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MatrixLN_TDecompBK));
   { TDecompBK *p; p=(TDecompBK*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNIpiv=",0,"size of row permutation index");
   G__memvar_setup((void*)0,73,0,0,-1,G__defined_typename("Int_t"),-1,2,"fIpiv=",0,"[fNIpiv] row permutation index");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR),G__defined_typename("TMatrixD"),-1,2,"fU=",0,"decomposed matrix so that a = u d u^T");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MatrixLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TDecompChol */
static void G__setup_memvarTDecompChol(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MatrixLN_TDecompChol));
   { TDecompChol *p; p=(TDecompChol*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR),G__defined_typename("TMatrixD"),-1,2,"fU=",0,"decomposed matrix fU so that a = fU^T fU");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MatrixLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TDecompLU */
static void G__setup_memvarTDecompLU(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MatrixLN_TDecompLU));
   { TDecompLU *p; p=(TDecompLU*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fImplicitPivot=",0,"control to determine implicit row scale before");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNIndex=",0,"size of row permutation index");
   G__memvar_setup((void*)0,73,0,0,-1,G__defined_typename("Int_t"),-1,2,"fIndex=",0,"[fNIndex] row permutation index");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fSign=",0,"= +/- 1 reflecting even/odd row permutations, resp.");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR),G__defined_typename("TMatrixD"),-1,2,"fLU=",0,"decomposed matrix so that a = l u where");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MatrixLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TDecompQRH */
static void G__setup_memvarTDecompQRH(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MatrixLN_TDecompQRH));
   { TDecompQRH *p; p=(TDecompQRH*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR),G__defined_typename("TMatrixD"),-1,2,"fQ=",0,"(m x n) - orthogonal matrix");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR),G__defined_typename("TMatrixD"),-1,2,"fR=",0,"(n x n) - upper triangular matrix");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR),G__defined_typename("TVectorD"),-1,2,"fUp=",0,"(n) - vector with Householder up's");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR),G__defined_typename("TVectorD"),-1,2,"fW=",0,"(n) - vector with Householder beta's");
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MatrixLN_TDecompQRHcLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kWorkMax=%lldLL",(long long)TDecompQRH::kWorkMax).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MatrixLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TDecompSparse */
static void G__setup_memvarTDecompSparse(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MatrixLN_TDecompSparse));
   { TDecompSparse *p; p=(TDecompSparse*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fVerbose=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fIcntl[31]=",0,"integer control numbers");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fCntl[6]=",0,"float control numbers");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fInfo[21]=",0,"array used for communication between programs");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fPrecision=",0,"precision we demand from the linear system solver. If it isn't");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MatrixLN_TArrayI),-1,-1,2,"fIkeep=",0,"pivot sequence and temporary storage information");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MatrixLN_TArrayI),-1,-1,2,"fIw=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MatrixLN_TArrayI),-1,-1,2,"fIw1=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MatrixLN_TArrayI),-1,-1,2,"fIw2=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNsteps=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fMaxfrt=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MatrixLN_TArrayD),-1,-1,2,"fW=",0,"temporary storage for the factorization");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fIPessimism=",0,"amounts by which to increase allocated factorization space when");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fRPessimism=",0,"inadequate space is detected. fIPessimism is for array \"fIw\",");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEdoublegR),G__defined_typename("TMatrixDSparse"),-1,2,"fA=",0,"original matrix; needed for the iterative solving procedure");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNrows=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNnonZeros=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MatrixLN_TArrayD),-1,-1,2,"fFact=",0,"size of fFact array; may be increased during the numerical factorization");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MatrixLN_TArrayI),-1,-1,2,"fRowFact=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MatrixLN_TArrayI),-1,-1,2,"fColFact=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MatrixLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TDecompSVD */
static void G__setup_memvarTDecompSVD(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MatrixLN_TDecompSVD));
   { TDecompSVD *p; p=(TDecompSVD*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR),G__defined_typename("TMatrixD"),-1,2,"fU=",0,"orthogonal matrix");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR),G__defined_typename("TMatrixD"),-1,2,"fV=",0,"orthogonal matrix");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR),G__defined_typename("TVectorD"),-1,2,"fSig=",0,"diagonal of diagonal matrix");
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MatrixLN_TDecompSVDcLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kWorkMax=%lldLL",(long long)TDecompSVD::kWorkMax).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MatrixLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMatrixDEigen */
static void G__setup_memvarTMatrixDEigen(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixDEigen));
   { TMatrixDEigen *p; p=(TMatrixDEigen*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR),G__defined_typename("TMatrixD"),-1,2,"fEigenVectors=",0,"Eigen-vectors of matrix");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR),G__defined_typename("TVectorD"),-1,2,"fEigenValuesRe=",0,"Eigen-values");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR),G__defined_typename("TVectorD"),-1,2,"fEigenValuesIm=",0,"Eigen-values");
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixDEigencLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kWorkMax=%lldLL",(long long)TMatrixDEigen::kWorkMax).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MatrixLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* THaarMatrixT<double> */
static void G__setup_memvarTHaarMatrixTlEdoublegR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MatrixLN_THaarMatrixTlEdoublegR));
   { THaarMatrixT<double> *p; p=(THaarMatrixT<double>*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MatrixLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* THilbertMatrixT<double> */
static void G__setup_memvarTHilbertMatrixTlEdoublegR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MatrixLN_THilbertMatrixTlEdoublegR));
   { THilbertMatrixT<double> *p; p=(THilbertMatrixT<double>*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MatrixLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* THilbertMatrixTSym<double> */
static void G__setup_memvarTHilbertMatrixTSymlEdoublegR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MatrixLN_THilbertMatrixTSymlEdoublegR));
   { THilbertMatrixTSym<double> *p; p=(THilbertMatrixTSym<double>*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MatrixLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMatrixDSymEigen */
static void G__setup_memvarTMatrixDSymEigen(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixDSymEigen));
   { TMatrixDSymEigen *p; p=(TMatrixDSymEigen*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR),G__defined_typename("TMatrixD"),-1,2,"fEigenVectors=",0,"Eigen-vectors of matrix");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR),G__defined_typename("TVectorD"),-1,2,"fEigenValues=",0,"Eigen-values");
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixDSymEigencLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kWorkMax=%lldLL",(long long)TMatrixDSymEigen::kWorkMax).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MatrixLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMatrixTFlat_const<float> */
static void G__setup_memvarTMatrixTFlat_constlEfloatgR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTFlat_constlEfloatgR));
   { TMatrixTFlat_const<float> *p; p=(TMatrixTFlat_const<float>*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEfloatgR),-1,-1,2,"fMatrix=",0,"the matrix I am the diagonal of");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNelems=",0,(char*)NULL);
   G__memvar_setup((void*)0,70,0,1,-1,-1,-1,2,"fPtr=",0,"pointer to the a[0,0]");
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MatrixLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMatrixTSub_const<float> */
static void G__setup_memvarTMatrixTSub_constlEfloatgR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSub_constlEfloatgR));
   { TMatrixTSub_const<float> *p; p=(TMatrixTSub_const<float>*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEfloatgR),-1,-1,2,"fMatrix=",0,"the matrix I am a submatrix of");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fRowOff=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fColOff=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNrowsSub=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNcolsSub=",0,(char*)NULL);
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MatrixLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMatrixTColumn<float> */
static void G__setup_memvarTMatrixTColumnlEfloatgR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTColumnlEfloatgR));
   { TMatrixTColumn<float> *p; p=(TMatrixTColumn<float>*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MatrixLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMatrixTDiag<float> */
static void G__setup_memvarTMatrixTDiaglEfloatgR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTDiaglEfloatgR));
   { TMatrixTDiag<float> *p; p=(TMatrixTDiag<float>*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MatrixLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMatrixTFlat<float> */
static void G__setup_memvarTMatrixTFlatlEfloatgR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTFlatlEfloatgR));
   { TMatrixTFlat<float> *p; p=(TMatrixTFlat<float>*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MatrixLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMatrixTSub<float> */
static void G__setup_memvarTMatrixTSublEfloatgR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSublEfloatgR));
   { TMatrixTSub<float> *p; p=(TMatrixTSub<float>*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSublEfloatgRcLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kWorkMax=%lldLL",(long long)TMatrixTSub<float>::kWorkMax).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MatrixLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMatrixTSparseDiag<float> */
static void G__setup_memvarTMatrixTSparseDiaglEfloatgR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparseDiaglEfloatgR));
   { TMatrixTSparseDiag<float> *p; p=(TMatrixTSparseDiag<float>*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MatrixLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* THaarMatrixT<float> */
static void G__setup_memvarTHaarMatrixTlEfloatgR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MatrixLN_THaarMatrixTlEfloatgR));
   { THaarMatrixT<float> *p; p=(THaarMatrixT<float>*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MatrixLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* THilbertMatrixT<float> */
static void G__setup_memvarTHilbertMatrixTlEfloatgR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MatrixLN_THilbertMatrixTlEfloatgR));
   { THilbertMatrixT<float> *p; p=(THilbertMatrixT<float>*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MatrixLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* THilbertMatrixTSym<float> */
static void G__setup_memvarTHilbertMatrixTSymlEfloatgR(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MatrixLN_THilbertMatrixTSymlEfloatgR));
   { THilbertMatrixTSym<float> *p; p=(THilbertMatrixTSym<float>*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MatrixLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMatrixTCramerInv */
static void G__setup_memvarTMatrixTCramerInv(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTCramerInv));
   {
   }
   G__tag_memvar_reset();
}


   /* TMatrixTSymCramerInv */
static void G__setup_memvarTMatrixTSymCramerInv(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymCramerInv));
   {
   }
   G__tag_memvar_reset();
}

extern "C" void G__cpp_setup_memvarG__Matrix() {
}
/***********************************************************
************************************************************
************************************************************
************************************************************
************************************************************
************************************************************
************************************************************
***********************************************************/

/*********************************************************
* Member function information setup for each class
*********************************************************/
static void G__setup_memfuncTMatrixTBaselEfloatgR(void) {
   /* TMatrixTBase<float> */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEfloatgR));
   G__memfunc_setup("GetElements",1117,(G__InterfaceMethod) NULL, 70, -1, -1, 0, 0, 1, 4, 0, "", "This function is now obsolete (and is not implemented) you should use TMatrix::GetMatrixArray().", (void*) NULL, 0);
   G__memfunc_setup("DoubleLexSort",1324,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 4, 3, 2, 0, 
"i - 'Int_t' 0 - n I - 'Int_t' 0 - first "
"I - 'Int_t' 0 - second F - - 0 - data", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IndexedLexSort",1426,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 6, 3, 2, 0, 
"i - 'Int_t' 0 - n I - 'Int_t' 0 - first "
"i - 'Int_t' 0 - swapFirst I - 'Int_t' 0 - second "
"i - 'Int_t' 0 - swapSecond I - 'Int_t' 0 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRowLwb",893,G__G__Matrix_110_0_5, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRowUpb",895,G__G__Matrix_110_0_6, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNrows",825,G__G__Matrix_110_0_7, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetColLwb",867,G__G__Matrix_110_0_8, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetColUpb",869,G__G__Matrix_110_0_9, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNcols",799,G__G__Matrix_110_0_10, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNoElements",1306,G__G__Matrix_110_0_11, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTol",591,G__G__Matrix_110_0_12, 102, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMatrixArray",1428,G__G__Matrix_110_0_13, 70, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetMatrixArray",1428,G__G__Matrix_110_0_14, 70, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetRowIndexArray",1615,G__G__Matrix_110_0_15, 73, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetRowIndexArray",1615,G__G__Matrix_110_0_16, 73, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetColIndexArray",1589,G__G__Matrix_110_0_17, 73, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetColIndexArray",1589,G__G__Matrix_110_0_18, 73, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetRowIndexArray",1627,G__G__Matrix_110_0_19, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEfloatgR), -1, 1, 1, 1, 1, 0, "I - 'Int_t' 0 - data", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetColIndexArray",1601,G__G__Matrix_110_0_20, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEfloatgR), -1, 1, 1, 1, 1, 0, "I - 'Int_t' 0 - data", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetMatrixArray",1440,G__G__Matrix_110_0_21, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEfloatgR), -1, 1, 2, 1, 1, 0, 
"F - - 10 - data C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTol",603,G__G__Matrix_110_0_22, 102, -1, -1, 0, 1, 1, 1, 0, "f - - 0 - newTol", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Clear",487,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Invalidate",1025,G__G__Matrix_110_0_24, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeValid",878,G__G__Matrix_110_0_25, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsValid",684,G__G__Matrix_110_0_26, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsOwner",711,G__G__Matrix_110_0_27, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsSymmetric",1145,G__G__Matrix_110_0_28, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetSub",586,G__G__Matrix_110_0_29, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEfloatgR), -1, 1, 6, 1, 1, 8, 
"i - 'Int_t' 0 - row_lwb i - 'Int_t' 0 - row_upb "
"i - 'Int_t' 0 - col_lwb i - 'Int_t' 0 - col_upb "
"u 'TMatrixTBase<float>' - 1 - target C - 'Option_t' 10 '\"S\"' option", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetSub",598,G__G__Matrix_110_0_30, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEfloatgR), -1, 1, 3, 1, 1, 0, 
"i - 'Int_t' 0 - row_lwb i - 'Int_t' 0 - col_lwb "
"u 'TMatrixTBase<float>' - 11 - source", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetMatrix2Array",1478,G__G__Matrix_110_0_31, 121, -1, -1, 0, 2, 1, 1, 8, 
"F - - 0 - data C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InsertRow",941,G__G__Matrix_110_0_32, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEfloatgR), -1, 1, 4, 1, 1, 0, 
"i - 'Int_t' 0 - row i - 'Int_t' 0 - col "
"F - - 10 - v i - 'Int_t' 0 '-1' n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ExtractRow",1043,G__G__Matrix_110_0_33, 121, -1, -1, 0, 4, 1, 1, 8, 
"i - 'Int_t' 0 - row i - 'Int_t' 0 - col "
"F - - 0 - v i - 'Int_t' 0 '-1' n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Shift",510,G__G__Matrix_110_0_34, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEfloatgR), -1, 1, 2, 1, 1, 0, 
"i - 'Int_t' 0 - row_shift i - 'Int_t' 0 - col_shift", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ResizeTo",821,G__G__Matrix_110_0_35, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEfloatgR), -1, 1, 3, 1, 1, 0, 
"i - 'Int_t' 0 - nrows i - 'Int_t' 0 - ncols "
"i - 'Int_t' 0 '-1' nr_nonzeros", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ResizeTo",821,G__G__Matrix_110_0_36, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEfloatgR), -1, 1, 5, 1, 1, 0, 
"i - 'Int_t' 0 - row_lwb i - 'Int_t' 0 - row_upb "
"i - 'Int_t' 0 - col_lwb i - 'Int_t' 0 - col_upb "
"i - 'Int_t' 0 '-1' nr_nonzeros", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Determinant",1147,G__G__Matrix_110_0_37, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Determinant",1147,G__G__Matrix_110_0_38, 121, -1, -1, 0, 2, 1, 1, 8, 
"d - 'Double_t' 1 - d1 d - 'Double_t' 1 - d2", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Zero",416,G__G__Matrix_110_0_39, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEfloatgR), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Abs",278,G__G__Matrix_110_0_40, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEfloatgR), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Sqr",310,G__G__Matrix_110_0_41, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEfloatgR), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Sqrt",426,G__G__Matrix_110_0_42, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEfloatgR), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("UnitMatrix",1045,G__G__Matrix_110_0_43, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEfloatgR), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("NormByDiag",972,G__G__Matrix_110_0_44, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEfloatgR), -1, 1, 2, 1, 1, 0, 
"u 'TVectorT<float>' - 11 - v C - 'Option_t' 10 '\"D\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RowNorm",724,G__G__Matrix_110_0_45, 102, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ColNorm",698,G__G__Matrix_110_0_46, 102, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("E2Norm",531,G__G__Matrix_110_0_47, 102, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("NormInf",697,G__G__Matrix_110_0_48, 102, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Norm1",461,G__G__Matrix_110_0_49, 102, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("NonZeros",830,G__G__Matrix_110_0_50, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Sum",309,G__G__Matrix_110_0_51, 102, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Min",292,G__G__Matrix_110_0_52, 102, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Max",294,G__G__Matrix_110_0_53, 102, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Draw",398,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' name", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("operator()",957,G__G__Matrix_110_0_56, 102, -1, -1, 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - rown i - 'Int_t' 0 - coln", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("operator()",957,G__G__Matrix_110_0_57, 102, -1, -1, 1, 2, 1, 1, 0, 
"i - 'Int_t' 0 - rown i - 'Int_t' 0 - coln", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("operator==",998,G__G__Matrix_110_0_58, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "f - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator!=",970,G__G__Matrix_110_0_59, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "f - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator<",936,G__G__Matrix_110_0_60, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "f - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator<=",997,G__G__Matrix_110_0_61, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "f - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator>",938,G__G__Matrix_110_0_62, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "f - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator>=",999,G__G__Matrix_110_0_63, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "f - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Apply",518,G__G__Matrix_110_0_64, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEfloatgR), -1, 1, 1, 1, 1, 0, "u 'TElementActionT<float>' - 11 - action", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Apply",518,G__G__Matrix_110_0_65, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEfloatgR), -1, 1, 1, 1, 1, 0, "u 'TElementPosActionT<float>' - 11 - action", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Randomize",937,G__G__Matrix_110_0_66, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEfloatgR), -1, 1, 3, 1, 1, 0, 
"f - - 0 - alpha f - - 0 - beta "
"d - 'Double_t' 1 - seed", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Matrix_110_0_67, 85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMatrixTBase<float>::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Matrix_110_0_68, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTBase<float>::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Matrix_110_0_69, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMatrixTBase<float>::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Matrix_110_0_70, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMatrixTBase<float>::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Matrix_110_0_74, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Matrix_110_0_75, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTBase<float>::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Matrix_110_0_76, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMatrixTBase<float>::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Matrix_110_0_77, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTBase<float>::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Matrix_110_0_78, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMatrixTBase<float>::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TMatrixTBase<float>", 1958, G__G__Matrix_110_0_79, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Matrix_110_0_80, (int) ('u'), G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEfloatgR), -1, 1, 1, 1, 1, 0, "u 'TMatrixTBase<float>' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMatrixTBaselEdoublegR(void) {
   /* TMatrixTBase<double> */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEdoublegR));
   G__memfunc_setup("GetElements",1117,(G__InterfaceMethod) NULL, 68, -1, -1, 0, 0, 1, 4, 0, "", "This function is now obsolete (and is not implemented) you should use TMatrix::GetMatrixArray().", (void*) NULL, 0);
   G__memfunc_setup("DoubleLexSort",1324,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 4, 3, 2, 0, 
"i - 'Int_t' 0 - n I - 'Int_t' 0 - first "
"I - 'Int_t' 0 - second D - - 0 - data", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IndexedLexSort",1426,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 6, 3, 2, 0, 
"i - 'Int_t' 0 - n I - 'Int_t' 0 - first "
"i - 'Int_t' 0 - swapFirst I - 'Int_t' 0 - second "
"i - 'Int_t' 0 - swapSecond I - 'Int_t' 0 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRowLwb",893,G__G__Matrix_111_0_5, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRowUpb",895,G__G__Matrix_111_0_6, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNrows",825,G__G__Matrix_111_0_7, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetColLwb",867,G__G__Matrix_111_0_8, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetColUpb",869,G__G__Matrix_111_0_9, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNcols",799,G__G__Matrix_111_0_10, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNoElements",1306,G__G__Matrix_111_0_11, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTol",591,G__G__Matrix_111_0_12, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMatrixArray",1428,G__G__Matrix_111_0_13, 68, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetMatrixArray",1428,G__G__Matrix_111_0_14, 68, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetRowIndexArray",1615,G__G__Matrix_111_0_15, 73, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetRowIndexArray",1615,G__G__Matrix_111_0_16, 73, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetColIndexArray",1589,G__G__Matrix_111_0_17, 73, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetColIndexArray",1589,G__G__Matrix_111_0_18, 73, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetRowIndexArray",1627,G__G__Matrix_111_0_19, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEdoublegR), -1, 1, 1, 1, 1, 0, "I - 'Int_t' 0 - data", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetColIndexArray",1601,G__G__Matrix_111_0_20, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEdoublegR), -1, 1, 1, 1, 1, 0, "I - 'Int_t' 0 - data", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetMatrixArray",1440,G__G__Matrix_111_0_21, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEdoublegR), -1, 1, 2, 1, 1, 0, 
"D - - 10 - data C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTol",603,G__G__Matrix_111_0_22, 100, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - newTol", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Clear",487,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Invalidate",1025,G__G__Matrix_111_0_24, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeValid",878,G__G__Matrix_111_0_25, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsValid",684,G__G__Matrix_111_0_26, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsOwner",711,G__G__Matrix_111_0_27, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsSymmetric",1145,G__G__Matrix_111_0_28, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetSub",586,G__G__Matrix_111_0_29, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEdoublegR), -1, 1, 6, 1, 1, 8, 
"i - 'Int_t' 0 - row_lwb i - 'Int_t' 0 - row_upb "
"i - 'Int_t' 0 - col_lwb i - 'Int_t' 0 - col_upb "
"u 'TMatrixTBase<double>' - 1 - target C - 'Option_t' 10 '\"S\"' option", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetSub",598,G__G__Matrix_111_0_30, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEdoublegR), -1, 1, 3, 1, 1, 0, 
"i - 'Int_t' 0 - row_lwb i - 'Int_t' 0 - col_lwb "
"u 'TMatrixTBase<double>' - 11 - source", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetMatrix2Array",1478,G__G__Matrix_111_0_31, 121, -1, -1, 0, 2, 1, 1, 8, 
"D - - 0 - data C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InsertRow",941,G__G__Matrix_111_0_32, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEdoublegR), -1, 1, 4, 1, 1, 0, 
"i - 'Int_t' 0 - row i - 'Int_t' 0 - col "
"D - - 10 - v i - 'Int_t' 0 '-1' n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ExtractRow",1043,G__G__Matrix_111_0_33, 121, -1, -1, 0, 4, 1, 1, 8, 
"i - 'Int_t' 0 - row i - 'Int_t' 0 - col "
"D - - 0 - v i - 'Int_t' 0 '-1' n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Shift",510,G__G__Matrix_111_0_34, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEdoublegR), -1, 1, 2, 1, 1, 0, 
"i - 'Int_t' 0 - row_shift i - 'Int_t' 0 - col_shift", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ResizeTo",821,G__G__Matrix_111_0_35, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEdoublegR), -1, 1, 3, 1, 1, 0, 
"i - 'Int_t' 0 - nrows i - 'Int_t' 0 - ncols "
"i - 'Int_t' 0 '-1' nr_nonzeros", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ResizeTo",821,G__G__Matrix_111_0_36, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEdoublegR), -1, 1, 5, 1, 1, 0, 
"i - 'Int_t' 0 - row_lwb i - 'Int_t' 0 - row_upb "
"i - 'Int_t' 0 - col_lwb i - 'Int_t' 0 - col_upb "
"i - 'Int_t' 0 '-1' nr_nonzeros", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Determinant",1147,G__G__Matrix_111_0_37, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Determinant",1147,G__G__Matrix_111_0_38, 121, -1, -1, 0, 2, 1, 1, 8, 
"d - 'Double_t' 1 - d1 d - 'Double_t' 1 - d2", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Zero",416,G__G__Matrix_111_0_39, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEdoublegR), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Abs",278,G__G__Matrix_111_0_40, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEdoublegR), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Sqr",310,G__G__Matrix_111_0_41, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEdoublegR), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Sqrt",426,G__G__Matrix_111_0_42, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEdoublegR), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("UnitMatrix",1045,G__G__Matrix_111_0_43, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEdoublegR), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("NormByDiag",972,G__G__Matrix_111_0_44, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEdoublegR), -1, 1, 2, 1, 1, 0, 
"u 'TVectorT<double>' - 11 - v C - 'Option_t' 10 '\"D\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RowNorm",724,G__G__Matrix_111_0_45, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ColNorm",698,G__G__Matrix_111_0_46, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("E2Norm",531,G__G__Matrix_111_0_47, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("NormInf",697,G__G__Matrix_111_0_48, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Norm1",461,G__G__Matrix_111_0_49, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("NonZeros",830,G__G__Matrix_111_0_50, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Sum",309,G__G__Matrix_111_0_51, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Min",292,G__G__Matrix_111_0_52, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Max",294,G__G__Matrix_111_0_53, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Draw",398,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' name", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("operator()",957,G__G__Matrix_111_0_56, 100, -1, -1, 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - rown i - 'Int_t' 0 - coln", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("operator()",957,G__G__Matrix_111_0_57, 100, -1, -1, 1, 2, 1, 1, 0, 
"i - 'Int_t' 0 - rown i - 'Int_t' 0 - coln", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("operator==",998,G__G__Matrix_111_0_58, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "d - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator!=",970,G__G__Matrix_111_0_59, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "d - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator<",936,G__G__Matrix_111_0_60, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "d - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator<=",997,G__G__Matrix_111_0_61, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "d - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator>",938,G__G__Matrix_111_0_62, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "d - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator>=",999,G__G__Matrix_111_0_63, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "d - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Apply",518,G__G__Matrix_111_0_64, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEdoublegR), -1, 1, 1, 1, 1, 0, "u 'TElementActionT<double>' - 11 - action", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Apply",518,G__G__Matrix_111_0_65, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEdoublegR), -1, 1, 1, 1, 1, 0, "u 'TElementPosActionT<double>' - 11 - action", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Randomize",937,G__G__Matrix_111_0_66, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEdoublegR), -1, 1, 3, 1, 1, 0, 
"d - - 0 - alpha d - - 0 - beta "
"d - 'Double_t' 1 - seed", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Matrix_111_0_67, 85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMatrixTBase<double>::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Matrix_111_0_68, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTBase<double>::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Matrix_111_0_69, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMatrixTBase<double>::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Matrix_111_0_70, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMatrixTBase<double>::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Matrix_111_0_74, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Matrix_111_0_75, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTBase<double>::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Matrix_111_0_76, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMatrixTBase<double>::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Matrix_111_0_77, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTBase<double>::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Matrix_111_0_78, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMatrixTBase<double>::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TMatrixTBase<double>", 2059, G__G__Matrix_111_0_79, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Matrix_111_0_80, (int) ('u'), G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEdoublegR), -1, 1, 1, 1, 1, 0, "u 'TMatrixTBase<double>' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTVectorTlEfloatgR(void) {
   /* TVectorT<float> */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEfloatgR));
   G__memfunc_setup("New_m",502,(G__InterfaceMethod) NULL, 70, -1, -1, 0, 1, 1, 2, 0, "i - 'Int_t' 0 - size", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Delete_m",799,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 0, 
"i - 'Int_t' 0 - size F - - 1 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Memcpy_m",823,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 5, 1, 2, 0, 
"F - - 0 - newp F - - 10 - oldp "
"i - 'Int_t' 0 - copySize i - 'Int_t' 0 - newSize "
"i - 'Int_t' 0 - oldSize", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Allocate",805,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 2, 0, 
"i - 'Int_t' 0 - nrows i - 'Int_t' 0 '0' row_lwb "
"i - 'Int_t' 0 '0' init", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TVectorT<float>",1451,G__G__Matrix_112_0_5, 105, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEfloatgR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TVectorT<float>",1451,G__G__Matrix_112_0_6, 105, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEfloatgR), -1, 0, 1, 5, 1, 0, "i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TVectorT<float>",1451,G__G__Matrix_112_0_7, 105, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEfloatgR), -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - lwb i - 'Int_t' 0 - upb", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TVectorT<float>",1451,G__G__Matrix_112_0_8, 105, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEfloatgR), -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - n F - - 10 - elements", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TVectorT<float>",1451,G__G__Matrix_112_0_9, 105, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEfloatgR), -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - lwb i - 'Int_t' 0 - upb "
"F - - 10 - elements", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TVectorT<float>",1451,G__G__Matrix_112_0_10, 105, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEfloatgR), -1, 0, 1, 1, 1, 0, "u 'TVectorT<float>' - 11 - another", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TVectorT<float>",1451,G__G__Matrix_112_0_11, 105, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEfloatgR), -1, 0, 1, 1, 1, 0, "u 'TMatrixTRow_const<float>' - 11 - mr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TVectorT<float>",1451,G__G__Matrix_112_0_12, 105, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEfloatgR), -1, 0, 1, 1, 1, 0, "u 'TMatrixTColumn_const<float>' - 11 - mc", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TVectorT<float>",1451,G__G__Matrix_112_0_13, 105, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEfloatgR), -1, 0, 1, 1, 1, 0, "u 'TMatrixTDiag_const<float>' - 11 - md", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLwb",581,G__G__Matrix_112_0_14, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetUpb",583,G__G__Matrix_112_0_15, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNrows",825,G__G__Matrix_112_0_16, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNoElements",1306,G__G__Matrix_112_0_17, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMatrixArray",1428,G__G__Matrix_112_0_18, 70, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMatrixArray",1428,G__G__Matrix_112_0_19, 70, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Invalidate",1025,G__G__Matrix_112_0_20, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeValid",878,G__G__Matrix_112_0_21, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsValid",684,G__G__Matrix_112_0_22, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsOwner",711,G__G__Matrix_112_0_23, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetElements",1129,G__G__Matrix_112_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "F - - 10 - elements", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Shift",510,G__G__Matrix_112_0_25, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEfloatgR), -1, 1, 1, 1, 1, 0, "i - 'Int_t' 0 - row_shift", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ResizeTo",821,G__G__Matrix_112_0_26, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEfloatgR), -1, 1, 2, 1, 1, 0, 
"i - 'Int_t' 0 - lwb i - 'Int_t' 0 - upb", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ResizeTo",821,G__G__Matrix_112_0_27, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEfloatgR), -1, 1, 1, 1, 1, 0, "i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ResizeTo",821,G__G__Matrix_112_0_28, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEfloatgR), -1, 1, 1, 1, 1, 0, "u 'TVectorT<float>' - 11 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Use",301,G__G__Matrix_112_0_29, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEfloatgR), -1, 1, 3, 1, 1, 0, 
"i - 'Int_t' 0 - lwb i - 'Int_t' 0 - upb "
"F - - 0 - data", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Use",301,G__G__Matrix_112_0_30, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEfloatgR), -1, 1, 3, 1, 1, 9, 
"i - 'Int_t' 0 - lwb i - 'Int_t' 0 - upb "
"F - - 10 - data", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Use",301,G__G__Matrix_112_0_31, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEfloatgR), -1, 1, 2, 1, 1, 0, 
"i - 'Int_t' 0 - n F - - 0 - data", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Use",301,G__G__Matrix_112_0_32, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEfloatgR), -1, 1, 2, 1, 1, 9, 
"i - 'Int_t' 0 - n F - - 10 - data", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Use",301,G__G__Matrix_112_0_33, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEfloatgR), -1, 1, 1, 1, 1, 0, "u 'TVectorT<float>' - 1 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Use",301,G__G__Matrix_112_0_34, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEfloatgR), -1, 1, 1, 1, 1, 9, "u 'TVectorT<float>' - 11 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSub",586,G__G__Matrix_112_0_35, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEfloatgR), -1, 1, 4, 1, 1, 8, 
"i - 'Int_t' 0 - row_lwb i - 'Int_t' 0 - row_upb "
"u 'TVectorT<float>' - 1 - target C - 'Option_t' 10 '\"S\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSub",586,G__G__Matrix_112_0_36, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEfloatgR), -1, 0, 3, 1, 1, 8, 
"i - 'Int_t' 0 - row_lwb i - 'Int_t' 0 - row_upb "
"C - 'Option_t' 10 '\"S\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSub",598,G__G__Matrix_112_0_37, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEfloatgR), -1, 1, 2, 1, 1, 0, 
"i - 'Int_t' 0 - row_lwb u 'TVectorT<float>' - 11 - source", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Zero",416,G__G__Matrix_112_0_38, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEfloatgR), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Abs",278,G__G__Matrix_112_0_39, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEfloatgR), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Sqr",310,G__G__Matrix_112_0_40, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEfloatgR), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Sqrt",426,G__G__Matrix_112_0_41, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEfloatgR), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Invert",632,G__G__Matrix_112_0_42, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEfloatgR), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SelectNonZeros",1438,G__G__Matrix_112_0_43, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEfloatgR), -1, 1, 1, 1, 1, 0, "u 'TVectorT<float>' - 11 - select", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Norm1",461,G__G__Matrix_112_0_44, 102, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Norm2Sqr",772,G__G__Matrix_112_0_45, 102, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("NormInf",697,G__G__Matrix_112_0_46, 102, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("NonZeros",830,G__G__Matrix_112_0_47, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Sum",309,G__G__Matrix_112_0_48, 102, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Min",292,G__G__Matrix_112_0_49, 102, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Max",294,G__G__Matrix_112_0_50, 102, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator()",957,G__G__Matrix_112_0_51, 102, -1, -1, 1, 1, 1, 1, 9, "i - 'Int_t' 0 - ind", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator()",957,G__G__Matrix_112_0_52, 102, -1, -1, 1, 1, 1, 1, 0, "i - 'Int_t' 0 - ind", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__G__Matrix_112_0_53, 102, -1, -1, 1, 1, 1, 1, 9, "i - 'Int_t' 0 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__G__Matrix_112_0_54, 102, -1, -1, 1, 1, 1, 1, 0, "i - 'Int_t' 0 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Matrix_112_0_55, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEfloatgR), -1, 1, 1, 1, 1, 0, "u 'TVectorT<float>' - 11 - source", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Matrix_112_0_56, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEfloatgR), -1, 1, 1, 1, 1, 0, "u 'TMatrixTRow_const<float>' - 11 - mr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Matrix_112_0_57, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEfloatgR), -1, 1, 1, 1, 1, 0, "u 'TMatrixTColumn_const<float>' - 11 - mc", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Matrix_112_0_58, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEfloatgR), -1, 1, 1, 1, 1, 0, "u 'TMatrixTDiag_const<float>' - 11 - md", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Matrix_112_0_59, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEfloatgR), -1, 1, 1, 1, 1, 0, "u 'TMatrixTSparseRow_const<float>' - 11 - md", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Matrix_112_0_60, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEfloatgR), -1, 1, 1, 1, 1, 0, "u 'TMatrixTSparseDiag_const<float>' - 11 - md", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Matrix_112_0_61, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEfloatgR), -1, 1, 1, 1, 1, 0, "f - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+=",980,G__G__Matrix_112_0_62, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEfloatgR), -1, 1, 1, 1, 1, 0, "f - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator-=",982,G__G__Matrix_112_0_63, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEfloatgR), -1, 1, 1, 1, 1, 0, "f - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*=",979,G__G__Matrix_112_0_64, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEfloatgR), -1, 1, 1, 1, 1, 0, "f - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+=",980,G__G__Matrix_112_0_65, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEfloatgR), -1, 1, 1, 1, 1, 0, "u 'TVectorT<float>' - 11 - source", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator-=",982,G__G__Matrix_112_0_66, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEfloatgR), -1, 1, 1, 1, 1, 0, "u 'TVectorT<float>' - 11 - source", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*=",979,G__G__Matrix_112_0_67, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEfloatgR), -1, 1, 1, 1, 1, 0, "u 'TMatrixT<float>' - 11 - a", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*=",979,G__G__Matrix_112_0_68, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEfloatgR), -1, 1, 1, 1, 1, 0, "u 'TMatrixTSym<float>' - 11 - a", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*=",979,G__G__Matrix_112_0_69, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEfloatgR), -1, 1, 1, 1, 1, 0, "u 'TMatrixTSparse<float>' - 11 - a", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator==",998,G__G__Matrix_112_0_70, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "f - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator!=",970,G__G__Matrix_112_0_71, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "f - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator<",936,G__G__Matrix_112_0_72, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "f - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator<=",997,G__G__Matrix_112_0_73, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "f - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator>",938,G__G__Matrix_112_0_74, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "f - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator>=",999,G__G__Matrix_112_0_75, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "f - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MatchesNonZeroPattern",2158,G__G__Matrix_112_0_76, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "u 'TVectorT<float>' - 11 - select", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SomePositive",1255,G__G__Matrix_112_0_77, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "u 'TVectorT<float>' - 11 - select", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddSomeConstant",1511,G__G__Matrix_112_0_78, 121, -1, -1, 0, 2, 1, 1, 0, 
"f - - 0 - val u 'TVectorT<float>' - 11 - select", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Randomize",937,G__G__Matrix_112_0_79, 121, -1, -1, 0, 3, 1, 1, 0, 
"f - - 0 - alpha f - - 0 - beta "
"d - 'Double_t' 1 - seed", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Apply",518,G__G__Matrix_112_0_80, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEfloatgR), -1, 1, 1, 1, 1, 0, "u 'TElementActionT<float>' - 11 - action", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Apply",518,G__G__Matrix_112_0_81, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEfloatgR), -1, 1, 1, 1, 1, 0, "u 'TElementPosActionT<float>' - 11 - action", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Add",265,G__G__Matrix_112_0_82, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TVectorT<float>' - 11 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Add",265,G__G__Matrix_112_0_83, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TVectorT<float>' - 11 - v1 u 'TVectorT<float>' - 11 - v2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Clear",487,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Draw",398,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Matrix_112_0_87, 85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TVectorT<float>::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Matrix_112_0_88, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TVectorT<float>::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Matrix_112_0_89, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TVectorT<float>::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Matrix_112_0_90, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TVectorT<float>::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Matrix_112_0_94, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Matrix_112_0_95, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TVectorT<float>::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Matrix_112_0_96, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TVectorT<float>::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Matrix_112_0_97, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TVectorT<float>::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Matrix_112_0_98, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TVectorT<float>::DeclFileLine) ), 0);
   G__memfunc_setup("TVectorT<float>",1451,G__G__Matrix_112_0_99, 105, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEfloatgR), -1, 0, 1, 1, 1, 0, "u 'TVectorT<double>' - 11 - another", (char*)NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TVectorT<float>", 1577, G__G__Matrix_112_0_100, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTVectorTlEdoublegR(void) {
   /* TVectorT<double> */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR));
   G__memfunc_setup("New_m",502,(G__InterfaceMethod) NULL, 68, -1, -1, 0, 1, 1, 2, 0, "i - 'Int_t' 0 - size", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Delete_m",799,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 0, 
"i - 'Int_t' 0 - size D - - 1 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Memcpy_m",823,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 5, 1, 2, 0, 
"D - - 0 - newp D - - 10 - oldp "
"i - 'Int_t' 0 - copySize i - 'Int_t' 0 - newSize "
"i - 'Int_t' 0 - oldSize", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Allocate",805,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 2, 0, 
"i - 'Int_t' 0 - nrows i - 'Int_t' 0 '0' row_lwb "
"i - 'Int_t' 0 '0' init", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TVectorT<double>",1552,G__G__Matrix_113_0_5, 105, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TVectorT<double>",1552,G__G__Matrix_113_0_6, 105, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR), -1, 0, 1, 5, 1, 0, "i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TVectorT<double>",1552,G__G__Matrix_113_0_7, 105, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR), -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - lwb i - 'Int_t' 0 - upb", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TVectorT<double>",1552,G__G__Matrix_113_0_8, 105, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR), -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - n D - - 10 - elements", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TVectorT<double>",1552,G__G__Matrix_113_0_9, 105, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR), -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - lwb i - 'Int_t' 0 - upb "
"D - - 10 - elements", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TVectorT<double>",1552,G__G__Matrix_113_0_10, 105, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR), -1, 0, 1, 1, 1, 0, "u 'TVectorT<double>' - 11 - another", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TVectorT<double>",1552,G__G__Matrix_113_0_11, 105, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR), -1, 0, 1, 1, 1, 0, "u 'TMatrixTRow_const<double>' - 11 - mr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TVectorT<double>",1552,G__G__Matrix_113_0_12, 105, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR), -1, 0, 1, 1, 1, 0, "u 'TMatrixTColumn_const<double>' - 11 - mc", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TVectorT<double>",1552,G__G__Matrix_113_0_13, 105, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR), -1, 0, 1, 1, 1, 0, "u 'TMatrixTDiag_const<double>' - 11 - md", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLwb",581,G__G__Matrix_113_0_14, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetUpb",583,G__G__Matrix_113_0_15, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNrows",825,G__G__Matrix_113_0_16, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNoElements",1306,G__G__Matrix_113_0_17, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMatrixArray",1428,G__G__Matrix_113_0_18, 68, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMatrixArray",1428,G__G__Matrix_113_0_19, 68, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Invalidate",1025,G__G__Matrix_113_0_20, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeValid",878,G__G__Matrix_113_0_21, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsValid",684,G__G__Matrix_113_0_22, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsOwner",711,G__G__Matrix_113_0_23, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetElements",1129,G__G__Matrix_113_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "D - - 10 - elements", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Shift",510,G__G__Matrix_113_0_25, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR), -1, 1, 1, 1, 1, 0, "i - 'Int_t' 0 - row_shift", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ResizeTo",821,G__G__Matrix_113_0_26, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR), -1, 1, 2, 1, 1, 0, 
"i - 'Int_t' 0 - lwb i - 'Int_t' 0 - upb", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ResizeTo",821,G__G__Matrix_113_0_27, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR), -1, 1, 1, 1, 1, 0, "i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ResizeTo",821,G__G__Matrix_113_0_28, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR), -1, 1, 1, 1, 1, 0, "u 'TVectorT<double>' - 11 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Use",301,G__G__Matrix_113_0_29, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR), -1, 1, 3, 1, 1, 0, 
"i - 'Int_t' 0 - lwb i - 'Int_t' 0 - upb "
"D - - 0 - data", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Use",301,G__G__Matrix_113_0_30, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR), -1, 1, 3, 1, 1, 9, 
"i - 'Int_t' 0 - lwb i - 'Int_t' 0 - upb "
"D - - 10 - data", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Use",301,G__G__Matrix_113_0_31, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR), -1, 1, 2, 1, 1, 0, 
"i - 'Int_t' 0 - n D - - 0 - data", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Use",301,G__G__Matrix_113_0_32, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR), -1, 1, 2, 1, 1, 9, 
"i - 'Int_t' 0 - n D - - 10 - data", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Use",301,G__G__Matrix_113_0_33, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR), -1, 1, 1, 1, 1, 0, "u 'TVectorT<double>' - 1 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Use",301,G__G__Matrix_113_0_34, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR), -1, 1, 1, 1, 1, 9, "u 'TVectorT<double>' - 11 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSub",586,G__G__Matrix_113_0_35, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR), -1, 1, 4, 1, 1, 8, 
"i - 'Int_t' 0 - row_lwb i - 'Int_t' 0 - row_upb "
"u 'TVectorT<double>' - 1 - target C - 'Option_t' 10 '\"S\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSub",586,G__G__Matrix_113_0_36, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR), -1, 0, 3, 1, 1, 8, 
"i - 'Int_t' 0 - row_lwb i - 'Int_t' 0 - row_upb "
"C - 'Option_t' 10 '\"S\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSub",598,G__G__Matrix_113_0_37, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR), -1, 1, 2, 1, 1, 0, 
"i - 'Int_t' 0 - row_lwb u 'TVectorT<double>' - 11 - source", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Zero",416,G__G__Matrix_113_0_38, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Abs",278,G__G__Matrix_113_0_39, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Sqr",310,G__G__Matrix_113_0_40, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Sqrt",426,G__G__Matrix_113_0_41, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Invert",632,G__G__Matrix_113_0_42, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SelectNonZeros",1438,G__G__Matrix_113_0_43, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR), -1, 1, 1, 1, 1, 0, "u 'TVectorT<double>' - 11 - select", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Norm1",461,G__G__Matrix_113_0_44, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Norm2Sqr",772,G__G__Matrix_113_0_45, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("NormInf",697,G__G__Matrix_113_0_46, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("NonZeros",830,G__G__Matrix_113_0_47, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Sum",309,G__G__Matrix_113_0_48, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Min",292,G__G__Matrix_113_0_49, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Max",294,G__G__Matrix_113_0_50, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator()",957,G__G__Matrix_113_0_51, 100, -1, -1, 1, 1, 1, 1, 9, "i - 'Int_t' 0 - ind", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator()",957,G__G__Matrix_113_0_52, 100, -1, -1, 1, 1, 1, 1, 0, "i - 'Int_t' 0 - ind", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__G__Matrix_113_0_53, 100, -1, -1, 1, 1, 1, 1, 9, "i - 'Int_t' 0 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__G__Matrix_113_0_54, 100, -1, -1, 1, 1, 1, 1, 0, "i - 'Int_t' 0 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Matrix_113_0_55, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR), -1, 1, 1, 1, 1, 0, "u 'TVectorT<double>' - 11 - source", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Matrix_113_0_56, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR), -1, 1, 1, 1, 1, 0, "u 'TMatrixTRow_const<double>' - 11 - mr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Matrix_113_0_57, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR), -1, 1, 1, 1, 1, 0, "u 'TMatrixTColumn_const<double>' - 11 - mc", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Matrix_113_0_58, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR), -1, 1, 1, 1, 1, 0, "u 'TMatrixTDiag_const<double>' - 11 - md", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Matrix_113_0_59, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR), -1, 1, 1, 1, 1, 0, "u 'TMatrixTSparseRow_const<double>' - 11 - md", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Matrix_113_0_60, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR), -1, 1, 1, 1, 1, 0, "u 'TMatrixTSparseDiag_const<double>' - 11 - md", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Matrix_113_0_61, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR), -1, 1, 1, 1, 1, 0, "d - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+=",980,G__G__Matrix_113_0_62, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR), -1, 1, 1, 1, 1, 0, "d - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator-=",982,G__G__Matrix_113_0_63, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR), -1, 1, 1, 1, 1, 0, "d - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*=",979,G__G__Matrix_113_0_64, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR), -1, 1, 1, 1, 1, 0, "d - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+=",980,G__G__Matrix_113_0_65, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR), -1, 1, 1, 1, 1, 0, "u 'TVectorT<double>' - 11 - source", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator-=",982,G__G__Matrix_113_0_66, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR), -1, 1, 1, 1, 1, 0, "u 'TVectorT<double>' - 11 - source", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*=",979,G__G__Matrix_113_0_67, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR), -1, 1, 1, 1, 1, 0, "u 'TMatrixT<double>' - 11 - a", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*=",979,G__G__Matrix_113_0_68, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR), -1, 1, 1, 1, 1, 0, "u 'TMatrixTSym<double>' - 11 - a", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*=",979,G__G__Matrix_113_0_69, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR), -1, 1, 1, 1, 1, 0, "u 'TMatrixTSparse<double>' - 11 - a", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator==",998,G__G__Matrix_113_0_70, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "d - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator!=",970,G__G__Matrix_113_0_71, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "d - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator<",936,G__G__Matrix_113_0_72, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "d - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator<=",997,G__G__Matrix_113_0_73, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "d - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator>",938,G__G__Matrix_113_0_74, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "d - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator>=",999,G__G__Matrix_113_0_75, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "d - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MatchesNonZeroPattern",2158,G__G__Matrix_113_0_76, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "u 'TVectorT<double>' - 11 - select", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SomePositive",1255,G__G__Matrix_113_0_77, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "u 'TVectorT<double>' - 11 - select", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddSomeConstant",1511,G__G__Matrix_113_0_78, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - - 0 - val u 'TVectorT<double>' - 11 - select", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Randomize",937,G__G__Matrix_113_0_79, 121, -1, -1, 0, 3, 1, 1, 0, 
"d - - 0 - alpha d - - 0 - beta "
"d - 'Double_t' 1 - seed", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Apply",518,G__G__Matrix_113_0_80, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR), -1, 1, 1, 1, 1, 0, "u 'TElementActionT<double>' - 11 - action", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Apply",518,G__G__Matrix_113_0_81, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR), -1, 1, 1, 1, 1, 0, "u 'TElementPosActionT<double>' - 11 - action", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Add",265,G__G__Matrix_113_0_82, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TVectorT<double>' - 11 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Add",265,G__G__Matrix_113_0_83, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TVectorT<double>' - 11 - v1 u 'TVectorT<double>' - 11 - v2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Clear",487,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Draw",398,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' option", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Matrix_113_0_87, 85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TVectorT<double>::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Matrix_113_0_88, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TVectorT<double>::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Matrix_113_0_89, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TVectorT<double>::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Matrix_113_0_90, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TVectorT<double>::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Matrix_113_0_94, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Matrix_113_0_95, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TVectorT<double>::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Matrix_113_0_96, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TVectorT<double>::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Matrix_113_0_97, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TVectorT<double>::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Matrix_113_0_98, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TVectorT<double>::DeclFileLine) ), 0);
   G__memfunc_setup("TVectorT<double>",1552,G__G__Matrix_113_0_99, 105, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR), -1, 0, 1, 1, 1, 0, "u 'TVectorT<float>' - 11 - another", (char*)NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TVectorT<double>", 1678, G__G__Matrix_113_0_100, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMatrixTlEdoublegR(void) {
   /* TMatrixT<double> */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR));
   G__memfunc_setup("New_m",502,(G__InterfaceMethod) NULL, 68, -1, -1, 0, 1, 1, 2, 0, "i - 'Int_t' 0 - size", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Delete_m",799,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 0, 
"i - 'Int_t' 0 - size D - - 1 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Memcpy_m",823,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 5, 1, 2, 0, 
"D - - 0 - newp D - - 10 - oldp "
"i - 'Int_t' 0 - copySize i - 'Int_t' 0 - newSize "
"i - 'Int_t' 0 - oldSize", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Allocate",805,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 6, 1, 2, 0, 
"i - 'Int_t' 0 - nrows i - 'Int_t' 0 - ncols "
"i - 'Int_t' 0 '0' row_lwb i - 'Int_t' 0 '0' col_lwb "
"i - 'Int_t' 0 '0' init i - 'Int_t' 0 '-1' -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixT<double>",1554,G__G__Matrix_122_0_5, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixT<double>",1554,G__G__Matrix_122_0_6, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - nrows i - 'Int_t' 0 - ncols", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixT<double>",1554,G__G__Matrix_122_0_7, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - row_lwb i - 'Int_t' 0 - row_upb "
"i - 'Int_t' 0 - col_lwb i - 'Int_t' 0 - col_upb", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixT<double>",1554,G__G__Matrix_122_0_8, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - nrows i - 'Int_t' 0 - ncols "
"D - - 10 - data C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixT<double>",1554,G__G__Matrix_122_0_9, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), -1, 0, 6, 1, 1, 0, 
"i - 'Int_t' 0 - row_lwb i - 'Int_t' 0 - row_upb "
"i - 'Int_t' 0 - col_lwb i - 'Int_t' 0 - col_upb "
"D - - 10 - data C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixT<double>",1554,G__G__Matrix_122_0_10, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), -1, 0, 1, 1, 1, 0, "u 'TMatrixT<double>' - 11 - another", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixT<double>",1554,G__G__Matrix_122_0_11, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), -1, 0, 1, 1, 1, 0, "u 'TMatrixTSym<double>' - 11 - another", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixT<double>",1554,G__G__Matrix_122_0_12, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), -1, 0, 1, 1, 1, 0, "u 'TMatrixTSparse<double>' - 11 - another", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixT<double>",1554,G__G__Matrix_122_0_13, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), -1, 0, 2, 1, 1, 0, 
"i 'TMatrixT<double>::EMatrixCreatorsOp1' - 0 - op u 'TMatrixT<double>' - 11 - prototype", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixT<double>",1554,G__G__Matrix_122_0_14, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), -1, 0, 3, 1, 1, 0, 
"u 'TMatrixT<double>' - 11 - a i 'TMatrixT<double>::EMatrixCreatorsOp2' - 0 - op "
"u 'TMatrixT<double>' - 11 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixT<double>",1554,G__G__Matrix_122_0_15, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), -1, 0, 3, 1, 1, 0, 
"u 'TMatrixT<double>' - 11 - a i 'TMatrixT<double>::EMatrixCreatorsOp2' - 0 - op "
"u 'TMatrixTSym<double>' - 11 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixT<double>",1554,G__G__Matrix_122_0_16, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), -1, 0, 3, 1, 1, 0, 
"u 'TMatrixTSym<double>' - 11 - a i 'TMatrixT<double>::EMatrixCreatorsOp2' - 0 - op "
"u 'TMatrixT<double>' - 11 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixT<double>",1554,G__G__Matrix_122_0_17, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), -1, 0, 3, 1, 1, 0, 
"u 'TMatrixTSym<double>' - 11 - a i 'TMatrixT<double>::EMatrixCreatorsOp2' - 0 - op "
"u 'TMatrixTSym<double>' - 11 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixT<double>",1554,G__G__Matrix_122_0_18, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), -1, 0, 1, 1, 1, 0, "u 'TMatrixTLazy<double>' - 11 - lazy_constructor", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Plus",420,G__G__Matrix_122_0_19, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TMatrixT<double>' - 11 - a u 'TMatrixT<double>' - 11 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Plus",420,G__G__Matrix_122_0_20, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TMatrixT<double>' - 11 - a u 'TMatrixTSym<double>' - 11 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Plus",420,G__G__Matrix_122_0_21, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TMatrixTSym<double>' - 11 - a u 'TMatrixT<double>' - 11 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Minus",524,G__G__Matrix_122_0_22, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TMatrixT<double>' - 11 - a u 'TMatrixT<double>' - 11 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Minus",524,G__G__Matrix_122_0_23, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TMatrixT<double>' - 11 - a u 'TMatrixTSym<double>' - 11 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Minus",524,G__G__Matrix_122_0_24, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TMatrixTSym<double>' - 11 - a u 'TMatrixT<double>' - 11 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Mult",418,G__G__Matrix_122_0_25, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TMatrixT<double>' - 11 - a u 'TMatrixT<double>' - 11 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Mult",418,G__G__Matrix_122_0_26, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TMatrixT<double>' - 11 - a u 'TMatrixTSym<double>' - 11 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Mult",418,G__G__Matrix_122_0_27, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TMatrixTSym<double>' - 11 - a u 'TMatrixT<double>' - 11 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Mult",418,G__G__Matrix_122_0_28, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TMatrixTSym<double>' - 11 - a u 'TMatrixTSym<double>' - 11 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMult",502,G__G__Matrix_122_0_29, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TMatrixT<double>' - 11 - a u 'TMatrixT<double>' - 11 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMult",502,G__G__Matrix_122_0_30, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TMatrixT<double>' - 11 - a u 'TMatrixTSym<double>' - 11 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMult",502,G__G__Matrix_122_0_31, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TMatrixTSym<double>' - 11 - a u 'TMatrixT<double>' - 11 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMult",502,G__G__Matrix_122_0_32, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TMatrixTSym<double>' - 11 - a u 'TMatrixTSym<double>' - 11 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MultT",502,G__G__Matrix_122_0_33, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TMatrixT<double>' - 11 - a u 'TMatrixT<double>' - 11 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MultT",502,G__G__Matrix_122_0_34, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TMatrixT<double>' - 11 - a u 'TMatrixTSym<double>' - 11 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MultT",502,G__G__Matrix_122_0_35, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TMatrixTSym<double>' - 11 - a u 'TMatrixT<double>' - 11 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MultT",502,G__G__Matrix_122_0_36, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TMatrixTSym<double>' - 11 - a u 'TMatrixTSym<double>' - 11 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMatrixArray",1428,(G__InterfaceMethod) NULL,68, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMatrixArray",1428,(G__InterfaceMethod) NULL,68, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRowIndexArray",1615,(G__InterfaceMethod) NULL,73, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRowIndexArray",1615,(G__InterfaceMethod) NULL,73, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetColIndexArray",1589,(G__InterfaceMethod) NULL,73, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetColIndexArray",1589,(G__InterfaceMethod) NULL,73, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetRowIndexArray",1627,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEdoublegR), -1, 1, 1, 1, 1, 0, "I - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetColIndexArray",1601,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEdoublegR), -1, 1, 1, 1, 1, 0, "I - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Clear",487,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Use",301,G__G__Matrix_122_0_46, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), -1, 1, 5, 1, 1, 0, 
"i - 'Int_t' 0 - row_lwb i - 'Int_t' 0 - row_upb "
"i - 'Int_t' 0 - col_lwb i - 'Int_t' 0 - col_upb "
"D - - 0 - data", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Use",301,G__G__Matrix_122_0_47, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), -1, 1, 5, 1, 1, 9, 
"i - 'Int_t' 0 - row_lwb i - 'Int_t' 0 - row_upb "
"i - 'Int_t' 0 - col_lwb i - 'Int_t' 0 - col_upb "
"D - - 10 - data", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Use",301,G__G__Matrix_122_0_48, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), -1, 1, 3, 1, 1, 0, 
"i - 'Int_t' 0 - nrows i - 'Int_t' 0 - ncols "
"D - - 0 - data", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Use",301,G__G__Matrix_122_0_49, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), -1, 1, 3, 1, 1, 9, 
"i - 'Int_t' 0 - nrows i - 'Int_t' 0 - ncols "
"D - - 10 - data", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Use",301,G__G__Matrix_122_0_50, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), -1, 1, 1, 1, 1, 0, "u 'TMatrixT<double>' - 1 - a", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Use",301,G__G__Matrix_122_0_51, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), -1, 1, 1, 1, 1, 9, "u 'TMatrixT<double>' - 11 - a", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSub",586,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEdoublegR), -1, 1, 6, 1, 1, 8, 
"i - 'Int_t' 0 - row_lwb i - 'Int_t' 0 - row_upb "
"i - 'Int_t' 0 - col_lwb i - 'Int_t' 0 - col_upb "
"u 'TMatrixTBase<double>' - 1 - target C - 'Option_t' 10 '\"S\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetSub",586,G__G__Matrix_122_0_53, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), -1, 0, 5, 1, 1, 8, 
"i - 'Int_t' 0 - row_lwb i - 'Int_t' 0 - row_upb "
"i - 'Int_t' 0 - col_lwb i - 'Int_t' 0 - col_upb "
"C - 'Option_t' 10 '\"S\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSub",598,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEdoublegR), -1, 1, 3, 1, 1, 0, 
"i - 'Int_t' 0 - row_lwb i - 'Int_t' 0 - col_lwb "
"u 'TMatrixTBase<double>' - 11 - source", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ResizeTo",821,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEdoublegR), -1, 1, 3, 1, 1, 0, 
"i - 'Int_t' 0 - nrows i - 'Int_t' 0 - ncols "
"i - 'Int_t' 0 '-1' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ResizeTo",821,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEdoublegR), -1, 1, 5, 1, 1, 0, 
"i - 'Int_t' 0 - row_lwb i - 'Int_t' 0 - row_upb "
"i - 'Int_t' 0 - col_lwb i - 'Int_t' 0 - col_upb "
"i - 'Int_t' 0 '-1' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ResizeTo",821,G__G__Matrix_122_0_57, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEdoublegR), -1, 1, 1, 1, 1, 0, "u 'TMatrixT<double>' - 11 - m", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Determinant",1147,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Determinant",1147,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 8, 
"d - 'Double_t' 1 - d1 d - 'Double_t' 1 - d2", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Invert",632,G__G__Matrix_122_0_60, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), -1, 1, 1, 1, 1, 0, "D - 'Double_t' 0 '0' det", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InvertFast",1030,G__G__Matrix_122_0_61, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), -1, 1, 1, 1, 1, 0, "D - 'Double_t' 0 '0' det", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Transpose",959,G__G__Matrix_122_0_62, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), -1, 1, 1, 1, 1, 0, "u 'TMatrixT<double>' - 11 - source", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("T",84,G__G__Matrix_122_0_63, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Rank1Update",1056,G__G__Matrix_122_0_64, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), -1, 1, 2, 1, 1, 0, 
"u 'TVectorT<double>' - 11 - v d - - 0 '1.0' alpha", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Rank1Update",1056,G__G__Matrix_122_0_65, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), -1, 1, 3, 1, 1, 0, 
"u 'TVectorT<double>' - 11 - v1 u 'TVectorT<double>' - 11 - v2 "
"d - - 0 '1.0' alpha", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Similarity",1063,G__G__Matrix_122_0_66, 100, -1, -1, 0, 1, 1, 1, 8, "u 'TVectorT<double>' - 11 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("NormByColumn",1221,G__G__Matrix_122_0_67, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), -1, 1, 2, 1, 1, 0, 
"u 'TVectorT<double>' - 11 - v C - 'Option_t' 10 '\"D\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("NormByRow",911,G__G__Matrix_122_0_68, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), -1, 1, 2, 1, 1, 0, 
"u 'TVectorT<double>' - 11 - v C - 'Option_t' 10 '\"D\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator()",957,(G__InterfaceMethod) NULL,100, -1, -1, 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - rown i - 'Int_t' 0 - coln", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("operator()",957,(G__InterfaceMethod) NULL,100, -1, -1, 1, 2, 1, 1, 0, 
"i - 'Int_t' 0 - rown i - 'Int_t' 0 - coln", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("operator[]",1060,G__G__Matrix_122_0_71, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTRow_constlEdoublegR), -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - rown", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__G__Matrix_122_0_72, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTRowlEdoublegR), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - rown", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Matrix_122_0_73, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), -1, 1, 1, 1, 1, 0, "u 'TMatrixT<double>' - 11 - source", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Matrix_122_0_74, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), -1, 1, 1, 1, 1, 0, "u 'TMatrixTSym<double>' - 11 - source", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Matrix_122_0_75, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), -1, 1, 1, 1, 1, 0, "u 'TMatrixTSparse<double>' - 11 - source", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Matrix_122_0_76, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), -1, 1, 1, 1, 1, 0, "u 'TMatrixTLazy<double>' - 11 - source", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Matrix_122_0_77, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), -1, 1, 1, 1, 1, 0, "d - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator-=",982,G__G__Matrix_122_0_78, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), -1, 1, 1, 1, 1, 0, "d - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+=",980,G__G__Matrix_122_0_79, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), -1, 1, 1, 1, 1, 0, "d - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*=",979,G__G__Matrix_122_0_80, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), -1, 1, 1, 1, 1, 0, "d - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+=",980,G__G__Matrix_122_0_81, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), -1, 1, 1, 1, 1, 0, "u 'TMatrixT<double>' - 11 - source", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+=",980,G__G__Matrix_122_0_82, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), -1, 1, 1, 1, 1, 0, "u 'TMatrixTSym<double>' - 11 - source", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator-=",982,G__G__Matrix_122_0_83, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), -1, 1, 1, 1, 1, 0, "u 'TMatrixT<double>' - 11 - source", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator-=",982,G__G__Matrix_122_0_84, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), -1, 1, 1, 1, 1, 0, "u 'TMatrixTSym<double>' - 11 - source", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*=",979,G__G__Matrix_122_0_85, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), -1, 1, 1, 1, 1, 0, "u 'TMatrixT<double>' - 11 - source", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*=",979,G__G__Matrix_122_0_86, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), -1, 1, 1, 1, 1, 0, "u 'TMatrixTSym<double>' - 11 - source", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*=",979,G__G__Matrix_122_0_87, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), -1, 1, 1, 1, 1, 0, "u 'TMatrixTDiag_const<double>' - 11 - diag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator/=",984,G__G__Matrix_122_0_88, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), -1, 1, 1, 1, 1, 0, "u 'TMatrixTDiag_const<double>' - 11 - diag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*=",979,G__G__Matrix_122_0_89, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), -1, 1, 1, 1, 1, 0, "u 'TMatrixTRow_const<double>' - 11 - row", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator/=",984,G__G__Matrix_122_0_90, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), -1, 1, 1, 1, 1, 0, "u 'TMatrixTRow_const<double>' - 11 - row", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*=",979,G__G__Matrix_122_0_91, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), -1, 1, 1, 1, 1, 0, "u 'TMatrixTColumn_const<double>' - 11 - col", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator/=",984,G__G__Matrix_122_0_92, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), -1, 1, 1, 1, 1, 0, "u 'TMatrixTColumn_const<double>' - 11 - col", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("EigenVectors",1230,G__G__Matrix_122_0_93, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), -1, 0, 1, 1, 1, 9, "u 'TVectorT<double>' - 1 - eigenValues", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Matrix_122_0_94, 85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMatrixT<double>::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Matrix_122_0_95, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixT<double>::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Matrix_122_0_96, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMatrixT<double>::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Matrix_122_0_97, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMatrixT<double>::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Matrix_122_0_101, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Matrix_122_0_102, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixT<double>::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Matrix_122_0_103, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMatrixT<double>::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Matrix_122_0_104, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixT<double>::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Matrix_122_0_105, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMatrixT<double>::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TMatrixT<double>", 1680, G__G__Matrix_122_0_106, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMatrixTSymlEdoublegR(void) {
   /* TMatrixTSym<double> */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEdoublegR));
   G__memfunc_setup("New_m",502,(G__InterfaceMethod) NULL, 68, -1, -1, 0, 1, 1, 2, 0, "i - 'Int_t' 0 - size", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Delete_m",799,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 0, 
"i - 'Int_t' 0 - size D - - 1 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Memcpy_m",823,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 5, 1, 2, 0, 
"D - - 0 - newp D - - 10 - oldp "
"i - 'Int_t' 0 - copySize i - 'Int_t' 0 - newSize "
"i - 'Int_t' 0 - oldSize", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Allocate",805,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 6, 1, 2, 0, 
"i - 'Int_t' 0 - nrows i - 'Int_t' 0 - ncols "
"i - 'Int_t' 0 '0' row_lwb i - 'Int_t' 0 '0' col_lwb "
"i - 'Int_t' 0 '0' init i - 'Int_t' 0 '-1' -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTSym<double>",1867,G__G__Matrix_126_0_5, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEdoublegR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTSym<double>",1867,G__G__Matrix_126_0_6, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEdoublegR), -1, 0, 1, 5, 1, 0, "i - 'Int_t' 0 - nrows", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTSym<double>",1867,G__G__Matrix_126_0_7, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEdoublegR), -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - row_lwb i - 'Int_t' 0 - row_upb", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTSym<double>",1867,G__G__Matrix_126_0_8, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEdoublegR), -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - nrows D - - 10 - data "
"C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTSym<double>",1867,G__G__Matrix_126_0_9, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEdoublegR), -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - row_lwb i - 'Int_t' 0 - row_upb "
"D - - 10 - data C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTSym<double>",1867,G__G__Matrix_126_0_10, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEdoublegR), -1, 0, 1, 1, 1, 0, "u 'TMatrixTSym<double>' - 11 - another", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTSym<double>",1867,G__G__Matrix_126_0_11, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEdoublegR), -1, 0, 2, 1, 1, 0, 
"i 'TMatrixTSym<double>::EMatrixCreatorsOp1' - 0 - op u 'TMatrixTSym<double>' - 11 - prototype", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTSym<double>",1867,G__G__Matrix_126_0_12, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEdoublegR), -1, 0, 2, 1, 1, 0, 
"i 'TMatrixTSym<double>::EMatrixCreatorsOp1' - 0 - op u 'TMatrixT<double>' - 11 - prototype", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTSym<double>",1867,G__G__Matrix_126_0_13, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEdoublegR), -1, 0, 3, 1, 1, 0, 
"u 'TMatrixTSym<double>' - 11 - a i 'TMatrixTSym<double>::EMatrixCreatorsOp2' - 0 - op "
"u 'TMatrixTSym<double>' - 11 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTSym<double>",1867,G__G__Matrix_126_0_14, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEdoublegR), -1, 0, 1, 1, 1, 0, "u 'TMatrixTSymLazy<double>' - 11 - lazy_constructor", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMult",502,G__G__Matrix_126_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMatrixT<double>' - 11 - a", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMult",502,G__G__Matrix_126_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMatrixTSym<double>' - 11 - a", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Mult",418,G__G__Matrix_126_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMatrixTSym<double>' - 11 - a", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Plus",420,G__G__Matrix_126_0_18, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TMatrixTSym<double>' - 11 - a u 'TMatrixTSym<double>' - 11 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Minus",524,G__G__Matrix_126_0_19, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TMatrixTSym<double>' - 11 - a u 'TMatrixTSym<double>' - 11 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMatrixArray",1428,(G__InterfaceMethod) NULL,68, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMatrixArray",1428,(G__InterfaceMethod) NULL,68, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRowIndexArray",1615,(G__InterfaceMethod) NULL,73, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRowIndexArray",1615,(G__InterfaceMethod) NULL,73, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetColIndexArray",1589,(G__InterfaceMethod) NULL,73, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetColIndexArray",1589,(G__InterfaceMethod) NULL,73, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetRowIndexArray",1627,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEdoublegR), -1, 1, 1, 1, 1, 0, "I - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetColIndexArray",1601,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEdoublegR), -1, 1, 1, 1, 1, 0, "I - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Clear",487,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsSymmetric",1145,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Use",301,G__G__Matrix_126_0_30, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEdoublegR), -1, 1, 3, 1, 1, 0, 
"i - 'Int_t' 0 - row_lwb i - 'Int_t' 0 - row_upb "
"D - - 0 - data", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Use",301,G__G__Matrix_126_0_31, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEdoublegR), -1, 1, 3, 1, 1, 9, 
"i - 'Int_t' 0 - row_lwb i - 'Int_t' 0 - row_upb "
"D - - 10 - data", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Use",301,G__G__Matrix_126_0_32, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEdoublegR), -1, 1, 2, 1, 1, 0, 
"i - 'Int_t' 0 - nrows D - - 0 - data", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Use",301,G__G__Matrix_126_0_33, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEdoublegR), -1, 1, 2, 1, 1, 9, 
"i - 'Int_t' 0 - nrows D - - 10 - data", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Use",301,G__G__Matrix_126_0_34, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEdoublegR), -1, 1, 1, 1, 1, 0, "u 'TMatrixTSym<double>' - 1 - a", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Use",301,G__G__Matrix_126_0_35, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEdoublegR), -1, 1, 1, 1, 1, 9, "u 'TMatrixTSym<double>' - 11 - a", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSub",586,G__G__Matrix_126_0_36, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEdoublegR), -1, 1, 4, 1, 1, 8, 
"i - 'Int_t' 0 - row_lwb i - 'Int_t' 0 - row_upb "
"u 'TMatrixTSym<double>' - 1 - target C - 'Option_t' 10 '\"S\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSub",586,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEdoublegR), -1, 1, 6, 1, 1, 8, 
"i - 'Int_t' 0 - row_lwb i - 'Int_t' 0 - row_upb "
"i - 'Int_t' 0 - col_lwb i - 'Int_t' 0 - col_upb "
"u 'TMatrixTBase<double>' - 1 - target C - 'Option_t' 10 '\"S\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetSub",586,G__G__Matrix_126_0_38, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEdoublegR), -1, 0, 5, 1, 1, 8, 
"i - 'Int_t' 0 - row_lwb i - 'Int_t' 0 - row_upb "
"i - 'Int_t' 0 - col_lwb i - 'Int_t' 0 - col_upb "
"C - 'Option_t' 10 '\"S\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSub",598,G__G__Matrix_126_0_39, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEdoublegR), -1, 1, 2, 1, 1, 0, 
"i - 'Int_t' 0 - row_lwb u 'TMatrixTBase<double>' - 11 - source", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSub",598,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEdoublegR), -1, 1, 3, 1, 1, 0, 
"i - 'Int_t' 0 - row_lwb i - 'Int_t' 0 - col_lwb "
"u 'TMatrixTBase<double>' - 11 - source", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetMatrixArray",1440,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEdoublegR), -1, 1, 2, 1, 1, 0, 
"D - - 10 - data C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Shift",510,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEdoublegR), -1, 1, 2, 1, 1, 0, 
"i - 'Int_t' 0 - row_shift i - 'Int_t' 0 - col_shift", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ResizeTo",821,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEdoublegR), -1, 1, 3, 1, 1, 0, 
"i - 'Int_t' 0 - nrows i - 'Int_t' 0 - ncols "
"i - 'Int_t' 0 '-1' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ResizeTo",821,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEdoublegR), -1, 1, 5, 1, 1, 0, 
"i - 'Int_t' 0 - row_lwb i - 'Int_t' 0 - row_upb "
"i - 'Int_t' 0 - col_lwb i - 'Int_t' 0 - col_upb "
"i - 'Int_t' 0 '-1' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ResizeTo",821,G__G__Matrix_126_0_45, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEdoublegR), -1, 1, 1, 1, 1, 0, "u 'TMatrixTSym<double>' - 11 - m", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Determinant",1147,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Determinant",1147,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 8, 
"d - 'Double_t' 1 - d1 d - 'Double_t' 1 - d2", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Invert",632,G__G__Matrix_126_0_48, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEdoublegR), -1, 1, 1, 1, 1, 0, "D - 'Double_t' 0 '0' det", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InvertFast",1030,G__G__Matrix_126_0_49, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEdoublegR), -1, 1, 1, 1, 1, 0, "D - 'Double_t' 0 '0' det", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Transpose",959,G__G__Matrix_126_0_50, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEdoublegR), -1, 1, 1, 1, 1, 0, "u 'TMatrixTSym<double>' - 11 - source", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("T",84,G__G__Matrix_126_0_51, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEdoublegR), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Rank1Update",1056,G__G__Matrix_126_0_52, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEdoublegR), -1, 1, 2, 1, 1, 0, 
"u 'TVectorT<double>' - 11 - v d - - 0 '1.0' alpha", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Similarity",1063,G__G__Matrix_126_0_53, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEdoublegR), -1, 1, 1, 1, 1, 0, "u 'TMatrixT<double>' - 11 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Similarity",1063,G__G__Matrix_126_0_54, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEdoublegR), -1, 1, 1, 1, 1, 0, "u 'TMatrixTSym<double>' - 11 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Similarity",1063,G__G__Matrix_126_0_55, 100, -1, -1, 0, 1, 1, 1, 8, "u 'TVectorT<double>' - 11 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SimilarityT",1147,G__G__Matrix_126_0_56, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEdoublegR), -1, 1, 1, 1, 1, 0, "u 'TMatrixT<double>' - 11 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator()",957,(G__InterfaceMethod) NULL,100, -1, -1, 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - rown i - 'Int_t' 0 - coln", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("operator()",957,(G__InterfaceMethod) NULL,100, -1, -1, 1, 2, 1, 1, 0, 
"i - 'Int_t' 0 - rown i - 'Int_t' 0 - coln", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("operator[]",1060,G__G__Matrix_126_0_59, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTRow_constlEdoublegR), -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - rown", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__G__Matrix_126_0_60, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTRowlEdoublegR), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - rown", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Matrix_126_0_61, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEdoublegR), -1, 1, 1, 1, 1, 0, "u 'TMatrixTSym<double>' - 11 - source", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Matrix_126_0_62, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEdoublegR), -1, 1, 1, 1, 1, 0, "u 'TMatrixTSymLazy<double>' - 11 - source", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Matrix_126_0_63, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEdoublegR), -1, 1, 1, 1, 1, 0, "d - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator-=",982,G__G__Matrix_126_0_64, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEdoublegR), -1, 1, 1, 1, 1, 0, "d - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+=",980,G__G__Matrix_126_0_65, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEdoublegR), -1, 1, 1, 1, 1, 0, "d - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*=",979,G__G__Matrix_126_0_66, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEdoublegR), -1, 1, 1, 1, 1, 0, "d - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+=",980,G__G__Matrix_126_0_67, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEdoublegR), -1, 1, 1, 1, 1, 0, "u 'TMatrixTSym<double>' - 11 - source", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator-=",982,G__G__Matrix_126_0_68, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEdoublegR), -1, 1, 1, 1, 1, 0, "u 'TMatrixTSym<double>' - 11 - source", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Apply",518,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEdoublegR), -1, 1, 1, 1, 1, 0, "u 'TElementActionT<double>' - 11 - action", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Apply",518,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEdoublegR), -1, 1, 1, 1, 1, 0, "u 'TElementPosActionT<double>' - 11 - action", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Randomize",937,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEdoublegR), -1, 1, 3, 1, 1, 0, 
"d - - 0 - alpha d - - 0 - beta "
"d - 'Double_t' 1 - seed", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RandomizePD",1085,G__G__Matrix_126_0_72, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEdoublegR), -1, 1, 3, 1, 1, 0, 
"d - - 0 - alpha d - - 0 - beta "
"d - 'Double_t' 1 - seed", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("EigenVectors",1230,G__G__Matrix_126_0_73, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), -1, 0, 1, 1, 1, 9, "u 'TVectorT<double>' - 1 - eigenValues", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Matrix_126_0_74, 85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMatrixTSym<double>::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Matrix_126_0_75, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTSym<double>::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Matrix_126_0_76, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMatrixTSym<double>::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Matrix_126_0_77, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMatrixTSym<double>::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Matrix_126_0_81, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Matrix_126_0_82, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTSym<double>::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Matrix_126_0_83, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMatrixTSym<double>::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Matrix_126_0_84, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTSym<double>::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Matrix_126_0_85, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMatrixTSym<double>::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TMatrixTSym<double>", 1993, G__G__Matrix_126_0_86, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMatrixTSparselEdoublegR(void) {
   /* TMatrixTSparse<double> */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEdoublegR));
   G__memfunc_setup("Allocate",805,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 6, 1, 2, 0, 
"i - 'Int_t' 0 - nrows i - 'Int_t' 0 - ncols "
"i - 'Int_t' 0 '0' row_lwb i - 'Int_t' 0 '0' col_lwb "
"i - 'Int_t' 0 '0' init i - 'Int_t' 0 '0' nr_nonzeros", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AMultB",549,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 2, 0, 
"u 'TMatrixTSparse<double>' - 11 - a u 'TMatrixTSparse<double>' - 11 - b "
"i - 'Int_t' 0 '0' constr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AMultB",549,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 2, 0, 
"u 'TMatrixTSparse<double>' - 11 - a u 'TMatrixT<double>' - 11 - b "
"i - 'Int_t' 0 '0' constr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AMultB",549,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 2, 0, 
"u 'TMatrixT<double>' - 11 - a u 'TMatrixTSparse<double>' - 11 - b "
"i - 'Int_t' 0 '0' constr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AMultBt",665,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 2, 0, 
"u 'TMatrixTSparse<double>' - 11 - a u 'TMatrixTSparse<double>' - 11 - b "
"i - 'Int_t' 0 '0' constr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AMultBt",665,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 2, 0, 
"u 'TMatrixTSparse<double>' - 11 - a u 'TMatrixT<double>' - 11 - b "
"i - 'Int_t' 0 '0' constr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AMultBt",665,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 2, 0, 
"u 'TMatrixT<double>' - 11 - a u 'TMatrixTSparse<double>' - 11 - b "
"i - 'Int_t' 0 '0' constr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("APlusB",551,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 2, 0, 
"u 'TMatrixTSparse<double>' - 11 - a u 'TMatrixTSparse<double>' - 11 - b "
"i - 'Int_t' 0 '0' constr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("APlusB",551,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 2, 0, 
"u 'TMatrixTSparse<double>' - 11 - a u 'TMatrixT<double>' - 11 - b "
"i - 'Int_t' 0 '0' constr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("APlusB",551,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 2, 0, 
"u 'TMatrixT<double>' - 11 - a u 'TMatrixTSparse<double>' - 11 - b "
"i - 'Int_t' 0 '0' constr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AMinusB",655,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 2, 0, 
"u 'TMatrixTSparse<double>' - 11 - a u 'TMatrixTSparse<double>' - 11 - b "
"i - 'Int_t' 0 '0' constr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AMinusB",655,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 2, 0, 
"u 'TMatrixTSparse<double>' - 11 - a u 'TMatrixT<double>' - 11 - b "
"i - 'Int_t' 0 '0' constr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AMinusB",655,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 2, 0, 
"u 'TMatrixT<double>' - 11 - a u 'TMatrixTSparse<double>' - 11 - b "
"i - 'Int_t' 0 '0' constr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTSparse<double>",2176,G__G__Matrix_127_0_14, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEdoublegR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTSparse<double>",2176,G__G__Matrix_127_0_15, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEdoublegR), -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - nrows i - 'Int_t' 0 - ncols", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTSparse<double>",2176,G__G__Matrix_127_0_16, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEdoublegR), -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - row_lwb i - 'Int_t' 0 - row_upb "
"i - 'Int_t' 0 - col_lwb i - 'Int_t' 0 - col_upb", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTSparse<double>",2176,G__G__Matrix_127_0_17, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEdoublegR), -1, 0, 8, 1, 1, 0, 
"i - 'Int_t' 0 - row_lwb i - 'Int_t' 0 - row_upb "
"i - 'Int_t' 0 - col_lwb i - 'Int_t' 0 - col_upb "
"i - 'Int_t' 0 - nr_nonzeros I - 'Int_t' 0 - row "
"I - 'Int_t' 0 - col D - - 0 - data", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTSparse<double>",2176,G__G__Matrix_127_0_18, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEdoublegR), -1, 0, 1, 1, 1, 0, "u 'TMatrixTSparse<double>' - 11 - another", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTSparse<double>",2176,G__G__Matrix_127_0_19, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEdoublegR), -1, 0, 1, 1, 1, 0, "u 'TMatrixT<double>' - 11 - another", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTSparse<double>",2176,G__G__Matrix_127_0_20, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEdoublegR), -1, 0, 2, 1, 1, 0, 
"i 'TMatrixTSparse<double>::EMatrixCreatorsOp1' - 0 - op u 'TMatrixTSparse<double>' - 11 - prototype", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTSparse<double>",2176,G__G__Matrix_127_0_21, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEdoublegR), -1, 0, 3, 1, 1, 0, 
"u 'TMatrixTSparse<double>' - 11 - a i 'TMatrixTSparse<double>::EMatrixCreatorsOp2' - 0 - op "
"u 'TMatrixTSparse<double>' - 11 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTSparse<double>",2176,G__G__Matrix_127_0_22, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEdoublegR), -1, 0, 3, 1, 1, 0, 
"u 'TMatrixTSparse<double>' - 11 - a i 'TMatrixTSparse<double>::EMatrixCreatorsOp2' - 0 - op "
"u 'TMatrixT<double>' - 11 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTSparse<double>",2176,G__G__Matrix_127_0_23, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEdoublegR), -1, 0, 3, 1, 1, 0, 
"u 'TMatrixT<double>' - 11 - a i 'TMatrixTSparse<double>::EMatrixCreatorsOp2' - 0 - op "
"u 'TMatrixTSparse<double>' - 11 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMatrixArray",1428,(G__InterfaceMethod) NULL,68, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMatrixArray",1428,(G__InterfaceMethod) NULL,68, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRowIndexArray",1615,(G__InterfaceMethod) NULL,73, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRowIndexArray",1615,(G__InterfaceMethod) NULL,73, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetColIndexArray",1589,(G__InterfaceMethod) NULL,73, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetColIndexArray",1589,(G__InterfaceMethod) NULL,73, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetRowIndexArray",1627,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEdoublegR), -1, 1, 1, 1, 1, 0, "I - 'Int_t' 0 - data", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetColIndexArray",1601,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEdoublegR), -1, 1, 1, 1, 1, 0, "I - 'Int_t' 0 - data", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetSparseIndex",1426,G__G__Matrix_127_0_32, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEdoublegR), -1, 1, 1, 1, 1, 0, "i - 'Int_t' 0 - nelem_new", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSparseIndex",1426,G__G__Matrix_127_0_33, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEdoublegR), -1, 1, 1, 1, 1, 0, "u 'TMatrixTBase<double>' - 11 - another", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSparseIndexAB",1557,G__G__Matrix_127_0_34, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEdoublegR), -1, 1, 2, 1, 1, 0, 
"u 'TMatrixTSparse<double>' - 11 - a u 'TMatrixTSparse<double>' - 11 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSparseIndexAB",1557,G__G__Matrix_127_0_35, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEdoublegR), -1, 1, 2, 1, 1, 0, 
"u 'TMatrixT<double>' - 11 - a u 'TMatrixTSparse<double>' - 11 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSparseIndexAB",1557,G__G__Matrix_127_0_36, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEdoublegR), -1, 1, 2, 1, 1, 0, 
"u 'TMatrixTSparse<double>' - 11 - a u 'TMatrixT<double>' - 11 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMatrix2Array",1478,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 8, 
"D - - 0 - data C - 'Option_t' 10 '\"\"' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetMatrixArray",1440,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEdoublegR), -1, 1, 2, 1, 1, 0, 
"D - - 10 - data C - 'Option_t' 10 '\"\"' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetMatrixArray",1440,G__G__Matrix_127_0_39, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEdoublegR), -1, 1, 4, 1, 1, 0, 
"i - 'Int_t' 0 - nr_nonzeros I - 'Int_t' 0 - irow "
"I - 'Int_t' 0 - icol D - - 0 - data", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InsertRow",941,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEdoublegR), -1, 1, 4, 1, 1, 0, 
"i - 'Int_t' 0 - row i - 'Int_t' 0 - col "
"D - - 10 - v i - 'Int_t' 0 '-1' n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ExtractRow",1043,(G__InterfaceMethod) NULL,121, -1, -1, 0, 4, 1, 1, 8, 
"i - 'Int_t' 0 - row i - 'Int_t' 0 - col "
"D - - 0 - v i - 'Int_t' 0 '-1' n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ResizeTo",821,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEdoublegR), -1, 1, 3, 1, 1, 0, 
"i - 'Int_t' 0 - nrows i - 'Int_t' 0 - ncols "
"i - 'Int_t' 0 '-1' nr_nonzeros", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ResizeTo",821,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEdoublegR), -1, 1, 5, 1, 1, 0, 
"i - 'Int_t' 0 - row_lwb i - 'Int_t' 0 - row_upb "
"i - 'Int_t' 0 - col_lwb i - 'Int_t' 0 - col_upb "
"i - 'Int_t' 0 '-1' nr_nonzeros", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ResizeTo",821,G__G__Matrix_127_0_44, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEdoublegR), -1, 1, 1, 1, 1, 0, "u 'TMatrixTSparse<double>' - 11 - m", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Clear",487,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Use",301,G__G__Matrix_127_0_46, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEdoublegR), -1, 1, 8, 1, 1, 0, 
"i - 'Int_t' 0 - row_lwb i - 'Int_t' 0 - row_upb "
"i - 'Int_t' 0 - col_lwb i - 'Int_t' 0 - col_upb "
"i - 'Int_t' 0 - nr_nonzeros I - 'Int_t' 0 - pRowIndex "
"I - 'Int_t' 0 - pColIndex D - - 0 - pData", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Use",301,G__G__Matrix_127_0_47, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEdoublegR), -1, 1, 8, 1, 1, 9, 
"i - 'Int_t' 0 - row_lwb i - 'Int_t' 0 - row_upb "
"i - 'Int_t' 0 - col_lwb i - 'Int_t' 0 - col_upb "
"i - 'Int_t' 0 - nr_nonzeros I - 'Int_t' 10 - pRowIndex "
"I - 'Int_t' 10 - pColIndex D - - 10 - pData", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Use",301,G__G__Matrix_127_0_48, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEdoublegR), -1, 1, 6, 1, 1, 0, 
"i - 'Int_t' 0 - nrows i - 'Int_t' 0 - ncols "
"i - 'Int_t' 0 - nr_nonzeros I - 'Int_t' 0 - pRowIndex "
"I - 'Int_t' 0 - pColIndex D - - 0 - pData", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Use",301,G__G__Matrix_127_0_49, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEdoublegR), -1, 1, 6, 1, 1, 9, 
"i - 'Int_t' 0 - nrows i - 'Int_t' 0 - ncols "
"i - 'Int_t' 0 - nr_nonzeros I - 'Int_t' 10 - pRowIndex "
"I - 'Int_t' 10 - pColIndex D - - 10 - pData", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Use",301,G__G__Matrix_127_0_50, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEdoublegR), -1, 1, 1, 1, 1, 0, "u 'TMatrixTSparse<double>' - 1 - a", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Use",301,G__G__Matrix_127_0_51, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEdoublegR), -1, 1, 1, 1, 1, 9, "u 'TMatrixTSparse<double>' - 11 - a", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSub",586,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEdoublegR), -1, 1, 6, 1, 1, 8, 
"i - 'Int_t' 0 - row_lwb i - 'Int_t' 0 - row_upb "
"i - 'Int_t' 0 - col_lwb i - 'Int_t' 0 - col_upb "
"u 'TMatrixTBase<double>' - 1 - target C - 'Option_t' 10 '\"S\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetSub",586,G__G__Matrix_127_0_53, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEdoublegR), -1, 0, 5, 1, 1, 8, 
"i - 'Int_t' 0 - row_lwb i - 'Int_t' 0 - row_upb "
"i - 'Int_t' 0 - col_lwb i - 'Int_t' 0 - col_upb "
"C - 'Option_t' 10 '\"S\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSub",598,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEdoublegR), -1, 1, 3, 1, 1, 0, 
"i - 'Int_t' 0 - row_lwb i - 'Int_t' 0 - col_lwb "
"u 'TMatrixTBase<double>' - 11 - source", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsSymmetric",1145,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Transpose",959,G__G__Matrix_127_0_56, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEdoublegR), -1, 1, 1, 1, 1, 0, "u 'TMatrixTSparse<double>' - 11 - source", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("T",84,G__G__Matrix_127_0_57, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEdoublegR), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Mult",418,G__G__Matrix_127_0_58, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TMatrixTSparse<double>' - 11 - a u 'TMatrixTSparse<double>' - 11 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Zero",416,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEdoublegR), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("UnitMatrix",1045,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEdoublegR), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RowNorm",724,(G__InterfaceMethod) NULL,100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ColNorm",698,(G__InterfaceMethod) NULL,100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("NonZeros",830,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("NormByDiag",972,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEdoublegR), -1, 1, 2, 1, 1, 0, 
"u 'TVectorT<double>' - 11 - - C - 'Option_t' 10 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("operator()",957,(G__InterfaceMethod) NULL,100, -1, -1, 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - rown i - 'Int_t' 0 - coln", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("operator()",957,(G__InterfaceMethod) NULL,100, -1, -1, 1, 2, 1, 1, 0, 
"i - 'Int_t' 0 - rown i - 'Int_t' 0 - coln", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("operator[]",1060,G__G__Matrix_127_0_67, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparseRow_constlEdoublegR), -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - rown", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__G__Matrix_127_0_68, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparseRowlEdoublegR), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - rown", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Matrix_127_0_69, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEdoublegR), -1, 1, 1, 1, 1, 0, "u 'TMatrixT<double>' - 11 - source", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Matrix_127_0_70, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEdoublegR), -1, 1, 1, 1, 1, 0, "u 'TMatrixTSparse<double>' - 11 - source", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Matrix_127_0_71, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEdoublegR), -1, 1, 1, 1, 1, 0, "d - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator-=",982,G__G__Matrix_127_0_72, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEdoublegR), -1, 1, 1, 1, 1, 0, "d - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+=",980,G__G__Matrix_127_0_73, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEdoublegR), -1, 1, 1, 1, 1, 0, "d - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*=",979,G__G__Matrix_127_0_74, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEdoublegR), -1, 1, 1, 1, 1, 0, "d - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+=",980,G__G__Matrix_127_0_75, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEdoublegR), -1, 1, 1, 1, 1, 0, "u 'TMatrixTSparse<double>' - 11 - source", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+=",980,G__G__Matrix_127_0_76, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEdoublegR), -1, 1, 1, 1, 1, 0, "u 'TMatrixT<double>' - 11 - source", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator-=",982,G__G__Matrix_127_0_77, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEdoublegR), -1, 1, 1, 1, 1, 0, "u 'TMatrixTSparse<double>' - 11 - source", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator-=",982,G__G__Matrix_127_0_78, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEdoublegR), -1, 1, 1, 1, 1, 0, "u 'TMatrixT<double>' - 11 - source", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*=",979,G__G__Matrix_127_0_79, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEdoublegR), -1, 1, 1, 1, 1, 0, "u 'TMatrixTSparse<double>' - 11 - source", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*=",979,G__G__Matrix_127_0_80, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEdoublegR), -1, 1, 1, 1, 1, 0, "u 'TMatrixT<double>' - 11 - source", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Randomize",937,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEdoublegR), -1, 1, 3, 1, 1, 0, 
"d - - 0 - alpha d - - 0 - beta "
"d - 'Double_t' 1 - seed", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RandomizePD",1085,G__G__Matrix_127_0_82, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEdoublegR), -1, 1, 3, 1, 1, 0, 
"d - - 0 - alpha d - - 0 - beta "
"d - 'Double_t' 1 - seed", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Matrix_127_0_83, 85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMatrixTSparse<double>::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Matrix_127_0_84, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTSparse<double>::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Matrix_127_0_85, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMatrixTSparse<double>::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Matrix_127_0_86, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMatrixTSparse<double>::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Matrix_127_0_90, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Matrix_127_0_91, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTSparse<double>::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Matrix_127_0_92, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMatrixTSparse<double>::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Matrix_127_0_93, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTSparse<double>::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Matrix_127_0_94, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMatrixTSparse<double>::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TMatrixTSparse<double>", 2302, G__G__Matrix_127_0_95, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMatrixTLazylEdoublegR(void) {
   /* TMatrixTLazy<double> */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTLazylEdoublegR));
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "u 'TMatrixTLazy<double>' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FillIn",574,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 8, "u 'TMatrixT<double>' - 1 - m", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetRowLwb",893,G__G__Matrix_128_0_7, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRowUpb",895,G__G__Matrix_128_0_8, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetColLwb",867,G__G__Matrix_128_0_9, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetColUpb",869,G__G__Matrix_128_0_10, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Matrix_128_0_11, 85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMatrixTLazy<double>::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Matrix_128_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTLazy<double>::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Matrix_128_0_13, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMatrixTLazy<double>::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Matrix_128_0_14, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMatrixTLazy<double>::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Matrix_128_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Matrix_128_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTLazy<double>::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Matrix_128_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMatrixTLazy<double>::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Matrix_128_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTLazy<double>::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Matrix_128_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMatrixTLazy<double>::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TMatrixTLazy<double>", 2096, G__G__Matrix_128_0_23, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMatrixTRow_constlEdoublegR(void) {
   /* TMatrixTRow_const<double> */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTRow_constlEdoublegR));
   G__memfunc_setup("TMatrixTRow_const<double>",2512,G__G__Matrix_129_0_1, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTRow_constlEdoublegR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTRow_const<double>",2512,G__G__Matrix_129_0_2, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTRow_constlEdoublegR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixT<double>' - 11 - matrix i - 'Int_t' 0 - row", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTRow_const<double>",2512,G__G__Matrix_129_0_3, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTRow_constlEdoublegR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixTSym<double>' - 11 - matrix i - 'Int_t' 0 - row", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTRow_const<double>",2512,G__G__Matrix_129_0_4, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTRow_constlEdoublegR), -1, 0, 1, 1, 1, 0, "u 'TMatrixTRow_const<double>' - 11 - trc", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Matrix_129_0_5, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTRow_constlEdoublegR), -1, 1, 1, 1, 1, 0, "u 'TMatrixTRow_const<double>' - 11 - trc", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMatrix",917,G__G__Matrix_129_0_6, 85, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEdoublegR), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRowIndex",1104,G__G__Matrix_129_0_7, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetInc",570,G__G__Matrix_129_0_8, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPtr",598,G__G__Matrix_129_0_9, 68, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator()",957,G__G__Matrix_129_0_10, 100, -1, -1, 1, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__G__Matrix_129_0_11, 100, -1, -1, 1, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Matrix_129_0_12, 85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMatrixTRow_const<double>::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Matrix_129_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTRow_const<double>::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Matrix_129_0_14, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMatrixTRow_const<double>::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Matrix_129_0_15, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMatrixTRow_const<double>::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Matrix_129_0_16, 85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__Matrix_129_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__Matrix_129_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Matrix_129_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Matrix_129_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTRow_const<double>::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Matrix_129_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMatrixTRow_const<double>::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Matrix_129_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTRow_const<double>::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Matrix_129_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMatrixTRow_const<double>::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TMatrixTRow_const<double>", 2638, G__G__Matrix_129_0_24, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMatrixTRowlEdoublegR(void) {
   /* TMatrixTRow<double> */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTRowlEdoublegR));
   G__memfunc_setup("TMatrixTRow<double>",1866,G__G__Matrix_130_0_1, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTRowlEdoublegR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTRow<double>",1866,G__G__Matrix_130_0_2, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTRowlEdoublegR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixT<double>' - 1 - matrix i - 'Int_t' 0 - row", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTRow<double>",1866,G__G__Matrix_130_0_3, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTRowlEdoublegR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixTSym<double>' - 1 - matrix i - 'Int_t' 0 - row", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTRow<double>",1866,G__G__Matrix_130_0_4, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTRowlEdoublegR), -1, 0, 1, 1, 1, 0, "u 'TMatrixTRow<double>' - 11 - mr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPtr",598,G__G__Matrix_130_0_5, 68, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator()",957,G__G__Matrix_130_0_6, 100, -1, -1, 1, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator()",957,G__G__Matrix_130_0_7, 100, -1, -1, 1, 1, 1, 1, 0, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__G__Matrix_130_0_8, 100, -1, -1, 1, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__G__Matrix_130_0_9, 100, -1, -1, 1, 1, 1, 1, 0, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Matrix_130_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+=",980,G__G__Matrix_130_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*=",979,G__G__Matrix_130_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Matrix_130_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMatrixTRow_const<double>' - 11 - r", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Matrix_130_0_14, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTRowlEdoublegR), -1, 1, 1, 1, 1, 0, "u 'TMatrixTRow<double>' - 11 - r", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Matrix_130_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TVectorT<double>' - 11 - vec", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+=",980,G__G__Matrix_130_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMatrixTRow_const<double>' - 11 - r", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*=",979,G__G__Matrix_130_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMatrixTRow_const<double>' - 11 - r", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Matrix_130_0_18, 85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMatrixTRow<double>::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Matrix_130_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTRow<double>::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Matrix_130_0_20, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMatrixTRow<double>::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Matrix_130_0_21, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMatrixTRow<double>::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Matrix_130_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Matrix_130_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTRow<double>::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Matrix_130_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMatrixTRow<double>::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Matrix_130_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTRow<double>::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Matrix_130_0_29, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMatrixTRow<double>::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TMatrixTRow<double>", 1992, G__G__Matrix_130_0_30, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMatrixTDiag_constlEdoublegR(void) {
   /* TMatrixTDiag_const<double> */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTDiag_constlEdoublegR));
   G__memfunc_setup("TMatrixTDiag_const<double>",2573,G__G__Matrix_131_0_1, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTDiag_constlEdoublegR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTDiag_const<double>",2573,G__G__Matrix_131_0_2, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTDiag_constlEdoublegR), -1, 0, 1, 1, 1, 0, "u 'TMatrixT<double>' - 11 - matrix", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTDiag_const<double>",2573,G__G__Matrix_131_0_3, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTDiag_constlEdoublegR), -1, 0, 1, 1, 1, 0, "u 'TMatrixTSym<double>' - 11 - matrix", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTDiag_const<double>",2573,G__G__Matrix_131_0_4, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTDiag_constlEdoublegR), -1, 0, 1, 1, 1, 0, "u 'TMatrixTDiag_const<double>' - 11 - trc", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Matrix_131_0_5, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTDiag_constlEdoublegR), -1, 1, 1, 1, 1, 0, "u 'TMatrixTDiag_const<double>' - 11 - trc", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMatrix",917,G__G__Matrix_131_0_6, 85, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEdoublegR), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPtr",598,G__G__Matrix_131_0_7, 68, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetInc",570,G__G__Matrix_131_0_8, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator()",957,G__G__Matrix_131_0_9, 100, -1, -1, 1, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__G__Matrix_131_0_10, 100, -1, -1, 1, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNdiags",886,G__G__Matrix_131_0_11, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Matrix_131_0_12, 85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMatrixTDiag_const<double>::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Matrix_131_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTDiag_const<double>::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Matrix_131_0_14, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMatrixTDiag_const<double>::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Matrix_131_0_15, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMatrixTDiag_const<double>::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Matrix_131_0_16, 85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__Matrix_131_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__Matrix_131_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Matrix_131_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Matrix_131_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTDiag_const<double>::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Matrix_131_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMatrixTDiag_const<double>::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Matrix_131_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTDiag_const<double>::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Matrix_131_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMatrixTDiag_const<double>::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TMatrixTDiag_const<double>", 2699, G__G__Matrix_131_0_24, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMatrixTColumn_constlEdoublegR(void) {
   /* TMatrixTColumn_const<double> */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTColumn_constlEdoublegR));
   G__memfunc_setup("TMatrixTColumn_const<double>",2822,G__G__Matrix_132_0_1, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTColumn_constlEdoublegR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTColumn_const<double>",2822,G__G__Matrix_132_0_2, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTColumn_constlEdoublegR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixT<double>' - 11 - matrix i - 'Int_t' 0 - col", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTColumn_const<double>",2822,G__G__Matrix_132_0_3, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTColumn_constlEdoublegR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixTSym<double>' - 11 - matrix i - 'Int_t' 0 - col", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTColumn_const<double>",2822,G__G__Matrix_132_0_4, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTColumn_constlEdoublegR), -1, 0, 1, 1, 1, 0, "u 'TMatrixTColumn_const<double>' - 11 - trc", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Matrix_132_0_5, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTColumn_constlEdoublegR), -1, 1, 1, 1, 1, 0, "u 'TMatrixTColumn_const<double>' - 11 - trc", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMatrix",917,G__G__Matrix_132_0_6, 85, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEdoublegR), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetColIndex",1078,G__G__Matrix_132_0_7, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetInc",570,G__G__Matrix_132_0_8, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPtr",598,G__G__Matrix_132_0_9, 68, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator()",957,G__G__Matrix_132_0_10, 100, -1, -1, 1, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__G__Matrix_132_0_11, 100, -1, -1, 1, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Matrix_132_0_12, 85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMatrixTColumn_const<double>::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Matrix_132_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTColumn_const<double>::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Matrix_132_0_14, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMatrixTColumn_const<double>::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Matrix_132_0_15, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMatrixTColumn_const<double>::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Matrix_132_0_16, 85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__Matrix_132_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__Matrix_132_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Matrix_132_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Matrix_132_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTColumn_const<double>::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Matrix_132_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMatrixTColumn_const<double>::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Matrix_132_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTColumn_const<double>::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Matrix_132_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMatrixTColumn_const<double>::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TMatrixTColumn_const<double>", 2948, G__G__Matrix_132_0_24, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMatrixTFlat_constlEdoublegR(void) {
   /* TMatrixTFlat_const<double> */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTFlat_constlEdoublegR));
   G__memfunc_setup("TMatrixTFlat_const<double>",2591,G__G__Matrix_133_0_1, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTFlat_constlEdoublegR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTFlat_const<double>",2591,G__G__Matrix_133_0_2, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTFlat_constlEdoublegR), -1, 0, 1, 1, 1, 0, "u 'TMatrixT<double>' - 11 - matrix", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTFlat_const<double>",2591,G__G__Matrix_133_0_3, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTFlat_constlEdoublegR), -1, 0, 1, 1, 1, 0, "u 'TMatrixTSym<double>' - 11 - matrix", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTFlat_const<double>",2591,G__G__Matrix_133_0_4, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTFlat_constlEdoublegR), -1, 0, 1, 1, 1, 0, "u 'TMatrixTFlat_const<double>' - 11 - trc", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Matrix_133_0_5, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTFlat_constlEdoublegR), -1, 1, 1, 1, 1, 0, "u 'TMatrixTFlat_const<double>' - 11 - trc", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMatrix",917,G__G__Matrix_133_0_6, 85, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEdoublegR), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPtr",598,G__G__Matrix_133_0_7, 68, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator()",957,G__G__Matrix_133_0_8, 100, -1, -1, 1, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__G__Matrix_133_0_9, 100, -1, -1, 1, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Matrix_133_0_10, 85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMatrixTFlat_const<double>::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Matrix_133_0_11, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTFlat_const<double>::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Matrix_133_0_12, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMatrixTFlat_const<double>::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Matrix_133_0_13, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMatrixTFlat_const<double>::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Matrix_133_0_14, 85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__Matrix_133_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__Matrix_133_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Matrix_133_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Matrix_133_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTFlat_const<double>::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Matrix_133_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMatrixTFlat_const<double>::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Matrix_133_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTFlat_const<double>::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Matrix_133_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMatrixTFlat_const<double>::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TMatrixTFlat_const<double>", 2717, G__G__Matrix_133_0_22, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMatrixTSub_constlEdoublegR(void) {
   /* TMatrixTSub_const<double> */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSub_constlEdoublegR));
   G__memfunc_setup("TMatrixTSub_const<double>",2498,G__G__Matrix_134_0_1, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSub_constlEdoublegR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTSub_const<double>",2498,G__G__Matrix_134_0_2, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSub_constlEdoublegR), -1, 0, 5, 1, 1, 0, 
"u 'TMatrixT<double>' - 11 - matrix i - 'Int_t' 0 - row_lwb "
"i - 'Int_t' 0 - row_upb i - 'Int_t' 0 - col_lwb "
"i - 'Int_t' 0 - col_upb", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTSub_const<double>",2498,G__G__Matrix_134_0_3, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSub_constlEdoublegR), -1, 0, 5, 1, 1, 0, 
"u 'TMatrixTSym<double>' - 11 - matrix i - 'Int_t' 0 - row_lwb "
"i - 'Int_t' 0 - row_upb i - 'Int_t' 0 - col_lwb "
"i - 'Int_t' 0 - col_upb", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMatrix",917,G__G__Matrix_134_0_4, 85, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEdoublegR), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRowOff",883,G__G__Matrix_134_0_5, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetColOff",857,G__G__Matrix_134_0_6, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNrows",825,G__G__Matrix_134_0_7, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNcols",799,G__G__Matrix_134_0_8, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator()",957,G__G__Matrix_134_0_9, 100, -1, -1, 1, 2, 1, 1, 9, 
"i - 'Int_t' 0 - rown i - 'Int_t' 0 - coln", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Matrix_134_0_10, 85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMatrixTSub_const<double>::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Matrix_134_0_11, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTSub_const<double>::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Matrix_134_0_12, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMatrixTSub_const<double>::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Matrix_134_0_13, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMatrixTSub_const<double>::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Matrix_134_0_14, 85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__Matrix_134_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__Matrix_134_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Matrix_134_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Matrix_134_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTSub_const<double>::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Matrix_134_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMatrixTSub_const<double>::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Matrix_134_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTSub_const<double>::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Matrix_134_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMatrixTSub_const<double>::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TMatrixTSub_const<double>", 2498, G__G__Matrix_134_0_22, (int) ('i'), 
G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSub_constlEdoublegR), -1, 0, 1, 1, 1, 0, "u 'TMatrixTSub_const<double>' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TMatrixTSub_const<double>", 2624, G__G__Matrix_134_0_23, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMatrixTSparseRow_constlEdoublegR(void) {
   /* TMatrixTSparseRow_const<double> */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparseRow_constlEdoublegR));
   G__memfunc_setup("TMatrixTSparseRow_const<double>",3134,G__G__Matrix_135_0_1, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparseRow_constlEdoublegR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTSparseRow_const<double>",3134,G__G__Matrix_135_0_2, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparseRow_constlEdoublegR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixTSparse<double>' - 11 - matrix i - 'Int_t' 0 - row", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTSparseRow_const<double>",3134,G__G__Matrix_135_0_3, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparseRow_constlEdoublegR), -1, 0, 1, 1, 1, 0, "u 'TMatrixTSparseRow_const<double>' - 11 - trc", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Matrix_135_0_4, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparseRow_constlEdoublegR), -1, 1, 1, 1, 1, 0, "u 'TMatrixTSparseRow_const<double>' - 11 - trc", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMatrix",917,G__G__Matrix_135_0_5, 85, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEdoublegR), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDataPtr",976,G__G__Matrix_135_0_6, 68, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetColPtr",884,G__G__Matrix_135_0_7, 73, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRowIndex",1104,G__G__Matrix_135_0_8, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNindex",902,G__G__Matrix_135_0_9, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator()",957,G__G__Matrix_135_0_10, 100, -1, -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__G__Matrix_135_0_11, 100, -1, -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Matrix_135_0_12, 85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMatrixTSparseRow_const<double>::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Matrix_135_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTSparseRow_const<double>::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Matrix_135_0_14, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMatrixTSparseRow_const<double>::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Matrix_135_0_15, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMatrixTSparseRow_const<double>::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Matrix_135_0_16, 85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__Matrix_135_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__Matrix_135_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Matrix_135_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Matrix_135_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTSparseRow_const<double>::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Matrix_135_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMatrixTSparseRow_const<double>::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Matrix_135_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTSparseRow_const<double>::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Matrix_135_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMatrixTSparseRow_const<double>::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TMatrixTSparseRow_const<double>", 3260, G__G__Matrix_135_0_24, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMatrixTSparseDiag_constlEdoublegR(void) {
   /* TMatrixTSparseDiag_const<double> */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparseDiag_constlEdoublegR));
   G__memfunc_setup("TMatrixTSparseDiag_const<double>",3195,G__G__Matrix_136_0_1, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparseDiag_constlEdoublegR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTSparseDiag_const<double>",3195,G__G__Matrix_136_0_2, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparseDiag_constlEdoublegR), -1, 0, 1, 1, 1, 0, "u 'TMatrixTSparse<double>' - 11 - matrix", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTSparseDiag_const<double>",3195,G__G__Matrix_136_0_3, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparseDiag_constlEdoublegR), -1, 0, 1, 1, 1, 0, "u 'TMatrixTSparseDiag_const<double>' - 11 - trc", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Matrix_136_0_4, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparseDiag_constlEdoublegR), -1, 1, 1, 1, 1, 0, "u 'TMatrixTSparseDiag_const<double>' - 11 - trc", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMatrix",917,G__G__Matrix_136_0_5, 85, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEdoublegR), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDataPtr",976,G__G__Matrix_136_0_6, 68, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNdiags",886,G__G__Matrix_136_0_7, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator()",957,G__G__Matrix_136_0_8, 100, -1, -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__G__Matrix_136_0_9, 100, -1, -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Matrix_136_0_10, 85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMatrixTSparseDiag_const<double>::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Matrix_136_0_11, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTSparseDiag_const<double>::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Matrix_136_0_12, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMatrixTSparseDiag_const<double>::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Matrix_136_0_13, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMatrixTSparseDiag_const<double>::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Matrix_136_0_14, 85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__Matrix_136_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__Matrix_136_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Matrix_136_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Matrix_136_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTSparseDiag_const<double>::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Matrix_136_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMatrixTSparseDiag_const<double>::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Matrix_136_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTSparseDiag_const<double>::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Matrix_136_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMatrixTSparseDiag_const<double>::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TMatrixTSparseDiag_const<double>", 3321, G__G__Matrix_136_0_22, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMatrixTColumnlEdoublegR(void) {
   /* TMatrixTColumn<double> */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTColumnlEdoublegR));
   G__memfunc_setup("TMatrixTColumn<double>",2176,G__G__Matrix_137_0_1, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTColumnlEdoublegR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTColumn<double>",2176,G__G__Matrix_137_0_2, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTColumnlEdoublegR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixT<double>' - 1 - matrix i - 'Int_t' 0 - col", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTColumn<double>",2176,G__G__Matrix_137_0_3, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTColumnlEdoublegR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixTSym<double>' - 1 - matrix i - 'Int_t' 0 - col", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTColumn<double>",2176,G__G__Matrix_137_0_4, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTColumnlEdoublegR), -1, 0, 1, 1, 1, 0, "u 'TMatrixTColumn<double>' - 11 - mc", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPtr",598,G__G__Matrix_137_0_5, 68, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator()",957,G__G__Matrix_137_0_6, 100, -1, -1, 1, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator()",957,G__G__Matrix_137_0_7, 100, -1, -1, 1, 1, 1, 1, 0, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__G__Matrix_137_0_8, 100, -1, -1, 1, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__G__Matrix_137_0_9, 100, -1, -1, 1, 1, 1, 1, 0, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Matrix_137_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+=",980,G__G__Matrix_137_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*=",979,G__G__Matrix_137_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Matrix_137_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMatrixTColumn_const<double>' - 11 - c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Matrix_137_0_14, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTColumnlEdoublegR), -1, 1, 1, 1, 1, 0, "u 'TMatrixTColumn<double>' - 11 - c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Matrix_137_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TVectorT<double>' - 11 - vec", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+=",980,G__G__Matrix_137_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMatrixTColumn_const<double>' - 11 - c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*=",979,G__G__Matrix_137_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMatrixTColumn_const<double>' - 11 - c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Matrix_137_0_18, 85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMatrixTColumn<double>::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Matrix_137_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTColumn<double>::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Matrix_137_0_20, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMatrixTColumn<double>::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Matrix_137_0_21, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMatrixTColumn<double>::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Matrix_137_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Matrix_137_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTColumn<double>::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Matrix_137_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMatrixTColumn<double>::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Matrix_137_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTColumn<double>::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Matrix_137_0_29, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMatrixTColumn<double>::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TMatrixTColumn<double>", 2302, G__G__Matrix_137_0_30, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMatrixTDiaglEdoublegR(void) {
   /* TMatrixTDiag<double> */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTDiaglEdoublegR));
   G__memfunc_setup("TMatrixTDiag<double>",1927,G__G__Matrix_138_0_1, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTDiaglEdoublegR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTDiag<double>",1927,G__G__Matrix_138_0_2, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTDiaglEdoublegR), -1, 0, 1, 1, 1, 0, "u 'TMatrixT<double>' - 1 - matrix", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTDiag<double>",1927,G__G__Matrix_138_0_3, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTDiaglEdoublegR), -1, 0, 1, 1, 1, 0, "u 'TMatrixTSym<double>' - 1 - matrix", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTDiag<double>",1927,G__G__Matrix_138_0_4, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTDiaglEdoublegR), -1, 0, 1, 1, 1, 0, "u 'TMatrixTDiag<double>' - 11 - md", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPtr",598,G__G__Matrix_138_0_5, 68, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator()",957,G__G__Matrix_138_0_6, 100, -1, -1, 1, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator()",957,G__G__Matrix_138_0_7, 100, -1, -1, 1, 1, 1, 1, 0, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__G__Matrix_138_0_8, 100, -1, -1, 1, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__G__Matrix_138_0_9, 100, -1, -1, 1, 1, 1, 1, 0, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Matrix_138_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+=",980,G__G__Matrix_138_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*=",979,G__G__Matrix_138_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Matrix_138_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMatrixTDiag_const<double>' - 11 - d", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Matrix_138_0_14, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTDiaglEdoublegR), -1, 1, 1, 1, 1, 0, "u 'TMatrixTDiag<double>' - 11 - d", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Matrix_138_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TVectorT<double>' - 11 - vec", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+=",980,G__G__Matrix_138_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMatrixTDiag_const<double>' - 11 - d", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*=",979,G__G__Matrix_138_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMatrixTDiag_const<double>' - 11 - d", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Matrix_138_0_18, 85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMatrixTDiag<double>::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Matrix_138_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTDiag<double>::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Matrix_138_0_20, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMatrixTDiag<double>::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Matrix_138_0_21, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMatrixTDiag<double>::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Matrix_138_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Matrix_138_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTDiag<double>::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Matrix_138_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMatrixTDiag<double>::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Matrix_138_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTDiag<double>::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Matrix_138_0_29, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMatrixTDiag<double>::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TMatrixTDiag<double>", 2053, G__G__Matrix_138_0_30, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMatrixTFlatlEdoublegR(void) {
   /* TMatrixTFlat<double> */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTFlatlEdoublegR));
   G__memfunc_setup("TMatrixTFlat<double>",1945,G__G__Matrix_139_0_1, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTFlatlEdoublegR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTFlat<double>",1945,G__G__Matrix_139_0_2, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTFlatlEdoublegR), -1, 0, 1, 1, 1, 0, "u 'TMatrixT<double>' - 1 - matrix", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTFlat<double>",1945,G__G__Matrix_139_0_3, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTFlatlEdoublegR), -1, 0, 1, 1, 1, 0, "u 'TMatrixTSym<double>' - 1 - matrix", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTFlat<double>",1945,G__G__Matrix_139_0_4, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTFlatlEdoublegR), -1, 0, 1, 1, 1, 0, "u 'TMatrixTFlat<double>' - 11 - mf", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPtr",598,G__G__Matrix_139_0_5, 68, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator()",957,G__G__Matrix_139_0_6, 100, -1, -1, 1, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator()",957,G__G__Matrix_139_0_7, 100, -1, -1, 1, 1, 1, 1, 0, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__G__Matrix_139_0_8, 100, -1, -1, 1, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__G__Matrix_139_0_9, 100, -1, -1, 1, 1, 1, 1, 0, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Matrix_139_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+=",980,G__G__Matrix_139_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*=",979,G__G__Matrix_139_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Matrix_139_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMatrixTFlat_const<double>' - 11 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Matrix_139_0_14, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTFlatlEdoublegR), -1, 1, 1, 1, 1, 0, "u 'TMatrixTFlat<double>' - 11 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Matrix_139_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TVectorT<double>' - 11 - vec", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+=",980,G__G__Matrix_139_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMatrixTFlat_const<double>' - 11 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*=",979,G__G__Matrix_139_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMatrixTFlat_const<double>' - 11 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Matrix_139_0_18, 85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMatrixTFlat<double>::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Matrix_139_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTFlat<double>::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Matrix_139_0_20, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMatrixTFlat<double>::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Matrix_139_0_21, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMatrixTFlat<double>::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Matrix_139_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Matrix_139_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTFlat<double>::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Matrix_139_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMatrixTFlat<double>::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Matrix_139_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTFlat<double>::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Matrix_139_0_29, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMatrixTFlat<double>::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TMatrixTFlat<double>", 2071, G__G__Matrix_139_0_30, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMatrixTSublEdoublegR(void) {
   /* TMatrixTSub<double> */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSublEdoublegR));
   G__memfunc_setup("TMatrixTSub<double>",1852,G__G__Matrix_140_0_1, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSublEdoublegR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTSub<double>",1852,G__G__Matrix_140_0_2, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSublEdoublegR), -1, 0, 5, 1, 1, 0, 
"u 'TMatrixT<double>' - 1 - matrix i - 'Int_t' 0 - row_lwb "
"i - 'Int_t' 0 - row_upb i - 'Int_t' 0 - col_lwb "
"i - 'Int_t' 0 - col_upb", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTSub<double>",1852,G__G__Matrix_140_0_3, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSublEdoublegR), -1, 0, 5, 1, 1, 0, 
"u 'TMatrixTSym<double>' - 1 - matrix i - 'Int_t' 0 - row_lwb "
"i - 'Int_t' 0 - row_upb i - 'Int_t' 0 - col_lwb "
"i - 'Int_t' 0 - col_upb", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTSub<double>",1852,G__G__Matrix_140_0_4, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSublEdoublegR), -1, 0, 1, 1, 1, 0, "u 'TMatrixTSub<double>' - 11 - ms", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator()",957,G__G__Matrix_140_0_5, 100, -1, -1, 1, 2, 1, 1, 0, 
"i - 'Int_t' 0 - rown i - 'Int_t' 0 - coln", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Rank1Update",1056,G__G__Matrix_140_0_6, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TVectorT<double>' - 11 - vec d - - 0 '1.0' alpha", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Matrix_140_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+=",980,G__G__Matrix_140_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*=",979,G__G__Matrix_140_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Matrix_140_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMatrixTSub_const<double>' - 11 - s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Matrix_140_0_11, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSublEdoublegR), -1, 1, 1, 1, 1, 0, "u 'TMatrixTSub<double>' - 11 - s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Matrix_140_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMatrixTBase<double>' - 11 - m", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+=",980,G__G__Matrix_140_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMatrixTSub_const<double>' - 11 - s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*=",979,G__G__Matrix_140_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMatrixTSub_const<double>' - 11 - s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+=",980,G__G__Matrix_140_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMatrixTBase<double>' - 11 - m", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*=",979,G__G__Matrix_140_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMatrixT<double>' - 11 - m", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*=",979,G__G__Matrix_140_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMatrixTSym<double>' - 11 - m", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Matrix_140_0_18, 85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMatrixTSub<double>::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Matrix_140_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTSub<double>::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Matrix_140_0_20, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMatrixTSub<double>::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Matrix_140_0_21, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMatrixTSub<double>::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Matrix_140_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Matrix_140_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTSub<double>::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Matrix_140_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMatrixTSub<double>::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Matrix_140_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTSub<double>::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Matrix_140_0_29, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMatrixTSub<double>::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TMatrixTSub<double>", 1978, G__G__Matrix_140_0_30, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMatrixTSparseRowlEdoublegR(void) {
   /* TMatrixTSparseRow<double> */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparseRowlEdoublegR));
   G__memfunc_setup("TMatrixTSparseRow<double>",2488,G__G__Matrix_142_0_1, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparseRowlEdoublegR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTSparseRow<double>",2488,G__G__Matrix_142_0_2, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparseRowlEdoublegR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixTSparse<double>' - 1 - matrix i - 'Int_t' 0 - row", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTSparseRow<double>",2488,G__G__Matrix_142_0_3, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparseRowlEdoublegR), -1, 0, 1, 1, 1, 0, "u 'TMatrixTSparseRow<double>' - 11 - mr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDataPtr",976,G__G__Matrix_142_0_4, 68, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator()",957,G__G__Matrix_142_0_5, 100, -1, -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator()",957,G__G__Matrix_142_0_6, 100, -1, -1, 1, 1, 1, 1, 0, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__G__Matrix_142_0_7, 100, -1, -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__G__Matrix_142_0_8, 100, -1, -1, 1, 1, 1, 1, 0, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Matrix_142_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+=",980,G__G__Matrix_142_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*=",979,G__G__Matrix_142_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Matrix_142_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMatrixTSparseRow_const<double>' - 11 - r", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Matrix_142_0_13, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparseRowlEdoublegR), -1, 1, 1, 1, 1, 0, "u 'TMatrixTSparseRow<double>' - 11 - r", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Matrix_142_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TVectorT<double>' - 11 - vec", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+=",980,G__G__Matrix_142_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMatrixTSparseRow_const<double>' - 11 - r", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*=",979,G__G__Matrix_142_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMatrixTSparseRow_const<double>' - 11 - r", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Matrix_142_0_17, 85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMatrixTSparseRow<double>::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Matrix_142_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTSparseRow<double>::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Matrix_142_0_19, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMatrixTSparseRow<double>::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Matrix_142_0_20, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMatrixTSparseRow<double>::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Matrix_142_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Matrix_142_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTSparseRow<double>::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Matrix_142_0_26, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMatrixTSparseRow<double>::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Matrix_142_0_27, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTSparseRow<double>::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Matrix_142_0_28, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMatrixTSparseRow<double>::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TMatrixTSparseRow<double>", 2614, G__G__Matrix_142_0_29, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMatrixTSparseDiaglEdoublegR(void) {
   /* TMatrixTSparseDiag<double> */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparseDiaglEdoublegR));
   G__memfunc_setup("TMatrixTSparseDiag<double>",2549,G__G__Matrix_143_0_1, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparseDiaglEdoublegR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTSparseDiag<double>",2549,G__G__Matrix_143_0_2, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparseDiaglEdoublegR), -1, 0, 1, 1, 1, 0, "u 'TMatrixTSparse<double>' - 1 - matrix", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTSparseDiag<double>",2549,G__G__Matrix_143_0_3, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparseDiaglEdoublegR), -1, 0, 1, 1, 1, 0, "u 'TMatrixTSparseDiag<double>' - 11 - md", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDataPtr",976,G__G__Matrix_143_0_4, 68, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator()",957,G__G__Matrix_143_0_5, 100, -1, -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator()",957,G__G__Matrix_143_0_6, 100, -1, -1, 1, 1, 1, 1, 0, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__G__Matrix_143_0_7, 100, -1, -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__G__Matrix_143_0_8, 100, -1, -1, 1, 1, 1, 1, 0, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Matrix_143_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+=",980,G__G__Matrix_143_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*=",979,G__G__Matrix_143_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Matrix_143_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMatrixTSparseDiag_const<double>' - 11 - d", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Matrix_143_0_13, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparseDiaglEdoublegR), -1, 1, 1, 1, 1, 0, "u 'TMatrixTSparseDiag<double>' - 11 - d", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Matrix_143_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TVectorT<double>' - 11 - vec", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+=",980,G__G__Matrix_143_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMatrixTSparseDiag_const<double>' - 11 - d", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*=",979,G__G__Matrix_143_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMatrixTSparseDiag_const<double>' - 11 - d", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Matrix_143_0_17, 85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMatrixTSparseDiag<double>::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Matrix_143_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTSparseDiag<double>::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Matrix_143_0_19, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMatrixTSparseDiag<double>::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Matrix_143_0_20, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMatrixTSparseDiag<double>::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Matrix_143_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Matrix_143_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTSparseDiag<double>::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Matrix_143_0_26, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMatrixTSparseDiag<double>::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Matrix_143_0_27, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTSparseDiag<double>::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Matrix_143_0_28, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMatrixTSparseDiag<double>::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TMatrixTSparseDiag<double>", 2675, G__G__Matrix_143_0_29, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMatrixTSymLazylEdoublegR(void) {
   /* TMatrixTSymLazy<double> */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymLazylEdoublegR));
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "u 'TMatrixTSymLazy<double>' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FillIn",574,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 8, "u 'TMatrixTSym<double>' - 1 - m", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetRowLwb",893,G__G__Matrix_147_0_7, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRowUpb",895,G__G__Matrix_147_0_8, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Matrix_147_0_9, 85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMatrixTSymLazy<double>::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Matrix_147_0_10, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTSymLazy<double>::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Matrix_147_0_11, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMatrixTSymLazy<double>::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Matrix_147_0_12, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMatrixTSymLazy<double>::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Matrix_147_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Matrix_147_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTSymLazy<double>::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Matrix_147_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMatrixTSymLazy<double>::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Matrix_147_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTSymLazy<double>::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Matrix_147_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMatrixTSymLazy<double>::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TMatrixTSymLazy<double>", 2409, G__G__Matrix_147_0_21, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMatrixTRow_constlEfloatgR(void) {
   /* TMatrixTRow_const<float> */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTRow_constlEfloatgR));
   G__memfunc_setup("TMatrixTRow_const<float>",2411,G__G__Matrix_152_0_1, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTRow_constlEfloatgR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTRow_const<float>",2411,G__G__Matrix_152_0_2, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTRow_constlEfloatgR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixT<float>' - 11 - matrix i - 'Int_t' 0 - row", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTRow_const<float>",2411,G__G__Matrix_152_0_3, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTRow_constlEfloatgR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixTSym<float>' - 11 - matrix i - 'Int_t' 0 - row", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTRow_const<float>",2411,G__G__Matrix_152_0_4, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTRow_constlEfloatgR), -1, 0, 1, 1, 1, 0, "u 'TMatrixTRow_const<float>' - 11 - trc", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Matrix_152_0_5, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTRow_constlEfloatgR), -1, 1, 1, 1, 1, 0, "u 'TMatrixTRow_const<float>' - 11 - trc", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMatrix",917,G__G__Matrix_152_0_6, 85, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEfloatgR), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRowIndex",1104,G__G__Matrix_152_0_7, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetInc",570,G__G__Matrix_152_0_8, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPtr",598,G__G__Matrix_152_0_9, 70, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator()",957,G__G__Matrix_152_0_10, 102, -1, -1, 1, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__G__Matrix_152_0_11, 102, -1, -1, 1, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Matrix_152_0_12, 85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMatrixTRow_const<float>::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Matrix_152_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTRow_const<float>::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Matrix_152_0_14, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMatrixTRow_const<float>::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Matrix_152_0_15, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMatrixTRow_const<float>::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Matrix_152_0_16, 85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__Matrix_152_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__Matrix_152_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Matrix_152_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Matrix_152_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTRow_const<float>::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Matrix_152_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMatrixTRow_const<float>::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Matrix_152_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTRow_const<float>::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Matrix_152_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMatrixTRow_const<float>::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TMatrixTRow_const<float>", 2537, G__G__Matrix_152_0_24, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMatrixTlEfloatgR(void) {
   /* TMatrixT<float> */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR));
   G__memfunc_setup("New_m",502,(G__InterfaceMethod) NULL, 70, -1, -1, 0, 1, 1, 2, 0, "i - 'Int_t' 0 - size", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Delete_m",799,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 0, 
"i - 'Int_t' 0 - size F - - 1 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Memcpy_m",823,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 5, 1, 2, 0, 
"F - - 0 - newp F - - 10 - oldp "
"i - 'Int_t' 0 - copySize i - 'Int_t' 0 - newSize "
"i - 'Int_t' 0 - oldSize", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Allocate",805,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 6, 1, 2, 0, 
"i - 'Int_t' 0 - nrows i - 'Int_t' 0 - ncols "
"i - 'Int_t' 0 '0' row_lwb i - 'Int_t' 0 '0' col_lwb "
"i - 'Int_t' 0 '0' init i - 'Int_t' 0 '-1' -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixT<float>",1453,G__G__Matrix_153_0_5, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixT<float>",1453,G__G__Matrix_153_0_6, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR), -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - nrows i - 'Int_t' 0 - ncols", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixT<float>",1453,G__G__Matrix_153_0_7, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR), -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - row_lwb i - 'Int_t' 0 - row_upb "
"i - 'Int_t' 0 - col_lwb i - 'Int_t' 0 - col_upb", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixT<float>",1453,G__G__Matrix_153_0_8, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR), -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - nrows i - 'Int_t' 0 - ncols "
"F - - 10 - data C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixT<float>",1453,G__G__Matrix_153_0_9, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR), -1, 0, 6, 1, 1, 0, 
"i - 'Int_t' 0 - row_lwb i - 'Int_t' 0 - row_upb "
"i - 'Int_t' 0 - col_lwb i - 'Int_t' 0 - col_upb "
"F - - 10 - data C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixT<float>",1453,G__G__Matrix_153_0_10, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR), -1, 0, 1, 1, 1, 0, "u 'TMatrixT<float>' - 11 - another", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixT<float>",1453,G__G__Matrix_153_0_11, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR), -1, 0, 1, 1, 1, 0, "u 'TMatrixTSym<float>' - 11 - another", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixT<float>",1453,G__G__Matrix_153_0_12, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR), -1, 0, 1, 1, 1, 0, "u 'TMatrixTSparse<float>' - 11 - another", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixT<float>",1453,G__G__Matrix_153_0_13, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR), -1, 0, 2, 1, 1, 0, 
"i 'TMatrixT<float>::EMatrixCreatorsOp1' - 0 - op u 'TMatrixT<float>' - 11 - prototype", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixT<float>",1453,G__G__Matrix_153_0_14, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR), -1, 0, 3, 1, 1, 0, 
"u 'TMatrixT<float>' - 11 - a i 'TMatrixT<float>::EMatrixCreatorsOp2' - 0 - op "
"u 'TMatrixT<float>' - 11 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixT<float>",1453,G__G__Matrix_153_0_15, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR), -1, 0, 3, 1, 1, 0, 
"u 'TMatrixT<float>' - 11 - a i 'TMatrixT<float>::EMatrixCreatorsOp2' - 0 - op "
"u 'TMatrixTSym<float>' - 11 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixT<float>",1453,G__G__Matrix_153_0_16, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR), -1, 0, 3, 1, 1, 0, 
"u 'TMatrixTSym<float>' - 11 - a i 'TMatrixT<float>::EMatrixCreatorsOp2' - 0 - op "
"u 'TMatrixT<float>' - 11 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixT<float>",1453,G__G__Matrix_153_0_17, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR), -1, 0, 3, 1, 1, 0, 
"u 'TMatrixTSym<float>' - 11 - a i 'TMatrixT<float>::EMatrixCreatorsOp2' - 0 - op "
"u 'TMatrixTSym<float>' - 11 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixT<float>",1453,G__G__Matrix_153_0_18, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR), -1, 0, 1, 1, 1, 0, "u 'TMatrixTLazy<float>' - 11 - lazy_constructor", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Plus",420,G__G__Matrix_153_0_19, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TMatrixT<float>' - 11 - a u 'TMatrixT<float>' - 11 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Plus",420,G__G__Matrix_153_0_20, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TMatrixT<float>' - 11 - a u 'TMatrixTSym<float>' - 11 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Plus",420,G__G__Matrix_153_0_21, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TMatrixTSym<float>' - 11 - a u 'TMatrixT<float>' - 11 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Minus",524,G__G__Matrix_153_0_22, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TMatrixT<float>' - 11 - a u 'TMatrixT<float>' - 11 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Minus",524,G__G__Matrix_153_0_23, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TMatrixT<float>' - 11 - a u 'TMatrixTSym<float>' - 11 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Minus",524,G__G__Matrix_153_0_24, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TMatrixTSym<float>' - 11 - a u 'TMatrixT<float>' - 11 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Mult",418,G__G__Matrix_153_0_25, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TMatrixT<float>' - 11 - a u 'TMatrixT<float>' - 11 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Mult",418,G__G__Matrix_153_0_26, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TMatrixT<float>' - 11 - a u 'TMatrixTSym<float>' - 11 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Mult",418,G__G__Matrix_153_0_27, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TMatrixTSym<float>' - 11 - a u 'TMatrixT<float>' - 11 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Mult",418,G__G__Matrix_153_0_28, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TMatrixTSym<float>' - 11 - a u 'TMatrixTSym<float>' - 11 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMult",502,G__G__Matrix_153_0_29, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TMatrixT<float>' - 11 - a u 'TMatrixT<float>' - 11 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMult",502,G__G__Matrix_153_0_30, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TMatrixT<float>' - 11 - a u 'TMatrixTSym<float>' - 11 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMult",502,G__G__Matrix_153_0_31, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TMatrixTSym<float>' - 11 - a u 'TMatrixT<float>' - 11 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMult",502,G__G__Matrix_153_0_32, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TMatrixTSym<float>' - 11 - a u 'TMatrixTSym<float>' - 11 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MultT",502,G__G__Matrix_153_0_33, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TMatrixT<float>' - 11 - a u 'TMatrixT<float>' - 11 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MultT",502,G__G__Matrix_153_0_34, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TMatrixT<float>' - 11 - a u 'TMatrixTSym<float>' - 11 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MultT",502,G__G__Matrix_153_0_35, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TMatrixTSym<float>' - 11 - a u 'TMatrixT<float>' - 11 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MultT",502,G__G__Matrix_153_0_36, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TMatrixTSym<float>' - 11 - a u 'TMatrixTSym<float>' - 11 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMatrixArray",1428,(G__InterfaceMethod) NULL,70, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMatrixArray",1428,(G__InterfaceMethod) NULL,70, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRowIndexArray",1615,(G__InterfaceMethod) NULL,73, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRowIndexArray",1615,(G__InterfaceMethod) NULL,73, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetColIndexArray",1589,(G__InterfaceMethod) NULL,73, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetColIndexArray",1589,(G__InterfaceMethod) NULL,73, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetRowIndexArray",1627,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEfloatgR), -1, 1, 1, 1, 1, 0, "I - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetColIndexArray",1601,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEfloatgR), -1, 1, 1, 1, 1, 0, "I - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Clear",487,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Use",301,G__G__Matrix_153_0_46, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR), -1, 1, 5, 1, 1, 0, 
"i - 'Int_t' 0 - row_lwb i - 'Int_t' 0 - row_upb "
"i - 'Int_t' 0 - col_lwb i - 'Int_t' 0 - col_upb "
"F - - 0 - data", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Use",301,G__G__Matrix_153_0_47, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR), -1, 1, 5, 1, 1, 9, 
"i - 'Int_t' 0 - row_lwb i - 'Int_t' 0 - row_upb "
"i - 'Int_t' 0 - col_lwb i - 'Int_t' 0 - col_upb "
"F - - 10 - data", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Use",301,G__G__Matrix_153_0_48, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR), -1, 1, 3, 1, 1, 0, 
"i - 'Int_t' 0 - nrows i - 'Int_t' 0 - ncols "
"F - - 0 - data", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Use",301,G__G__Matrix_153_0_49, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR), -1, 1, 3, 1, 1, 9, 
"i - 'Int_t' 0 - nrows i - 'Int_t' 0 - ncols "
"F - - 10 - data", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Use",301,G__G__Matrix_153_0_50, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR), -1, 1, 1, 1, 1, 0, "u 'TMatrixT<float>' - 1 - a", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Use",301,G__G__Matrix_153_0_51, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR), -1, 1, 1, 1, 1, 9, "u 'TMatrixT<float>' - 11 - a", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSub",586,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEfloatgR), -1, 1, 6, 1, 1, 8, 
"i - 'Int_t' 0 - row_lwb i - 'Int_t' 0 - row_upb "
"i - 'Int_t' 0 - col_lwb i - 'Int_t' 0 - col_upb "
"u 'TMatrixTBase<float>' - 1 - target C - 'Option_t' 10 '\"S\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetSub",586,G__G__Matrix_153_0_53, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR), -1, 0, 5, 1, 1, 8, 
"i - 'Int_t' 0 - row_lwb i - 'Int_t' 0 - row_upb "
"i - 'Int_t' 0 - col_lwb i - 'Int_t' 0 - col_upb "
"C - 'Option_t' 10 '\"S\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSub",598,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEfloatgR), -1, 1, 3, 1, 1, 0, 
"i - 'Int_t' 0 - row_lwb i - 'Int_t' 0 - col_lwb "
"u 'TMatrixTBase<float>' - 11 - source", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ResizeTo",821,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEfloatgR), -1, 1, 3, 1, 1, 0, 
"i - 'Int_t' 0 - nrows i - 'Int_t' 0 - ncols "
"i - 'Int_t' 0 '-1' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ResizeTo",821,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEfloatgR), -1, 1, 5, 1, 1, 0, 
"i - 'Int_t' 0 - row_lwb i - 'Int_t' 0 - row_upb "
"i - 'Int_t' 0 - col_lwb i - 'Int_t' 0 - col_upb "
"i - 'Int_t' 0 '-1' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ResizeTo",821,G__G__Matrix_153_0_57, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEfloatgR), -1, 1, 1, 1, 1, 0, "u 'TMatrixT<float>' - 11 - m", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Determinant",1147,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Determinant",1147,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 8, 
"d - 'Double_t' 1 - d1 d - 'Double_t' 1 - d2", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Invert",632,G__G__Matrix_153_0_60, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR), -1, 1, 1, 1, 1, 0, "D - 'Double_t' 0 '0' det", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InvertFast",1030,G__G__Matrix_153_0_61, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR), -1, 1, 1, 1, 1, 0, "D - 'Double_t' 0 '0' det", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Transpose",959,G__G__Matrix_153_0_62, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR), -1, 1, 1, 1, 1, 0, "u 'TMatrixT<float>' - 11 - source", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("T",84,G__G__Matrix_153_0_63, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Rank1Update",1056,G__G__Matrix_153_0_64, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR), -1, 1, 2, 1, 1, 0, 
"u 'TVectorT<float>' - 11 - v f - - 0 '1.0' alpha", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Rank1Update",1056,G__G__Matrix_153_0_65, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR), -1, 1, 3, 1, 1, 0, 
"u 'TVectorT<float>' - 11 - v1 u 'TVectorT<float>' - 11 - v2 "
"f - - 0 '1.0' alpha", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Similarity",1063,G__G__Matrix_153_0_66, 102, -1, -1, 0, 1, 1, 1, 8, "u 'TVectorT<float>' - 11 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("NormByColumn",1221,G__G__Matrix_153_0_67, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR), -1, 1, 2, 1, 1, 0, 
"u 'TVectorT<float>' - 11 - v C - 'Option_t' 10 '\"D\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("NormByRow",911,G__G__Matrix_153_0_68, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR), -1, 1, 2, 1, 1, 0, 
"u 'TVectorT<float>' - 11 - v C - 'Option_t' 10 '\"D\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator()",957,(G__InterfaceMethod) NULL,102, -1, -1, 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - rown i - 'Int_t' 0 - coln", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("operator()",957,(G__InterfaceMethod) NULL,102, -1, -1, 1, 2, 1, 1, 0, 
"i - 'Int_t' 0 - rown i - 'Int_t' 0 - coln", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("operator[]",1060,G__G__Matrix_153_0_71, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTRow_constlEfloatgR), -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - rown", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__G__Matrix_153_0_72, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTRowlEfloatgR), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - rown", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Matrix_153_0_73, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR), -1, 1, 1, 1, 1, 0, "u 'TMatrixT<float>' - 11 - source", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Matrix_153_0_74, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR), -1, 1, 1, 1, 1, 0, "u 'TMatrixTSym<float>' - 11 - source", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Matrix_153_0_75, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR), -1, 1, 1, 1, 1, 0, "u 'TMatrixTSparse<float>' - 11 - source", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Matrix_153_0_76, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR), -1, 1, 1, 1, 1, 0, "u 'TMatrixTLazy<float>' - 11 - source", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Matrix_153_0_77, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR), -1, 1, 1, 1, 1, 0, "f - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator-=",982,G__G__Matrix_153_0_78, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR), -1, 1, 1, 1, 1, 0, "f - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+=",980,G__G__Matrix_153_0_79, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR), -1, 1, 1, 1, 1, 0, "f - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*=",979,G__G__Matrix_153_0_80, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR), -1, 1, 1, 1, 1, 0, "f - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+=",980,G__G__Matrix_153_0_81, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR), -1, 1, 1, 1, 1, 0, "u 'TMatrixT<float>' - 11 - source", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+=",980,G__G__Matrix_153_0_82, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR), -1, 1, 1, 1, 1, 0, "u 'TMatrixTSym<float>' - 11 - source", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator-=",982,G__G__Matrix_153_0_83, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR), -1, 1, 1, 1, 1, 0, "u 'TMatrixT<float>' - 11 - source", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator-=",982,G__G__Matrix_153_0_84, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR), -1, 1, 1, 1, 1, 0, "u 'TMatrixTSym<float>' - 11 - source", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*=",979,G__G__Matrix_153_0_85, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR), -1, 1, 1, 1, 1, 0, "u 'TMatrixT<float>' - 11 - source", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*=",979,G__G__Matrix_153_0_86, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR), -1, 1, 1, 1, 1, 0, "u 'TMatrixTSym<float>' - 11 - source", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*=",979,G__G__Matrix_153_0_87, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR), -1, 1, 1, 1, 1, 0, "u 'TMatrixTDiag_const<float>' - 11 - diag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator/=",984,G__G__Matrix_153_0_88, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR), -1, 1, 1, 1, 1, 0, "u 'TMatrixTDiag_const<float>' - 11 - diag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*=",979,G__G__Matrix_153_0_89, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR), -1, 1, 1, 1, 1, 0, "u 'TMatrixTRow_const<float>' - 11 - row", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator/=",984,G__G__Matrix_153_0_90, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR), -1, 1, 1, 1, 1, 0, "u 'TMatrixTRow_const<float>' - 11 - row", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*=",979,G__G__Matrix_153_0_91, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR), -1, 1, 1, 1, 1, 0, "u 'TMatrixTColumn_const<float>' - 11 - col", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator/=",984,G__G__Matrix_153_0_92, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR), -1, 1, 1, 1, 1, 0, "u 'TMatrixTColumn_const<float>' - 11 - col", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("EigenVectors",1230,G__G__Matrix_153_0_93, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR), -1, 0, 1, 1, 1, 9, "u 'TVectorT<float>' - 1 - eigenValues", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Matrix_153_0_94, 85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMatrixT<float>::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Matrix_153_0_95, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixT<float>::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Matrix_153_0_96, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMatrixT<float>::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Matrix_153_0_97, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMatrixT<float>::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Matrix_153_0_101, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Matrix_153_0_102, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixT<float>::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Matrix_153_0_103, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMatrixT<float>::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Matrix_153_0_104, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixT<float>::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Matrix_153_0_105, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMatrixT<float>::DeclFileLine) ), 0);
   G__memfunc_setup("TMatrixT<float>",1453,G__G__Matrix_153_0_106, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR), -1, 0, 1, 1, 1, 0, "u 'TMatrixT<double>' - 11 - another", (char*)NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TMatrixT<float>", 1579, G__G__Matrix_153_0_107, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMatrixTSymlEfloatgR(void) {
   /* TMatrixTSym<float> */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEfloatgR));
   G__memfunc_setup("New_m",502,(G__InterfaceMethod) NULL, 70, -1, -1, 0, 1, 1, 2, 0, "i - 'Int_t' 0 - size", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Delete_m",799,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 0, 
"i - 'Int_t' 0 - size F - - 1 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Memcpy_m",823,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 5, 1, 2, 0, 
"F - - 0 - newp F - - 10 - oldp "
"i - 'Int_t' 0 - copySize i - 'Int_t' 0 - newSize "
"i - 'Int_t' 0 - oldSize", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Allocate",805,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 6, 1, 2, 0, 
"i - 'Int_t' 0 - nrows i - 'Int_t' 0 - ncols "
"i - 'Int_t' 0 '0' row_lwb i - 'Int_t' 0 '0' col_lwb "
"i - 'Int_t' 0 '0' init i - 'Int_t' 0 '-1' -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTSym<float>",1766,G__G__Matrix_157_0_5, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEfloatgR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTSym<float>",1766,G__G__Matrix_157_0_6, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEfloatgR), -1, 0, 1, 5, 1, 0, "i - 'Int_t' 0 - nrows", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTSym<float>",1766,G__G__Matrix_157_0_7, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEfloatgR), -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - row_lwb i - 'Int_t' 0 - row_upb", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTSym<float>",1766,G__G__Matrix_157_0_8, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEfloatgR), -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - nrows F - - 10 - data "
"C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTSym<float>",1766,G__G__Matrix_157_0_9, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEfloatgR), -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - row_lwb i - 'Int_t' 0 - row_upb "
"F - - 10 - data C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTSym<float>",1766,G__G__Matrix_157_0_10, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEfloatgR), -1, 0, 1, 1, 1, 0, "u 'TMatrixTSym<float>' - 11 - another", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTSym<float>",1766,G__G__Matrix_157_0_11, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEfloatgR), -1, 0, 2, 1, 1, 0, 
"i 'TMatrixTSym<float>::EMatrixCreatorsOp1' - 0 - op u 'TMatrixTSym<float>' - 11 - prototype", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTSym<float>",1766,G__G__Matrix_157_0_12, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEfloatgR), -1, 0, 2, 1, 1, 0, 
"i 'TMatrixTSym<float>::EMatrixCreatorsOp1' - 0 - op u 'TMatrixT<float>' - 11 - prototype", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTSym<float>",1766,G__G__Matrix_157_0_13, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEfloatgR), -1, 0, 3, 1, 1, 0, 
"u 'TMatrixTSym<float>' - 11 - a i 'TMatrixTSym<float>::EMatrixCreatorsOp2' - 0 - op "
"u 'TMatrixTSym<float>' - 11 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTSym<float>",1766,G__G__Matrix_157_0_14, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEfloatgR), -1, 0, 1, 1, 1, 0, "u 'TMatrixTSymLazy<float>' - 11 - lazy_constructor", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMult",502,G__G__Matrix_157_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMatrixT<float>' - 11 - a", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMult",502,G__G__Matrix_157_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMatrixTSym<float>' - 11 - a", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Mult",418,G__G__Matrix_157_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMatrixTSym<float>' - 11 - a", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Plus",420,G__G__Matrix_157_0_18, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TMatrixTSym<float>' - 11 - a u 'TMatrixTSym<float>' - 11 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Minus",524,G__G__Matrix_157_0_19, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TMatrixTSym<float>' - 11 - a u 'TMatrixTSym<float>' - 11 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMatrixArray",1428,(G__InterfaceMethod) NULL,70, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMatrixArray",1428,(G__InterfaceMethod) NULL,70, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRowIndexArray",1615,(G__InterfaceMethod) NULL,73, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRowIndexArray",1615,(G__InterfaceMethod) NULL,73, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetColIndexArray",1589,(G__InterfaceMethod) NULL,73, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetColIndexArray",1589,(G__InterfaceMethod) NULL,73, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetRowIndexArray",1627,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEfloatgR), -1, 1, 1, 1, 1, 0, "I - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetColIndexArray",1601,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEfloatgR), -1, 1, 1, 1, 1, 0, "I - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Clear",487,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsSymmetric",1145,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Use",301,G__G__Matrix_157_0_30, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEfloatgR), -1, 1, 3, 1, 1, 0, 
"i - 'Int_t' 0 - row_lwb i - 'Int_t' 0 - row_upb "
"F - - 0 - data", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Use",301,G__G__Matrix_157_0_31, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEfloatgR), -1, 1, 3, 1, 1, 9, 
"i - 'Int_t' 0 - row_lwb i - 'Int_t' 0 - row_upb "
"F - - 10 - data", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Use",301,G__G__Matrix_157_0_32, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEfloatgR), -1, 1, 2, 1, 1, 0, 
"i - 'Int_t' 0 - nrows F - - 0 - data", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Use",301,G__G__Matrix_157_0_33, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEfloatgR), -1, 1, 2, 1, 1, 9, 
"i - 'Int_t' 0 - nrows F - - 10 - data", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Use",301,G__G__Matrix_157_0_34, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEfloatgR), -1, 1, 1, 1, 1, 0, "u 'TMatrixTSym<float>' - 1 - a", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Use",301,G__G__Matrix_157_0_35, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEfloatgR), -1, 1, 1, 1, 1, 9, "u 'TMatrixTSym<float>' - 11 - a", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSub",586,G__G__Matrix_157_0_36, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEfloatgR), -1, 1, 4, 1, 1, 8, 
"i - 'Int_t' 0 - row_lwb i - 'Int_t' 0 - row_upb "
"u 'TMatrixTSym<float>' - 1 - target C - 'Option_t' 10 '\"S\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSub",586,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEfloatgR), -1, 1, 6, 1, 1, 8, 
"i - 'Int_t' 0 - row_lwb i - 'Int_t' 0 - row_upb "
"i - 'Int_t' 0 - col_lwb i - 'Int_t' 0 - col_upb "
"u 'TMatrixTBase<float>' - 1 - target C - 'Option_t' 10 '\"S\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetSub",586,G__G__Matrix_157_0_38, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEfloatgR), -1, 0, 5, 1, 1, 8, 
"i - 'Int_t' 0 - row_lwb i - 'Int_t' 0 - row_upb "
"i - 'Int_t' 0 - col_lwb i - 'Int_t' 0 - col_upb "
"C - 'Option_t' 10 '\"S\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSub",598,G__G__Matrix_157_0_39, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEfloatgR), -1, 1, 2, 1, 1, 0, 
"i - 'Int_t' 0 - row_lwb u 'TMatrixTBase<float>' - 11 - source", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSub",598,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEfloatgR), -1, 1, 3, 1, 1, 0, 
"i - 'Int_t' 0 - row_lwb i - 'Int_t' 0 - col_lwb "
"u 'TMatrixTBase<float>' - 11 - source", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetMatrixArray",1440,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEfloatgR), -1, 1, 2, 1, 1, 0, 
"F - - 10 - data C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Shift",510,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEfloatgR), -1, 1, 2, 1, 1, 0, 
"i - 'Int_t' 0 - row_shift i - 'Int_t' 0 - col_shift", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ResizeTo",821,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEfloatgR), -1, 1, 3, 1, 1, 0, 
"i - 'Int_t' 0 - nrows i - 'Int_t' 0 - ncols "
"i - 'Int_t' 0 '-1' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ResizeTo",821,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEfloatgR), -1, 1, 5, 1, 1, 0, 
"i - 'Int_t' 0 - row_lwb i - 'Int_t' 0 - row_upb "
"i - 'Int_t' 0 - col_lwb i - 'Int_t' 0 - col_upb "
"i - 'Int_t' 0 '-1' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ResizeTo",821,G__G__Matrix_157_0_45, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEfloatgR), -1, 1, 1, 1, 1, 0, "u 'TMatrixTSym<float>' - 11 - m", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Determinant",1147,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Determinant",1147,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 8, 
"d - 'Double_t' 1 - d1 d - 'Double_t' 1 - d2", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Invert",632,G__G__Matrix_157_0_48, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEfloatgR), -1, 1, 1, 1, 1, 0, "D - 'Double_t' 0 '0' det", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InvertFast",1030,G__G__Matrix_157_0_49, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEfloatgR), -1, 1, 1, 1, 1, 0, "D - 'Double_t' 0 '0' det", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Transpose",959,G__G__Matrix_157_0_50, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEfloatgR), -1, 1, 1, 1, 1, 0, "u 'TMatrixTSym<float>' - 11 - source", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("T",84,G__G__Matrix_157_0_51, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEfloatgR), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Rank1Update",1056,G__G__Matrix_157_0_52, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEfloatgR), -1, 1, 2, 1, 1, 0, 
"u 'TVectorT<float>' - 11 - v f - - 0 '1.0' alpha", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Similarity",1063,G__G__Matrix_157_0_53, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEfloatgR), -1, 1, 1, 1, 1, 0, "u 'TMatrixT<float>' - 11 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Similarity",1063,G__G__Matrix_157_0_54, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEfloatgR), -1, 1, 1, 1, 1, 0, "u 'TMatrixTSym<float>' - 11 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Similarity",1063,G__G__Matrix_157_0_55, 102, -1, -1, 0, 1, 1, 1, 8, "u 'TVectorT<float>' - 11 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SimilarityT",1147,G__G__Matrix_157_0_56, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEfloatgR), -1, 1, 1, 1, 1, 0, "u 'TMatrixT<float>' - 11 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator()",957,(G__InterfaceMethod) NULL,102, -1, -1, 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - rown i - 'Int_t' 0 - coln", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("operator()",957,(G__InterfaceMethod) NULL,102, -1, -1, 1, 2, 1, 1, 0, 
"i - 'Int_t' 0 - rown i - 'Int_t' 0 - coln", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("operator[]",1060,G__G__Matrix_157_0_59, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTRow_constlEfloatgR), -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - rown", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__G__Matrix_157_0_60, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTRowlEfloatgR), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - rown", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Matrix_157_0_61, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEfloatgR), -1, 1, 1, 1, 1, 0, "u 'TMatrixTSym<float>' - 11 - source", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Matrix_157_0_62, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEfloatgR), -1, 1, 1, 1, 1, 0, "u 'TMatrixTSymLazy<float>' - 11 - source", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Matrix_157_0_63, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEfloatgR), -1, 1, 1, 1, 1, 0, "f - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator-=",982,G__G__Matrix_157_0_64, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEfloatgR), -1, 1, 1, 1, 1, 0, "f - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+=",980,G__G__Matrix_157_0_65, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEfloatgR), -1, 1, 1, 1, 1, 0, "f - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*=",979,G__G__Matrix_157_0_66, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEfloatgR), -1, 1, 1, 1, 1, 0, "f - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+=",980,G__G__Matrix_157_0_67, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEfloatgR), -1, 1, 1, 1, 1, 0, "u 'TMatrixTSym<float>' - 11 - source", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator-=",982,G__G__Matrix_157_0_68, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEfloatgR), -1, 1, 1, 1, 1, 0, "u 'TMatrixTSym<float>' - 11 - source", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Apply",518,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEfloatgR), -1, 1, 1, 1, 1, 0, "u 'TElementActionT<float>' - 11 - action", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Apply",518,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEfloatgR), -1, 1, 1, 1, 1, 0, "u 'TElementPosActionT<float>' - 11 - action", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Randomize",937,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEfloatgR), -1, 1, 3, 1, 1, 0, 
"f - - 0 - alpha f - - 0 - beta "
"d - 'Double_t' 1 - seed", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RandomizePD",1085,G__G__Matrix_157_0_72, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEfloatgR), -1, 1, 3, 1, 1, 0, 
"f - - 0 - alpha f - - 0 - beta "
"d - 'Double_t' 1 - seed", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("EigenVectors",1230,G__G__Matrix_157_0_73, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR), -1, 0, 1, 1, 1, 9, "u 'TVectorT<float>' - 1 - eigenValues", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Matrix_157_0_74, 85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMatrixTSym<float>::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Matrix_157_0_75, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTSym<float>::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Matrix_157_0_76, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMatrixTSym<float>::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Matrix_157_0_77, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMatrixTSym<float>::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Matrix_157_0_81, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Matrix_157_0_82, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTSym<float>::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Matrix_157_0_83, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMatrixTSym<float>::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Matrix_157_0_84, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTSym<float>::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Matrix_157_0_85, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMatrixTSym<float>::DeclFileLine) ), 0);
   G__memfunc_setup("TMatrixTSym<float>",1766,G__G__Matrix_157_0_86, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEfloatgR), -1, 0, 1, 1, 1, 0, "u 'TMatrixTSym<double>' - 11 - another", (char*)NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TMatrixTSym<float>", 1892, G__G__Matrix_157_0_87, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMatrixTSymLazylEfloatgR(void) {
   /* TMatrixTSymLazy<float> */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymLazylEfloatgR));
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "u 'TMatrixTSymLazy<float>' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FillIn",574,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 8, "u 'TMatrixTSym<float>' - 1 - m", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetRowLwb",893,G__G__Matrix_161_0_7, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRowUpb",895,G__G__Matrix_161_0_8, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Matrix_161_0_9, 85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMatrixTSymLazy<float>::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Matrix_161_0_10, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTSymLazy<float>::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Matrix_161_0_11, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMatrixTSymLazy<float>::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Matrix_161_0_12, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMatrixTSymLazy<float>::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Matrix_161_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Matrix_161_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTSymLazy<float>::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Matrix_161_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMatrixTSymLazy<float>::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Matrix_161_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTSymLazy<float>::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Matrix_161_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMatrixTSymLazy<float>::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TMatrixTSymLazy<float>", 2308, G__G__Matrix_161_0_21, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMatrixTRowlEfloatgR(void) {
   /* TMatrixTRow<float> */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTRowlEfloatgR));
   G__memfunc_setup("TMatrixTRow<float>",1765,G__G__Matrix_162_0_1, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTRowlEfloatgR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTRow<float>",1765,G__G__Matrix_162_0_2, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTRowlEfloatgR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixT<float>' - 1 - matrix i - 'Int_t' 0 - row", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTRow<float>",1765,G__G__Matrix_162_0_3, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTRowlEfloatgR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixTSym<float>' - 1 - matrix i - 'Int_t' 0 - row", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTRow<float>",1765,G__G__Matrix_162_0_4, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTRowlEfloatgR), -1, 0, 1, 1, 1, 0, "u 'TMatrixTRow<float>' - 11 - mr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPtr",598,G__G__Matrix_162_0_5, 70, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator()",957,G__G__Matrix_162_0_6, 102, -1, -1, 1, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator()",957,G__G__Matrix_162_0_7, 102, -1, -1, 1, 1, 1, 1, 0, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__G__Matrix_162_0_8, 102, -1, -1, 1, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__G__Matrix_162_0_9, 102, -1, -1, 1, 1, 1, 1, 0, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Matrix_162_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "f - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+=",980,G__G__Matrix_162_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "f - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*=",979,G__G__Matrix_162_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "f - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Matrix_162_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMatrixTRow_const<float>' - 11 - r", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Matrix_162_0_14, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTRowlEfloatgR), -1, 1, 1, 1, 1, 0, "u 'TMatrixTRow<float>' - 11 - r", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Matrix_162_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TVectorT<float>' - 11 - vec", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+=",980,G__G__Matrix_162_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMatrixTRow_const<float>' - 11 - r", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*=",979,G__G__Matrix_162_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMatrixTRow_const<float>' - 11 - r", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Matrix_162_0_18, 85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMatrixTRow<float>::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Matrix_162_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTRow<float>::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Matrix_162_0_20, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMatrixTRow<float>::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Matrix_162_0_21, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMatrixTRow<float>::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Matrix_162_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Matrix_162_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTRow<float>::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Matrix_162_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMatrixTRow<float>::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Matrix_162_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTRow<float>::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Matrix_162_0_29, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMatrixTRow<float>::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TMatrixTRow<float>", 1891, G__G__Matrix_162_0_30, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMatrixTSparselEfloatgR(void) {
   /* TMatrixTSparse<float> */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEfloatgR));
   G__memfunc_setup("Allocate",805,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 6, 1, 2, 0, 
"i - 'Int_t' 0 - nrows i - 'Int_t' 0 - ncols "
"i - 'Int_t' 0 '0' row_lwb i - 'Int_t' 0 '0' col_lwb "
"i - 'Int_t' 0 '0' init i - 'Int_t' 0 '0' nr_nonzeros", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AMultB",549,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 2, 0, 
"u 'TMatrixTSparse<float>' - 11 - a u 'TMatrixTSparse<float>' - 11 - b "
"i - 'Int_t' 0 '0' constr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AMultB",549,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 2, 0, 
"u 'TMatrixTSparse<float>' - 11 - a u 'TMatrixT<float>' - 11 - b "
"i - 'Int_t' 0 '0' constr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AMultB",549,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 2, 0, 
"u 'TMatrixT<float>' - 11 - a u 'TMatrixTSparse<float>' - 11 - b "
"i - 'Int_t' 0 '0' constr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AMultBt",665,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 2, 0, 
"u 'TMatrixTSparse<float>' - 11 - a u 'TMatrixTSparse<float>' - 11 - b "
"i - 'Int_t' 0 '0' constr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AMultBt",665,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 2, 0, 
"u 'TMatrixTSparse<float>' - 11 - a u 'TMatrixT<float>' - 11 - b "
"i - 'Int_t' 0 '0' constr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AMultBt",665,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 2, 0, 
"u 'TMatrixT<float>' - 11 - a u 'TMatrixTSparse<float>' - 11 - b "
"i - 'Int_t' 0 '0' constr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("APlusB",551,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 2, 0, 
"u 'TMatrixTSparse<float>' - 11 - a u 'TMatrixTSparse<float>' - 11 - b "
"i - 'Int_t' 0 '0' constr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("APlusB",551,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 2, 0, 
"u 'TMatrixTSparse<float>' - 11 - a u 'TMatrixT<float>' - 11 - b "
"i - 'Int_t' 0 '0' constr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("APlusB",551,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 2, 0, 
"u 'TMatrixT<float>' - 11 - a u 'TMatrixTSparse<float>' - 11 - b "
"i - 'Int_t' 0 '0' constr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AMinusB",655,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 2, 0, 
"u 'TMatrixTSparse<float>' - 11 - a u 'TMatrixTSparse<float>' - 11 - b "
"i - 'Int_t' 0 '0' constr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AMinusB",655,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 2, 0, 
"u 'TMatrixTSparse<float>' - 11 - a u 'TMatrixT<float>' - 11 - b "
"i - 'Int_t' 0 '0' constr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AMinusB",655,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 2, 0, 
"u 'TMatrixT<float>' - 11 - a u 'TMatrixTSparse<float>' - 11 - b "
"i - 'Int_t' 0 '0' constr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTSparse<float>",2075,G__G__Matrix_163_0_14, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEfloatgR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTSparse<float>",2075,G__G__Matrix_163_0_15, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEfloatgR), -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - nrows i - 'Int_t' 0 - ncols", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTSparse<float>",2075,G__G__Matrix_163_0_16, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEfloatgR), -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - row_lwb i - 'Int_t' 0 - row_upb "
"i - 'Int_t' 0 - col_lwb i - 'Int_t' 0 - col_upb", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTSparse<float>",2075,G__G__Matrix_163_0_17, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEfloatgR), -1, 0, 8, 1, 1, 0, 
"i - 'Int_t' 0 - row_lwb i - 'Int_t' 0 - row_upb "
"i - 'Int_t' 0 - col_lwb i - 'Int_t' 0 - col_upb "
"i - 'Int_t' 0 - nr_nonzeros I - 'Int_t' 0 - row "
"I - 'Int_t' 0 - col F - - 0 - data", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTSparse<float>",2075,G__G__Matrix_163_0_18, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEfloatgR), -1, 0, 1, 1, 1, 0, "u 'TMatrixTSparse<float>' - 11 - another", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTSparse<float>",2075,G__G__Matrix_163_0_19, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEfloatgR), -1, 0, 1, 1, 1, 0, "u 'TMatrixT<float>' - 11 - another", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTSparse<float>",2075,G__G__Matrix_163_0_20, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEfloatgR), -1, 0, 2, 1, 1, 0, 
"i 'TMatrixTSparse<float>::EMatrixCreatorsOp1' - 0 - op u 'TMatrixTSparse<float>' - 11 - prototype", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTSparse<float>",2075,G__G__Matrix_163_0_21, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEfloatgR), -1, 0, 3, 1, 1, 0, 
"u 'TMatrixTSparse<float>' - 11 - a i 'TMatrixTSparse<float>::EMatrixCreatorsOp2' - 0 - op "
"u 'TMatrixTSparse<float>' - 11 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTSparse<float>",2075,G__G__Matrix_163_0_22, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEfloatgR), -1, 0, 3, 1, 1, 0, 
"u 'TMatrixTSparse<float>' - 11 - a i 'TMatrixTSparse<float>::EMatrixCreatorsOp2' - 0 - op "
"u 'TMatrixT<float>' - 11 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTSparse<float>",2075,G__G__Matrix_163_0_23, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEfloatgR), -1, 0, 3, 1, 1, 0, 
"u 'TMatrixT<float>' - 11 - a i 'TMatrixTSparse<float>::EMatrixCreatorsOp2' - 0 - op "
"u 'TMatrixTSparse<float>' - 11 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMatrixArray",1428,(G__InterfaceMethod) NULL,70, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMatrixArray",1428,(G__InterfaceMethod) NULL,70, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRowIndexArray",1615,(G__InterfaceMethod) NULL,73, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRowIndexArray",1615,(G__InterfaceMethod) NULL,73, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetColIndexArray",1589,(G__InterfaceMethod) NULL,73, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetColIndexArray",1589,(G__InterfaceMethod) NULL,73, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetRowIndexArray",1627,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEfloatgR), -1, 1, 1, 1, 1, 0, "I - 'Int_t' 0 - data", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetColIndexArray",1601,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEfloatgR), -1, 1, 1, 1, 1, 0, "I - 'Int_t' 0 - data", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetSparseIndex",1426,G__G__Matrix_163_0_32, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEfloatgR), -1, 1, 1, 1, 1, 0, "i - 'Int_t' 0 - nelem_new", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSparseIndex",1426,G__G__Matrix_163_0_33, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEfloatgR), -1, 1, 1, 1, 1, 0, "u 'TMatrixTBase<float>' - 11 - another", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSparseIndexAB",1557,G__G__Matrix_163_0_34, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEfloatgR), -1, 1, 2, 1, 1, 0, 
"u 'TMatrixTSparse<float>' - 11 - a u 'TMatrixTSparse<float>' - 11 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSparseIndexAB",1557,G__G__Matrix_163_0_35, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEfloatgR), -1, 1, 2, 1, 1, 0, 
"u 'TMatrixT<float>' - 11 - a u 'TMatrixTSparse<float>' - 11 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSparseIndexAB",1557,G__G__Matrix_163_0_36, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEfloatgR), -1, 1, 2, 1, 1, 0, 
"u 'TMatrixTSparse<float>' - 11 - a u 'TMatrixT<float>' - 11 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMatrix2Array",1478,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 8, 
"F - - 0 - data C - 'Option_t' 10 '\"\"' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetMatrixArray",1440,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEfloatgR), -1, 1, 2, 1, 1, 0, 
"F - - 10 - data C - 'Option_t' 10 '\"\"' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetMatrixArray",1440,G__G__Matrix_163_0_39, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEfloatgR), -1, 1, 4, 1, 1, 0, 
"i - 'Int_t' 0 - nr_nonzeros I - 'Int_t' 0 - irow "
"I - 'Int_t' 0 - icol F - - 0 - data", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InsertRow",941,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEfloatgR), -1, 1, 4, 1, 1, 0, 
"i - 'Int_t' 0 - row i - 'Int_t' 0 - col "
"F - - 10 - v i - 'Int_t' 0 '-1' n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ExtractRow",1043,(G__InterfaceMethod) NULL,121, -1, -1, 0, 4, 1, 1, 8, 
"i - 'Int_t' 0 - row i - 'Int_t' 0 - col "
"F - - 0 - v i - 'Int_t' 0 '-1' n", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ResizeTo",821,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEfloatgR), -1, 1, 3, 1, 1, 0, 
"i - 'Int_t' 0 - nrows i - 'Int_t' 0 - ncols "
"i - 'Int_t' 0 '-1' nr_nonzeros", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ResizeTo",821,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEfloatgR), -1, 1, 5, 1, 1, 0, 
"i - 'Int_t' 0 - row_lwb i - 'Int_t' 0 - row_upb "
"i - 'Int_t' 0 - col_lwb i - 'Int_t' 0 - col_upb "
"i - 'Int_t' 0 '-1' nr_nonzeros", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ResizeTo",821,G__G__Matrix_163_0_44, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEfloatgR), -1, 1, 1, 1, 1, 0, "u 'TMatrixTSparse<float>' - 11 - m", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Clear",487,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Use",301,G__G__Matrix_163_0_46, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEfloatgR), -1, 1, 8, 1, 1, 0, 
"i - 'Int_t' 0 - row_lwb i - 'Int_t' 0 - row_upb "
"i - 'Int_t' 0 - col_lwb i - 'Int_t' 0 - col_upb "
"i - 'Int_t' 0 - nr_nonzeros I - 'Int_t' 0 - pRowIndex "
"I - 'Int_t' 0 - pColIndex F - - 0 - pData", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Use",301,G__G__Matrix_163_0_47, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEfloatgR), -1, 1, 8, 1, 1, 9, 
"i - 'Int_t' 0 - row_lwb i - 'Int_t' 0 - row_upb "
"i - 'Int_t' 0 - col_lwb i - 'Int_t' 0 - col_upb "
"i - 'Int_t' 0 - nr_nonzeros I - 'Int_t' 10 - pRowIndex "
"I - 'Int_t' 10 - pColIndex F - - 10 - pData", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Use",301,G__G__Matrix_163_0_48, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEfloatgR), -1, 1, 6, 1, 1, 0, 
"i - 'Int_t' 0 - nrows i - 'Int_t' 0 - ncols "
"i - 'Int_t' 0 - nr_nonzeros I - 'Int_t' 0 - pRowIndex "
"I - 'Int_t' 0 - pColIndex F - - 0 - pData", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Use",301,G__G__Matrix_163_0_49, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEfloatgR), -1, 1, 6, 1, 1, 9, 
"i - 'Int_t' 0 - nrows i - 'Int_t' 0 - ncols "
"i - 'Int_t' 0 - nr_nonzeros I - 'Int_t' 10 - pRowIndex "
"I - 'Int_t' 10 - pColIndex F - - 10 - pData", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Use",301,G__G__Matrix_163_0_50, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEfloatgR), -1, 1, 1, 1, 1, 0, "u 'TMatrixTSparse<float>' - 1 - a", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Use",301,G__G__Matrix_163_0_51, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEfloatgR), -1, 1, 1, 1, 1, 9, "u 'TMatrixTSparse<float>' - 11 - a", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSub",586,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEfloatgR), -1, 1, 6, 1, 1, 8, 
"i - 'Int_t' 0 - row_lwb i - 'Int_t' 0 - row_upb "
"i - 'Int_t' 0 - col_lwb i - 'Int_t' 0 - col_upb "
"u 'TMatrixTBase<float>' - 1 - target C - 'Option_t' 10 '\"S\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetSub",586,G__G__Matrix_163_0_53, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEfloatgR), -1, 0, 5, 1, 1, 8, 
"i - 'Int_t' 0 - row_lwb i - 'Int_t' 0 - row_upb "
"i - 'Int_t' 0 - col_lwb i - 'Int_t' 0 - col_upb "
"C - 'Option_t' 10 '\"S\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSub",598,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEfloatgR), -1, 1, 3, 1, 1, 0, 
"i - 'Int_t' 0 - row_lwb i - 'Int_t' 0 - col_lwb "
"u 'TMatrixTBase<float>' - 11 - source", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsSymmetric",1145,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Transpose",959,G__G__Matrix_163_0_56, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEfloatgR), -1, 1, 1, 1, 1, 0, "u 'TMatrixTSparse<float>' - 11 - source", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("T",84,G__G__Matrix_163_0_57, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEfloatgR), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Mult",418,G__G__Matrix_163_0_58, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TMatrixTSparse<float>' - 11 - a u 'TMatrixTSparse<float>' - 11 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Zero",416,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEfloatgR), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("UnitMatrix",1045,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEfloatgR), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RowNorm",724,(G__InterfaceMethod) NULL,102, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ColNorm",698,(G__InterfaceMethod) NULL,102, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("NonZeros",830,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("NormByDiag",972,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEfloatgR), -1, 1, 2, 1, 1, 0, 
"u 'TVectorT<float>' - 11 - - C - 'Option_t' 10 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("operator()",957,(G__InterfaceMethod) NULL,102, -1, -1, 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - rown i - 'Int_t' 0 - coln", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("operator()",957,(G__InterfaceMethod) NULL,102, -1, -1, 1, 2, 1, 1, 0, 
"i - 'Int_t' 0 - rown i - 'Int_t' 0 - coln", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("operator[]",1060,G__G__Matrix_163_0_67, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparseRow_constlEfloatgR), -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - rown", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__G__Matrix_163_0_68, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparseRowlEfloatgR), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - rown", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Matrix_163_0_69, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEfloatgR), -1, 1, 1, 1, 1, 0, "u 'TMatrixT<float>' - 11 - source", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Matrix_163_0_70, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEfloatgR), -1, 1, 1, 1, 1, 0, "u 'TMatrixTSparse<float>' - 11 - source", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Matrix_163_0_71, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEfloatgR), -1, 1, 1, 1, 1, 0, "f - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator-=",982,G__G__Matrix_163_0_72, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEfloatgR), -1, 1, 1, 1, 1, 0, "f - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+=",980,G__G__Matrix_163_0_73, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEfloatgR), -1, 1, 1, 1, 1, 0, "f - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*=",979,G__G__Matrix_163_0_74, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEfloatgR), -1, 1, 1, 1, 1, 0, "f - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+=",980,G__G__Matrix_163_0_75, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEfloatgR), -1, 1, 1, 1, 1, 0, "u 'TMatrixTSparse<float>' - 11 - source", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+=",980,G__G__Matrix_163_0_76, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEfloatgR), -1, 1, 1, 1, 1, 0, "u 'TMatrixT<float>' - 11 - source", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator-=",982,G__G__Matrix_163_0_77, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEfloatgR), -1, 1, 1, 1, 1, 0, "u 'TMatrixTSparse<float>' - 11 - source", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator-=",982,G__G__Matrix_163_0_78, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEfloatgR), -1, 1, 1, 1, 1, 0, "u 'TMatrixT<float>' - 11 - source", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*=",979,G__G__Matrix_163_0_79, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEfloatgR), -1, 1, 1, 1, 1, 0, "u 'TMatrixTSparse<float>' - 11 - source", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*=",979,G__G__Matrix_163_0_80, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEfloatgR), -1, 1, 1, 1, 1, 0, "u 'TMatrixT<float>' - 11 - source", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Randomize",937,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEfloatgR), -1, 1, 3, 1, 1, 0, 
"f - - 0 - alpha f - - 0 - beta "
"d - 'Double_t' 1 - seed", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("RandomizePD",1085,G__G__Matrix_163_0_82, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEfloatgR), -1, 1, 3, 1, 1, 0, 
"f - - 0 - alpha f - - 0 - beta "
"d - 'Double_t' 1 - seed", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Matrix_163_0_83, 85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMatrixTSparse<float>::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Matrix_163_0_84, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTSparse<float>::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Matrix_163_0_85, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMatrixTSparse<float>::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Matrix_163_0_86, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMatrixTSparse<float>::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Matrix_163_0_90, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Matrix_163_0_91, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTSparse<float>::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Matrix_163_0_92, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMatrixTSparse<float>::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Matrix_163_0_93, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTSparse<float>::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Matrix_163_0_94, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMatrixTSparse<float>::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TMatrixTSparse<float>", 2201, G__G__Matrix_163_0_95, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMatrixTSparseRow_constlEfloatgR(void) {
   /* TMatrixTSparseRow_const<float> */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparseRow_constlEfloatgR));
   G__memfunc_setup("TMatrixTSparseRow_const<float>",3033,G__G__Matrix_166_0_1, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparseRow_constlEfloatgR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTSparseRow_const<float>",3033,G__G__Matrix_166_0_2, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparseRow_constlEfloatgR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixTSparse<float>' - 11 - matrix i - 'Int_t' 0 - row", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTSparseRow_const<float>",3033,G__G__Matrix_166_0_3, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparseRow_constlEfloatgR), -1, 0, 1, 1, 1, 0, "u 'TMatrixTSparseRow_const<float>' - 11 - trc", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Matrix_166_0_4, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparseRow_constlEfloatgR), -1, 1, 1, 1, 1, 0, "u 'TMatrixTSparseRow_const<float>' - 11 - trc", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMatrix",917,G__G__Matrix_166_0_5, 85, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEfloatgR), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDataPtr",976,G__G__Matrix_166_0_6, 70, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetColPtr",884,G__G__Matrix_166_0_7, 73, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRowIndex",1104,G__G__Matrix_166_0_8, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNindex",902,G__G__Matrix_166_0_9, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator()",957,G__G__Matrix_166_0_10, 102, -1, -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__G__Matrix_166_0_11, 102, -1, -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Matrix_166_0_12, 85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMatrixTSparseRow_const<float>::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Matrix_166_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTSparseRow_const<float>::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Matrix_166_0_14, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMatrixTSparseRow_const<float>::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Matrix_166_0_15, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMatrixTSparseRow_const<float>::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Matrix_166_0_16, 85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__Matrix_166_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__Matrix_166_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Matrix_166_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Matrix_166_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTSparseRow_const<float>::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Matrix_166_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMatrixTSparseRow_const<float>::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Matrix_166_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTSparseRow_const<float>::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Matrix_166_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMatrixTSparseRow_const<float>::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TMatrixTSparseRow_const<float>", 3159, G__G__Matrix_166_0_24, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMatrixTSparseRowlEfloatgR(void) {
   /* TMatrixTSparseRow<float> */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparseRowlEfloatgR));
   G__memfunc_setup("TMatrixTSparseRow<float>",2387,G__G__Matrix_167_0_1, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparseRowlEfloatgR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTSparseRow<float>",2387,G__G__Matrix_167_0_2, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparseRowlEfloatgR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixTSparse<float>' - 1 - matrix i - 'Int_t' 0 - row", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTSparseRow<float>",2387,G__G__Matrix_167_0_3, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparseRowlEfloatgR), -1, 0, 1, 1, 1, 0, "u 'TMatrixTSparseRow<float>' - 11 - mr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDataPtr",976,G__G__Matrix_167_0_4, 70, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator()",957,G__G__Matrix_167_0_5, 102, -1, -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator()",957,G__G__Matrix_167_0_6, 102, -1, -1, 1, 1, 1, 1, 0, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__G__Matrix_167_0_7, 102, -1, -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__G__Matrix_167_0_8, 102, -1, -1, 1, 1, 1, 1, 0, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Matrix_167_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "f - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+=",980,G__G__Matrix_167_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "f - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*=",979,G__G__Matrix_167_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "f - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Matrix_167_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMatrixTSparseRow_const<float>' - 11 - r", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Matrix_167_0_13, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparseRowlEfloatgR), -1, 1, 1, 1, 1, 0, "u 'TMatrixTSparseRow<float>' - 11 - r", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Matrix_167_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TVectorT<float>' - 11 - vec", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+=",980,G__G__Matrix_167_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMatrixTSparseRow_const<float>' - 11 - r", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*=",979,G__G__Matrix_167_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMatrixTSparseRow_const<float>' - 11 - r", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Matrix_167_0_17, 85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMatrixTSparseRow<float>::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Matrix_167_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTSparseRow<float>::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Matrix_167_0_19, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMatrixTSparseRow<float>::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Matrix_167_0_20, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMatrixTSparseRow<float>::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Matrix_167_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Matrix_167_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTSparseRow<float>::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Matrix_167_0_26, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMatrixTSparseRow<float>::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Matrix_167_0_27, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTSparseRow<float>::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Matrix_167_0_28, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMatrixTSparseRow<float>::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TMatrixTSparseRow<float>", 2513, G__G__Matrix_167_0_29, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMatrixTLazylEfloatgR(void) {
   /* TMatrixTLazy<float> */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTLazylEfloatgR));
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "u 'TMatrixTLazy<float>' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FillIn",574,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 8, "u 'TMatrixT<float>' - 1 - m", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetRowLwb",893,G__G__Matrix_168_0_7, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRowUpb",895,G__G__Matrix_168_0_8, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetColLwb",867,G__G__Matrix_168_0_9, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetColUpb",869,G__G__Matrix_168_0_10, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Matrix_168_0_11, 85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMatrixTLazy<float>::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Matrix_168_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTLazy<float>::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Matrix_168_0_13, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMatrixTLazy<float>::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Matrix_168_0_14, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMatrixTLazy<float>::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Matrix_168_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Matrix_168_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTLazy<float>::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Matrix_168_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMatrixTLazy<float>::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Matrix_168_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTLazy<float>::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Matrix_168_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMatrixTLazy<float>::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TMatrixTLazy<float>", 1995, G__G__Matrix_168_0_23, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMatrixTDiag_constlEfloatgR(void) {
   /* TMatrixTDiag_const<float> */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTDiag_constlEfloatgR));
   G__memfunc_setup("TMatrixTDiag_const<float>",2472,G__G__Matrix_169_0_1, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTDiag_constlEfloatgR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTDiag_const<float>",2472,G__G__Matrix_169_0_2, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTDiag_constlEfloatgR), -1, 0, 1, 1, 1, 0, "u 'TMatrixT<float>' - 11 - matrix", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTDiag_const<float>",2472,G__G__Matrix_169_0_3, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTDiag_constlEfloatgR), -1, 0, 1, 1, 1, 0, "u 'TMatrixTSym<float>' - 11 - matrix", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTDiag_const<float>",2472,G__G__Matrix_169_0_4, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTDiag_constlEfloatgR), -1, 0, 1, 1, 1, 0, "u 'TMatrixTDiag_const<float>' - 11 - trc", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Matrix_169_0_5, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTDiag_constlEfloatgR), -1, 1, 1, 1, 1, 0, "u 'TMatrixTDiag_const<float>' - 11 - trc", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMatrix",917,G__G__Matrix_169_0_6, 85, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEfloatgR), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPtr",598,G__G__Matrix_169_0_7, 70, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetInc",570,G__G__Matrix_169_0_8, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator()",957,G__G__Matrix_169_0_9, 102, -1, -1, 1, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__G__Matrix_169_0_10, 102, -1, -1, 1, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNdiags",886,G__G__Matrix_169_0_11, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Matrix_169_0_12, 85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMatrixTDiag_const<float>::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Matrix_169_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTDiag_const<float>::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Matrix_169_0_14, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMatrixTDiag_const<float>::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Matrix_169_0_15, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMatrixTDiag_const<float>::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Matrix_169_0_16, 85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__Matrix_169_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__Matrix_169_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Matrix_169_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Matrix_169_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTDiag_const<float>::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Matrix_169_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMatrixTDiag_const<float>::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Matrix_169_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTDiag_const<float>::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Matrix_169_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMatrixTDiag_const<float>::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TMatrixTDiag_const<float>", 2598, G__G__Matrix_169_0_24, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMatrixTColumn_constlEfloatgR(void) {
   /* TMatrixTColumn_const<float> */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTColumn_constlEfloatgR));
   G__memfunc_setup("TMatrixTColumn_const<float>",2721,G__G__Matrix_170_0_1, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTColumn_constlEfloatgR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTColumn_const<float>",2721,G__G__Matrix_170_0_2, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTColumn_constlEfloatgR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixT<float>' - 11 - matrix i - 'Int_t' 0 - col", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTColumn_const<float>",2721,G__G__Matrix_170_0_3, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTColumn_constlEfloatgR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixTSym<float>' - 11 - matrix i - 'Int_t' 0 - col", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTColumn_const<float>",2721,G__G__Matrix_170_0_4, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTColumn_constlEfloatgR), -1, 0, 1, 1, 1, 0, "u 'TMatrixTColumn_const<float>' - 11 - trc", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Matrix_170_0_5, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTColumn_constlEfloatgR), -1, 1, 1, 1, 1, 0, "u 'TMatrixTColumn_const<float>' - 11 - trc", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMatrix",917,G__G__Matrix_170_0_6, 85, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEfloatgR), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetColIndex",1078,G__G__Matrix_170_0_7, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetInc",570,G__G__Matrix_170_0_8, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPtr",598,G__G__Matrix_170_0_9, 70, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator()",957,G__G__Matrix_170_0_10, 102, -1, -1, 1, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__G__Matrix_170_0_11, 102, -1, -1, 1, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Matrix_170_0_12, 85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMatrixTColumn_const<float>::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Matrix_170_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTColumn_const<float>::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Matrix_170_0_14, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMatrixTColumn_const<float>::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Matrix_170_0_15, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMatrixTColumn_const<float>::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Matrix_170_0_16, 85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__Matrix_170_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__Matrix_170_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Matrix_170_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Matrix_170_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTColumn_const<float>::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Matrix_170_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMatrixTColumn_const<float>::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Matrix_170_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTColumn_const<float>::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Matrix_170_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMatrixTColumn_const<float>::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TMatrixTColumn_const<float>", 2847, G__G__Matrix_170_0_24, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMatrixTSparseDiag_constlEfloatgR(void) {
   /* TMatrixTSparseDiag_const<float> */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparseDiag_constlEfloatgR));
   G__memfunc_setup("TMatrixTSparseDiag_const<float>",3094,G__G__Matrix_171_0_1, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparseDiag_constlEfloatgR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTSparseDiag_const<float>",3094,G__G__Matrix_171_0_2, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparseDiag_constlEfloatgR), -1, 0, 1, 1, 1, 0, "u 'TMatrixTSparse<float>' - 11 - matrix", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTSparseDiag_const<float>",3094,G__G__Matrix_171_0_3, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparseDiag_constlEfloatgR), -1, 0, 1, 1, 1, 0, "u 'TMatrixTSparseDiag_const<float>' - 11 - trc", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Matrix_171_0_4, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparseDiag_constlEfloatgR), -1, 1, 1, 1, 1, 0, "u 'TMatrixTSparseDiag_const<float>' - 11 - trc", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMatrix",917,G__G__Matrix_171_0_5, 85, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEfloatgR), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDataPtr",976,G__G__Matrix_171_0_6, 70, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNdiags",886,G__G__Matrix_171_0_7, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator()",957,G__G__Matrix_171_0_8, 102, -1, -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__G__Matrix_171_0_9, 102, -1, -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Matrix_171_0_10, 85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMatrixTSparseDiag_const<float>::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Matrix_171_0_11, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTSparseDiag_const<float>::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Matrix_171_0_12, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMatrixTSparseDiag_const<float>::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Matrix_171_0_13, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMatrixTSparseDiag_const<float>::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Matrix_171_0_14, 85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__Matrix_171_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__Matrix_171_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Matrix_171_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Matrix_171_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTSparseDiag_const<float>::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Matrix_171_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMatrixTSparseDiag_const<float>::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Matrix_171_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTSparseDiag_const<float>::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Matrix_171_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMatrixTSparseDiag_const<float>::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TMatrixTSparseDiag_const<float>", 3220, G__G__Matrix_171_0_22, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTDecompBase(void) {
   /* TDecompBase */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MatrixLN_TDecompBase));
   G__memfunc_setup("ResetStatus",1159,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Hager",487,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 2, 0, 
"d - 'Double_t' 1 - est i - 'Int_t' 0 '5' iter", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DiagProd",778,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 4, 3, 2, 0, 
"u 'TVectorT<double>' 'TVectorD' 11 - diag d - 'Double_t' 0 - tol "
"d - 'Double_t' 1 - d1 d - 'Double_t' 1 - d2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDecompMatrix",1517,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEdoublegR), G__defined_typename("TMatrixDBase"), 1, 0, 1, 2, 9, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetTol",591,G__G__Matrix_174_0_7, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDet1",622,G__G__Matrix_174_0_8, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDet2",623,G__G__Matrix_174_0_9, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCondition",1223,G__G__Matrix_174_0_10, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNrows",825,G__G__Matrix_174_0_11, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetNcols",799,G__G__Matrix_174_0_12, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetRowLwb",893,G__G__Matrix_174_0_13, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetColLwb",867,G__G__Matrix_174_0_14, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTol",603,G__G__Matrix_174_0_15, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "d - 'Double_t' 0 - newTol", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Condition",935,G__G__Matrix_174_0_16, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Det",285,G__G__Matrix_174_0_17, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 1 - d1 d - 'Double_t' 1 - d2", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Decompose",927,G__G__Matrix_174_0_18, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Solve",521,G__G__Matrix_174_0_19, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "u 'TVectorT<double>' 'TVectorD' 1 - b", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Solve",521,G__G__Matrix_174_0_20, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR), G__defined_typename("TVectorD"), 0, 2, 1, 1, 0, 
"u 'TVectorT<double>' 'TVectorD' 11 - b g - 'Bool_t' 1 - ok", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Solve",521,G__G__Matrix_174_0_21, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "u 'TMatrixTColumn<double>' 'TMatrixDColumn' 1 - b", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("TransSolve",1041,G__G__Matrix_174_0_22, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "u 'TVectorT<double>' 'TVectorD' 1 - b", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("TransSolve",1041,G__G__Matrix_174_0_23, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR), G__defined_typename("TVectorD"), 0, 2, 1, 1, 0, 
"u 'TVectorT<double>' 'TVectorD' 11 - b g - 'Bool_t' 1 - ok", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("TransSolve",1041,G__G__Matrix_174_0_24, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "u 'TMatrixTColumn<double>' 'TMatrixDColumn' 1 - b", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("MultiSolve",1044,G__G__Matrix_174_0_25, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "u 'TMatrixT<double>' 'TMatrixD' 1 - B", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("operator=",937,G__G__Matrix_174_0_27, 117, G__get_linked_tagnum(&G__G__MatrixLN_TDecompBase), -1, 1, 1, 1, 1, 0, "u 'TDecompBase' - 11 - source", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Matrix_174_0_28, 85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TDecompBase::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Matrix_174_0_29, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TDecompBase::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Matrix_174_0_30, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TDecompBase::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Matrix_174_0_31, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TDecompBase::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Matrix_174_0_35, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Matrix_174_0_36, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TDecompBase::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Matrix_174_0_37, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TDecompBase::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Matrix_174_0_38, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TDecompBase::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Matrix_174_0_39, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TDecompBase::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TDecompBase", 1189, G__G__Matrix_174_0_40, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTDecompBK(void) {
   /* TDecompBK */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MatrixLN_TDecompBK));
   G__memfunc_setup("GetDecompMatrix",1517,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEdoublegR), G__defined_typename("TMatrixDBase"), 1, 0, 1, 2, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TDecompBK",825,G__G__Matrix_177_0_2, 105, G__get_linked_tagnum(&G__G__MatrixLN_TDecompBK), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TDecompBK",825,G__G__Matrix_177_0_3, 105, G__get_linked_tagnum(&G__G__MatrixLN_TDecompBK), -1, 0, 1, 5, 1, 0, "i - 'Int_t' 0 - nrows", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TDecompBK",825,G__G__Matrix_177_0_4, 105, G__get_linked_tagnum(&G__G__MatrixLN_TDecompBK), -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - row_lwb i - 'Int_t' 0 - row_upb", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TDecompBK",825,G__G__Matrix_177_0_5, 105, G__get_linked_tagnum(&G__G__MatrixLN_TDecompBK), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixTSym<double>' 'TMatrixDSym' 11 - m d - 'Double_t' 0 '0.0' tol", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TDecompBK",825,G__G__Matrix_177_0_6, 105, G__get_linked_tagnum(&G__G__MatrixLN_TDecompBK), -1, 0, 1, 1, 1, 0, "u 'TDecompBK' - 11 - another", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNrows",825,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNcols",799,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetU",373,G__G__Matrix_177_0_9, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), G__defined_typename("TMatrixD"), 1, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMatrix",929,G__G__Matrix_177_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMatrixTSym<double>' 'TMatrixDSym' 11 - a", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Decompose",927,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Solve",521,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "u 'TVectorT<double>' 'TVectorD' 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Solve",521,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR), G__defined_typename("TVectorD"), 0, 2, 1, 1, 0, 
"u 'TVectorT<double>' 'TVectorD' 11 - b g - 'Bool_t' 1 - ok", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Solve",521,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "u 'TMatrixTColumn<double>' 'TMatrixDColumn' 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TransSolve",1041,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "u 'TVectorT<double>' 'TVectorD' 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TransSolve",1041,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR), G__defined_typename("TVectorD"), 0, 2, 1, 1, 0, 
"u 'TVectorT<double>' 'TVectorD' 11 - b g - 'Bool_t' 1 - ok", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TransSolve",1041,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "u 'TMatrixTColumn<double>' 'TMatrixDColumn' 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Det",285,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 1 - - d - 'Double_t' 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Invert",632,G__G__Matrix_177_0_19, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "u 'TMatrixTSym<double>' 'TMatrixDSym' 1 - inv", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Invert",632,G__G__Matrix_177_0_20, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEdoublegR), G__defined_typename("TMatrixDSym"), 0, 1, 1, 1, 0, "g - 'Bool_t' 1 - status", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Invert",632,G__G__Matrix_177_0_21, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEdoublegR), G__defined_typename("TMatrixDSym"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' opt", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("operator=",937,G__G__Matrix_177_0_23, 117, G__get_linked_tagnum(&G__G__MatrixLN_TDecompBK), -1, 1, 1, 1, 1, 0, "u 'TDecompBK' - 11 - source", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Matrix_177_0_24, 85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TDecompBK::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Matrix_177_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TDecompBK::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Matrix_177_0_26, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TDecompBK::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Matrix_177_0_27, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TDecompBK::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Matrix_177_0_31, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Matrix_177_0_32, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TDecompBK::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Matrix_177_0_33, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TDecompBK::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Matrix_177_0_34, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TDecompBK::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Matrix_177_0_35, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TDecompBK::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TDecompBK", 951, G__G__Matrix_177_0_36, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTDecompChol(void) {
   /* TDecompChol */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MatrixLN_TDecompChol));
   G__memfunc_setup("GetDecompMatrix",1517,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEdoublegR), G__defined_typename("TMatrixDBase"), 1, 0, 1, 2, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TDecompChol",1074,G__G__Matrix_178_0_2, 105, G__get_linked_tagnum(&G__G__MatrixLN_TDecompChol), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TDecompChol",1074,G__G__Matrix_178_0_3, 105, G__get_linked_tagnum(&G__G__MatrixLN_TDecompChol), -1, 0, 1, 5, 1, 0, "i - 'Int_t' 0 - nrows", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TDecompChol",1074,G__G__Matrix_178_0_4, 105, G__get_linked_tagnum(&G__G__MatrixLN_TDecompChol), -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - row_lwb i - 'Int_t' 0 - row_upb", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TDecompChol",1074,G__G__Matrix_178_0_5, 105, G__get_linked_tagnum(&G__G__MatrixLN_TDecompChol), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixTSym<double>' 'TMatrixDSym' 11 - a d - 'Double_t' 0 '0.0' tol", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TDecompChol",1074,G__G__Matrix_178_0_6, 105, G__get_linked_tagnum(&G__G__MatrixLN_TDecompChol), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixT<double>' 'TMatrixD' 11 - a d - 'Double_t' 0 '0.0' tol", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TDecompChol",1074,G__G__Matrix_178_0_7, 105, G__get_linked_tagnum(&G__G__MatrixLN_TDecompChol), -1, 0, 1, 1, 1, 0, "u 'TDecompChol' - 11 - another", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMatrix",917,G__G__Matrix_178_0_8, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEdoublegR), G__defined_typename("TMatrixDSym"), 0, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNrows",825,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNcols",799,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetU",373,G__G__Matrix_178_0_11, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), G__defined_typename("TMatrixD"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMatrix",929,G__G__Matrix_178_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMatrixTSym<double>' 'TMatrixDSym' 11 - a", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Decompose",927,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Solve",521,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "u 'TVectorT<double>' 'TVectorD' 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Solve",521,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR), G__defined_typename("TVectorD"), 0, 2, 1, 1, 0, 
"u 'TVectorT<double>' 'TVectorD' 11 - b g - 'Bool_t' 1 - ok", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Solve",521,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "u 'TMatrixTColumn<double>' 'TMatrixDColumn' 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TransSolve",1041,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "u 'TVectorT<double>' 'TVectorD' 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TransSolve",1041,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR), G__defined_typename("TVectorD"), 0, 2, 1, 1, 0, 
"u 'TVectorT<double>' 'TVectorD' 11 - b g - 'Bool_t' 1 - ok", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TransSolve",1041,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "u 'TMatrixTColumn<double>' 'TMatrixDColumn' 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Det",285,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 1 - d1 d - 'Double_t' 1 - d2", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Invert",632,G__G__Matrix_178_0_21, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "u 'TMatrixTSym<double>' 'TMatrixDSym' 1 - inv", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Invert",632,G__G__Matrix_178_0_22, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEdoublegR), G__defined_typename("TMatrixDSym"), 0, 1, 1, 1, 0, "g - 'Bool_t' 1 - status", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Invert",632,G__G__Matrix_178_0_23, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEdoublegR), G__defined_typename("TMatrixDSym"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' opt", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("operator=",937,G__G__Matrix_178_0_25, 117, G__get_linked_tagnum(&G__G__MatrixLN_TDecompChol), -1, 1, 1, 1, 1, 0, "u 'TDecompChol' - 11 - source", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Matrix_178_0_26, 85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TDecompChol::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Matrix_178_0_27, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TDecompChol::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Matrix_178_0_28, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TDecompChol::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Matrix_178_0_29, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TDecompChol::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Matrix_178_0_33, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Matrix_178_0_34, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TDecompChol::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Matrix_178_0_35, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TDecompChol::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Matrix_178_0_36, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TDecompChol::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Matrix_178_0_37, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TDecompChol::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TDecompChol", 1200, G__G__Matrix_178_0_38, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTDecompLU(void) {
   /* TDecompLU */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MatrixLN_TDecompLU));
   G__memfunc_setup("DecomposeLUCrout",1613,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 5, 3, 2, 0, 
"u 'TMatrixT<double>' 'TMatrixD' 1 - lu I - 'Int_t' 0 - index "
"d - 'Double_t' 1 - sign d - 'Double_t' 0 - tol "
"i - 'Int_t' 1 - nrZeros", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DecomposeLUGauss",1603,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 5, 3, 2, 0, 
"u 'TMatrixT<double>' 'TMatrixD' 1 - lu I - 'Int_t' 0 - index "
"d - 'Double_t' 1 - sign d - 'Double_t' 0 - tol "
"i - 'Int_t' 1 - nrZeros", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDecompMatrix",1517,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEdoublegR), G__defined_typename("TMatrixDBase"), 1, 0, 1, 2, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TDecompLU",845,G__G__Matrix_179_0_4, 105, G__get_linked_tagnum(&G__G__MatrixLN_TDecompLU), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TDecompLU",845,G__G__Matrix_179_0_5, 105, G__get_linked_tagnum(&G__G__MatrixLN_TDecompLU), -1, 0, 1, 5, 1, 0, "i - 'Int_t' 0 - nrows", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TDecompLU",845,G__G__Matrix_179_0_6, 105, G__get_linked_tagnum(&G__G__MatrixLN_TDecompLU), -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - row_lwb i - 'Int_t' 0 - row_upb", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TDecompLU",845,G__G__Matrix_179_0_7, 105, G__get_linked_tagnum(&G__G__MatrixLN_TDecompLU), -1, 0, 3, 1, 1, 0, 
"u 'TMatrixT<double>' 'TMatrixD' 11 - m d - 'Double_t' 0 '0.0' tol "
"i - 'Int_t' 0 '1' implicit", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TDecompLU",845,G__G__Matrix_179_0_8, 105, G__get_linked_tagnum(&G__G__MatrixLN_TDecompLU), -1, 0, 1, 1, 1, 0, "u 'TDecompLU' - 11 - another", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMatrix",917,G__G__Matrix_179_0_9, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), G__defined_typename("TMatrixD"), 0, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNrows",825,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNcols",799,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetLU",449,G__G__Matrix_179_0_12, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), G__defined_typename("TMatrixD"), 1, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMatrix",929,G__G__Matrix_179_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMatrixT<double>' 'TMatrixD' 11 - a", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Decompose",927,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Solve",521,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "u 'TVectorT<double>' 'TVectorD' 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Solve",521,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR), G__defined_typename("TVectorD"), 0, 2, 1, 1, 0, 
"u 'TVectorT<double>' 'TVectorD' 11 - b g - 'Bool_t' 1 - ok", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Solve",521,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "u 'TMatrixTColumn<double>' 'TMatrixDColumn' 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TransSolve",1041,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "u 'TVectorT<double>' 'TVectorD' 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TransSolve",1041,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR), G__defined_typename("TVectorD"), 0, 2, 1, 1, 0, 
"u 'TVectorT<double>' 'TVectorD' 11 - b g - 'Bool_t' 1 - ok", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TransSolve",1041,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "u 'TMatrixTColumn<double>' 'TMatrixDColumn' 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Det",285,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 1 - d1 d - 'Double_t' 1 - d2", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InvertLU",793,G__G__Matrix_179_0_22, 103, -1, G__defined_typename("Bool_t"), 0, 3, 3, 1, 0, 
"u 'TMatrixT<double>' 'TMatrixD' 1 - a d - 'Double_t' 0 - tol "
"D - 'Double_t' 0 '0' det", (char*)NULL, (void*) G__func2void( (Bool_t (*)(TMatrixD&, Double_t, Double_t*))(&TDecompLU::InvertLU) ), 0);
   G__memfunc_setup("Invert",632,G__G__Matrix_179_0_23, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "u 'TMatrixT<double>' 'TMatrixD' 1 - inv", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Invert",632,G__G__Matrix_179_0_24, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), G__defined_typename("TMatrixD"), 0, 1, 1, 1, 0, "g - 'Bool_t' 1 - status", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Invert",632,G__G__Matrix_179_0_25, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), G__defined_typename("TMatrixD"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' opt", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("operator=",937,G__G__Matrix_179_0_27, 117, G__get_linked_tagnum(&G__G__MatrixLN_TDecompLU), -1, 1, 1, 1, 1, 0, "u 'TDecompLU' - 11 - source", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Matrix_179_0_28, 85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TDecompLU::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Matrix_179_0_29, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TDecompLU::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Matrix_179_0_30, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TDecompLU::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Matrix_179_0_31, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TDecompLU::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Matrix_179_0_35, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Matrix_179_0_36, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TDecompLU::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Matrix_179_0_37, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TDecompLU::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Matrix_179_0_38, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TDecompLU::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Matrix_179_0_39, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TDecompLU::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TDecompLU", 971, G__G__Matrix_179_0_40, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTDecompQRH(void) {
   /* TDecompQRH */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MatrixLN_TDecompQRH));
   G__memfunc_setup("QRH",235,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 5, 3, 2, 0, 
"u 'TMatrixT<double>' 'TMatrixD' 1 - q u 'TVectorT<double>' 'TVectorD' 1 - diagR "
"u 'TVectorT<double>' 'TVectorD' 1 - up u 'TVectorT<double>' 'TVectorD' 1 - w "
"d - 'Double_t' 0 - tol", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDecompMatrix",1517,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEdoublegR), G__defined_typename("TMatrixDBase"), 1, 0, 1, 2, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TDecompQRH",919,G__G__Matrix_180_0_3, 105, G__get_linked_tagnum(&G__G__MatrixLN_TDecompQRH), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TDecompQRH",919,G__G__Matrix_180_0_4, 105, G__get_linked_tagnum(&G__G__MatrixLN_TDecompQRH), -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - nrows i - 'Int_t' 0 - ncols", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TDecompQRH",919,G__G__Matrix_180_0_5, 105, G__get_linked_tagnum(&G__G__MatrixLN_TDecompQRH), -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - row_lwb i - 'Int_t' 0 - row_upb "
"i - 'Int_t' 0 - col_lwb i - 'Int_t' 0 - col_upb", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TDecompQRH",919,G__G__Matrix_180_0_6, 105, G__get_linked_tagnum(&G__G__MatrixLN_TDecompQRH), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixT<double>' 'TMatrixD' 11 - m d - 'Double_t' 0 '0.0' tol", "be careful for slicing in operator=", (void*) NULL, 0);
   G__memfunc_setup("TDecompQRH",919,G__G__Matrix_180_0_7, 105, G__get_linked_tagnum(&G__G__MatrixLN_TDecompQRH), -1, 0, 1, 1, 1, 0, "u 'TDecompQRH' - 11 - another", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNrows",825,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNcols",799,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetQ",369,G__G__Matrix_180_0_10, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), G__defined_typename("TMatrixD"), 1, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetR",370,G__G__Matrix_180_0_11, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), G__defined_typename("TMatrixD"), 1, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetUp",485,G__G__Matrix_180_0_12, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR), G__defined_typename("TVectorD"), 1, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetW",375,G__G__Matrix_180_0_13, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR), G__defined_typename("TVectorD"), 1, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetMatrix",929,G__G__Matrix_180_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMatrixT<double>' 'TMatrixD' 11 - a", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Decompose",927,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Solve",521,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "u 'TVectorT<double>' 'TVectorD' 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Solve",521,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR), G__defined_typename("TVectorD"), 0, 2, 1, 1, 0, 
"u 'TVectorT<double>' 'TVectorD' 11 - b g - 'Bool_t' 1 - ok", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Solve",521,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "u 'TMatrixTColumn<double>' 'TMatrixDColumn' 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TransSolve",1041,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "u 'TVectorT<double>' 'TVectorD' 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TransSolve",1041,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR), G__defined_typename("TVectorD"), 0, 2, 1, 1, 0, 
"u 'TVectorT<double>' 'TVectorD' 11 - b g - 'Bool_t' 1 - ok", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TransSolve",1041,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "u 'TMatrixTColumn<double>' 'TMatrixDColumn' 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Det",285,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 1 - d1 d - 'Double_t' 1 - d2", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Invert",632,G__G__Matrix_180_0_23, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "u 'TMatrixT<double>' 'TMatrixD' 1 - inv", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Invert",632,G__G__Matrix_180_0_24, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), G__defined_typename("TMatrixD"), 0, 1, 1, 1, 0, "g - 'Bool_t' 1 - status", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Invert",632,G__G__Matrix_180_0_25, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), G__defined_typename("TMatrixD"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' opt", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("operator=",937,G__G__Matrix_180_0_27, 117, G__get_linked_tagnum(&G__G__MatrixLN_TDecompQRH), -1, 1, 1, 1, 1, 0, "u 'TDecompQRH' - 11 - source", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Matrix_180_0_28, 85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TDecompQRH::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Matrix_180_0_29, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TDecompQRH::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Matrix_180_0_30, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TDecompQRH::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Matrix_180_0_31, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TDecompQRH::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Matrix_180_0_35, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Matrix_180_0_36, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TDecompQRH::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Matrix_180_0_37, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TDecompQRH::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Matrix_180_0_38, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TDecompQRH::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Matrix_180_0_39, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TDecompQRH::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TDecompQRH", 1045, G__G__Matrix_180_0_40, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTDecompSparse(void) {
   /* TDecompSparse */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MatrixLN_TDecompSparse));
   G__memfunc_setup("NonZerosUpperTriang",1967,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 3, 2, 0, "u 'TMatrixTSparse<double>' 'TMatrixDSparse' 11 - a", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CopyUpperTriang",1548,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 3, 2, 0, 
"u 'TMatrixTSparse<double>' 'TMatrixDSparse' 11 - a D - 'Double_t' 0 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InitParam",901,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InitPivot",934,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 13, 3, 2, 0, 
"i - 'Int_t' 10 - n i - 'Int_t' 10 - nz "
"u 'TArrayI' - 1 - Airn u 'TArrayI' - 1 - Aicn "
"u 'TArrayI' - 1 - Aiw u 'TArrayI' - 1 - Aikeep "
"u 'TArrayI' - 1 - Aiw1 i - 'Int_t' 1 - nsteps "
"i - 'Int_t' 10 - iflag I - 'Int_t' 0 - icntl "
"D - 'Double_t' 0 - cntl I - 'Int_t' 0 - info "
"d - 'Double_t' 1 - ops", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Factor",607,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 13, 3, 2, 0, 
"i - 'Int_t' 10 - n i - 'Int_t' 10 - nz "
"u 'TArrayI' - 1 - Airn u 'TArrayI' - 1 - Aicn "
"u 'TArrayD' - 1 - Aa u 'TArrayI' - 1 - Aiw "
"u 'TArrayI' - 1 - Aikeep i - 'Int_t' 10 - nsteps "
"i - 'Int_t' 1 - maxfrt u 'TArrayI' - 1 - Aiw1 "
"I - 'Int_t' 0 - icntl D - 'Double_t' 0 - cntl "
"I - 'Int_t' 0 - info", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Solve",521,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 10, 3, 2, 0, 
"i - 'Int_t' 10 - n u 'TArrayD' - 1 - Aa "
"u 'TArrayI' - 1 - Aiw u 'TArrayD' - 1 - Aw "
"i - 'Int_t' 10 - maxfrt u 'TVectorT<double>' 'TVectorD' 1 - b "
"u 'TArrayI' - 1 - Aiw1 i - 'Int_t' 10 - nsteps "
"I - 'Int_t' 0 - icntl I - 'Int_t' 0 - info", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InitPivot_sub1",1408,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 11, 3, 2, 0, 
"i - 'Int_t' 10 - n i - 'Int_t' 10 - nz "
"I - 'Int_t' 0 - irn I - 'Int_t' 0 - icn "
"I - 'Int_t' 0 - iw I - 'Int_t' 0 - ipe "
"I - 'Int_t' 0 - iq I - 'Int_t' 0 - flag "
"i - 'Int_t' 1 - iwfr I - 'Int_t' 0 - icntl "
"I - 'Int_t' 0 - info", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InitPivot_sub2",1409,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 13, 3, 2, 0, 
"i - 'Int_t' 10 - n I - 'Int_t' 0 - ipe "
"I - 'Int_t' 0 - iw i - 'Int_t' 10 - lw "
"i - 'Int_t' 1 - iwfr I - 'Int_t' 0 - nv "
"I - 'Int_t' 0 - nxt I - 'Int_t' 0 - lst "
"I - 'Int_t' 0 - ipd I - 'Int_t' 0 - flag "
"i - 'Int_t' 10 - iovflo i - 'Int_t' 1 - ncmpa "
"d - 'Double_t' 10 - fratio", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InitPivot_sub2a",1506,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 6, 3, 2, 0, 
"i - 'Int_t' 10 - n I - 'Int_t' 0 - ipe "
"I - 'Int_t' 0 - iw i - 'Int_t' 10 - lw "
"i - 'Int_t' 1 - iwfr i - 'Int_t' 1 - ncmpa", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InitPivot_sub3",1410,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 12, 3, 2, 0, 
"i - 'Int_t' 10 - n i - 'Int_t' 10 - nz "
"I - 'Int_t' 0 - irn I - 'Int_t' 0 - icn "
"I - 'Int_t' 0 - perm I - 'Int_t' 0 - iw "
"I - 'Int_t' 0 - ipe I - 'Int_t' 0 - iq "
"I - 'Int_t' 0 - flag i - 'Int_t' 1 - iwfr "
"I - 'Int_t' 0 - icntl I - 'Int_t' 0 - info", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InitPivot_sub4",1411,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 10, 3, 2, 0, 
"i - 'Int_t' 10 - n I - 'Int_t' 0 - ipe "
"I - 'Int_t' 0 - iw i - 'Int_t' 10 - lw "
"i - 'Int_t' 1 - iwfr I - 'Int_t' 0 - ips "
"I - 'Int_t' 0 - ipv I - 'Int_t' 0 - nv "
"I - 'Int_t' 0 - flag i - 'Int_t' 1 - ncmpa", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InitPivot_sub5",1412,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 9, 3, 2, 0, 
"i - 'Int_t' 10 - n I - 'Int_t' 0 - ipe "
"I - 'Int_t' 0 - nv I - 'Int_t' 0 - ips "
"I - 'Int_t' 0 - ne I - 'Int_t' 0 - na "
"I - 'Int_t' 0 - nd i - 'Int_t' 1 - nsteps "
"i - 'Int_t' 10 - nemin", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InitPivot_sub6",1413,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 14, 3, 2, 0, 
"i - 'Int_t' 10 - n i - 'Int_t' 10 - nz "
"I - 'Int_t' 0 - irn I - 'Int_t' 0 - icn "
"I - 'Int_t' 0 - perm I - 'Int_t' 0 - na "
"I - 'Int_t' 0 - ne I - 'Int_t' 0 - nd "
"i - 'Int_t' 10 - nsteps I - 'Int_t' 0 - lstki "
"I - 'Int_t' 0 - lstkr I - 'Int_t' 0 - iw "
"I - 'Int_t' 0 - info d - 'Double_t' 1 - ops", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Factor_sub1",1081,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 13, 3, 2, 0, 
"i - 'Int_t' 10 - n i - 'Int_t' 10 - nz "
"i - 'Int_t' 1 - nz1 D - 'Double_t' 0 - a "
"i - 'Int_t' 10 - la I - 'Int_t' 0 - irn "
"I - 'Int_t' 0 - icn I - 'Int_t' 0 - iw "
"i - 'Int_t' 10 - liw I - 'Int_t' 0 - perm "
"I - 'Int_t' 0 - iw2 I - 'Int_t' 0 - icntl "
"I - 'Int_t' 0 - info", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Factor_sub2",1082,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 15, 3, 2, 0, 
"i - 'Int_t' 10 - n i - 'Int_t' 10 - nz "
"D - 'Double_t' 0 - a i - 'Int_t' 10 - la "
"I - 'Int_t' 0 - iw i - 'Int_t' 10 - liw "
"I - 'Int_t' 0 - perm I - 'Int_t' 0 - nstk "
"i - 'Int_t' 10 - nsteps i - 'Int_t' 1 - maxfrt "
"I - 'Int_t' 0 - nelim I - 'Int_t' 0 - iw2 "
"I - 'Int_t' 0 - icntl D - 'Double_t' 0 - cntl "
"I - 'Int_t' 0 - info", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Factor_sub3",1083,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 8, 3, 2, 0, 
"D - 'Double_t' 0 - a I - 'Int_t' 0 - iw "
"i - 'Int_t' 1 - j1 i - 'Int_t' 1 - j2 "
"i - 'Int_t' 10 - itop i - 'Int_t' 10 - ireal "
"i - 'Int_t' 1 - ncmpbr i - 'Int_t' 1 - ncmpbi", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Solve_sub1",995,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 9, 3, 2, 0, 
"i - 'Int_t' 10 - n D - 'Double_t' 0 - a "
"I - 'Int_t' 0 - iw D - 'Double_t' 0 - w "
"D - 'Double_t' 0 - rhs I - 'Int_t' 0 - iw2 "
"i - 'Int_t' 10 - nblk i - 'Int_t' 1 - latop "
"I - 'Int_t' 0 - icntl", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Solve_sub2",996,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 9, 3, 2, 0, 
"i - 'Int_t' 10 - n D - 'Double_t' 0 - a "
"I - 'Int_t' 0 - iw D - 'Double_t' 0 - w "
"D - 'Double_t' 0 - rhs I - 'Int_t' 0 - iw2 "
"i - 'Int_t' 10 - nblk i - 'Int_t' 10 - latop "
"I - 'Int_t' 0 - icntl", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IDiag",446,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 2, 3, 2, 0, 
"i - 'Int_t' 0 - ix i - 'Int_t' 0 - iy", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IError",595,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MinRealWorkspace",1623,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MinIntWorkspace",1534,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ErrorFlag",900,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetThresholdPivoting",2077,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTreatAsZero",1396,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetThresholdPivoting",2089,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "d - 'Double_t' 0 - piv", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTreatAsZero",1408,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "d - 'Double_t' 0 - tol", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDecompMatrix",1517,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEdoublegR), G__defined_typename("TMatrixDBase"), 1, 0, 1, 2, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TDecompSparse",1306,G__G__Matrix_185_0_29, 105, G__get_linked_tagnum(&G__G__MatrixLN_TDecompSparse), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TDecompSparse",1306,G__G__Matrix_185_0_30, 105, G__get_linked_tagnum(&G__G__MatrixLN_TDecompSparse), -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - nRows i - 'Int_t' 0 - nr_nonZeros "
"i - 'Int_t' 0 - verbose", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TDecompSparse",1306,G__G__Matrix_185_0_31, 105, G__get_linked_tagnum(&G__G__MatrixLN_TDecompSparse), -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - row_lwb i - 'Int_t' 0 - row_upb "
"i - 'Int_t' 0 - nr_nonZeros i - 'Int_t' 0 - verbose", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TDecompSparse",1306,G__G__Matrix_185_0_32, 105, G__get_linked_tagnum(&G__G__MatrixLN_TDecompSparse), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixTSparse<double>' 'TMatrixDSparse' 11 - a i - 'Int_t' 0 - verbose", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TDecompSparse",1306,G__G__Matrix_185_0_33, 105, G__get_linked_tagnum(&G__G__MatrixLN_TDecompSparse), -1, 0, 1, 1, 1, 0, "u 'TDecompSparse' - 11 - another", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetVerbose",1026,G__G__Matrix_185_0_34, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNrows",825,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNcols",799,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetMatrix",929,G__G__Matrix_185_0_37, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMatrixTSparse<double>' 'TMatrixDSparse' 11 - a", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Decompose",927,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Solve",521,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "u 'TVectorT<double>' 'TVectorD' 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Solve",521,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR), G__defined_typename("TVectorD"), 0, 2, 1, 1, 0, 
"u 'TVectorT<double>' 'TVectorD' 11 - b g - 'Bool_t' 1 - ok", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Solve",521,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "u 'TMatrixTColumn<double>' 'TMatrixDColumn' 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TransSolve",1041,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "u 'TVectorT<double>' 'TVectorD' 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TransSolve",1041,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR), G__defined_typename("TVectorD"), 0, 2, 1, 1, 0, 
"u 'TVectorT<double>' 'TVectorD' 11 - b g - 'Bool_t' 1 - ok", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TransSolve",1041,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "u 'TMatrixTColumn<double>' 'TMatrixDColumn' 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Det",285,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 1 - - d - 'Double_t' 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' opt", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("operator=",937,G__G__Matrix_185_0_47, 117, G__get_linked_tagnum(&G__G__MatrixLN_TDecompSparse), -1, 1, 1, 1, 1, 0, "u 'TDecompSparse' - 11 - source", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Matrix_185_0_48, 85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TDecompSparse::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Matrix_185_0_49, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TDecompSparse::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Matrix_185_0_50, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TDecompSparse::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Matrix_185_0_51, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TDecompSparse::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Matrix_185_0_55, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Matrix_185_0_56, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TDecompSparse::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Matrix_185_0_57, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TDecompSparse::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Matrix_185_0_58, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TDecompSparse::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Matrix_185_0_59, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TDecompSparse::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TDecompSparse", 1432, G__G__Matrix_185_0_60, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTDecompSVD(void) {
   /* TDecompSVD */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MatrixLN_TDecompSVD));
   G__memfunc_setup("Bidiagonalize",1330,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 4, 3, 2, 0, 
"u 'TMatrixT<double>' 'TMatrixD' 1 - v u 'TMatrixT<double>' 'TMatrixD' 1 - u "
"u 'TVectorT<double>' 'TVectorD' 1 - sDiag u 'TVectorT<double>' 'TVectorD' 1 - oDiag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Diagonalize",1127,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 4, 3, 2, 0, 
"u 'TMatrixT<double>' 'TMatrixD' 1 - v u 'TMatrixT<double>' 'TMatrixD' 1 - u "
"u 'TVectorT<double>' 'TVectorD' 1 - sDiag u 'TVectorT<double>' 'TVectorD' 1 - oDiag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Diag_1",517,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 4, 3, 2, 0, 
"u 'TMatrixT<double>' 'TMatrixD' 1 - v u 'TVectorT<double>' 'TVectorD' 1 - sDiag "
"u 'TVectorT<double>' 'TVectorD' 1 - oDiag i - 'Int_t' 0 - k", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Diag_2",518,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 4, 3, 2, 0, 
"u 'TVectorT<double>' 'TVectorD' 1 - sDiag u 'TVectorT<double>' 'TVectorD' 1 - oDiag "
"i - 'Int_t' 0 - k i - 'Int_t' 0 - l", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Diag_3",519,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 6, 3, 2, 0, 
"u 'TMatrixT<double>' 'TMatrixD' 1 - v u 'TMatrixT<double>' 'TMatrixD' 1 - u "
"u 'TVectorT<double>' 'TVectorD' 1 - sDiag u 'TVectorT<double>' 'TVectorD' 1 - oDiag "
"i - 'Int_t' 0 - k i - 'Int_t' 0 - l", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SortSingular",1261,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 3, 2, 0, 
"u 'TMatrixT<double>' 'TMatrixD' 1 - v u 'TMatrixT<double>' 'TMatrixD' 1 - u "
"u 'TVectorT<double>' 'TVectorD' 1 - sDiag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDecompMatrix",1517,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEdoublegR), G__defined_typename("TMatrixDBase"), 1, 0, 1, 2, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TDecompSVD",921,G__G__Matrix_186_0_8, 105, G__get_linked_tagnum(&G__G__MatrixLN_TDecompSVD), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TDecompSVD",921,G__G__Matrix_186_0_9, 105, G__get_linked_tagnum(&G__G__MatrixLN_TDecompSVD), -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - nrows i - 'Int_t' 0 - ncols", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TDecompSVD",921,G__G__Matrix_186_0_10, 105, G__get_linked_tagnum(&G__G__MatrixLN_TDecompSVD), -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - row_lwb i - 'Int_t' 0 - row_upb "
"i - 'Int_t' 0 - col_lwb i - 'Int_t' 0 - col_upb", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TDecompSVD",921,G__G__Matrix_186_0_11, 105, G__get_linked_tagnum(&G__G__MatrixLN_TDecompSVD), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixT<double>' 'TMatrixD' 11 - m d - 'Double_t' 0 '0.0' tol", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TDecompSVD",921,G__G__Matrix_186_0_12, 105, G__get_linked_tagnum(&G__G__MatrixLN_TDecompSVD), -1, 0, 1, 1, 1, 0, "u 'TDecompSVD' - 11 - another", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMatrix",917,G__G__Matrix_186_0_13, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), G__defined_typename("TMatrixD"), 0, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNrows",825,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNcols",799,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetU",373,G__G__Matrix_186_0_16, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), G__defined_typename("TMatrixD"), 1, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetV",374,G__G__Matrix_186_0_17, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), G__defined_typename("TMatrixD"), 1, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSig",579,G__G__Matrix_186_0_18, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR), G__defined_typename("TVectorD"), 1, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMatrix",929,G__G__Matrix_186_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMatrixT<double>' 'TMatrixD' 11 - a", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Decompose",927,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Solve",521,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "u 'TVectorT<double>' 'TVectorD' 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Solve",521,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR), G__defined_typename("TVectorD"), 0, 2, 1, 1, 0, 
"u 'TVectorT<double>' 'TVectorD' 11 - b g - 'Bool_t' 1 - ok", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Solve",521,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "u 'TMatrixTColumn<double>' 'TMatrixDColumn' 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TransSolve",1041,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "u 'TVectorT<double>' 'TVectorD' 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TransSolve",1041,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR), G__defined_typename("TVectorD"), 0, 2, 1, 1, 0, 
"u 'TVectorT<double>' 'TVectorD' 11 - b g - 'Bool_t' 1 - ok", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TransSolve",1041,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "u 'TMatrixTColumn<double>' 'TMatrixDColumn' 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Condition",935,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Det",285,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 1 - d1 d - 'Double_t' 1 - d2", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Invert",632,G__G__Matrix_186_0_29, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "u 'TMatrixT<double>' 'TMatrixD' 1 - inv", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Invert",632,G__G__Matrix_186_0_30, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), G__defined_typename("TMatrixD"), 0, 1, 1, 1, 0, "g - 'Bool_t' 1 - status", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Invert",632,G__G__Matrix_186_0_31, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), G__defined_typename("TMatrixD"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' opt", "*MENU*", (void*) NULL, 1);
   G__memfunc_setup("operator=",937,G__G__Matrix_186_0_33, 117, G__get_linked_tagnum(&G__G__MatrixLN_TDecompSVD), -1, 1, 1, 1, 1, 0, "u 'TDecompSVD' - 11 - source", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Matrix_186_0_34, 85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TDecompSVD::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Matrix_186_0_35, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TDecompSVD::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Matrix_186_0_36, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TDecompSVD::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Matrix_186_0_37, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TDecompSVD::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Matrix_186_0_41, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Matrix_186_0_42, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TDecompSVD::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Matrix_186_0_43, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TDecompSVD::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Matrix_186_0_44, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TDecompSVD::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Matrix_186_0_45, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TDecompSVD::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TDecompSVD", 1047, G__G__Matrix_186_0_46, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMatrixDEigen(void) {
   /* TMatrixDEigen */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixDEigen));
   G__memfunc_setup("MakeHessenBerg",1380,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 3, 2, 0, 
"u 'TMatrixT<double>' 'TMatrixD' 1 - v u 'TVectorT<double>' 'TVectorD' 1 - ortho "
"u 'TMatrixT<double>' 'TMatrixD' 1 - H", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeSchurr",1013,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 4, 3, 2, 0, 
"u 'TMatrixT<double>' 'TMatrixD' 1 - v u 'TVectorT<double>' 'TVectorD' 1 - d "
"u 'TVectorT<double>' 'TVectorD' 1 - e u 'TMatrixT<double>' 'TMatrixD' 1 - H", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Sort",424,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 3, 2, 0, 
"u 'TMatrixT<double>' 'TMatrixD' 1 - v u 'TVectorT<double>' 'TVectorD' 1 - d "
"u 'TVectorT<double>' 'TVectorD' 1 - e", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixDEigen",1269,G__G__Matrix_188_0_4, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixDEigen), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixDEigen",1269,G__G__Matrix_188_0_5, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixDEigen), -1, 0, 1, 1, 1, 0, "u 'TMatrixT<double>' 'TMatrixD' 11 - a", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixDEigen",1269,G__G__Matrix_188_0_6, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixDEigen), -1, 0, 1, 1, 1, 0, "u 'TMatrixDEigen' - 11 - another", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEigenVectors",1518,G__G__Matrix_188_0_7, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), G__defined_typename("TMatrixD"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEigenValuesRe",1583,G__G__Matrix_188_0_8, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR), G__defined_typename("TVectorD"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEigenValuesIm",1582,G__G__Matrix_188_0_9, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR), G__defined_typename("TVectorD"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEigenValues",1400,G__G__Matrix_188_0_10, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), G__defined_typename("TMatrixD"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Matrix_188_0_11, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixDEigen), -1, 1, 1, 1, 1, 0, "u 'TMatrixDEigen' - 11 - source", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Matrix_188_0_12, 85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMatrixDEigen::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Matrix_188_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixDEigen::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Matrix_188_0_14, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMatrixDEigen::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Matrix_188_0_15, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMatrixDEigen::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Matrix_188_0_16, 85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__Matrix_188_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__Matrix_188_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Matrix_188_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Matrix_188_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixDEigen::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Matrix_188_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMatrixDEigen::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Matrix_188_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixDEigen::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Matrix_188_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMatrixDEigen::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TMatrixDEigen", 1395, G__G__Matrix_188_0_24, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTHaarMatrixTlEdoublegR(void) {
   /* THaarMatrixT<double> */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MatrixLN_THaarMatrixTlEdoublegR));
   G__memfunc_setup("FillIn",574,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 8, "u 'TMatrixT<double>' - 1 - m", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("THaarMatrixT<double>",1934,G__G__Matrix_190_0_2, 105, G__get_linked_tagnum(&G__G__MatrixLN_THaarMatrixTlEdoublegR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("THaarMatrixT<double>",1934,G__G__Matrix_190_0_3, 105, G__get_linked_tagnum(&G__G__MatrixLN_THaarMatrixTlEdoublegR), -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - n i - 'Int_t' 0 '0' no_cols", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Matrix_190_0_4, 85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&THaarMatrixT<double>::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Matrix_190_0_5, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THaarMatrixT<double>::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Matrix_190_0_6, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&THaarMatrixT<double>::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Matrix_190_0_7, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&THaarMatrixT<double>::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Matrix_190_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Matrix_190_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THaarMatrixT<double>::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Matrix_190_0_13, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&THaarMatrixT<double>::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Matrix_190_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THaarMatrixT<double>::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Matrix_190_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&THaarMatrixT<double>::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("THaarMatrixT<double>", 1934, G__G__Matrix_190_0_16, (int) ('i'), G__get_linked_tagnum(&G__G__MatrixLN_THaarMatrixTlEdoublegR), -1, 0, 1, 1, 1, 0, "u 'THaarMatrixT<double>' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~THaarMatrixT<double>", 2060, G__G__Matrix_190_0_17, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTHilbertMatrixTlEdoublegR(void) {
   /* THilbertMatrixT<double> */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MatrixLN_THilbertMatrixTlEdoublegR));
   G__memfunc_setup("FillIn",574,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 8, "u 'TMatrixT<double>' - 1 - m", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("THilbertMatrixT<double>",2268,G__G__Matrix_191_0_2, 105, G__get_linked_tagnum(&G__G__MatrixLN_THilbertMatrixTlEdoublegR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("THilbertMatrixT<double>",2268,G__G__Matrix_191_0_3, 105, G__get_linked_tagnum(&G__G__MatrixLN_THilbertMatrixTlEdoublegR), -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - no_rows i - 'Int_t' 0 - no_cols", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("THilbertMatrixT<double>",2268,G__G__Matrix_191_0_4, 105, G__get_linked_tagnum(&G__G__MatrixLN_THilbertMatrixTlEdoublegR), -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - row_lwb i - 'Int_t' 0 - row_upb "
"i - 'Int_t' 0 - col_lwb i - 'Int_t' 0 - col_upb", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Matrix_191_0_5, 85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&THilbertMatrixT<double>::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Matrix_191_0_6, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THilbertMatrixT<double>::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Matrix_191_0_7, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&THilbertMatrixT<double>::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Matrix_191_0_8, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&THilbertMatrixT<double>::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Matrix_191_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Matrix_191_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THilbertMatrixT<double>::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Matrix_191_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&THilbertMatrixT<double>::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Matrix_191_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THilbertMatrixT<double>::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Matrix_191_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&THilbertMatrixT<double>::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("THilbertMatrixT<double>", 2268, G__G__Matrix_191_0_17, (int) ('i'), 
G__get_linked_tagnum(&G__G__MatrixLN_THilbertMatrixTlEdoublegR), -1, 0, 1, 1, 1, 0, "u 'THilbertMatrixT<double>' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~THilbertMatrixT<double>", 2394, G__G__Matrix_191_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTHilbertMatrixTSymlEdoublegR(void) {
   /* THilbertMatrixTSym<double> */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MatrixLN_THilbertMatrixTSymlEdoublegR));
   G__memfunc_setup("FillIn",574,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 8, "u 'TMatrixTSym<double>' - 1 - m", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("THilbertMatrixTSym<double>",2581,G__G__Matrix_192_0_2, 105, G__get_linked_tagnum(&G__G__MatrixLN_THilbertMatrixTSymlEdoublegR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("THilbertMatrixTSym<double>",2581,G__G__Matrix_192_0_3, 105, G__get_linked_tagnum(&G__G__MatrixLN_THilbertMatrixTSymlEdoublegR), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - no_rows", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("THilbertMatrixTSym<double>",2581,G__G__Matrix_192_0_4, 105, G__get_linked_tagnum(&G__G__MatrixLN_THilbertMatrixTSymlEdoublegR), -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - row_lwb i - 'Int_t' 0 - row_upb", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Matrix_192_0_5, 85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&THilbertMatrixTSym<double>::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Matrix_192_0_6, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THilbertMatrixTSym<double>::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Matrix_192_0_7, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&THilbertMatrixTSym<double>::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Matrix_192_0_8, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&THilbertMatrixTSym<double>::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Matrix_192_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Matrix_192_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THilbertMatrixTSym<double>::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Matrix_192_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&THilbertMatrixTSym<double>::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Matrix_192_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THilbertMatrixTSym<double>::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Matrix_192_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&THilbertMatrixTSym<double>::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("THilbertMatrixTSym<double>", 2581, G__G__Matrix_192_0_17, (int) ('i'), 
G__get_linked_tagnum(&G__G__MatrixLN_THilbertMatrixTSymlEdoublegR), -1, 0, 1, 1, 1, 0, "u 'THilbertMatrixTSym<double>' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~THilbertMatrixTSym<double>", 2707, G__G__Matrix_192_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMatrixDSymEigen(void) {
   /* TMatrixDSymEigen */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixDSymEigen));
   G__memfunc_setup("MakeTridiagonal",1516,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 3, 2, 0, 
"u 'TMatrixT<double>' 'TMatrixD' 1 - v u 'TVectorT<double>' 'TVectorD' 1 - d "
"u 'TVectorT<double>' 'TVectorD' 1 - e", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeEigenVectors",1612,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 3, 2, 0, 
"u 'TMatrixT<double>' 'TMatrixD' 1 - v u 'TVectorT<double>' 'TVectorD' 1 - d "
"u 'TVectorT<double>' 'TVectorD' 1 - e", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixDSymEigen",1582,G__G__Matrix_193_0_3, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixDSymEigen), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixDSymEigen",1582,G__G__Matrix_193_0_4, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixDSymEigen), -1, 0, 1, 1, 1, 0, "u 'TMatrixTSym<double>' 'TMatrixDSym' 11 - a", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixDSymEigen",1582,G__G__Matrix_193_0_5, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixDSymEigen), -1, 0, 1, 1, 1, 0, "u 'TMatrixDSymEigen' - 11 - another", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEigenVectors",1518,G__G__Matrix_193_0_6, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), G__defined_typename("TMatrixD"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEigenValues",1400,G__G__Matrix_193_0_7, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR), G__defined_typename("TVectorD"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Matrix_193_0_8, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixDSymEigen), -1, 1, 1, 1, 1, 0, "u 'TMatrixDSymEigen' - 11 - source", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Matrix_193_0_9, 85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMatrixDSymEigen::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Matrix_193_0_10, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixDSymEigen::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Matrix_193_0_11, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMatrixDSymEigen::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Matrix_193_0_12, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMatrixDSymEigen::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Matrix_193_0_13, 85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__Matrix_193_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__Matrix_193_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Matrix_193_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Matrix_193_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixDSymEigen::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Matrix_193_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMatrixDSymEigen::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Matrix_193_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixDSymEigen::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Matrix_193_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMatrixDSymEigen::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TMatrixDSymEigen", 1708, G__G__Matrix_193_0_21, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMatrixTFlat_constlEfloatgR(void) {
   /* TMatrixTFlat_const<float> */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTFlat_constlEfloatgR));
   G__memfunc_setup("TMatrixTFlat_const<float>",2490,G__G__Matrix_195_0_1, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTFlat_constlEfloatgR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTFlat_const<float>",2490,G__G__Matrix_195_0_2, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTFlat_constlEfloatgR), -1, 0, 1, 1, 1, 0, "u 'TMatrixT<float>' - 11 - matrix", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTFlat_const<float>",2490,G__G__Matrix_195_0_3, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTFlat_constlEfloatgR), -1, 0, 1, 1, 1, 0, "u 'TMatrixTSym<float>' - 11 - matrix", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTFlat_const<float>",2490,G__G__Matrix_195_0_4, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTFlat_constlEfloatgR), -1, 0, 1, 1, 1, 0, "u 'TMatrixTFlat_const<float>' - 11 - trc", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Matrix_195_0_5, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTFlat_constlEfloatgR), -1, 1, 1, 1, 1, 0, "u 'TMatrixTFlat_const<float>' - 11 - trc", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMatrix",917,G__G__Matrix_195_0_6, 85, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEfloatgR), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPtr",598,G__G__Matrix_195_0_7, 70, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator()",957,G__G__Matrix_195_0_8, 102, -1, -1, 1, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__G__Matrix_195_0_9, 102, -1, -1, 1, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Matrix_195_0_10, 85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMatrixTFlat_const<float>::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Matrix_195_0_11, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTFlat_const<float>::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Matrix_195_0_12, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMatrixTFlat_const<float>::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Matrix_195_0_13, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMatrixTFlat_const<float>::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Matrix_195_0_14, 85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__Matrix_195_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__Matrix_195_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Matrix_195_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Matrix_195_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTFlat_const<float>::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Matrix_195_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMatrixTFlat_const<float>::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Matrix_195_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTFlat_const<float>::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Matrix_195_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMatrixTFlat_const<float>::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TMatrixTFlat_const<float>", 2616, G__G__Matrix_195_0_22, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMatrixTSub_constlEfloatgR(void) {
   /* TMatrixTSub_const<float> */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSub_constlEfloatgR));
   G__memfunc_setup("TMatrixTSub_const<float>",2397,G__G__Matrix_196_0_1, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSub_constlEfloatgR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTSub_const<float>",2397,G__G__Matrix_196_0_2, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSub_constlEfloatgR), -1, 0, 5, 1, 1, 0, 
"u 'TMatrixT<float>' - 11 - matrix i - 'Int_t' 0 - row_lwb "
"i - 'Int_t' 0 - row_upb i - 'Int_t' 0 - col_lwb "
"i - 'Int_t' 0 - col_upb", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTSub_const<float>",2397,G__G__Matrix_196_0_3, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSub_constlEfloatgR), -1, 0, 5, 1, 1, 0, 
"u 'TMatrixTSym<float>' - 11 - matrix i - 'Int_t' 0 - row_lwb "
"i - 'Int_t' 0 - row_upb i - 'Int_t' 0 - col_lwb "
"i - 'Int_t' 0 - col_upb", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMatrix",917,G__G__Matrix_196_0_4, 85, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTBaselEfloatgR), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRowOff",883,G__G__Matrix_196_0_5, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetColOff",857,G__G__Matrix_196_0_6, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNrows",825,G__G__Matrix_196_0_7, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNcols",799,G__G__Matrix_196_0_8, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator()",957,G__G__Matrix_196_0_9, 102, -1, -1, 1, 2, 1, 1, 9, 
"i - 'Int_t' 0 - rown i - 'Int_t' 0 - coln", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Matrix_196_0_10, 85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMatrixTSub_const<float>::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Matrix_196_0_11, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTSub_const<float>::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Matrix_196_0_12, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMatrixTSub_const<float>::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Matrix_196_0_13, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMatrixTSub_const<float>::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Matrix_196_0_14, 85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__Matrix_196_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__Matrix_196_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Matrix_196_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Matrix_196_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTSub_const<float>::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Matrix_196_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMatrixTSub_const<float>::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Matrix_196_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTSub_const<float>::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Matrix_196_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMatrixTSub_const<float>::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TMatrixTSub_const<float>", 2397, G__G__Matrix_196_0_22, (int) ('i'), 
G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSub_constlEfloatgR), -1, 0, 1, 1, 1, 0, "u 'TMatrixTSub_const<float>' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TMatrixTSub_const<float>", 2523, G__G__Matrix_196_0_23, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMatrixTColumnlEfloatgR(void) {
   /* TMatrixTColumn<float> */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTColumnlEfloatgR));
   G__memfunc_setup("TMatrixTColumn<float>",2075,G__G__Matrix_197_0_1, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTColumnlEfloatgR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTColumn<float>",2075,G__G__Matrix_197_0_2, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTColumnlEfloatgR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixT<float>' - 1 - matrix i - 'Int_t' 0 - col", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTColumn<float>",2075,G__G__Matrix_197_0_3, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTColumnlEfloatgR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixTSym<float>' - 1 - matrix i - 'Int_t' 0 - col", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTColumn<float>",2075,G__G__Matrix_197_0_4, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTColumnlEfloatgR), -1, 0, 1, 1, 1, 0, "u 'TMatrixTColumn<float>' - 11 - mc", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPtr",598,G__G__Matrix_197_0_5, 70, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator()",957,G__G__Matrix_197_0_6, 102, -1, -1, 1, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator()",957,G__G__Matrix_197_0_7, 102, -1, -1, 1, 1, 1, 1, 0, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__G__Matrix_197_0_8, 102, -1, -1, 1, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__G__Matrix_197_0_9, 102, -1, -1, 1, 1, 1, 1, 0, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Matrix_197_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "f - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+=",980,G__G__Matrix_197_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "f - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*=",979,G__G__Matrix_197_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "f - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Matrix_197_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMatrixTColumn_const<float>' - 11 - c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Matrix_197_0_14, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTColumnlEfloatgR), -1, 1, 1, 1, 1, 0, "u 'TMatrixTColumn<float>' - 11 - c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Matrix_197_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TVectorT<float>' - 11 - vec", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+=",980,G__G__Matrix_197_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMatrixTColumn_const<float>' - 11 - c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*=",979,G__G__Matrix_197_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMatrixTColumn_const<float>' - 11 - c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Matrix_197_0_18, 85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMatrixTColumn<float>::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Matrix_197_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTColumn<float>::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Matrix_197_0_20, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMatrixTColumn<float>::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Matrix_197_0_21, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMatrixTColumn<float>::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Matrix_197_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Matrix_197_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTColumn<float>::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Matrix_197_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMatrixTColumn<float>::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Matrix_197_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTColumn<float>::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Matrix_197_0_29, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMatrixTColumn<float>::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TMatrixTColumn<float>", 2201, G__G__Matrix_197_0_30, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMatrixTDiaglEfloatgR(void) {
   /* TMatrixTDiag<float> */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTDiaglEfloatgR));
   G__memfunc_setup("TMatrixTDiag<float>",1826,G__G__Matrix_198_0_1, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTDiaglEfloatgR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTDiag<float>",1826,G__G__Matrix_198_0_2, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTDiaglEfloatgR), -1, 0, 1, 1, 1, 0, "u 'TMatrixT<float>' - 1 - matrix", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTDiag<float>",1826,G__G__Matrix_198_0_3, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTDiaglEfloatgR), -1, 0, 1, 1, 1, 0, "u 'TMatrixTSym<float>' - 1 - matrix", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTDiag<float>",1826,G__G__Matrix_198_0_4, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTDiaglEfloatgR), -1, 0, 1, 1, 1, 0, "u 'TMatrixTDiag<float>' - 11 - md", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPtr",598,G__G__Matrix_198_0_5, 70, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator()",957,G__G__Matrix_198_0_6, 102, -1, -1, 1, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator()",957,G__G__Matrix_198_0_7, 102, -1, -1, 1, 1, 1, 1, 0, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__G__Matrix_198_0_8, 102, -1, -1, 1, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__G__Matrix_198_0_9, 102, -1, -1, 1, 1, 1, 1, 0, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Matrix_198_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "f - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+=",980,G__G__Matrix_198_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "f - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*=",979,G__G__Matrix_198_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "f - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Matrix_198_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMatrixTDiag_const<float>' - 11 - d", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Matrix_198_0_14, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTDiaglEfloatgR), -1, 1, 1, 1, 1, 0, "u 'TMatrixTDiag<float>' - 11 - d", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Matrix_198_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TVectorT<float>' - 11 - vec", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+=",980,G__G__Matrix_198_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMatrixTDiag_const<float>' - 11 - d", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*=",979,G__G__Matrix_198_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMatrixTDiag_const<float>' - 11 - d", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Matrix_198_0_18, 85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMatrixTDiag<float>::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Matrix_198_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTDiag<float>::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Matrix_198_0_20, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMatrixTDiag<float>::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Matrix_198_0_21, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMatrixTDiag<float>::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Matrix_198_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Matrix_198_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTDiag<float>::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Matrix_198_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMatrixTDiag<float>::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Matrix_198_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTDiag<float>::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Matrix_198_0_29, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMatrixTDiag<float>::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TMatrixTDiag<float>", 1952, G__G__Matrix_198_0_30, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMatrixTFlatlEfloatgR(void) {
   /* TMatrixTFlat<float> */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTFlatlEfloatgR));
   G__memfunc_setup("TMatrixTFlat<float>",1844,G__G__Matrix_199_0_1, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTFlatlEfloatgR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTFlat<float>",1844,G__G__Matrix_199_0_2, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTFlatlEfloatgR), -1, 0, 1, 1, 1, 0, "u 'TMatrixT<float>' - 1 - matrix", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTFlat<float>",1844,G__G__Matrix_199_0_3, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTFlatlEfloatgR), -1, 0, 1, 1, 1, 0, "u 'TMatrixTSym<float>' - 1 - matrix", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTFlat<float>",1844,G__G__Matrix_199_0_4, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTFlatlEfloatgR), -1, 0, 1, 1, 1, 0, "u 'TMatrixTFlat<float>' - 11 - mf", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPtr",598,G__G__Matrix_199_0_5, 70, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator()",957,G__G__Matrix_199_0_6, 102, -1, -1, 1, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator()",957,G__G__Matrix_199_0_7, 102, -1, -1, 1, 1, 1, 1, 0, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__G__Matrix_199_0_8, 102, -1, -1, 1, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__G__Matrix_199_0_9, 102, -1, -1, 1, 1, 1, 1, 0, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Matrix_199_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "f - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+=",980,G__G__Matrix_199_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "f - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*=",979,G__G__Matrix_199_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "f - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Matrix_199_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMatrixTFlat_const<float>' - 11 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Matrix_199_0_14, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTFlatlEfloatgR), -1, 1, 1, 1, 1, 0, "u 'TMatrixTFlat<float>' - 11 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Matrix_199_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TVectorT<float>' - 11 - vec", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+=",980,G__G__Matrix_199_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMatrixTFlat_const<float>' - 11 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*=",979,G__G__Matrix_199_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMatrixTFlat_const<float>' - 11 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Matrix_199_0_18, 85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMatrixTFlat<float>::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Matrix_199_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTFlat<float>::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Matrix_199_0_20, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMatrixTFlat<float>::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Matrix_199_0_21, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMatrixTFlat<float>::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Matrix_199_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Matrix_199_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTFlat<float>::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Matrix_199_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMatrixTFlat<float>::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Matrix_199_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTFlat<float>::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Matrix_199_0_29, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMatrixTFlat<float>::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TMatrixTFlat<float>", 1970, G__G__Matrix_199_0_30, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMatrixTSublEfloatgR(void) {
   /* TMatrixTSub<float> */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSublEfloatgR));
   G__memfunc_setup("TMatrixTSub<float>",1751,G__G__Matrix_200_0_1, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSublEfloatgR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTSub<float>",1751,G__G__Matrix_200_0_2, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSublEfloatgR), -1, 0, 5, 1, 1, 0, 
"u 'TMatrixT<float>' - 1 - matrix i - 'Int_t' 0 - row_lwb "
"i - 'Int_t' 0 - row_upb i - 'Int_t' 0 - col_lwb "
"i - 'Int_t' 0 - col_upb", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTSub<float>",1751,G__G__Matrix_200_0_3, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSublEfloatgR), -1, 0, 5, 1, 1, 0, 
"u 'TMatrixTSym<float>' - 1 - matrix i - 'Int_t' 0 - row_lwb "
"i - 'Int_t' 0 - row_upb i - 'Int_t' 0 - col_lwb "
"i - 'Int_t' 0 - col_upb", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTSub<float>",1751,G__G__Matrix_200_0_4, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSublEfloatgR), -1, 0, 1, 1, 1, 0, "u 'TMatrixTSub<float>' - 11 - ms", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator()",957,G__G__Matrix_200_0_5, 102, -1, -1, 1, 2, 1, 1, 0, 
"i - 'Int_t' 0 - rown i - 'Int_t' 0 - coln", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Rank1Update",1056,G__G__Matrix_200_0_6, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TVectorT<float>' - 11 - vec f - - 0 '1.0' alpha", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Matrix_200_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "f - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+=",980,G__G__Matrix_200_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "f - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*=",979,G__G__Matrix_200_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "f - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Matrix_200_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMatrixTSub_const<float>' - 11 - s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Matrix_200_0_11, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSublEfloatgR), -1, 1, 1, 1, 1, 0, "u 'TMatrixTSub<float>' - 11 - s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Matrix_200_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMatrixTBase<float>' - 11 - m", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+=",980,G__G__Matrix_200_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMatrixTSub_const<float>' - 11 - s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*=",979,G__G__Matrix_200_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMatrixTSub_const<float>' - 11 - s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+=",980,G__G__Matrix_200_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMatrixTBase<float>' - 11 - m", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*=",979,G__G__Matrix_200_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMatrixT<float>' - 11 - m", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*=",979,G__G__Matrix_200_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMatrixTSym<float>' - 11 - m", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Matrix_200_0_18, 85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMatrixTSub<float>::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Matrix_200_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTSub<float>::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Matrix_200_0_20, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMatrixTSub<float>::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Matrix_200_0_21, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMatrixTSub<float>::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Matrix_200_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Matrix_200_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTSub<float>::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Matrix_200_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMatrixTSub<float>::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Matrix_200_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTSub<float>::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Matrix_200_0_29, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMatrixTSub<float>::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TMatrixTSub<float>", 1877, G__G__Matrix_200_0_30, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMatrixTSparseDiaglEfloatgR(void) {
   /* TMatrixTSparseDiag<float> */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparseDiaglEfloatgR));
   G__memfunc_setup("TMatrixTSparseDiag<float>",2448,G__G__Matrix_202_0_1, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparseDiaglEfloatgR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTSparseDiag<float>",2448,G__G__Matrix_202_0_2, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparseDiaglEfloatgR), -1, 0, 1, 1, 1, 0, "u 'TMatrixTSparse<float>' - 1 - matrix", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMatrixTSparseDiag<float>",2448,G__G__Matrix_202_0_3, 105, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparseDiaglEfloatgR), -1, 0, 1, 1, 1, 0, "u 'TMatrixTSparseDiag<float>' - 11 - md", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDataPtr",976,G__G__Matrix_202_0_4, 70, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator()",957,G__G__Matrix_202_0_5, 102, -1, -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator()",957,G__G__Matrix_202_0_6, 102, -1, -1, 1, 1, 1, 1, 0, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__G__Matrix_202_0_7, 102, -1, -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__G__Matrix_202_0_8, 102, -1, -1, 1, 1, 1, 1, 0, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Matrix_202_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "f - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+=",980,G__G__Matrix_202_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "f - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*=",979,G__G__Matrix_202_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "f - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Matrix_202_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMatrixTSparseDiag_const<float>' - 11 - d", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Matrix_202_0_13, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparseDiaglEfloatgR), -1, 1, 1, 1, 1, 0, "u 'TMatrixTSparseDiag<float>' - 11 - d", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Matrix_202_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TVectorT<float>' - 11 - vec", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator+=",980,G__G__Matrix_202_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMatrixTSparseDiag_const<float>' - 11 - d", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*=",979,G__G__Matrix_202_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMatrixTSparseDiag_const<float>' - 11 - d", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Matrix_202_0_17, 85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMatrixTSparseDiag<float>::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Matrix_202_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTSparseDiag<float>::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Matrix_202_0_19, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMatrixTSparseDiag<float>::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Matrix_202_0_20, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMatrixTSparseDiag<float>::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Matrix_202_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Matrix_202_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTSparseDiag<float>::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Matrix_202_0_26, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMatrixTSparseDiag<float>::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Matrix_202_0_27, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMatrixTSparseDiag<float>::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Matrix_202_0_28, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMatrixTSparseDiag<float>::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TMatrixTSparseDiag<float>", 2574, G__G__Matrix_202_0_29, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTHaarMatrixTlEfloatgR(void) {
   /* THaarMatrixT<float> */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MatrixLN_THaarMatrixTlEfloatgR));
   G__memfunc_setup("FillIn",574,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 8, "u 'TMatrixT<float>' - 1 - m", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("THaarMatrixT<float>",1833,G__G__Matrix_203_0_2, 105, G__get_linked_tagnum(&G__G__MatrixLN_THaarMatrixTlEfloatgR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("THaarMatrixT<float>",1833,G__G__Matrix_203_0_3, 105, G__get_linked_tagnum(&G__G__MatrixLN_THaarMatrixTlEfloatgR), -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - n i - 'Int_t' 0 '0' no_cols", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Matrix_203_0_4, 85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&THaarMatrixT<float>::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Matrix_203_0_5, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THaarMatrixT<float>::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Matrix_203_0_6, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&THaarMatrixT<float>::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Matrix_203_0_7, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&THaarMatrixT<float>::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Matrix_203_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Matrix_203_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THaarMatrixT<float>::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Matrix_203_0_13, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&THaarMatrixT<float>::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Matrix_203_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THaarMatrixT<float>::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Matrix_203_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&THaarMatrixT<float>::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("THaarMatrixT<float>", 1833, G__G__Matrix_203_0_16, (int) ('i'), G__get_linked_tagnum(&G__G__MatrixLN_THaarMatrixTlEfloatgR), -1, 0, 1, 1, 1, 0, "u 'THaarMatrixT<float>' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~THaarMatrixT<float>", 1959, G__G__Matrix_203_0_17, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTHilbertMatrixTlEfloatgR(void) {
   /* THilbertMatrixT<float> */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MatrixLN_THilbertMatrixTlEfloatgR));
   G__memfunc_setup("FillIn",574,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 8, "u 'TMatrixT<float>' - 1 - m", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("THilbertMatrixT<float>",2167,G__G__Matrix_204_0_2, 105, G__get_linked_tagnum(&G__G__MatrixLN_THilbertMatrixTlEfloatgR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("THilbertMatrixT<float>",2167,G__G__Matrix_204_0_3, 105, G__get_linked_tagnum(&G__G__MatrixLN_THilbertMatrixTlEfloatgR), -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - no_rows i - 'Int_t' 0 - no_cols", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("THilbertMatrixT<float>",2167,G__G__Matrix_204_0_4, 105, G__get_linked_tagnum(&G__G__MatrixLN_THilbertMatrixTlEfloatgR), -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - row_lwb i - 'Int_t' 0 - row_upb "
"i - 'Int_t' 0 - col_lwb i - 'Int_t' 0 - col_upb", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Matrix_204_0_5, 85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&THilbertMatrixT<float>::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Matrix_204_0_6, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THilbertMatrixT<float>::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Matrix_204_0_7, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&THilbertMatrixT<float>::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Matrix_204_0_8, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&THilbertMatrixT<float>::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Matrix_204_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Matrix_204_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THilbertMatrixT<float>::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Matrix_204_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&THilbertMatrixT<float>::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Matrix_204_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THilbertMatrixT<float>::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Matrix_204_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&THilbertMatrixT<float>::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("THilbertMatrixT<float>", 2167, G__G__Matrix_204_0_17, (int) ('i'), 
G__get_linked_tagnum(&G__G__MatrixLN_THilbertMatrixTlEfloatgR), -1, 0, 1, 1, 1, 0, "u 'THilbertMatrixT<float>' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~THilbertMatrixT<float>", 2293, G__G__Matrix_204_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTHilbertMatrixTSymlEfloatgR(void) {
   /* THilbertMatrixTSym<float> */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MatrixLN_THilbertMatrixTSymlEfloatgR));
   G__memfunc_setup("FillIn",574,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 8, "u 'TMatrixTSym<float>' - 1 - m", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("THilbertMatrixTSym<float>",2480,G__G__Matrix_205_0_2, 105, G__get_linked_tagnum(&G__G__MatrixLN_THilbertMatrixTSymlEfloatgR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("THilbertMatrixTSym<float>",2480,G__G__Matrix_205_0_3, 105, G__get_linked_tagnum(&G__G__MatrixLN_THilbertMatrixTSymlEfloatgR), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - no_rows", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("THilbertMatrixTSym<float>",2480,G__G__Matrix_205_0_4, 105, G__get_linked_tagnum(&G__G__MatrixLN_THilbertMatrixTSymlEfloatgR), -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - row_lwb i - 'Int_t' 0 - row_upb", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Matrix_205_0_5, 85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&THilbertMatrixTSym<float>::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Matrix_205_0_6, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THilbertMatrixTSym<float>::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Matrix_205_0_7, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&THilbertMatrixTSym<float>::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Matrix_205_0_8, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&THilbertMatrixTSym<float>::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__MatrixLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Matrix_205_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Matrix_205_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THilbertMatrixTSym<float>::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Matrix_205_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&THilbertMatrixTSym<float>::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Matrix_205_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&THilbertMatrixTSym<float>::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Matrix_205_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&THilbertMatrixTSym<float>::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("THilbertMatrixTSym<float>", 2480, G__G__Matrix_205_0_17, (int) ('i'), 
G__get_linked_tagnum(&G__G__MatrixLN_THilbertMatrixTSymlEfloatgR), -1, 0, 1, 1, 1, 0, "u 'THilbertMatrixTSym<float>' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~THilbertMatrixTSym<float>", 2606, G__G__Matrix_205_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMatrixTCramerInv(void) {
   /* TMatrixTCramerInv */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTCramerInv));
   G__memfunc_setup("Inv2x2",521,G__G__Matrix_206_0_1, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"u 'TMatrixT<float>' - 1 - m D - 'Double_t' 0 - determ", (char*)NULL, (void*) G__func2void( (Bool_t (*)(TMatrixT<float>&, Double_t*))(&TMatrixTCramerInv::Inv2x2) ), 0);
   G__memfunc_setup("Inv2x2",521,G__G__Matrix_206_0_2, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"u 'TMatrixT<double>' - 1 - m D - 'Double_t' 0 - determ", (char*)NULL, (void*) G__func2void( (Bool_t (*)(TMatrixT<double>&, Double_t*))(&TMatrixTCramerInv::Inv2x2) ), 0);
   G__memfunc_setup("Inv3x3",523,G__G__Matrix_206_0_3, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"u 'TMatrixT<float>' - 1 - m D - 'Double_t' 0 - determ", (char*)NULL, (void*) G__func2void( (Bool_t (*)(TMatrixT<float>&, Double_t*))(&TMatrixTCramerInv::Inv3x3) ), 0);
   G__memfunc_setup("Inv3x3",523,G__G__Matrix_206_0_4, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"u 'TMatrixT<double>' - 1 - m D - 'Double_t' 0 - determ", (char*)NULL, (void*) G__func2void( (Bool_t (*)(TMatrixT<double>&, Double_t*))(&TMatrixTCramerInv::Inv3x3) ), 0);
   G__memfunc_setup("Inv4x4",525,G__G__Matrix_206_0_5, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"u 'TMatrixT<float>' - 1 - m D - 'Double_t' 0 - determ", (char*)NULL, (void*) G__func2void( (Bool_t (*)(TMatrixT<float>&, Double_t*))(&TMatrixTCramerInv::Inv4x4) ), 0);
   G__memfunc_setup("Inv4x4",525,G__G__Matrix_206_0_6, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"u 'TMatrixT<double>' - 1 - m D - 'Double_t' 0 - determ", (char*)NULL, (void*) G__func2void( (Bool_t (*)(TMatrixT<double>&, Double_t*))(&TMatrixTCramerInv::Inv4x4) ), 0);
   G__memfunc_setup("Inv5x5",527,G__G__Matrix_206_0_7, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"u 'TMatrixT<float>' - 1 - m D - 'Double_t' 0 - determ", (char*)NULL, (void*) G__func2void( (Bool_t (*)(TMatrixT<float>&, Double_t*))(&TMatrixTCramerInv::Inv5x5) ), 0);
   G__memfunc_setup("Inv5x5",527,G__G__Matrix_206_0_8, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"u 'TMatrixT<double>' - 1 - m D - 'Double_t' 0 - determ", (char*)NULL, (void*) G__func2void( (Bool_t (*)(TMatrixT<double>&, Double_t*))(&TMatrixTCramerInv::Inv5x5) ), 0);
   G__memfunc_setup("Inv6x6",529,G__G__Matrix_206_0_9, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"u 'TMatrixT<float>' - 1 - m D - 'Double_t' 0 - determ", (char*)NULL, (void*) G__func2void( (Bool_t (*)(TMatrixT<float>&, Double_t*))(&TMatrixTCramerInv::Inv6x6) ), 0);
   G__memfunc_setup("Inv6x6",529,G__G__Matrix_206_0_10, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"u 'TMatrixT<double>' - 1 - m D - 'Double_t' 0 - determ", (char*)NULL, (void*) G__func2void( (Bool_t (*)(TMatrixT<double>&, Double_t*))(&TMatrixTCramerInv::Inv6x6) ), 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMatrixTSymCramerInv(void) {
   /* TMatrixTSymCramerInv */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymCramerInv));
   G__memfunc_setup("Inv2x2",521,G__G__Matrix_207_0_1, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"u 'TMatrixTSym<float>' - 1 - m D - 'Double_t' 0 - determ", (char*)NULL, (void*) G__func2void( (Bool_t (*)(TMatrixTSym<float>&, Double_t*))(&TMatrixTSymCramerInv::Inv2x2) ), 0);
   G__memfunc_setup("Inv2x2",521,G__G__Matrix_207_0_2, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"u 'TMatrixTSym<double>' - 1 - m D - 'Double_t' 0 - determ", (char*)NULL, (void*) G__func2void( (Bool_t (*)(TMatrixTSym<double>&, Double_t*))(&TMatrixTSymCramerInv::Inv2x2) ), 0);
   G__memfunc_setup("Inv3x3",523,G__G__Matrix_207_0_3, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"u 'TMatrixTSym<float>' - 1 - m D - 'Double_t' 0 - determ", (char*)NULL, (void*) G__func2void( (Bool_t (*)(TMatrixTSym<float>&, Double_t*))(&TMatrixTSymCramerInv::Inv3x3) ), 0);
   G__memfunc_setup("Inv3x3",523,G__G__Matrix_207_0_4, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"u 'TMatrixTSym<double>' - 1 - m D - 'Double_t' 0 - determ", (char*)NULL, (void*) G__func2void( (Bool_t (*)(TMatrixTSym<double>&, Double_t*))(&TMatrixTSymCramerInv::Inv3x3) ), 0);
   G__memfunc_setup("Inv4x4",525,G__G__Matrix_207_0_5, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"u 'TMatrixTSym<float>' - 1 - m D - 'Double_t' 0 - determ", (char*)NULL, (void*) G__func2void( (Bool_t (*)(TMatrixTSym<float>&, Double_t*))(&TMatrixTSymCramerInv::Inv4x4) ), 0);
   G__memfunc_setup("Inv4x4",525,G__G__Matrix_207_0_6, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"u 'TMatrixTSym<double>' - 1 - m D - 'Double_t' 0 - determ", (char*)NULL, (void*) G__func2void( (Bool_t (*)(TMatrixTSym<double>&, Double_t*))(&TMatrixTSymCramerInv::Inv4x4) ), 0);
   G__memfunc_setup("Inv5x5",527,G__G__Matrix_207_0_7, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"u 'TMatrixTSym<float>' - 1 - m D - 'Double_t' 0 - determ", (char*)NULL, (void*) G__func2void( (Bool_t (*)(TMatrixTSym<float>&, Double_t*))(&TMatrixTSymCramerInv::Inv5x5) ), 0);
   G__memfunc_setup("Inv5x5",527,G__G__Matrix_207_0_8, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"u 'TMatrixTSym<double>' - 1 - m D - 'Double_t' 0 - determ", (char*)NULL, (void*) G__func2void( (Bool_t (*)(TMatrixTSym<double>&, Double_t*))(&TMatrixTSymCramerInv::Inv5x5) ), 0);
   G__memfunc_setup("Inv6x6",529,G__G__Matrix_207_0_9, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"u 'TMatrixTSym<float>' - 1 - m D - 'Double_t' 0 - determ", (char*)NULL, (void*) G__func2void( (Bool_t (*)(TMatrixTSym<float>&, Double_t*))(&TMatrixTSymCramerInv::Inv6x6) ), 0);
   G__memfunc_setup("Inv6x6",529,G__G__Matrix_207_0_10, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"u 'TMatrixTSym<double>' - 1 - m D - 'Double_t' 0 - determ", (char*)NULL, (void*) G__func2void( (Bool_t (*)(TMatrixTSym<double>&, Double_t*))(&TMatrixTSymCramerInv::Inv6x6) ), 0);
   G__tag_memfunc_reset();
}


/*********************************************************
* Member function information setup
*********************************************************/
extern "C" void G__cpp_setup_memfuncG__Matrix() {
}

/*********************************************************
* Global variable information setup for each class
*********************************************************/
static void G__cpp_setup_global0() {

   /* Setting up global variables */
   G__resetplocal();

}

static void G__cpp_setup_global1() {
   G__memvar_setup((void*)(&gMatrixCheck),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"gMatrixCheck=",0,(char*)NULL);
}

static void G__cpp_setup_global2() {

   G__resetglobalenv();
}
extern "C" void G__cpp_setup_globalG__Matrix() {
  G__cpp_setup_global0();
  G__cpp_setup_global1();
  G__cpp_setup_global2();
}

/*********************************************************
* Global function information setup for each class
*********************************************************/
static void G__cpp_setup_func0() {
   G__lastifuncposition();

}

static void G__cpp_setup_func1() {
}

static void G__cpp_setup_func2() {
}

static void G__cpp_setup_func3() {
   G__memfunc_setup("NormalEqn", 909, G__G__Matrix__0_359, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR), G__defined_typename("TVectorD"), 0, 2, 1, 1, 0, 
"u 'TMatrixT<double>' 'TMatrixD' 11 - A u 'TVectorT<double>' 'TVectorD' 11 - b", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("NormalEqn", 909, G__G__Matrix__0_360, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR), G__defined_typename("TVectorD"), 0, 3, 1, 1, 0, 
"u 'TMatrixT<double>' 'TMatrixD' 11 - A u 'TVectorT<double>' 'TVectorD' 11 - b "
"u 'TVectorT<double>' 'TVectorD' 11 - std", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("NormalEqn", 909, G__G__Matrix__0_361, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), G__defined_typename("TMatrixD"), 0, 2, 1, 1, 0, 
"u 'TMatrixT<double>' 'TMatrixD' 11 - A u 'TMatrixT<double>' 'TMatrixD' 11 - b", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("NormalEqn", 909, G__G__Matrix__0_362, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), G__defined_typename("TMatrixD"), 0, 3, 1, 1, 0, 
"u 'TMatrixT<double>' 'TMatrixD' 11 - A u 'TMatrixT<double>' 'TMatrixD' 11 - B "
"u 'TVectorT<double>' 'TVectorD' 11 - std", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator==", 998, G__G__Matrix__0_369, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"u 'TVectorT<float>' - 11 - source1 u 'TVectorT<float>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator+", 919, G__G__Matrix__0_370, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEfloatgR), -1, 0, 2, 1, 1, 0, 
"u 'TVectorT<float>' - 11 - source1 u 'TVectorT<float>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator-", 921, G__G__Matrix__0_371, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEfloatgR), -1, 0, 2, 1, 1, 0, 
"u 'TVectorT<float>' - 11 - source1 u 'TVectorT<float>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator*", 918, G__G__Matrix__0_372, 102, -1, -1, 0, 2, 1, 1, 0, 
"u 'TVectorT<float>' - 11 - source1 u 'TVectorT<float>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator*", 918, G__G__Matrix__0_373, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEfloatgR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixT<float>' - 11 - a u 'TVectorT<float>' - 11 - source", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator*", 918, G__G__Matrix__0_374, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEfloatgR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixTSym<float>' - 11 - a u 'TVectorT<float>' - 11 - source", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator*", 918, G__G__Matrix__0_375, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEfloatgR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixTSparse<float>' - 11 - a u 'TVectorT<float>' - 11 - source", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator*", 918, G__G__Matrix__0_376, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEfloatgR), -1, 0, 2, 1, 1, 0, 
"f - - 0 - val u 'TVectorT<float>' - 11 - source", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("Dot", 295, G__G__Matrix__0_377, 102, -1, -1, 0, 2, 1, 1, 0, 
"u 'TVectorT<float>' - 11 - source1 u 'TVectorT<float>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("OuterProduct", 1264, G__G__Matrix__0_378, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR), -1, 0, 2, 1, 1, 0, 
"u 'TVectorT<float>' - 11 - v1 u 'TVectorT<float>' - 11 - v2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("OuterProduct", 1264, G__G__Matrix__0_379, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR), -1, 1, 3, 1, 1, 0, 
"u 'TMatrixT<float>' - 1 - target u 'TVectorT<float>' - 11 - v1 "
"u 'TVectorT<float>' - 11 - v2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("Mult", 418, G__G__Matrix__0_380, 102, -1, -1, 0, 3, 1, 1, 0, 
"u 'TVectorT<float>' - 11 - v1 u 'TMatrixT<float>' - 11 - m "
"u 'TVectorT<float>' - 11 - v2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("Add", 265, G__G__Matrix__0_381, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEfloatgR), -1, 1, 3, 1, 1, 0, 
"u 'TVectorT<float>' - 1 - target f - - 0 - scalar "
"u 'TVectorT<float>' - 11 - source", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("Add", 265, G__G__Matrix__0_382, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEfloatgR), -1, 1, 4, 1, 1, 0, 
"u 'TVectorT<float>' - 1 - target f - - 0 - scalar "
"u 'TMatrixT<float>' - 11 - a u 'TVectorT<float>' - 11 - source", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("Add", 265, G__G__Matrix__0_383, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEfloatgR), -1, 1, 4, 1, 1, 0, 
"u 'TVectorT<float>' - 1 - target f - - 0 - scalar "
"u 'TMatrixTSym<float>' - 11 - a u 'TVectorT<float>' - 11 - source", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("Add", 265, G__G__Matrix__0_384, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEfloatgR), -1, 1, 4, 1, 1, 0, 
"u 'TVectorT<float>' - 1 - target f - - 0 - scalar "
"u 'TMatrixTSparse<float>' - 11 - a u 'TVectorT<float>' - 11 - source", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("AddElemMult", 1070, G__G__Matrix__0_385, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEfloatgR), -1, 1, 4, 1, 1, 0, 
"u 'TVectorT<float>' - 1 - target f - - 0 - scalar "
"u 'TVectorT<float>' - 11 - source1 u 'TVectorT<float>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("AddElemMult", 1070, G__G__Matrix__0_386, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEfloatgR), -1, 1, 5, 1, 1, 0, 
"u 'TVectorT<float>' - 1 - target f - - 0 - scalar "
"u 'TVectorT<float>' - 11 - source1 u 'TVectorT<float>' - 11 - source2 "
"u 'TVectorT<float>' - 11 - select", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("AddElemDiv", 943, G__G__Matrix__0_387, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEfloatgR), -1, 1, 4, 1, 1, 0, 
"u 'TVectorT<float>' - 1 - target f - - 0 - scalar "
"u 'TVectorT<float>' - 11 - source1 u 'TVectorT<float>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("AddElemDiv", 943, G__G__Matrix__0_388, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEfloatgR), -1, 1, 5, 1, 1, 0, 
"u 'TVectorT<float>' - 1 - target f - - 0 - scalar "
"u 'TVectorT<float>' - 11 - source1 u 'TVectorT<float>' - 11 - source2 "
"u 'TVectorT<float>' - 11 - select", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("ElementMult", 1132, G__G__Matrix__0_389, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEfloatgR), -1, 1, 2, 1, 1, 0, 
"u 'TVectorT<float>' - 1 - target u 'TVectorT<float>' - 11 - source", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("ElementMult", 1132, G__G__Matrix__0_390, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEfloatgR), -1, 1, 3, 1, 1, 0, 
"u 'TVectorT<float>' - 1 - target u 'TVectorT<float>' - 11 - source "
"u 'TVectorT<float>' - 11 - select", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("ElementDiv", 1005, G__G__Matrix__0_391, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEfloatgR), -1, 1, 2, 1, 1, 0, 
"u 'TVectorT<float>' - 1 - target u 'TVectorT<float>' - 11 - source", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("ElementDiv", 1005, G__G__Matrix__0_392, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEfloatgR), -1, 1, 3, 1, 1, 0, 
"u 'TVectorT<float>' - 1 - target u 'TVectorT<float>' - 11 - source "
"u 'TVectorT<float>' - 11 - select", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("AreCompatible", 1304, G__G__Matrix__0_393, 103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0, 
"u 'TVectorT<float>' - 11 - v1 u 'TVectorT<float>' - 11 - v2 "
"i - 'Int_t' 0 '0' verbose", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("AreCompatible", 1304, G__G__Matrix__0_394, 103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0, 
"u 'TVectorT<float>' - 11 - v1 u 'TVectorT<double>' - 11 - v2 "
"i - 'Int_t' 0 '0' verbose", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("AreCompatible", 1304, G__G__Matrix__0_395, 103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0, 
"u 'TMatrixT<float>' - 11 - m u 'TVectorT<float>' - 11 - v "
"i - 'Int_t' 0 '0' verbose", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("AreCompatible", 1304, G__G__Matrix__0_396, 103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0, 
"u 'TVectorT<float>' - 11 - v u 'TMatrixT<float>' - 11 - m "
"i - 'Int_t' 0 '0' verbose", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("Compare", 711, G__G__Matrix__0_397, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TVectorT<float>' - 11 - source1 u 'TVectorT<float>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("VerifyVectorValue", 1765, G__G__Matrix__0_398, 103, -1, G__defined_typename("Bool_t"), 0, 4, 1, 1, 0, 
"u 'TVectorT<float>' - 11 - m f - - 0 - val "
"i - 'Int_t' 0 - verbose f - - 0 - maxDevAllow", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("VerifyVectorIdentity", 2098, G__G__Matrix__0_399, 103, -1, G__defined_typename("Bool_t"), 0, 4, 1, 1, 0, 
"u 'TVectorT<float>' - 11 - m1 u 'TVectorT<float>' - 11 - m2 "
"i - 'Int_t' 0 - verbose f - - 0 - maxDevAllow", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator==", 998, G__G__Matrix__0_400, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"u 'TMatrixTBase<float>' - 11 - m1 u 'TMatrixTBase<float>' - 11 - m2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("E2Norm", 531, G__G__Matrix__0_401, 102, -1, -1, 0, 2, 1, 1, 0, 
"u 'TMatrixTBase<float>' - 11 - m1 u 'TMatrixTBase<float>' - 11 - m2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("AreCompatible", 1304, G__G__Matrix__0_402, 103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0, 
"u 'TMatrixTBase<float>' - 11 - m1 u 'TMatrixTBase<float>' - 11 - m2 "
"i - 'Int_t' 0 '0' verbose", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("AreCompatible", 1304, G__G__Matrix__0_403, 103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0, 
"u 'TMatrixTBase<float>' - 11 - m1 u 'TMatrixTBase<double>' - 11 - m2 "
"i - 'Int_t' 0 '0' verbose", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("Compare", 711, G__G__Matrix__0_404, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TMatrixTBase<float>' - 11 - m1 u 'TMatrixTBase<float>' - 11 - m2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("VerifyMatrixValue", 1767, G__G__Matrix__0_405, 103, -1, G__defined_typename("Bool_t"), 0, 4, 1, 1, 0, 
"u 'TMatrixTBase<float>' - 11 - m f - - 0 - val "
"i - 'Int_t' 0 - verbose f - - 0 - maxDevAllow", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("VerifyMatrixIdentity", 2100, G__G__Matrix__0_406, 103, -1, G__defined_typename("Bool_t"), 0, 4, 1, 1, 0, 
"u 'TMatrixTBase<float>' - 11 - m1 u 'TMatrixTBase<float>' - 11 - m2 "
"i - 'Int_t' 0 - verbose f - - 0 - maxDevAllow", (char*) NULL
, (void*) NULL, 0);
}

static void G__cpp_setup_func4() {
   G__memfunc_setup("operator+", 919, G__G__Matrix__0_407, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixT<float>' - 11 - source1 u 'TMatrixT<float>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator+", 919, G__G__Matrix__0_408, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixT<float>' - 11 - source1 u 'TMatrixTSym<float>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator+", 919, G__G__Matrix__0_409, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixTSym<float>' - 11 - source1 u 'TMatrixT<float>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator+", 919, G__G__Matrix__0_410, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixT<float>' - 11 - source f - - 0 - val", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator+", 919, G__G__Matrix__0_411, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR), -1, 0, 2, 1, 1, 0, 
"f - - 0 - val u 'TMatrixT<float>' - 11 - source", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator-", 921, G__G__Matrix__0_412, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixT<float>' - 11 - source1 u 'TMatrixT<float>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator-", 921, G__G__Matrix__0_413, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixT<float>' - 11 - source1 u 'TMatrixTSym<float>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator-", 921, G__G__Matrix__0_414, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixTSym<float>' - 11 - source1 u 'TMatrixT<float>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator-", 921, G__G__Matrix__0_415, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixT<float>' - 11 - source f - - 0 - val", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator-", 921, G__G__Matrix__0_416, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR), -1, 0, 2, 1, 1, 0, 
"f - - 0 - val u 'TMatrixT<float>' - 11 - source", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator*", 918, G__G__Matrix__0_417, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR), -1, 0, 2, 1, 1, 0, 
"f - - 0 - val u 'TMatrixT<float>' - 11 - source", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator*", 918, G__G__Matrix__0_418, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixT<float>' - 11 - source f - - 0 - val", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator*", 918, G__G__Matrix__0_419, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixT<float>' - 11 - source1 u 'TMatrixT<float>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator*", 918, G__G__Matrix__0_420, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixT<float>' - 11 - source1 u 'TMatrixTSym<float>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator*", 918, G__G__Matrix__0_421, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixTSym<float>' - 11 - source1 u 'TMatrixT<float>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator*", 918, G__G__Matrix__0_422, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixTSym<float>' - 11 - source1 u 'TMatrixTSym<float>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator&&", 952, G__G__Matrix__0_423, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixT<float>' - 11 - source1 u 'TMatrixT<float>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator&&", 952, G__G__Matrix__0_424, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixT<float>' - 11 - source1 u 'TMatrixTSym<float>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator&&", 952, G__G__Matrix__0_425, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixTSym<float>' - 11 - source1 u 'TMatrixT<float>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator||", 1124, G__G__Matrix__0_426, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixT<float>' - 11 - source1 u 'TMatrixT<float>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator||", 1124, G__G__Matrix__0_427, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixT<float>' - 11 - source1 u 'TMatrixTSym<float>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator||", 1124, G__G__Matrix__0_428, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixTSym<float>' - 11 - source1 u 'TMatrixT<float>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator>", 938, G__G__Matrix__0_429, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixT<float>' - 11 - source1 u 'TMatrixT<float>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator>", 938, G__G__Matrix__0_430, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixT<float>' - 11 - source1 u 'TMatrixTSym<float>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator>", 938, G__G__Matrix__0_431, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixTSym<float>' - 11 - source1 u 'TMatrixT<float>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator>=", 999, G__G__Matrix__0_432, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixT<float>' - 11 - source1 u 'TMatrixT<float>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator>=", 999, G__G__Matrix__0_433, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixT<float>' - 11 - source1 u 'TMatrixTSym<float>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator>=", 999, G__G__Matrix__0_434, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixTSym<float>' - 11 - source1 u 'TMatrixT<float>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator<=", 997, G__G__Matrix__0_435, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixT<float>' - 11 - source1 u 'TMatrixT<float>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator<=", 997, G__G__Matrix__0_436, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixT<float>' - 11 - source1 u 'TMatrixTSym<float>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator<=", 997, G__G__Matrix__0_437, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixTSym<float>' - 11 - source1 u 'TMatrixT<float>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator<", 936, G__G__Matrix__0_438, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixT<float>' - 11 - source1 u 'TMatrixT<float>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator<", 936, G__G__Matrix__0_439, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixT<float>' - 11 - source1 u 'TMatrixTSym<float>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator<", 936, G__G__Matrix__0_440, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixTSym<float>' - 11 - source1 u 'TMatrixT<float>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator!=", 970, G__G__Matrix__0_441, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixT<float>' - 11 - source1 u 'TMatrixT<float>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator!=", 970, G__G__Matrix__0_442, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixT<float>' - 11 - source1 u 'TMatrixTSym<float>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator!=", 970, G__G__Matrix__0_443, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixTSym<float>' - 11 - source1 u 'TMatrixT<float>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("Add", 265, G__G__Matrix__0_444, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR), -1, 1, 3, 1, 1, 0, 
"u 'TMatrixT<float>' - 1 - target f - - 0 - scalar "
"u 'TMatrixT<float>' - 11 - source", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("Add", 265, G__G__Matrix__0_445, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR), -1, 1, 3, 1, 1, 0, 
"u 'TMatrixT<float>' - 1 - target f - - 0 - scalar "
"u 'TMatrixTSym<float>' - 11 - source", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("ElementMult", 1132, G__G__Matrix__0_446, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR), -1, 1, 2, 1, 1, 0, 
"u 'TMatrixT<float>' - 1 - target u 'TMatrixT<float>' - 11 - source", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("ElementMult", 1132, G__G__Matrix__0_447, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR), -1, 1, 2, 1, 1, 0, 
"u 'TMatrixT<float>' - 1 - target u 'TMatrixTSym<float>' - 11 - source", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("ElementDiv", 1005, G__G__Matrix__0_448, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR), -1, 1, 2, 1, 1, 0, 
"u 'TMatrixT<float>' - 1 - target u 'TMatrixT<float>' - 11 - source", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("ElementDiv", 1005, G__G__Matrix__0_449, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEfloatgR), -1, 1, 2, 1, 1, 0, 
"u 'TMatrixT<float>' - 1 - target u 'TMatrixTSym<float>' - 11 - source", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator==", 998, G__G__Matrix__0_450, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"u 'TMatrixTSym<float>' - 11 - source1 u 'TMatrixTSym<float>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator+", 919, G__G__Matrix__0_451, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEfloatgR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixTSym<float>' - 11 - source1 u 'TMatrixTSym<float>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator+", 919, G__G__Matrix__0_452, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEfloatgR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixTSym<float>' - 11 - source1 f - - 0 - val", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator+", 919, G__G__Matrix__0_453, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEfloatgR), -1, 0, 2, 1, 1, 0, 
"f - - 0 - val u 'TMatrixTSym<float>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator-", 921, G__G__Matrix__0_454, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEfloatgR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixTSym<float>' - 11 - source1 u 'TMatrixTSym<float>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator-", 921, G__G__Matrix__0_455, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEfloatgR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixTSym<float>' - 11 - source1 f - - 0 - val", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator-", 921, G__G__Matrix__0_456, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEfloatgR), -1, 0, 2, 1, 1, 0, 
"f - - 0 - val u 'TMatrixTSym<float>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator*", 918, G__G__Matrix__0_457, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEfloatgR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixTSym<float>' - 11 - source f - - 0 - val", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator*", 918, G__G__Matrix__0_458, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEfloatgR), -1, 0, 2, 1, 1, 0, 
"f - - 0 - val u 'TMatrixTSym<float>' - 11 - source", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator&&", 952, G__G__Matrix__0_459, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEfloatgR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixTSym<float>' - 11 - source1 u 'TMatrixTSym<float>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator||", 1124, G__G__Matrix__0_460, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEfloatgR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixTSym<float>' - 11 - source1 u 'TMatrixTSym<float>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator>", 938, G__G__Matrix__0_461, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEfloatgR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixTSym<float>' - 11 - source1 u 'TMatrixTSym<float>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator>=", 999, G__G__Matrix__0_462, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEfloatgR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixTSym<float>' - 11 - source1 u 'TMatrixTSym<float>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator<=", 997, G__G__Matrix__0_463, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEfloatgR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixTSym<float>' - 11 - source1 u 'TMatrixTSym<float>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator<", 936, G__G__Matrix__0_464, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEfloatgR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixTSym<float>' - 11 - source1 u 'TMatrixTSym<float>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("Add", 265, G__G__Matrix__0_465, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEfloatgR), -1, 1, 3, 1, 1, 0, 
"u 'TMatrixTSym<float>' - 1 - target f - - 0 - scalar "
"u 'TMatrixTSym<float>' - 11 - source", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("ElementMult", 1132, G__G__Matrix__0_466, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEfloatgR), -1, 1, 2, 1, 1, 0, 
"u 'TMatrixTSym<float>' - 1 - target u 'TMatrixTSym<float>' - 11 - source", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("ElementDiv", 1005, G__G__Matrix__0_467, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEfloatgR), -1, 1, 2, 1, 1, 0, 
"u 'TMatrixTSym<float>' - 1 - target u 'TMatrixTSym<float>' - 11 - source", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator+", 919, G__G__Matrix__0_468, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEfloatgR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixTSparse<float>' - 11 - source1 u 'TMatrixTSparse<float>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator+", 919, G__G__Matrix__0_469, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEfloatgR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixTSparse<float>' - 11 - source1 u 'TMatrixT<float>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator+", 919, G__G__Matrix__0_470, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEfloatgR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixT<float>' - 11 - source1 u 'TMatrixTSparse<float>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator+", 919, G__G__Matrix__0_471, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEfloatgR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixTSparse<float>' - 11 - source f - - 0 - val", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator+", 919, G__G__Matrix__0_472, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEfloatgR), -1, 0, 2, 1, 1, 0, 
"f - - 0 - val u 'TMatrixTSparse<float>' - 11 - source", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator-", 921, G__G__Matrix__0_473, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEfloatgR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixTSparse<float>' - 11 - source1 u 'TMatrixTSparse<float>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator-", 921, G__G__Matrix__0_474, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEfloatgR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixTSparse<float>' - 11 - source1 u 'TMatrixT<float>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator-", 921, G__G__Matrix__0_475, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEfloatgR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixT<float>' - 11 - source1 u 'TMatrixTSparse<float>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator-", 921, G__G__Matrix__0_476, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEfloatgR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixTSparse<float>' - 11 - source f - - 0 - val", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator-", 921, G__G__Matrix__0_477, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEfloatgR), -1, 0, 2, 1, 1, 0, 
"f - - 0 - val u 'TMatrixTSparse<float>' - 11 - source", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator*", 918, G__G__Matrix__0_478, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEfloatgR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixTSparse<float>' - 11 - source1 u 'TMatrixTSparse<float>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator*", 918, G__G__Matrix__0_479, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEfloatgR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixTSparse<float>' - 11 - source1 u 'TMatrixT<float>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator*", 918, G__G__Matrix__0_480, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEfloatgR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixT<float>' - 11 - source1 u 'TMatrixTSparse<float>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator*", 918, G__G__Matrix__0_481, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEfloatgR), -1, 0, 2, 1, 1, 0, 
"f - - 0 - val u 'TMatrixTSparse<float>' - 11 - source", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator*", 918, G__G__Matrix__0_482, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEfloatgR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixTSparse<float>' - 11 - source f - - 0 - val", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("Add", 265, G__G__Matrix__0_483, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEfloatgR), -1, 1, 3, 1, 1, 0, 
"u 'TMatrixTSparse<float>' - 1 - target f - - 0 - scalar "
"u 'TMatrixTSparse<float>' - 11 - source", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("ElementMult", 1132, G__G__Matrix__0_484, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEfloatgR), -1, 1, 2, 1, 1, 0, 
"u 'TMatrixTSparse<float>' - 1 - target u 'TMatrixTSparse<float>' - 11 - source", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("ElementDiv", 1005, G__G__Matrix__0_485, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEfloatgR), -1, 1, 2, 1, 1, 0, 
"u 'TMatrixTSparse<float>' - 1 - target u 'TMatrixTSparse<float>' - 11 - source", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("AreCompatible", 1304, G__G__Matrix__0_486, 103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0, 
"u 'TMatrixTSparse<float>' - 11 - m1 u 'TMatrixTSparse<float>' - 11 - m2 "
"i - 'Int_t' 0 '0' verbose", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator==", 998, G__G__Matrix__0_487, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"u 'TVectorT<double>' - 11 - source1 u 'TVectorT<double>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator+", 919, G__G__Matrix__0_488, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR), -1, 0, 2, 1, 1, 0, 
"u 'TVectorT<double>' - 11 - source1 u 'TVectorT<double>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator-", 921, G__G__Matrix__0_489, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR), -1, 0, 2, 1, 1, 0, 
"u 'TVectorT<double>' - 11 - source1 u 'TVectorT<double>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator*", 918, G__G__Matrix__0_490, 100, -1, -1, 0, 2, 1, 1, 0, 
"u 'TVectorT<double>' - 11 - source1 u 'TVectorT<double>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator*", 918, G__G__Matrix__0_491, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixT<double>' - 11 - a u 'TVectorT<double>' - 11 - source", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator*", 918, G__G__Matrix__0_492, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixTSym<double>' - 11 - a u 'TVectorT<double>' - 11 - source", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator*", 918, G__G__Matrix__0_493, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixTSparse<double>' - 11 - a u 'TVectorT<double>' - 11 - source", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator*", 918, G__G__Matrix__0_494, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR), -1, 0, 2, 1, 1, 0, 
"d - - 0 - val u 'TVectorT<double>' - 11 - source", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("Dot", 295, G__G__Matrix__0_495, 100, -1, -1, 0, 2, 1, 1, 0, 
"u 'TVectorT<double>' - 11 - source1 u 'TVectorT<double>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("OuterProduct", 1264, G__G__Matrix__0_496, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), -1, 0, 2, 1, 1, 0, 
"u 'TVectorT<double>' - 11 - v1 u 'TVectorT<double>' - 11 - v2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("OuterProduct", 1264, G__G__Matrix__0_497, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), -1, 1, 3, 1, 1, 0, 
"u 'TMatrixT<double>' - 1 - target u 'TVectorT<double>' - 11 - v1 "
"u 'TVectorT<double>' - 11 - v2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("Mult", 418, G__G__Matrix__0_498, 100, -1, -1, 0, 3, 1, 1, 0, 
"u 'TVectorT<double>' - 11 - v1 u 'TMatrixT<double>' - 11 - m "
"u 'TVectorT<double>' - 11 - v2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("Add", 265, G__G__Matrix__0_499, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR), -1, 1, 3, 1, 1, 0, 
"u 'TVectorT<double>' - 1 - target d - - 0 - scalar "
"u 'TVectorT<double>' - 11 - source", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("Add", 265, G__G__Matrix__0_500, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR), -1, 1, 4, 1, 1, 0, 
"u 'TVectorT<double>' - 1 - target d - - 0 - scalar "
"u 'TMatrixT<double>' - 11 - a u 'TVectorT<double>' - 11 - source", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("Add", 265, G__G__Matrix__0_501, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR), -1, 1, 4, 1, 1, 0, 
"u 'TVectorT<double>' - 1 - target d - - 0 - scalar "
"u 'TMatrixTSym<double>' - 11 - a u 'TVectorT<double>' - 11 - source", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("Add", 265, G__G__Matrix__0_502, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR), -1, 1, 4, 1, 1, 0, 
"u 'TVectorT<double>' - 1 - target d - - 0 - scalar "
"u 'TMatrixTSparse<double>' - 11 - a u 'TVectorT<double>' - 11 - source", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("AddElemMult", 1070, G__G__Matrix__0_503, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR), -1, 1, 4, 1, 1, 0, 
"u 'TVectorT<double>' - 1 - target d - - 0 - scalar "
"u 'TVectorT<double>' - 11 - source1 u 'TVectorT<double>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("AddElemMult", 1070, G__G__Matrix__0_504, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR), -1, 1, 5, 1, 1, 0, 
"u 'TVectorT<double>' - 1 - target d - - 0 - scalar "
"u 'TVectorT<double>' - 11 - source1 u 'TVectorT<double>' - 11 - source2 "
"u 'TVectorT<double>' - 11 - select", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("AddElemDiv", 943, G__G__Matrix__0_505, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR), -1, 1, 4, 1, 1, 0, 
"u 'TVectorT<double>' - 1 - target d - - 0 - scalar "
"u 'TVectorT<double>' - 11 - source1 u 'TVectorT<double>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("AddElemDiv", 943, G__G__Matrix__0_506, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR), -1, 1, 5, 1, 1, 0, 
"u 'TVectorT<double>' - 1 - target d - - 0 - scalar "
"u 'TVectorT<double>' - 11 - source1 u 'TVectorT<double>' - 11 - source2 "
"u 'TVectorT<double>' - 11 - select", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("ElementMult", 1132, G__G__Matrix__0_507, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR), -1, 1, 2, 1, 1, 0, 
"u 'TVectorT<double>' - 1 - target u 'TVectorT<double>' - 11 - source", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("ElementMult", 1132, G__G__Matrix__0_508, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR), -1, 1, 3, 1, 1, 0, 
"u 'TVectorT<double>' - 1 - target u 'TVectorT<double>' - 11 - source "
"u 'TVectorT<double>' - 11 - select", (char*) NULL
, (void*) NULL, 0);
}

static void G__cpp_setup_func5() {
   G__memfunc_setup("ElementDiv", 1005, G__G__Matrix__0_509, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR), -1, 1, 2, 1, 1, 0, 
"u 'TVectorT<double>' - 1 - target u 'TVectorT<double>' - 11 - source", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("ElementDiv", 1005, G__G__Matrix__0_510, 117, G__get_linked_tagnum(&G__G__MatrixLN_TVectorTlEdoublegR), -1, 1, 3, 1, 1, 0, 
"u 'TVectorT<double>' - 1 - target u 'TVectorT<double>' - 11 - source "
"u 'TVectorT<double>' - 11 - select", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("AreCompatible", 1304, G__G__Matrix__0_511, 103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0, 
"u 'TVectorT<double>' - 11 - v1 u 'TVectorT<double>' - 11 - v2 "
"i - 'Int_t' 0 '0' verbose", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("AreCompatible", 1304, G__G__Matrix__0_512, 103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0, 
"u 'TVectorT<double>' - 11 - v1 u 'TVectorT<float>' - 11 - v2 "
"i - 'Int_t' 0 '0' verbose", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("AreCompatible", 1304, G__G__Matrix__0_513, 103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0, 
"u 'TMatrixT<double>' - 11 - m u 'TVectorT<double>' - 11 - v "
"i - 'Int_t' 0 '0' verbose", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("AreCompatible", 1304, G__G__Matrix__0_514, 103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0, 
"u 'TVectorT<double>' - 11 - v u 'TMatrixT<double>' - 11 - m "
"i - 'Int_t' 0 '0' verbose", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("Compare", 711, G__G__Matrix__0_515, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TVectorT<double>' - 11 - source1 u 'TVectorT<double>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("VerifyVectorValue", 1765, G__G__Matrix__0_516, 103, -1, G__defined_typename("Bool_t"), 0, 4, 1, 1, 0, 
"u 'TVectorT<double>' - 11 - m d - - 0 - val "
"i - 'Int_t' 0 - verbose d - - 0 - maxDevAllow", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("VerifyVectorIdentity", 2098, G__G__Matrix__0_517, 103, -1, G__defined_typename("Bool_t"), 0, 4, 1, 1, 0, 
"u 'TVectorT<double>' - 11 - m1 u 'TVectorT<double>' - 11 - m2 "
"i - 'Int_t' 0 - verbose d - - 0 - maxDevAllow", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator==", 998, G__G__Matrix__0_518, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"u 'TMatrixTBase<double>' - 11 - m1 u 'TMatrixTBase<double>' - 11 - m2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("E2Norm", 531, G__G__Matrix__0_519, 100, -1, -1, 0, 2, 1, 1, 0, 
"u 'TMatrixTBase<double>' - 11 - m1 u 'TMatrixTBase<double>' - 11 - m2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("AreCompatible", 1304, G__G__Matrix__0_520, 103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0, 
"u 'TMatrixTBase<double>' - 11 - m1 u 'TMatrixTBase<double>' - 11 - m2 "
"i - 'Int_t' 0 '0' verbose", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("AreCompatible", 1304, G__G__Matrix__0_521, 103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0, 
"u 'TMatrixTBase<double>' - 11 - m1 u 'TMatrixTBase<float>' - 11 - m2 "
"i - 'Int_t' 0 '0' verbose", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("Compare", 711, G__G__Matrix__0_522, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TMatrixTBase<double>' - 11 - m1 u 'TMatrixTBase<double>' - 11 - m2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("VerifyMatrixValue", 1767, G__G__Matrix__0_523, 103, -1, G__defined_typename("Bool_t"), 0, 4, 1, 1, 0, 
"u 'TMatrixTBase<double>' - 11 - m d - - 0 - val "
"i - 'Int_t' 0 - verbose d - - 0 - maxDevAllow", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("VerifyMatrixIdentity", 2100, G__G__Matrix__0_524, 103, -1, G__defined_typename("Bool_t"), 0, 4, 1, 1, 0, 
"u 'TMatrixTBase<double>' - 11 - m1 u 'TMatrixTBase<double>' - 11 - m2 "
"i - 'Int_t' 0 - verbose d - - 0 - maxDevAllow", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator+", 919, G__G__Matrix__0_525, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixT<double>' - 11 - source1 u 'TMatrixT<double>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator+", 919, G__G__Matrix__0_526, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixT<double>' - 11 - source1 u 'TMatrixTSym<double>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator+", 919, G__G__Matrix__0_527, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixTSym<double>' - 11 - source1 u 'TMatrixT<double>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator+", 919, G__G__Matrix__0_528, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixT<double>' - 11 - source d - - 0 - val", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator+", 919, G__G__Matrix__0_529, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), -1, 0, 2, 1, 1, 0, 
"d - - 0 - val u 'TMatrixT<double>' - 11 - source", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator-", 921, G__G__Matrix__0_530, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixT<double>' - 11 - source1 u 'TMatrixT<double>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator-", 921, G__G__Matrix__0_531, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixT<double>' - 11 - source1 u 'TMatrixTSym<double>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator-", 921, G__G__Matrix__0_532, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixTSym<double>' - 11 - source1 u 'TMatrixT<double>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator-", 921, G__G__Matrix__0_533, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixT<double>' - 11 - source d - - 0 - val", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator-", 921, G__G__Matrix__0_534, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), -1, 0, 2, 1, 1, 0, 
"d - - 0 - val u 'TMatrixT<double>' - 11 - source", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator*", 918, G__G__Matrix__0_535, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), -1, 0, 2, 1, 1, 0, 
"d - - 0 - val u 'TMatrixT<double>' - 11 - source", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator*", 918, G__G__Matrix__0_536, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixT<double>' - 11 - source d - - 0 - val", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator*", 918, G__G__Matrix__0_537, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixT<double>' - 11 - source1 u 'TMatrixT<double>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator*", 918, G__G__Matrix__0_538, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixT<double>' - 11 - source1 u 'TMatrixTSym<double>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator*", 918, G__G__Matrix__0_539, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixTSym<double>' - 11 - source1 u 'TMatrixT<double>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator*", 918, G__G__Matrix__0_540, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixTSym<double>' - 11 - source1 u 'TMatrixTSym<double>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator&&", 952, G__G__Matrix__0_541, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixT<double>' - 11 - source1 u 'TMatrixT<double>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator&&", 952, G__G__Matrix__0_542, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixT<double>' - 11 - source1 u 'TMatrixTSym<double>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator&&", 952, G__G__Matrix__0_543, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixTSym<double>' - 11 - source1 u 'TMatrixT<double>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator||", 1124, G__G__Matrix__0_544, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixT<double>' - 11 - source1 u 'TMatrixT<double>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator||", 1124, G__G__Matrix__0_545, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixT<double>' - 11 - source1 u 'TMatrixTSym<double>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator||", 1124, G__G__Matrix__0_546, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixTSym<double>' - 11 - source1 u 'TMatrixT<double>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator>", 938, G__G__Matrix__0_547, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixT<double>' - 11 - source1 u 'TMatrixT<double>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator>", 938, G__G__Matrix__0_548, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixT<double>' - 11 - source1 u 'TMatrixTSym<double>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator>", 938, G__G__Matrix__0_549, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixTSym<double>' - 11 - source1 u 'TMatrixT<double>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator>=", 999, G__G__Matrix__0_550, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixT<double>' - 11 - source1 u 'TMatrixT<double>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator>=", 999, G__G__Matrix__0_551, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixT<double>' - 11 - source1 u 'TMatrixTSym<double>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator>=", 999, G__G__Matrix__0_552, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixTSym<double>' - 11 - source1 u 'TMatrixT<double>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator<=", 997, G__G__Matrix__0_553, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixT<double>' - 11 - source1 u 'TMatrixT<double>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator<=", 997, G__G__Matrix__0_554, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixT<double>' - 11 - source1 u 'TMatrixTSym<double>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator<=", 997, G__G__Matrix__0_555, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixTSym<double>' - 11 - source1 u 'TMatrixT<double>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator<", 936, G__G__Matrix__0_556, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixT<double>' - 11 - source1 u 'TMatrixT<double>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator<", 936, G__G__Matrix__0_557, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixT<double>' - 11 - source1 u 'TMatrixTSym<double>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator<", 936, G__G__Matrix__0_558, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixTSym<double>' - 11 - source1 u 'TMatrixT<double>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator!=", 970, G__G__Matrix__0_559, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixT<double>' - 11 - source1 u 'TMatrixT<double>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator!=", 970, G__G__Matrix__0_560, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixT<double>' - 11 - source1 u 'TMatrixTSym<double>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator!=", 970, G__G__Matrix__0_561, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixTSym<double>' - 11 - source1 u 'TMatrixT<double>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("Add", 265, G__G__Matrix__0_562, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), -1, 1, 3, 1, 1, 0, 
"u 'TMatrixT<double>' - 1 - target d - - 0 - scalar "
"u 'TMatrixT<double>' - 11 - source", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("Add", 265, G__G__Matrix__0_563, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), -1, 1, 3, 1, 1, 0, 
"u 'TMatrixT<double>' - 1 - target d - - 0 - scalar "
"u 'TMatrixTSym<double>' - 11 - source", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("ElementMult", 1132, G__G__Matrix__0_564, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), -1, 1, 2, 1, 1, 0, 
"u 'TMatrixT<double>' - 1 - target u 'TMatrixT<double>' - 11 - source", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("ElementMult", 1132, G__G__Matrix__0_565, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), -1, 1, 2, 1, 1, 0, 
"u 'TMatrixT<double>' - 1 - target u 'TMatrixTSym<double>' - 11 - source", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("ElementDiv", 1005, G__G__Matrix__0_566, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), -1, 1, 2, 1, 1, 0, 
"u 'TMatrixT<double>' - 1 - target u 'TMatrixT<double>' - 11 - source", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("ElementDiv", 1005, G__G__Matrix__0_567, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTlEdoublegR), -1, 1, 2, 1, 1, 0, 
"u 'TMatrixT<double>' - 1 - target u 'TMatrixTSym<double>' - 11 - source", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator==", 998, G__G__Matrix__0_568, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"u 'TMatrixTSym<double>' - 11 - source1 u 'TMatrixTSym<double>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator+", 919, G__G__Matrix__0_569, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEdoublegR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixTSym<double>' - 11 - source1 u 'TMatrixTSym<double>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator+", 919, G__G__Matrix__0_570, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEdoublegR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixTSym<double>' - 11 - source1 d - - 0 - val", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator+", 919, G__G__Matrix__0_571, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEdoublegR), -1, 0, 2, 1, 1, 0, 
"d - - 0 - val u 'TMatrixTSym<double>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator-", 921, G__G__Matrix__0_572, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEdoublegR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixTSym<double>' - 11 - source1 u 'TMatrixTSym<double>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator-", 921, G__G__Matrix__0_573, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEdoublegR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixTSym<double>' - 11 - source1 d - - 0 - val", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator-", 921, G__G__Matrix__0_574, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEdoublegR), -1, 0, 2, 1, 1, 0, 
"d - - 0 - val u 'TMatrixTSym<double>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator*", 918, G__G__Matrix__0_575, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEdoublegR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixTSym<double>' - 11 - source d - - 0 - val", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator*", 918, G__G__Matrix__0_576, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEdoublegR), -1, 0, 2, 1, 1, 0, 
"d - - 0 - val u 'TMatrixTSym<double>' - 11 - source", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator&&", 952, G__G__Matrix__0_577, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEdoublegR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixTSym<double>' - 11 - source1 u 'TMatrixTSym<double>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator||", 1124, G__G__Matrix__0_578, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEdoublegR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixTSym<double>' - 11 - source1 u 'TMatrixTSym<double>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator>", 938, G__G__Matrix__0_579, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEdoublegR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixTSym<double>' - 11 - source1 u 'TMatrixTSym<double>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator>=", 999, G__G__Matrix__0_580, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEdoublegR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixTSym<double>' - 11 - source1 u 'TMatrixTSym<double>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator<=", 997, G__G__Matrix__0_581, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEdoublegR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixTSym<double>' - 11 - source1 u 'TMatrixTSym<double>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator<", 936, G__G__Matrix__0_582, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEdoublegR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixTSym<double>' - 11 - source1 u 'TMatrixTSym<double>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("Add", 265, G__G__Matrix__0_583, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEdoublegR), -1, 1, 3, 1, 1, 0, 
"u 'TMatrixTSym<double>' - 1 - target d - - 0 - scalar "
"u 'TMatrixTSym<double>' - 11 - source", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("ElementMult", 1132, G__G__Matrix__0_584, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEdoublegR), -1, 1, 2, 1, 1, 0, 
"u 'TMatrixTSym<double>' - 1 - target u 'TMatrixTSym<double>' - 11 - source", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("ElementDiv", 1005, G__G__Matrix__0_585, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSymlEdoublegR), -1, 1, 2, 1, 1, 0, 
"u 'TMatrixTSym<double>' - 1 - target u 'TMatrixTSym<double>' - 11 - source", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator+", 919, G__G__Matrix__0_586, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEdoublegR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixTSparse<double>' - 11 - source1 u 'TMatrixTSparse<double>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator+", 919, G__G__Matrix__0_587, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEdoublegR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixTSparse<double>' - 11 - source1 u 'TMatrixT<double>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator+", 919, G__G__Matrix__0_588, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEdoublegR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixT<double>' - 11 - source1 u 'TMatrixTSparse<double>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator+", 919, G__G__Matrix__0_589, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEdoublegR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixTSparse<double>' - 11 - source d - - 0 - val", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator+", 919, G__G__Matrix__0_590, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEdoublegR), -1, 0, 2, 1, 1, 0, 
"d - - 0 - val u 'TMatrixTSparse<double>' - 11 - source", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator-", 921, G__G__Matrix__0_591, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEdoublegR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixTSparse<double>' - 11 - source1 u 'TMatrixTSparse<double>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator-", 921, G__G__Matrix__0_592, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEdoublegR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixTSparse<double>' - 11 - source1 u 'TMatrixT<double>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator-", 921, G__G__Matrix__0_593, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEdoublegR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixT<double>' - 11 - source1 u 'TMatrixTSparse<double>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator-", 921, G__G__Matrix__0_594, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEdoublegR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixTSparse<double>' - 11 - source d - - 0 - val", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator-", 921, G__G__Matrix__0_595, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEdoublegR), -1, 0, 2, 1, 1, 0, 
"d - - 0 - val u 'TMatrixTSparse<double>' - 11 - source", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator*", 918, G__G__Matrix__0_596, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEdoublegR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixTSparse<double>' - 11 - source1 u 'TMatrixTSparse<double>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator*", 918, G__G__Matrix__0_597, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEdoublegR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixTSparse<double>' - 11 - source1 u 'TMatrixT<double>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator*", 918, G__G__Matrix__0_598, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEdoublegR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixT<double>' - 11 - source1 u 'TMatrixTSparse<double>' - 11 - source2", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator*", 918, G__G__Matrix__0_599, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEdoublegR), -1, 0, 2, 1, 1, 0, 
"d - - 0 - val u 'TMatrixTSparse<double>' - 11 - source", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("operator*", 918, G__G__Matrix__0_600, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEdoublegR), -1, 0, 2, 1, 1, 0, 
"u 'TMatrixTSparse<double>' - 11 - source d - - 0 - val", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("Add", 265, G__G__Matrix__0_601, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEdoublegR), -1, 1, 3, 1, 1, 0, 
"u 'TMatrixTSparse<double>' - 1 - target d - - 0 - scalar "
"u 'TMatrixTSparse<double>' - 11 - source", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("ElementMult", 1132, G__G__Matrix__0_602, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEdoublegR), -1, 1, 2, 1, 1, 0, 
"u 'TMatrixTSparse<double>' - 1 - target u 'TMatrixTSparse<double>' - 11 - source", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("ElementDiv", 1005, G__G__Matrix__0_603, 117, G__get_linked_tagnum(&G__G__MatrixLN_TMatrixTSparselEdoublegR), -1, 1, 2, 1, 1, 0, 
"u 'TMatrixTSparse<double>' - 1 - target u 'TMatrixTSparse<double>' - 11 - source", (char*) NULL
, (void*) NULL, 0);
   G__memfunc_setup("AreCompatible", 1304, G__G__Matrix__0_604, 103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0, 
"u 'TMatrixTSparse<double>' - 11 - m1 u 'TMatrixTSparse<double>' - 11 - m2 "
"i - 'Int_t' 0 '0' verbose", (char*) NULL
, (void*) NULL, 0);

   G__resetifuncposition();
}

extern "C" void G__cpp_setup_funcG__Matrix() {
  G__cpp_setup_func0();
  G__cpp_setup_func1();
  G__cpp_setup_func2();
  G__cpp_setup_func3();
  G__cpp_setup_func4();
  G__cpp_setup_func5();
}

/*********************************************************
* Class,struct,union,enum tag information setup
*********************************************************/
/* Setup class/struct taginfo */
G__linked_taginfo G__G__MatrixLN_TClass = { "TClass" , 99 , -1 };
G__linked_taginfo G__G__MatrixLN_TBuffer = { "TBuffer" , 99 , -1 };
G__linked_taginfo G__G__MatrixLN_TMemberInspector = { "TMemberInspector" , 99 , -1 };
G__linked_taginfo G__G__MatrixLN_TObject = { "TObject" , 99 , -1 };
G__linked_taginfo G__G__MatrixLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR = { "vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >" , 99 , -1 };
G__linked_taginfo G__G__MatrixLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR = { "reverse_iterator<vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__MatrixLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR = { "vector<TVirtualArray*,allocator<TVirtualArray*> >" , 99 , -1 };
G__linked_taginfo G__G__MatrixLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TVirtualArray*,allocator<TVirtualArray*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__MatrixLN_TMatrixTBaselEfloatgR = { "TMatrixTBase<float>" , 99 , -1 };
G__linked_taginfo G__G__MatrixLN_TMatrixTBaselEdoublegR = { "TMatrixTBase<double>" , 99 , -1 };
G__linked_taginfo G__G__MatrixLN_TVectorTlEfloatgR = { "TVectorT<float>" , 99 , -1 };
G__linked_taginfo G__G__MatrixLN_TVectorTlEdoublegR = { "TVectorT<double>" , 99 , -1 };
G__linked_taginfo G__G__MatrixLN_TMatrixTBaselEfloatgRcLcLdA = { "TMatrixTBase<float>::$" , 101 , -1 };
G__linked_taginfo G__G__MatrixLN_TMatrixTBaselEfloatgRcLcLEMatrixStatusBits = { "TMatrixTBase<float>::EMatrixStatusBits" , 101 , -1 };
G__linked_taginfo G__G__MatrixLN_TElementActionTlEfloatgR = { "TElementActionT<float>" , 99 , -1 };
G__linked_taginfo G__G__MatrixLN_TElementPosActionTlEfloatgR = { "TElementPosActionT<float>" , 99 , -1 };
G__linked_taginfo G__G__MatrixLN_TMatrixTBaselEdoublegRcLcLdA = { "TMatrixTBase<double>::$" , 101 , -1 };
G__linked_taginfo G__G__MatrixLN_TMatrixTBaselEdoublegRcLcLEMatrixStatusBits = { "TMatrixTBase<double>::EMatrixStatusBits" , 101 , -1 };
G__linked_taginfo G__G__MatrixLN_TElementActionTlEdoublegR = { "TElementActionT<double>" , 99 , -1 };
G__linked_taginfo G__G__MatrixLN_TElementPosActionTlEdoublegR = { "TElementPosActionT<double>" , 99 , -1 };
G__linked_taginfo G__G__MatrixLN_TMatrixTlEdoublegR = { "TMatrixT<double>" , 99 , -1 };
G__linked_taginfo G__G__MatrixLN_TMatrixTlEdoublegRcLcLdA = { "TMatrixT<double>::$" , 101 , -1 };
G__linked_taginfo G__G__MatrixLN_TMatrixTlEdoublegRcLcLEMatrixCreatorsOp1 = { "TMatrixT<double>::EMatrixCreatorsOp1" , 101 , -1 };
G__linked_taginfo G__G__MatrixLN_TMatrixTlEdoublegRcLcLEMatrixCreatorsOp2 = { "TMatrixT<double>::EMatrixCreatorsOp2" , 101 , -1 };
G__linked_taginfo G__G__MatrixLN_TMatrixTSymlEdoublegR = { "TMatrixTSym<double>" , 99 , -1 };
G__linked_taginfo G__G__MatrixLN_TMatrixTSparselEdoublegR = { "TMatrixTSparse<double>" , 99 , -1 };
G__linked_taginfo G__G__MatrixLN_TMatrixTLazylEdoublegR = { "TMatrixTLazy<double>" , 99 , -1 };
G__linked_taginfo G__G__MatrixLN_TMatrixTRow_constlEdoublegR = { "TMatrixTRow_const<double>" , 99 , -1 };
G__linked_taginfo G__G__MatrixLN_TMatrixTRowlEdoublegR = { "TMatrixTRow<double>" , 99 , -1 };
G__linked_taginfo G__G__MatrixLN_TMatrixTDiag_constlEdoublegR = { "TMatrixTDiag_const<double>" , 99 , -1 };
G__linked_taginfo G__G__MatrixLN_TMatrixTColumn_constlEdoublegR = { "TMatrixTColumn_const<double>" , 99 , -1 };
G__linked_taginfo G__G__MatrixLN_TMatrixTFlat_constlEdoublegR = { "TMatrixTFlat_const<double>" , 99 , -1 };
G__linked_taginfo G__G__MatrixLN_TMatrixTSub_constlEdoublegR = { "TMatrixTSub_const<double>" , 99 , -1 };
G__linked_taginfo G__G__MatrixLN_TMatrixTSparseRow_constlEdoublegR = { "TMatrixTSparseRow_const<double>" , 99 , -1 };
G__linked_taginfo G__G__MatrixLN_TMatrixTSparseDiag_constlEdoublegR = { "TMatrixTSparseDiag_const<double>" , 99 , -1 };
G__linked_taginfo G__G__MatrixLN_TMatrixTColumnlEdoublegR = { "TMatrixTColumn<double>" , 99 , -1 };
G__linked_taginfo G__G__MatrixLN_TMatrixTDiaglEdoublegR = { "TMatrixTDiag<double>" , 99 , -1 };
G__linked_taginfo G__G__MatrixLN_TMatrixTFlatlEdoublegR = { "TMatrixTFlat<double>" , 99 , -1 };
G__linked_taginfo G__G__MatrixLN_TMatrixTSublEdoublegR = { "TMatrixTSub<double>" , 99 , -1 };
G__linked_taginfo G__G__MatrixLN_TMatrixTSublEdoublegRcLcLdA = { "TMatrixTSub<double>::$" , 101 , -1 };
G__linked_taginfo G__G__MatrixLN_TMatrixTSparseRowlEdoublegR = { "TMatrixTSparseRow<double>" , 99 , -1 };
G__linked_taginfo G__G__MatrixLN_TMatrixTSparseDiaglEdoublegR = { "TMatrixTSparseDiag<double>" , 99 , -1 };
G__linked_taginfo G__G__MatrixLN_TMatrixTSymlEdoublegRcLcLdA = { "TMatrixTSym<double>::$" , 101 , -1 };
G__linked_taginfo G__G__MatrixLN_TMatrixTSymlEdoublegRcLcLEMatrixCreatorsOp1 = { "TMatrixTSym<double>::EMatrixCreatorsOp1" , 101 , -1 };
G__linked_taginfo G__G__MatrixLN_TMatrixTSymlEdoublegRcLcLEMatrixCreatorsOp2 = { "TMatrixTSym<double>::EMatrixCreatorsOp2" , 101 , -1 };
G__linked_taginfo G__G__MatrixLN_TMatrixTSymLazylEdoublegR = { "TMatrixTSymLazy<double>" , 99 , -1 };
G__linked_taginfo G__G__MatrixLN_TMatrixTSparselEdoublegRcLcLEMatrixCreatorsOp1 = { "TMatrixTSparse<double>::EMatrixCreatorsOp1" , 101 , -1 };
G__linked_taginfo G__G__MatrixLN_TMatrixTSparselEdoublegRcLcLEMatrixCreatorsOp2 = { "TMatrixTSparse<double>::EMatrixCreatorsOp2" , 101 , -1 };
G__linked_taginfo G__G__MatrixLN_TVectorTlEfloatgRcLcLdA = { "TVectorT<float>::$" , 101 , -1 };
G__linked_taginfo G__G__MatrixLN_TVectorTlEfloatgRcLcLEVectorStatusBits = { "TVectorT<float>::EVectorStatusBits" , 101 , -1 };
G__linked_taginfo G__G__MatrixLN_TMatrixTRow_constlEfloatgR = { "TMatrixTRow_const<float>" , 99 , -1 };
G__linked_taginfo G__G__MatrixLN_TMatrixTlEfloatgR = { "TMatrixT<float>" , 99 , -1 };
G__linked_taginfo G__G__MatrixLN_TMatrixTlEfloatgRcLcLdA = { "TMatrixT<float>::$" , 101 , -1 };
G__linked_taginfo G__G__MatrixLN_TMatrixTlEfloatgRcLcLEMatrixCreatorsOp1 = { "TMatrixT<float>::EMatrixCreatorsOp1" , 101 , -1 };
G__linked_taginfo G__G__MatrixLN_TMatrixTlEfloatgRcLcLEMatrixCreatorsOp2 = { "TMatrixT<float>::EMatrixCreatorsOp2" , 101 , -1 };
G__linked_taginfo G__G__MatrixLN_TMatrixTSymlEfloatgR = { "TMatrixTSym<float>" , 99 , -1 };
G__linked_taginfo G__G__MatrixLN_TMatrixTSymlEfloatgRcLcLdA = { "TMatrixTSym<float>::$" , 101 , -1 };
G__linked_taginfo G__G__MatrixLN_TMatrixTSymlEfloatgRcLcLEMatrixCreatorsOp1 = { "TMatrixTSym<float>::EMatrixCreatorsOp1" , 101 , -1 };
G__linked_taginfo G__G__MatrixLN_TMatrixTSymlEfloatgRcLcLEMatrixCreatorsOp2 = { "TMatrixTSym<float>::EMatrixCreatorsOp2" , 101 , -1 };
G__linked_taginfo G__G__MatrixLN_TMatrixTSymLazylEfloatgR = { "TMatrixTSymLazy<float>" , 99 , -1 };
G__linked_taginfo G__G__MatrixLN_TMatrixTRowlEfloatgR = { "TMatrixTRow<float>" , 99 , -1 };
G__linked_taginfo G__G__MatrixLN_TMatrixTSparselEfloatgR = { "TMatrixTSparse<float>" , 99 , -1 };
G__linked_taginfo G__G__MatrixLN_TMatrixTSparselEfloatgRcLcLEMatrixCreatorsOp1 = { "TMatrixTSparse<float>::EMatrixCreatorsOp1" , 101 , -1 };
G__linked_taginfo G__G__MatrixLN_TMatrixTSparselEfloatgRcLcLEMatrixCreatorsOp2 = { "TMatrixTSparse<float>::EMatrixCreatorsOp2" , 101 , -1 };
G__linked_taginfo G__G__MatrixLN_TMatrixTSparseRow_constlEfloatgR = { "TMatrixTSparseRow_const<float>" , 99 , -1 };
G__linked_taginfo G__G__MatrixLN_TMatrixTSparseRowlEfloatgR = { "TMatrixTSparseRow<float>" , 99 , -1 };
G__linked_taginfo G__G__MatrixLN_TMatrixTLazylEfloatgR = { "TMatrixTLazy<float>" , 99 , -1 };
G__linked_taginfo G__G__MatrixLN_TMatrixTDiag_constlEfloatgR = { "TMatrixTDiag_const<float>" , 99 , -1 };
G__linked_taginfo G__G__MatrixLN_TMatrixTColumn_constlEfloatgR = { "TMatrixTColumn_const<float>" , 99 , -1 };
G__linked_taginfo G__G__MatrixLN_TMatrixTSparseDiag_constlEfloatgR = { "TMatrixTSparseDiag_const<float>" , 99 , -1 };
G__linked_taginfo G__G__MatrixLN_TVectorTlEdoublegRcLcLdA = { "TVectorT<double>::$" , 101 , -1 };
G__linked_taginfo G__G__MatrixLN_TVectorTlEdoublegRcLcLEVectorStatusBits = { "TVectorT<double>::EVectorStatusBits" , 101 , -1 };
G__linked_taginfo G__G__MatrixLN_TDecompBase = { "TDecompBase" , 99 , -1 };
G__linked_taginfo G__G__MatrixLN_TDecompBasecLcLEMatrixDecompStat = { "TDecompBase::EMatrixDecompStat" , 101 , -1 };
G__linked_taginfo G__G__MatrixLN_TDecompBasecLcLdA = { "TDecompBase::$" , 101 , -1 };
G__linked_taginfo G__G__MatrixLN_TDecompBK = { "TDecompBK" , 99 , -1 };
G__linked_taginfo G__G__MatrixLN_TDecompChol = { "TDecompChol" , 99 , -1 };
G__linked_taginfo G__G__MatrixLN_TDecompLU = { "TDecompLU" , 99 , -1 };
G__linked_taginfo G__G__MatrixLN_TDecompQRH = { "TDecompQRH" , 99 , -1 };
G__linked_taginfo G__G__MatrixLN_TDecompQRHcLcLdA = { "TDecompQRH::$" , 101 , -1 };
G__linked_taginfo G__G__MatrixLN_TArrayD = { "TArrayD" , 99 , -1 };
G__linked_taginfo G__G__MatrixLN_TArrayI = { "TArrayI" , 99 , -1 };
G__linked_taginfo G__G__MatrixLN_TDecompSparse = { "TDecompSparse" , 99 , -1 };
G__linked_taginfo G__G__MatrixLN_TDecompSVD = { "TDecompSVD" , 99 , -1 };
G__linked_taginfo G__G__MatrixLN_TDecompSVDcLcLdA = { "TDecompSVD::$" , 101 , -1 };
G__linked_taginfo G__G__MatrixLN_TMatrixDEigen = { "TMatrixDEigen" , 99 , -1 };
G__linked_taginfo G__G__MatrixLN_TMatrixDEigencLcLdA = { "TMatrixDEigen::$" , 101 , -1 };
G__linked_taginfo G__G__MatrixLN_THaarMatrixTlEdoublegR = { "THaarMatrixT<double>" , 99 , -1 };
G__linked_taginfo G__G__MatrixLN_THilbertMatrixTlEdoublegR = { "THilbertMatrixT<double>" , 99 , -1 };
G__linked_taginfo G__G__MatrixLN_THilbertMatrixTSymlEdoublegR = { "THilbertMatrixTSym<double>" , 99 , -1 };
G__linked_taginfo G__G__MatrixLN_TMatrixDSymEigen = { "TMatrixDSymEigen" , 99 , -1 };
G__linked_taginfo G__G__MatrixLN_TMatrixDSymEigencLcLdA = { "TMatrixDSymEigen::$" , 101 , -1 };
G__linked_taginfo G__G__MatrixLN_TMatrixTFlat_constlEfloatgR = { "TMatrixTFlat_const<float>" , 99 , -1 };
G__linked_taginfo G__G__MatrixLN_TMatrixTSub_constlEfloatgR = { "TMatrixTSub_const<float>" , 99 , -1 };
G__linked_taginfo G__G__MatrixLN_TMatrixTColumnlEfloatgR = { "TMatrixTColumn<float>" , 99 , -1 };
G__linked_taginfo G__G__MatrixLN_TMatrixTDiaglEfloatgR = { "TMatrixTDiag<float>" , 99 , -1 };
G__linked_taginfo G__G__MatrixLN_TMatrixTFlatlEfloatgR = { "TMatrixTFlat<float>" , 99 , -1 };
G__linked_taginfo G__G__MatrixLN_TMatrixTSublEfloatgR = { "TMatrixTSub<float>" , 99 , -1 };
G__linked_taginfo G__G__MatrixLN_TMatrixTSublEfloatgRcLcLdA = { "TMatrixTSub<float>::$" , 101 , -1 };
G__linked_taginfo G__G__MatrixLN_TMatrixTSparseDiaglEfloatgR = { "TMatrixTSparseDiag<float>" , 99 , -1 };
G__linked_taginfo G__G__MatrixLN_THaarMatrixTlEfloatgR = { "THaarMatrixT<float>" , 99 , -1 };
G__linked_taginfo G__G__MatrixLN_THilbertMatrixTlEfloatgR = { "THilbertMatrixT<float>" , 99 , -1 };
G__linked_taginfo G__G__MatrixLN_THilbertMatrixTSymlEfloatgR = { "THilbertMatrixTSym<float>" , 99 , -1 };
G__linked_taginfo G__G__MatrixLN_TMatrixTCramerInv = { "TMatrixTCramerInv" , 110 , -1 };
G__linked_taginfo G__G__MatrixLN_TMatrixTSymCramerInv = { "TMatrixTSymCramerInv" , 110 , -1 };

/* Reset class/struct taginfo */
extern "C" void G__cpp_reset_tagtableG__Matrix() {
  G__G__MatrixLN_TClass.tagnum = -1 ;
  G__G__MatrixLN_TBuffer.tagnum = -1 ;
  G__G__MatrixLN_TMemberInspector.tagnum = -1 ;
  G__G__MatrixLN_TObject.tagnum = -1 ;
  G__G__MatrixLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR.tagnum = -1 ;
  G__G__MatrixLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__MatrixLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR.tagnum = -1 ;
  G__G__MatrixLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__MatrixLN_TMatrixTBaselEfloatgR.tagnum = -1 ;
  G__G__MatrixLN_TMatrixTBaselEdoublegR.tagnum = -1 ;
  G__G__MatrixLN_TVectorTlEfloatgR.tagnum = -1 ;
  G__G__MatrixLN_TVectorTlEdoublegR.tagnum = -1 ;
  G__G__MatrixLN_TMatrixTBaselEfloatgRcLcLdA.tagnum = -1 ;
  G__G__MatrixLN_TMatrixTBaselEfloatgRcLcLEMatrixStatusBits.tagnum = -1 ;
  G__G__MatrixLN_TElementActionTlEfloatgR.tagnum = -1 ;
  G__G__MatrixLN_TElementPosActionTlEfloatgR.tagnum = -1 ;
  G__G__MatrixLN_TMatrixTBaselEdoublegRcLcLdA.tagnum = -1 ;
  G__G__MatrixLN_TMatrixTBaselEdoublegRcLcLEMatrixStatusBits.tagnum = -1 ;
  G__G__MatrixLN_TElementActionTlEdoublegR.tagnum = -1 ;
  G__G__MatrixLN_TElementPosActionTlEdoublegR.tagnum = -1 ;
  G__G__MatrixLN_TMatrixTlEdoublegR.tagnum = -1 ;
  G__G__MatrixLN_TMatrixTlEdoublegRcLcLdA.tagnum = -1 ;
  G__G__MatrixLN_TMatrixTlEdoublegRcLcLEMatrixCreatorsOp1.tagnum = -1 ;
  G__G__MatrixLN_TMatrixTlEdoublegRcLcLEMatrixCreatorsOp2.tagnum = -1 ;
  G__G__MatrixLN_TMatrixTSymlEdoublegR.tagnum = -1 ;
  G__G__MatrixLN_TMatrixTSparselEdoublegR.tagnum = -1 ;
  G__G__MatrixLN_TMatrixTLazylEdoublegR.tagnum = -1 ;
  G__G__MatrixLN_TMatrixTRow_constlEdoublegR.tagnum = -1 ;
  G__G__MatrixLN_TMatrixTRowlEdoublegR.tagnum = -1 ;
  G__G__MatrixLN_TMatrixTDiag_constlEdoublegR.tagnum = -1 ;
  G__G__MatrixLN_TMatrixTColumn_constlEdoublegR.tagnum = -1 ;
  G__G__MatrixLN_TMatrixTFlat_constlEdoublegR.tagnum = -1 ;
  G__G__MatrixLN_TMatrixTSub_constlEdoublegR.tagnum = -1 ;
  G__G__MatrixLN_TMatrixTSparseRow_constlEdoublegR.tagnum = -1 ;
  G__G__MatrixLN_TMatrixTSparseDiag_constlEdoublegR.tagnum = -1 ;
  G__G__MatrixLN_TMatrixTColumnlEdoublegR.tagnum = -1 ;
  G__G__MatrixLN_TMatrixTDiaglEdoublegR.tagnum = -1 ;
  G__G__MatrixLN_TMatrixTFlatlEdoublegR.tagnum = -1 ;
  G__G__MatrixLN_TMatrixTSublEdoublegR.tagnum = -1 ;
  G__G__MatrixLN_TMatrixTSublEdoublegRcLcLdA.tagnum = -1 ;
  G__G__MatrixLN_TMatrixTSparseRowlEdoublegR.tagnum = -1 ;
  G__G__MatrixLN_TMatrixTSparseDiaglEdoublegR.tagnum = -1 ;
  G__G__MatrixLN_TMatrixTSymlEdoublegRcLcLdA.tagnum = -1 ;
  G__G__MatrixLN_TMatrixTSymlEdoublegRcLcLEMatrixCreatorsOp1.tagnum = -1 ;
  G__G__MatrixLN_TMatrixTSymlEdoublegRcLcLEMatrixCreatorsOp2.tagnum = -1 ;
  G__G__MatrixLN_TMatrixTSymLazylEdoublegR.tagnum = -1 ;
  G__G__MatrixLN_TMatrixTSparselEdoublegRcLcLEMatrixCreatorsOp1.tagnum = -1 ;
  G__G__MatrixLN_TMatrixTSparselEdoublegRcLcLEMatrixCreatorsOp2.tagnum = -1 ;
  G__G__MatrixLN_TVectorTlEfloatgRcLcLdA.tagnum = -1 ;
  G__G__MatrixLN_TVectorTlEfloatgRcLcLEVectorStatusBits.tagnum = -1 ;
  G__G__MatrixLN_TMatrixTRow_constlEfloatgR.tagnum = -1 ;
  G__G__MatrixLN_TMatrixTlEfloatgR.tagnum = -1 ;
  G__G__MatrixLN_TMatrixTlEfloatgRcLcLdA.tagnum = -1 ;
  G__G__MatrixLN_TMatrixTlEfloatgRcLcLEMatrixCreatorsOp1.tagnum = -1 ;
  G__G__MatrixLN_TMatrixTlEfloatgRcLcLEMatrixCreatorsOp2.tagnum = -1 ;
  G__G__MatrixLN_TMatrixTSymlEfloatgR.tagnum = -1 ;
  G__G__MatrixLN_TMatrixTSymlEfloatgRcLcLdA.tagnum = -1 ;
  G__G__MatrixLN_TMatrixTSymlEfloatgRcLcLEMatrixCreatorsOp1.tagnum = -1 ;
  G__G__MatrixLN_TMatrixTSymlEfloatgRcLcLEMatrixCreatorsOp2.tagnum = -1 ;
  G__G__MatrixLN_TMatrixTSymLazylEfloatgR.tagnum = -1 ;
  G__G__MatrixLN_TMatrixTRowlEfloatgR.tagnum = -1 ;
  G__G__MatrixLN_TMatrixTSparselEfloatgR.tagnum = -1 ;
  G__G__MatrixLN_TMatrixTSparselEfloatgRcLcLEMatrixCreatorsOp1.tagnum = -1 ;
  G__G__MatrixLN_TMatrixTSparselEfloatgRcLcLEMatrixCreatorsOp2.tagnum = -1 ;
  G__G__MatrixLN_TMatrixTSparseRow_constlEfloatgR.tagnum = -1 ;
  G__G__MatrixLN_TMatrixTSparseRowlEfloatgR.tagnum = -1 ;
  G__G__MatrixLN_TMatrixTLazylEfloatgR.tagnum = -1 ;
  G__G__MatrixLN_TMatrixTDiag_constlEfloatgR.tagnum = -1 ;
  G__G__MatrixLN_TMatrixTColumn_constlEfloatgR.tagnum = -1 ;
  G__G__MatrixLN_TMatrixTSparseDiag_constlEfloatgR.tagnum = -1 ;
  G__G__MatrixLN_TVectorTlEdoublegRcLcLdA.tagnum = -1 ;
  G__G__MatrixLN_TVectorTlEdoublegRcLcLEVectorStatusBits.tagnum = -1 ;
  G__G__MatrixLN_TDecompBase.tagnum = -1 ;
  G__G__MatrixLN_TDecompBasecLcLEMatrixDecompStat.tagnum = -1 ;
  G__G__MatrixLN_TDecompBasecLcLdA.tagnum = -1 ;
  G__G__MatrixLN_TDecompBK.tagnum = -1 ;
  G__G__MatrixLN_TDecompChol.tagnum = -1 ;
  G__G__MatrixLN_TDecompLU.tagnum = -1 ;
  G__G__MatrixLN_TDecompQRH.tagnum = -1 ;
  G__G__MatrixLN_TDecompQRHcLcLdA.tagnum = -1 ;
  G__G__MatrixLN_TArrayD.tagnum = -1 ;
  G__G__MatrixLN_TArrayI.tagnum = -1 ;
  G__G__MatrixLN_TDecompSparse.tagnum = -1 ;
  G__G__MatrixLN_TDecompSVD.tagnum = -1 ;
  G__G__MatrixLN_TDecompSVDcLcLdA.tagnum = -1 ;
  G__G__MatrixLN_TMatrixDEigen.tagnum = -1 ;
  G__G__MatrixLN_TMatrixDEigencLcLdA.tagnum = -1 ;
  G__G__MatrixLN_THaarMatrixTlEdoublegR.tagnum = -1 ;
  G__G__MatrixLN_THilbertMatrixTlEdoublegR.tagnum = -1 ;
  G__G__MatrixLN_THilbertMatrixTSymlEdoublegR.tagnum = -1 ;
  G__G__MatrixLN_TMatrixDSymEigen.tagnum = -1 ;
  G__G__MatrixLN_TMatrixDSymEigencLcLdA.tagnum = -1 ;
  G__G__MatrixLN_TMatrixTFlat_constlEfloatgR.tagnum = -1 ;
  G__G__MatrixLN_TMatrixTSub_constlEfloatgR.tagnum = -1 ;
  G__G__MatrixLN_TMatrixTColumnlEfloatgR.tagnum = -1 ;
  G__G__MatrixLN_TMatrixTDiaglEfloatgR.tagnum = -1 ;
  G__G__MatrixLN_TMatrixTFlatlEfloatgR.tagnum = -1 ;
  G__G__MatrixLN_TMatrixTSublEfloatgR.tagnum = -1 ;
  G__G__MatrixLN_TMatrixTSublEfloatgRcLcLdA.tagnum = -1 ;
  G__G__MatrixLN_TMatrixTSparseDiaglEfloatgR.tagnum = -1 ;
  G__G__MatrixLN_THaarMatrixTlEfloatgR.tagnum = -1 ;
  G__G__MatrixLN_THilbertMatrixTlEfloatgR.tagnum = -1 ;
  G__G__MatrixLN_THilbertMatrixTSymlEfloatgR.tagnum = -1 ;
  G__G__MatrixLN_TMatrixTCramerInv.tagnum = -1 ;
  G__G__MatrixLN_TMatrixTSymCramerInv.tagnum = -1 ;
}


extern "C" void G__cpp_setup_tagtableG__Matrix() {

   /* Setting up class,struct,union tag entry */
   G__get_linked_tagnum_fwd(&G__G__MatrixLN_TClass);
   G__get_linked_tagnum_fwd(&G__G__MatrixLN_TBuffer);
   G__get_linked_tagnum_fwd(&G__G__MatrixLN_TMemberInspector);
   G__get_linked_tagnum_fwd(&G__G__MatrixLN_TObject);
   G__get_linked_tagnum_fwd(&G__G__MatrixLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR);
   G__get_linked_tagnum_fwd(&G__G__MatrixLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__MatrixLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__MatrixLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MatrixLN_TMatrixTBaselEfloatgR),sizeof(TMatrixTBase<float>),-1,95503,"Matrix base class (template)",G__setup_memvarTMatrixTBaselEfloatgR,G__setup_memfuncTMatrixTBaselEfloatgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MatrixLN_TMatrixTBaselEdoublegR),sizeof(TMatrixTBase<double>),-1,95503,"Matrix base class (template)",G__setup_memvarTMatrixTBaselEdoublegR,G__setup_memfuncTMatrixTBaselEdoublegR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MatrixLN_TVectorTlEfloatgR),sizeof(TVectorT<float>),-1,130816,"Template of Vector class",G__setup_memvarTVectorTlEfloatgR,G__setup_memfuncTVectorTlEfloatgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MatrixLN_TVectorTlEdoublegR),sizeof(TVectorT<double>),-1,130816,"Template of Vector class",G__setup_memvarTVectorTlEdoublegR,G__setup_memfuncTVectorTlEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__MatrixLN_TMatrixTBaselEfloatgRcLcLdA);
   G__get_linked_tagnum_fwd(&G__G__MatrixLN_TMatrixTBaselEfloatgRcLcLEMatrixStatusBits);
   G__get_linked_tagnum_fwd(&G__G__MatrixLN_TElementActionTlEfloatgR);
   G__get_linked_tagnum_fwd(&G__G__MatrixLN_TElementPosActionTlEfloatgR);
   G__get_linked_tagnum_fwd(&G__G__MatrixLN_TMatrixTBaselEdoublegRcLcLdA);
   G__get_linked_tagnum_fwd(&G__G__MatrixLN_TMatrixTBaselEdoublegRcLcLEMatrixStatusBits);
   G__get_linked_tagnum_fwd(&G__G__MatrixLN_TElementActionTlEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__MatrixLN_TElementPosActionTlEdoublegR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MatrixLN_TMatrixTlEdoublegR),sizeof(TMatrixT<double>),-1,130816,"Template of General Matrix class",G__setup_memvarTMatrixTlEdoublegR,G__setup_memfuncTMatrixTlEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__MatrixLN_TMatrixTlEdoublegRcLcLdA);
   G__get_linked_tagnum_fwd(&G__G__MatrixLN_TMatrixTlEdoublegRcLcLEMatrixCreatorsOp1);
   G__get_linked_tagnum_fwd(&G__G__MatrixLN_TMatrixTlEdoublegRcLcLEMatrixCreatorsOp2);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MatrixLN_TMatrixTSymlEdoublegR),sizeof(TMatrixTSym<double>),-1,130816,"Template of Symmetric Matrix class",G__setup_memvarTMatrixTSymlEdoublegR,G__setup_memfuncTMatrixTSymlEdoublegR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MatrixLN_TMatrixTSparselEdoublegR),sizeof(TMatrixTSparse<double>),-1,130816,"Template of Sparse Matrix class",G__setup_memvarTMatrixTSparselEdoublegR,G__setup_memfuncTMatrixTSparselEdoublegR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MatrixLN_TMatrixTLazylEdoublegR),sizeof(TMatrixTLazy<double>),-1,327425,"Template of Lazy Matrix class",G__setup_memvarTMatrixTLazylEdoublegR,G__setup_memfuncTMatrixTLazylEdoublegR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MatrixLN_TMatrixTRow_constlEdoublegR),sizeof(TMatrixTRow_const<double>),-1,36608,"Template of General Matrix Row Access class",G__setup_memvarTMatrixTRow_constlEdoublegR,G__setup_memfuncTMatrixTRow_constlEdoublegR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MatrixLN_TMatrixTRowlEdoublegR),sizeof(TMatrixTRow<double>),-1,35584,"Template of General Matrix Row Access class",G__setup_memvarTMatrixTRowlEdoublegR,G__setup_memfuncTMatrixTRowlEdoublegR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MatrixLN_TMatrixTDiag_constlEdoublegR),sizeof(TMatrixTDiag_const<double>),-1,36608,"Template of General Matrix Diagonal Access class",G__setup_memvarTMatrixTDiag_constlEdoublegR,G__setup_memfuncTMatrixTDiag_constlEdoublegR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MatrixLN_TMatrixTColumn_constlEdoublegR),sizeof(TMatrixTColumn_const<double>),-1,36608,"Template of General Matrix Column Access class",G__setup_memvarTMatrixTColumn_constlEdoublegR,G__setup_memfuncTMatrixTColumn_constlEdoublegR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MatrixLN_TMatrixTFlat_constlEdoublegR),sizeof(TMatrixTFlat_const<double>),-1,36608,"Template of General Matrix Flat Representation class",G__setup_memvarTMatrixTFlat_constlEdoublegR,G__setup_memfuncTMatrixTFlat_constlEdoublegR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MatrixLN_TMatrixTSub_constlEdoublegR),sizeof(TMatrixTSub_const<double>),-1,34048,"Template of Sub Matrix Access class",G__setup_memvarTMatrixTSub_constlEdoublegR,G__setup_memfuncTMatrixTSub_constlEdoublegR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MatrixLN_TMatrixTSparseRow_constlEdoublegR),sizeof(TMatrixTSparseRow_const<double>),-1,36608,"Template of Sparse Matrix Row Access class",G__setup_memvarTMatrixTSparseRow_constlEdoublegR,G__setup_memfuncTMatrixTSparseRow_constlEdoublegR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MatrixLN_TMatrixTSparseDiag_constlEdoublegR),sizeof(TMatrixTSparseDiag_const<double>),-1,36608,"Template of Sparse Matrix Diagonal Access class",G__setup_memvarTMatrixTSparseDiag_constlEdoublegR,G__setup_memfuncTMatrixTSparseDiag_constlEdoublegR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MatrixLN_TMatrixTColumnlEdoublegR),sizeof(TMatrixTColumn<double>),-1,35584,"Template of General Matrix Column Access class",G__setup_memvarTMatrixTColumnlEdoublegR,G__setup_memfuncTMatrixTColumnlEdoublegR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MatrixLN_TMatrixTDiaglEdoublegR),sizeof(TMatrixTDiag<double>),-1,35584,"Template of General Matrix Diagonal Access class",G__setup_memvarTMatrixTDiaglEdoublegR,G__setup_memfuncTMatrixTDiaglEdoublegR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MatrixLN_TMatrixTFlatlEdoublegR),sizeof(TMatrixTFlat<double>),-1,35584,"Template of General Matrix Flat Representation class",G__setup_memvarTMatrixTFlatlEdoublegR,G__setup_memfuncTMatrixTFlatlEdoublegR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MatrixLN_TMatrixTSublEdoublegR),sizeof(TMatrixTSub<double>),-1,35584,"Template of Sub Matrix Access class",G__setup_memvarTMatrixTSublEdoublegR,G__setup_memfuncTMatrixTSublEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__MatrixLN_TMatrixTSublEdoublegRcLcLdA);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MatrixLN_TMatrixTSparseRowlEdoublegR),sizeof(TMatrixTSparseRow<double>),-1,35584,"Template of Sparse Matrix Row Access class",G__setup_memvarTMatrixTSparseRowlEdoublegR,G__setup_memfuncTMatrixTSparseRowlEdoublegR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MatrixLN_TMatrixTSparseDiaglEdoublegR),sizeof(TMatrixTSparseDiag<double>),-1,35584,"Template of Sparse Matrix Diagonal Access class",G__setup_memvarTMatrixTSparseDiaglEdoublegR,G__setup_memfuncTMatrixTSparseDiaglEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__MatrixLN_TMatrixTSymlEdoublegRcLcLdA);
   G__get_linked_tagnum_fwd(&G__G__MatrixLN_TMatrixTSymlEdoublegRcLcLEMatrixCreatorsOp1);
   G__get_linked_tagnum_fwd(&G__G__MatrixLN_TMatrixTSymlEdoublegRcLcLEMatrixCreatorsOp2);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MatrixLN_TMatrixTSymLazylEdoublegR),sizeof(TMatrixTSymLazy<double>),-1,327425,"Template of Lazy Symmeytric class",G__setup_memvarTMatrixTSymLazylEdoublegR,G__setup_memfuncTMatrixTSymLazylEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__MatrixLN_TMatrixTSparselEdoublegRcLcLEMatrixCreatorsOp1);
   G__get_linked_tagnum_fwd(&G__G__MatrixLN_TMatrixTSparselEdoublegRcLcLEMatrixCreatorsOp2);
   G__get_linked_tagnum_fwd(&G__G__MatrixLN_TVectorTlEfloatgRcLcLdA);
   G__get_linked_tagnum_fwd(&G__G__MatrixLN_TVectorTlEfloatgRcLcLEVectorStatusBits);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MatrixLN_TMatrixTRow_constlEfloatgR),sizeof(TMatrixTRow_const<float>),-1,36608,"Template of General Matrix Row Access class",G__setup_memvarTMatrixTRow_constlEfloatgR,G__setup_memfuncTMatrixTRow_constlEfloatgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MatrixLN_TMatrixTlEfloatgR),sizeof(TMatrixT<float>),-1,130816,"Template of General Matrix class",G__setup_memvarTMatrixTlEfloatgR,G__setup_memfuncTMatrixTlEfloatgR);
   G__get_linked_tagnum_fwd(&G__G__MatrixLN_TMatrixTlEfloatgRcLcLdA);
   G__get_linked_tagnum_fwd(&G__G__MatrixLN_TMatrixTlEfloatgRcLcLEMatrixCreatorsOp1);
   G__get_linked_tagnum_fwd(&G__G__MatrixLN_TMatrixTlEfloatgRcLcLEMatrixCreatorsOp2);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MatrixLN_TMatrixTSymlEfloatgR),sizeof(TMatrixTSym<float>),-1,130816,"Template of Symmetric Matrix class",G__setup_memvarTMatrixTSymlEfloatgR,G__setup_memfuncTMatrixTSymlEfloatgR);
   G__get_linked_tagnum_fwd(&G__G__MatrixLN_TMatrixTSymlEfloatgRcLcLdA);
   G__get_linked_tagnum_fwd(&G__G__MatrixLN_TMatrixTSymlEfloatgRcLcLEMatrixCreatorsOp1);
   G__get_linked_tagnum_fwd(&G__G__MatrixLN_TMatrixTSymlEfloatgRcLcLEMatrixCreatorsOp2);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MatrixLN_TMatrixTSymLazylEfloatgR),sizeof(TMatrixTSymLazy<float>),-1,327425,"Template of Lazy Symmeytric class",G__setup_memvarTMatrixTSymLazylEfloatgR,G__setup_memfuncTMatrixTSymLazylEfloatgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MatrixLN_TMatrixTRowlEfloatgR),sizeof(TMatrixTRow<float>),-1,35584,"Template of General Matrix Row Access class",G__setup_memvarTMatrixTRowlEfloatgR,G__setup_memfuncTMatrixTRowlEfloatgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MatrixLN_TMatrixTSparselEfloatgR),sizeof(TMatrixTSparse<float>),-1,130816,"Template of Sparse Matrix class",G__setup_memvarTMatrixTSparselEfloatgR,G__setup_memfuncTMatrixTSparselEfloatgR);
   G__get_linked_tagnum_fwd(&G__G__MatrixLN_TMatrixTSparselEfloatgRcLcLEMatrixCreatorsOp1);
   G__get_linked_tagnum_fwd(&G__G__MatrixLN_TMatrixTSparselEfloatgRcLcLEMatrixCreatorsOp2);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MatrixLN_TMatrixTSparseRow_constlEfloatgR),sizeof(TMatrixTSparseRow_const<float>),-1,36608,"Template of Sparse Matrix Row Access class",G__setup_memvarTMatrixTSparseRow_constlEfloatgR,G__setup_memfuncTMatrixTSparseRow_constlEfloatgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MatrixLN_TMatrixTSparseRowlEfloatgR),sizeof(TMatrixTSparseRow<float>),-1,35584,"Template of Sparse Matrix Row Access class",G__setup_memvarTMatrixTSparseRowlEfloatgR,G__setup_memfuncTMatrixTSparseRowlEfloatgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MatrixLN_TMatrixTLazylEfloatgR),sizeof(TMatrixTLazy<float>),-1,327425,"Template of Lazy Matrix class",G__setup_memvarTMatrixTLazylEfloatgR,G__setup_memfuncTMatrixTLazylEfloatgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MatrixLN_TMatrixTDiag_constlEfloatgR),sizeof(TMatrixTDiag_const<float>),-1,36608,"Template of General Matrix Diagonal Access class",G__setup_memvarTMatrixTDiag_constlEfloatgR,G__setup_memfuncTMatrixTDiag_constlEfloatgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MatrixLN_TMatrixTColumn_constlEfloatgR),sizeof(TMatrixTColumn_const<float>),-1,36608,"Template of General Matrix Column Access class",G__setup_memvarTMatrixTColumn_constlEfloatgR,G__setup_memfuncTMatrixTColumn_constlEfloatgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MatrixLN_TMatrixTSparseDiag_constlEfloatgR),sizeof(TMatrixTSparseDiag_const<float>),-1,36608,"Template of Sparse Matrix Diagonal Access class",G__setup_memvarTMatrixTSparseDiag_constlEfloatgR,G__setup_memfuncTMatrixTSparseDiag_constlEfloatgR);
   G__get_linked_tagnum_fwd(&G__G__MatrixLN_TVectorTlEdoublegRcLcLdA);
   G__get_linked_tagnum_fwd(&G__G__MatrixLN_TVectorTlEdoublegRcLcLEVectorStatusBits);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MatrixLN_TDecompBase),sizeof(TDecompBase),-1,294666,"Matrix Decomposition Base",G__setup_memvarTDecompBase,G__setup_memfuncTDecompBase);
   G__get_linked_tagnum_fwd(&G__G__MatrixLN_TDecompBasecLcLEMatrixDecompStat);
   G__get_linked_tagnum_fwd(&G__G__MatrixLN_TDecompBasecLcLdA);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MatrixLN_TDecompBK),sizeof(TDecompBK),-1,327424,"Matrix Decomposition Bunch-Kaufman",G__setup_memvarTDecompBK,G__setup_memfuncTDecompBK);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MatrixLN_TDecompChol),sizeof(TDecompChol),-1,327424,"Matrix Decompositition Cholesky",G__setup_memvarTDecompChol,G__setup_memfuncTDecompChol);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MatrixLN_TDecompLU),sizeof(TDecompLU),-1,327424,"Matrix Decompositition LU",G__setup_memvarTDecompLU,G__setup_memfuncTDecompLU);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MatrixLN_TDecompQRH),sizeof(TDecompQRH),-1,327424,"Matrix Decompositition QRH",G__setup_memvarTDecompQRH,G__setup_memfuncTDecompQRH);
   G__get_linked_tagnum_fwd(&G__G__MatrixLN_TDecompQRHcLcLdA);
   G__get_linked_tagnum_fwd(&G__G__MatrixLN_TArrayD);
   G__get_linked_tagnum_fwd(&G__G__MatrixLN_TArrayI);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MatrixLN_TDecompSparse),sizeof(TDecompSparse),-1,327424,"Matrix Decompositition LU",G__setup_memvarTDecompSparse,G__setup_memfuncTDecompSparse);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MatrixLN_TDecompSVD),sizeof(TDecompSVD),-1,327424,"Matrix Decompositition SVD",G__setup_memvarTDecompSVD,G__setup_memfuncTDecompSVD);
   G__get_linked_tagnum_fwd(&G__G__MatrixLN_TDecompSVDcLcLdA);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MatrixLN_TMatrixDEigen),sizeof(TMatrixDEigen),-1,298752,"Eigen-Vectors/Values of a Matrix",G__setup_memvarTMatrixDEigen,G__setup_memfuncTMatrixDEigen);
   G__get_linked_tagnum_fwd(&G__G__MatrixLN_TMatrixDEigencLcLdA);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MatrixLN_THaarMatrixTlEdoublegR),sizeof(THaarMatrixT<double>),-1,324864,"Template of Haar Matrix class",G__setup_memvarTHaarMatrixTlEdoublegR,G__setup_memfuncTHaarMatrixTlEdoublegR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MatrixLN_THilbertMatrixTlEdoublegR),sizeof(THilbertMatrixT<double>),-1,324864,"Template of Hilbert Matrix class",G__setup_memvarTHilbertMatrixTlEdoublegR,G__setup_memfuncTHilbertMatrixTlEdoublegR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MatrixLN_THilbertMatrixTSymlEdoublegR),sizeof(THilbertMatrixTSym<double>),-1,324864,"Template of Symmetric Hilbert Matrix class",G__setup_memvarTHilbertMatrixTSymlEdoublegR,G__setup_memfuncTHilbertMatrixTSymlEdoublegR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MatrixLN_TMatrixDSymEigen),sizeof(TMatrixDSymEigen),-1,298752,"Eigen-Vectors/Values of a Matrix",G__setup_memvarTMatrixDSymEigen,G__setup_memfuncTMatrixDSymEigen);
   G__get_linked_tagnum_fwd(&G__G__MatrixLN_TMatrixDSymEigencLcLdA);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MatrixLN_TMatrixTFlat_constlEfloatgR),sizeof(TMatrixTFlat_const<float>),-1,36608,"Template of General Matrix Flat Representation class",G__setup_memvarTMatrixTFlat_constlEfloatgR,G__setup_memfuncTMatrixTFlat_constlEfloatgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MatrixLN_TMatrixTSub_constlEfloatgR),sizeof(TMatrixTSub_const<float>),-1,34048,"Template of Sub Matrix Access class",G__setup_memvarTMatrixTSub_constlEfloatgR,G__setup_memfuncTMatrixTSub_constlEfloatgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MatrixLN_TMatrixTColumnlEfloatgR),sizeof(TMatrixTColumn<float>),-1,35584,"Template of General Matrix Column Access class",G__setup_memvarTMatrixTColumnlEfloatgR,G__setup_memfuncTMatrixTColumnlEfloatgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MatrixLN_TMatrixTDiaglEfloatgR),sizeof(TMatrixTDiag<float>),-1,35584,"Template of General Matrix Diagonal Access class",G__setup_memvarTMatrixTDiaglEfloatgR,G__setup_memfuncTMatrixTDiaglEfloatgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MatrixLN_TMatrixTFlatlEfloatgR),sizeof(TMatrixTFlat<float>),-1,35584,"Template of General Matrix Flat Representation class",G__setup_memvarTMatrixTFlatlEfloatgR,G__setup_memfuncTMatrixTFlatlEfloatgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MatrixLN_TMatrixTSublEfloatgR),sizeof(TMatrixTSub<float>),-1,35584,"Template of Sub Matrix Access class",G__setup_memvarTMatrixTSublEfloatgR,G__setup_memfuncTMatrixTSublEfloatgR);
   G__get_linked_tagnum_fwd(&G__G__MatrixLN_TMatrixTSublEfloatgRcLcLdA);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MatrixLN_TMatrixTSparseDiaglEfloatgR),sizeof(TMatrixTSparseDiag<float>),-1,35584,"Template of Sparse Matrix Diagonal Access class",G__setup_memvarTMatrixTSparseDiaglEfloatgR,G__setup_memfuncTMatrixTSparseDiaglEfloatgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MatrixLN_THaarMatrixTlEfloatgR),sizeof(THaarMatrixT<float>),-1,324864,"Template of Haar Matrix class",G__setup_memvarTHaarMatrixTlEfloatgR,G__setup_memfuncTHaarMatrixTlEfloatgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MatrixLN_THilbertMatrixTlEfloatgR),sizeof(THilbertMatrixT<float>),-1,324864,"Template of Hilbert Matrix class",G__setup_memvarTHilbertMatrixTlEfloatgR,G__setup_memfuncTHilbertMatrixTlEfloatgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MatrixLN_THilbertMatrixTSymlEfloatgR),sizeof(THilbertMatrixTSym<float>),-1,324864,"Template of Symmetric Hilbert Matrix class",G__setup_memvarTHilbertMatrixTSymlEfloatgR,G__setup_memfuncTHilbertMatrixTSymlEfloatgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MatrixLN_TMatrixTCramerInv),0,-1,0,(char*)NULL,G__setup_memvarTMatrixTCramerInv,G__setup_memfuncTMatrixTCramerInv);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MatrixLN_TMatrixTSymCramerInv),0,-1,0,(char*)NULL,G__setup_memvarTMatrixTSymCramerInv,G__setup_memfuncTMatrixTSymCramerInv);
}
extern "C" void G__cpp_setupG__Matrix(void) {
  G__check_setup_version(30051515,"G__cpp_setupG__Matrix()");
  G__set_cpp_environmentG__Matrix();
  G__cpp_setup_tagtableG__Matrix();

  G__cpp_setup_inheritanceG__Matrix();

  G__cpp_setup_typetableG__Matrix();

  G__cpp_setup_memvarG__Matrix();

  G__cpp_setup_memfuncG__Matrix();
  G__cpp_setup_globalG__Matrix();
  G__cpp_setup_funcG__Matrix();

   if(0==G__getsizep2memfunc()) G__get_sizep2memfuncG__Matrix();
  return;
}
class G__cpp_setup_initG__Matrix {
  public:
    G__cpp_setup_initG__Matrix() { G__add_setup_func("G__Matrix",(G__incsetup)(&G__cpp_setupG__Matrix)); G__call_setup_funcs(); }
   ~G__cpp_setup_initG__Matrix() { G__remove_setup_func("G__Matrix"); }
};
G__cpp_setup_initG__Matrix G__cpp_setup_initializerG__Matrix;

---