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

#define R__DICTIONARY_FILENAME G__Smatrix
#define R__NO_DEPRECATION

/*******************************************************************/
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#define G__DICTIONARY
#include "ROOT/RConfig.hxx"
#include "TClass.h"
#include "TDictAttributeMap.h"
#include "TInterpreter.h"
#include "TROOT.h"
#include "TBuffer.h"
#include "TMemberInspector.h"
#include "TInterpreter.h"
#include "TVirtualMutex.h"
#include "TError.h"

#ifndef G__ROOT
#define G__ROOT
#endif

#include "RtypesImp.h"
#include "TIsAProxy.h"
#include "TFileMergeInfo.h"
#include <algorithm>
#include "TCollectionProxyInfo.h"
/*******************************************************************/

#include "TDataMember.h"

#include "TBuffer.h"
#include "TVirtualObject.h"
#include <vector>
#include "TSchemaHelper.h"


// Header files passed as explicit arguments
#include "Math/BinaryOperators.h"
#include "Math/BinaryOpPolicy.h"
#include "Math/CholeskyDecomp.h"
#include "Math/Dfact.h"
#include "Math/Dfactir.h"
#include "Math/Dfinv.h"
#include "Math/Dinv.h"
#include "Math/Dsfact.h"
#include "Math/Dsinv.h"
#include "Math/Expression.h"
#include "Math/Functions.h"
#include "Math/HelperOps.h"
#include "Math/MatrixFunctions.h"
#include "Math/MatrixRepresentationsStatic.h"
#include "Math/MConfig.h"
#include "Math/SMatrixDfwd.h"
#include "Math/SMatrixFfwd.h"
#include "Math/SMatrix.h"
#include "Math/StaticCheck.h"
#include "Math/SVector.h"
#include "Math/UnaryOperators.h"

// Header files passed via #pragma extra_include

// The generated code does not explicitly qualify STL entities
namespace std {} using namespace std;

namespace ROOT {
   namespace Math {
   namespace ROOTDict {
      inline ::ROOT::TGenericClassInfo *GenerateInitInstance();
      static TClass *ROOTcLcLMath_Dictionary();

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

      // Dictionary for non-ClassDef classes
      static TClass *ROOTcLcLMath_Dictionary() {
         return GenerateInitInstance()->GetClass();
      }

   }
}
}

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLMatRepStdlEdoublecO2cO2gR_Dictionary();
   static void ROOTcLcLMathcLcLMatRepStdlEdoublecO2cO2gR_TClassManip(TClass*);
   static void *new_ROOTcLcLMathcLcLMatRepStdlEdoublecO2cO2gR(void *p = nullptr);
   static void *newArray_ROOTcLcLMathcLcLMatRepStdlEdoublecO2cO2gR(Long_t size, void *p);
   static void delete_ROOTcLcLMathcLcLMatRepStdlEdoublecO2cO2gR(void *p);
   static void deleteArray_ROOTcLcLMathcLcLMatRepStdlEdoublecO2cO2gR(void *p);
   static void destruct_ROOTcLcLMathcLcLMatRepStdlEdoublecO2cO2gR(void *p);

   // Schema evolution read functions

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::MatRepStd<double,2,2>*)
   {
      ::ROOT::Math::MatRepStd<double,2,2> *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::MatRepStd<double,2,2>));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::MatRepStd<double,2,2>", "Math/MatrixRepresentationsStatic.h", 54,
                  typeid(::ROOT::Math::MatRepStd<double,2,2>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLMatRepStdlEdoublecO2cO2gR_Dictionary, isa_proxy, 4,
                  sizeof(::ROOT::Math::MatRepStd<double,2,2>) );
      instance.SetNew(&new_ROOTcLcLMathcLcLMatRepStdlEdoublecO2cO2gR);
      instance.SetNewArray(&newArray_ROOTcLcLMathcLcLMatRepStdlEdoublecO2cO2gR);
      instance.SetDelete(&delete_ROOTcLcLMathcLcLMatRepStdlEdoublecO2cO2gR);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLMatRepStdlEdoublecO2cO2gR);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLMatRepStdlEdoublecO2cO2gR);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::MatRepStd<double,2,2>","ROOT::Math::MatRepStd<double, 2u, 2u>"));

      ::ROOT::Internal::TSchemaHelper* rule;

      // the io read rules
      std::vector<::ROOT::Internal::TSchemaHelper> readrules(3);
      rule = &readrules[0];
      rule->fSourceClass = "ROOT::Math::MatRepStd<Double32_t,2,2>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[1];
      rule->fSourceClass = "ROOT::Math::MatRepStd<float,2,2>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[2];
      rule->fSourceClass = "ROOT::Math::MatRepStd<Float16_t,2,2>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      instance.SetReadRules( readrules );
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::MatRepStd<double,2,2>*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::MatRepStd<double,2,2>*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::MatRepStd<double,2,2>*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLMatRepStdlEdoublecO2cO2gR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::MatRepStd<double,2,2>*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLMatRepStdlEdoublecO2cO2gR_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLMatRepStdlEdoublecO2cO2gR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLMatRepStdlEdoublecO3cO3gR_Dictionary();
   static void ROOTcLcLMathcLcLMatRepStdlEdoublecO3cO3gR_TClassManip(TClass*);
   static void *new_ROOTcLcLMathcLcLMatRepStdlEdoublecO3cO3gR(void *p = nullptr);
   static void *newArray_ROOTcLcLMathcLcLMatRepStdlEdoublecO3cO3gR(Long_t size, void *p);
   static void delete_ROOTcLcLMathcLcLMatRepStdlEdoublecO3cO3gR(void *p);
   static void deleteArray_ROOTcLcLMathcLcLMatRepStdlEdoublecO3cO3gR(void *p);
   static void destruct_ROOTcLcLMathcLcLMatRepStdlEdoublecO3cO3gR(void *p);

   // Schema evolution read functions

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::MatRepStd<double,3,3>*)
   {
      ::ROOT::Math::MatRepStd<double,3,3> *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::MatRepStd<double,3,3>));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::MatRepStd<double,3,3>", "Math/MatrixRepresentationsStatic.h", 54,
                  typeid(::ROOT::Math::MatRepStd<double,3,3>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLMatRepStdlEdoublecO3cO3gR_Dictionary, isa_proxy, 4,
                  sizeof(::ROOT::Math::MatRepStd<double,3,3>) );
      instance.SetNew(&new_ROOTcLcLMathcLcLMatRepStdlEdoublecO3cO3gR);
      instance.SetNewArray(&newArray_ROOTcLcLMathcLcLMatRepStdlEdoublecO3cO3gR);
      instance.SetDelete(&delete_ROOTcLcLMathcLcLMatRepStdlEdoublecO3cO3gR);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLMatRepStdlEdoublecO3cO3gR);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLMatRepStdlEdoublecO3cO3gR);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::MatRepStd<double,3,3>","ROOT::Math::MatRepStd<double, 3u, 3u>"));

      ::ROOT::Internal::TSchemaHelper* rule;

      // the io read rules
      std::vector<::ROOT::Internal::TSchemaHelper> readrules(3);
      rule = &readrules[0];
      rule->fSourceClass = "ROOT::Math::MatRepStd<Double32_t,3,3>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[1];
      rule->fSourceClass = "ROOT::Math::MatRepStd<float,3,3>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[2];
      rule->fSourceClass = "ROOT::Math::MatRepStd<Float16_t,3,3>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      instance.SetReadRules( readrules );
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::MatRepStd<double,3,3>*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::MatRepStd<double,3,3>*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::MatRepStd<double,3,3>*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLMatRepStdlEdoublecO3cO3gR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::MatRepStd<double,3,3>*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLMatRepStdlEdoublecO3cO3gR_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLMatRepStdlEdoublecO3cO3gR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLMatRepStdlEdoublecO4cO4gR_Dictionary();
   static void ROOTcLcLMathcLcLMatRepStdlEdoublecO4cO4gR_TClassManip(TClass*);
   static void *new_ROOTcLcLMathcLcLMatRepStdlEdoublecO4cO4gR(void *p = nullptr);
   static void *newArray_ROOTcLcLMathcLcLMatRepStdlEdoublecO4cO4gR(Long_t size, void *p);
   static void delete_ROOTcLcLMathcLcLMatRepStdlEdoublecO4cO4gR(void *p);
   static void deleteArray_ROOTcLcLMathcLcLMatRepStdlEdoublecO4cO4gR(void *p);
   static void destruct_ROOTcLcLMathcLcLMatRepStdlEdoublecO4cO4gR(void *p);

   // Schema evolution read functions

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::MatRepStd<double,4,4>*)
   {
      ::ROOT::Math::MatRepStd<double,4,4> *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::MatRepStd<double,4,4>));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::MatRepStd<double,4,4>", "Math/MatrixRepresentationsStatic.h", 54,
                  typeid(::ROOT::Math::MatRepStd<double,4,4>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLMatRepStdlEdoublecO4cO4gR_Dictionary, isa_proxy, 4,
                  sizeof(::ROOT::Math::MatRepStd<double,4,4>) );
      instance.SetNew(&new_ROOTcLcLMathcLcLMatRepStdlEdoublecO4cO4gR);
      instance.SetNewArray(&newArray_ROOTcLcLMathcLcLMatRepStdlEdoublecO4cO4gR);
      instance.SetDelete(&delete_ROOTcLcLMathcLcLMatRepStdlEdoublecO4cO4gR);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLMatRepStdlEdoublecO4cO4gR);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLMatRepStdlEdoublecO4cO4gR);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::MatRepStd<double,4,4>","ROOT::Math::MatRepStd<double, 4u, 4u>"));

      ::ROOT::Internal::TSchemaHelper* rule;

      // the io read rules
      std::vector<::ROOT::Internal::TSchemaHelper> readrules(3);
      rule = &readrules[0];
      rule->fSourceClass = "ROOT::Math::MatRepStd<Double32_t,4,4>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[1];
      rule->fSourceClass = "ROOT::Math::MatRepStd<float,4,4>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[2];
      rule->fSourceClass = "ROOT::Math::MatRepStd<Float16_t,4,4>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      instance.SetReadRules( readrules );
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::MatRepStd<double,4,4>*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::MatRepStd<double,4,4>*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::MatRepStd<double,4,4>*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLMatRepStdlEdoublecO4cO4gR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::MatRepStd<double,4,4>*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLMatRepStdlEdoublecO4cO4gR_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLMatRepStdlEdoublecO4cO4gR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLMatRepStdlEdoublecO5cO5gR_Dictionary();
   static void ROOTcLcLMathcLcLMatRepStdlEdoublecO5cO5gR_TClassManip(TClass*);
   static void *new_ROOTcLcLMathcLcLMatRepStdlEdoublecO5cO5gR(void *p = nullptr);
   static void *newArray_ROOTcLcLMathcLcLMatRepStdlEdoublecO5cO5gR(Long_t size, void *p);
   static void delete_ROOTcLcLMathcLcLMatRepStdlEdoublecO5cO5gR(void *p);
   static void deleteArray_ROOTcLcLMathcLcLMatRepStdlEdoublecO5cO5gR(void *p);
   static void destruct_ROOTcLcLMathcLcLMatRepStdlEdoublecO5cO5gR(void *p);

   // Schema evolution read functions

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::MatRepStd<double,5,5>*)
   {
      ::ROOT::Math::MatRepStd<double,5,5> *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::MatRepStd<double,5,5>));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::MatRepStd<double,5,5>", "Math/MatrixRepresentationsStatic.h", 54,
                  typeid(::ROOT::Math::MatRepStd<double,5,5>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLMatRepStdlEdoublecO5cO5gR_Dictionary, isa_proxy, 4,
                  sizeof(::ROOT::Math::MatRepStd<double,5,5>) );
      instance.SetNew(&new_ROOTcLcLMathcLcLMatRepStdlEdoublecO5cO5gR);
      instance.SetNewArray(&newArray_ROOTcLcLMathcLcLMatRepStdlEdoublecO5cO5gR);
      instance.SetDelete(&delete_ROOTcLcLMathcLcLMatRepStdlEdoublecO5cO5gR);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLMatRepStdlEdoublecO5cO5gR);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLMatRepStdlEdoublecO5cO5gR);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::MatRepStd<double,5,5>","ROOT::Math::MatRepStd<double, 5u, 5u>"));

      ::ROOT::Internal::TSchemaHelper* rule;

      // the io read rules
      std::vector<::ROOT::Internal::TSchemaHelper> readrules(3);
      rule = &readrules[0];
      rule->fSourceClass = "ROOT::Math::MatRepStd<Double32_t,5,5>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[1];
      rule->fSourceClass = "ROOT::Math::MatRepStd<float,5,5>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[2];
      rule->fSourceClass = "ROOT::Math::MatRepStd<Float16_t,5,5>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      instance.SetReadRules( readrules );
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::MatRepStd<double,5,5>*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::MatRepStd<double,5,5>*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::MatRepStd<double,5,5>*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLMatRepStdlEdoublecO5cO5gR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::MatRepStd<double,5,5>*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLMatRepStdlEdoublecO5cO5gR_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLMatRepStdlEdoublecO5cO5gR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLMatRepStdlEdoublecO6cO6gR_Dictionary();
   static void ROOTcLcLMathcLcLMatRepStdlEdoublecO6cO6gR_TClassManip(TClass*);
   static void *new_ROOTcLcLMathcLcLMatRepStdlEdoublecO6cO6gR(void *p = nullptr);
   static void *newArray_ROOTcLcLMathcLcLMatRepStdlEdoublecO6cO6gR(Long_t size, void *p);
   static void delete_ROOTcLcLMathcLcLMatRepStdlEdoublecO6cO6gR(void *p);
   static void deleteArray_ROOTcLcLMathcLcLMatRepStdlEdoublecO6cO6gR(void *p);
   static void destruct_ROOTcLcLMathcLcLMatRepStdlEdoublecO6cO6gR(void *p);

   // Schema evolution read functions

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::MatRepStd<double,6,6>*)
   {
      ::ROOT::Math::MatRepStd<double,6,6> *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::MatRepStd<double,6,6>));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::MatRepStd<double,6,6>", "Math/MatrixRepresentationsStatic.h", 54,
                  typeid(::ROOT::Math::MatRepStd<double,6,6>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLMatRepStdlEdoublecO6cO6gR_Dictionary, isa_proxy, 4,
                  sizeof(::ROOT::Math::MatRepStd<double,6,6>) );
      instance.SetNew(&new_ROOTcLcLMathcLcLMatRepStdlEdoublecO6cO6gR);
      instance.SetNewArray(&newArray_ROOTcLcLMathcLcLMatRepStdlEdoublecO6cO6gR);
      instance.SetDelete(&delete_ROOTcLcLMathcLcLMatRepStdlEdoublecO6cO6gR);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLMatRepStdlEdoublecO6cO6gR);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLMatRepStdlEdoublecO6cO6gR);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::MatRepStd<double,6,6>","ROOT::Math::MatRepStd<double, 6u, 6u>"));

      ::ROOT::Internal::TSchemaHelper* rule;

      // the io read rules
      std::vector<::ROOT::Internal::TSchemaHelper> readrules(3);
      rule = &readrules[0];
      rule->fSourceClass = "ROOT::Math::MatRepStd<Double32_t,6,6>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[1];
      rule->fSourceClass = "ROOT::Math::MatRepStd<float,6,6>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[2];
      rule->fSourceClass = "ROOT::Math::MatRepStd<Float16_t,6,6>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      instance.SetReadRules( readrules );
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::MatRepStd<double,6,6>*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::MatRepStd<double,6,6>*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::MatRepStd<double,6,6>*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLMatRepStdlEdoublecO6cO6gR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::MatRepStd<double,6,6>*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLMatRepStdlEdoublecO6cO6gR_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLMatRepStdlEdoublecO6cO6gR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLMatRepStdlEdoublecO7cO7gR_Dictionary();
   static void ROOTcLcLMathcLcLMatRepStdlEdoublecO7cO7gR_TClassManip(TClass*);
   static void *new_ROOTcLcLMathcLcLMatRepStdlEdoublecO7cO7gR(void *p = nullptr);
   static void *newArray_ROOTcLcLMathcLcLMatRepStdlEdoublecO7cO7gR(Long_t size, void *p);
   static void delete_ROOTcLcLMathcLcLMatRepStdlEdoublecO7cO7gR(void *p);
   static void deleteArray_ROOTcLcLMathcLcLMatRepStdlEdoublecO7cO7gR(void *p);
   static void destruct_ROOTcLcLMathcLcLMatRepStdlEdoublecO7cO7gR(void *p);

   // Schema evolution read functions

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::MatRepStd<double,7,7>*)
   {
      ::ROOT::Math::MatRepStd<double,7,7> *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::MatRepStd<double,7,7>));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::MatRepStd<double,7,7>", "Math/MatrixRepresentationsStatic.h", 54,
                  typeid(::ROOT::Math::MatRepStd<double,7,7>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLMatRepStdlEdoublecO7cO7gR_Dictionary, isa_proxy, 4,
                  sizeof(::ROOT::Math::MatRepStd<double,7,7>) );
      instance.SetNew(&new_ROOTcLcLMathcLcLMatRepStdlEdoublecO7cO7gR);
      instance.SetNewArray(&newArray_ROOTcLcLMathcLcLMatRepStdlEdoublecO7cO7gR);
      instance.SetDelete(&delete_ROOTcLcLMathcLcLMatRepStdlEdoublecO7cO7gR);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLMatRepStdlEdoublecO7cO7gR);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLMatRepStdlEdoublecO7cO7gR);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::MatRepStd<double,7,7>","ROOT::Math::MatRepStd<double, 7u, 7u>"));

      ::ROOT::Internal::TSchemaHelper* rule;

      // the io read rules
      std::vector<::ROOT::Internal::TSchemaHelper> readrules(3);
      rule = &readrules[0];
      rule->fSourceClass = "ROOT::Math::MatRepStd<Double32_t,7,7>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[1];
      rule->fSourceClass = "ROOT::Math::MatRepStd<float,7,7>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[2];
      rule->fSourceClass = "ROOT::Math::MatRepStd<Float16_t,7,7>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      instance.SetReadRules( readrules );
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::MatRepStd<double,7,7>*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::MatRepStd<double,7,7>*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::MatRepStd<double,7,7>*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLMatRepStdlEdoublecO7cO7gR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::MatRepStd<double,7,7>*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLMatRepStdlEdoublecO7cO7gR_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLMatRepStdlEdoublecO7cO7gR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLMatRepStdlEfloatcO2cO2gR_Dictionary();
   static void ROOTcLcLMathcLcLMatRepStdlEfloatcO2cO2gR_TClassManip(TClass*);
   static void *new_ROOTcLcLMathcLcLMatRepStdlEfloatcO2cO2gR(void *p = nullptr);
   static void *newArray_ROOTcLcLMathcLcLMatRepStdlEfloatcO2cO2gR(Long_t size, void *p);
   static void delete_ROOTcLcLMathcLcLMatRepStdlEfloatcO2cO2gR(void *p);
   static void deleteArray_ROOTcLcLMathcLcLMatRepStdlEfloatcO2cO2gR(void *p);
   static void destruct_ROOTcLcLMathcLcLMatRepStdlEfloatcO2cO2gR(void *p);

   // Schema evolution read functions

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::MatRepStd<float,2,2>*)
   {
      ::ROOT::Math::MatRepStd<float,2,2> *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::MatRepStd<float,2,2>));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::MatRepStd<float,2,2>", "Math/MatrixRepresentationsStatic.h", 54,
                  typeid(::ROOT::Math::MatRepStd<float,2,2>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLMatRepStdlEfloatcO2cO2gR_Dictionary, isa_proxy, 4,
                  sizeof(::ROOT::Math::MatRepStd<float,2,2>) );
      instance.SetNew(&new_ROOTcLcLMathcLcLMatRepStdlEfloatcO2cO2gR);
      instance.SetNewArray(&newArray_ROOTcLcLMathcLcLMatRepStdlEfloatcO2cO2gR);
      instance.SetDelete(&delete_ROOTcLcLMathcLcLMatRepStdlEfloatcO2cO2gR);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLMatRepStdlEfloatcO2cO2gR);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLMatRepStdlEfloatcO2cO2gR);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::MatRepStd<float,2,2>","ROOT::Math::MatRepStd<float, 2u, 2u>"));

      ::ROOT::Internal::TSchemaHelper* rule;

      // the io read rules
      std::vector<::ROOT::Internal::TSchemaHelper> readrules(3);
      rule = &readrules[0];
      rule->fSourceClass = "ROOT::Math::MatRepStd<double,2,2>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[1];
      rule->fSourceClass = "ROOT::Math::MatRepStd<Double32_t,2,2>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[2];
      rule->fSourceClass = "ROOT::Math::MatRepStd<Float16_t,2,2>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      instance.SetReadRules( readrules );
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::MatRepStd<float,2,2>*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::MatRepStd<float,2,2>*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::MatRepStd<float,2,2>*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLMatRepStdlEfloatcO2cO2gR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::MatRepStd<float,2,2>*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLMatRepStdlEfloatcO2cO2gR_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLMatRepStdlEfloatcO2cO2gR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLMatRepStdlEfloatcO3cO3gR_Dictionary();
   static void ROOTcLcLMathcLcLMatRepStdlEfloatcO3cO3gR_TClassManip(TClass*);
   static void *new_ROOTcLcLMathcLcLMatRepStdlEfloatcO3cO3gR(void *p = nullptr);
   static void *newArray_ROOTcLcLMathcLcLMatRepStdlEfloatcO3cO3gR(Long_t size, void *p);
   static void delete_ROOTcLcLMathcLcLMatRepStdlEfloatcO3cO3gR(void *p);
   static void deleteArray_ROOTcLcLMathcLcLMatRepStdlEfloatcO3cO3gR(void *p);
   static void destruct_ROOTcLcLMathcLcLMatRepStdlEfloatcO3cO3gR(void *p);

   // Schema evolution read functions

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::MatRepStd<float,3,3>*)
   {
      ::ROOT::Math::MatRepStd<float,3,3> *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::MatRepStd<float,3,3>));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::MatRepStd<float,3,3>", "Math/MatrixRepresentationsStatic.h", 54,
                  typeid(::ROOT::Math::MatRepStd<float,3,3>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLMatRepStdlEfloatcO3cO3gR_Dictionary, isa_proxy, 4,
                  sizeof(::ROOT::Math::MatRepStd<float,3,3>) );
      instance.SetNew(&new_ROOTcLcLMathcLcLMatRepStdlEfloatcO3cO3gR);
      instance.SetNewArray(&newArray_ROOTcLcLMathcLcLMatRepStdlEfloatcO3cO3gR);
      instance.SetDelete(&delete_ROOTcLcLMathcLcLMatRepStdlEfloatcO3cO3gR);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLMatRepStdlEfloatcO3cO3gR);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLMatRepStdlEfloatcO3cO3gR);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::MatRepStd<float,3,3>","ROOT::Math::MatRepStd<float, 3u, 3u>"));

      ::ROOT::Internal::TSchemaHelper* rule;

      // the io read rules
      std::vector<::ROOT::Internal::TSchemaHelper> readrules(3);
      rule = &readrules[0];
      rule->fSourceClass = "ROOT::Math::MatRepStd<double,3,3>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[1];
      rule->fSourceClass = "ROOT::Math::MatRepStd<Double32_t,3,3>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[2];
      rule->fSourceClass = "ROOT::Math::MatRepStd<Float16_t,3,3>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      instance.SetReadRules( readrules );
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::MatRepStd<float,3,3>*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::MatRepStd<float,3,3>*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::MatRepStd<float,3,3>*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLMatRepStdlEfloatcO3cO3gR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::MatRepStd<float,3,3>*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLMatRepStdlEfloatcO3cO3gR_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLMatRepStdlEfloatcO3cO3gR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLMatRepStdlEfloatcO4cO4gR_Dictionary();
   static void ROOTcLcLMathcLcLMatRepStdlEfloatcO4cO4gR_TClassManip(TClass*);
   static void *new_ROOTcLcLMathcLcLMatRepStdlEfloatcO4cO4gR(void *p = nullptr);
   static void *newArray_ROOTcLcLMathcLcLMatRepStdlEfloatcO4cO4gR(Long_t size, void *p);
   static void delete_ROOTcLcLMathcLcLMatRepStdlEfloatcO4cO4gR(void *p);
   static void deleteArray_ROOTcLcLMathcLcLMatRepStdlEfloatcO4cO4gR(void *p);
   static void destruct_ROOTcLcLMathcLcLMatRepStdlEfloatcO4cO4gR(void *p);

   // Schema evolution read functions

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::MatRepStd<float,4,4>*)
   {
      ::ROOT::Math::MatRepStd<float,4,4> *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::MatRepStd<float,4,4>));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::MatRepStd<float,4,4>", "Math/MatrixRepresentationsStatic.h", 54,
                  typeid(::ROOT::Math::MatRepStd<float,4,4>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLMatRepStdlEfloatcO4cO4gR_Dictionary, isa_proxy, 4,
                  sizeof(::ROOT::Math::MatRepStd<float,4,4>) );
      instance.SetNew(&new_ROOTcLcLMathcLcLMatRepStdlEfloatcO4cO4gR);
      instance.SetNewArray(&newArray_ROOTcLcLMathcLcLMatRepStdlEfloatcO4cO4gR);
      instance.SetDelete(&delete_ROOTcLcLMathcLcLMatRepStdlEfloatcO4cO4gR);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLMatRepStdlEfloatcO4cO4gR);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLMatRepStdlEfloatcO4cO4gR);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::MatRepStd<float,4,4>","ROOT::Math::MatRepStd<float, 4u, 4u>"));

      ::ROOT::Internal::TSchemaHelper* rule;

      // the io read rules
      std::vector<::ROOT::Internal::TSchemaHelper> readrules(3);
      rule = &readrules[0];
      rule->fSourceClass = "ROOT::Math::MatRepStd<double,4,4>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[1];
      rule->fSourceClass = "ROOT::Math::MatRepStd<Double32_t,4,4>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[2];
      rule->fSourceClass = "ROOT::Math::MatRepStd<Float16_t,4,4>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      instance.SetReadRules( readrules );
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::MatRepStd<float,4,4>*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::MatRepStd<float,4,4>*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::MatRepStd<float,4,4>*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLMatRepStdlEfloatcO4cO4gR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::MatRepStd<float,4,4>*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLMatRepStdlEfloatcO4cO4gR_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLMatRepStdlEfloatcO4cO4gR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLMatRepStdlEfloatcO5cO5gR_Dictionary();
   static void ROOTcLcLMathcLcLMatRepStdlEfloatcO5cO5gR_TClassManip(TClass*);
   static void *new_ROOTcLcLMathcLcLMatRepStdlEfloatcO5cO5gR(void *p = nullptr);
   static void *newArray_ROOTcLcLMathcLcLMatRepStdlEfloatcO5cO5gR(Long_t size, void *p);
   static void delete_ROOTcLcLMathcLcLMatRepStdlEfloatcO5cO5gR(void *p);
   static void deleteArray_ROOTcLcLMathcLcLMatRepStdlEfloatcO5cO5gR(void *p);
   static void destruct_ROOTcLcLMathcLcLMatRepStdlEfloatcO5cO5gR(void *p);

   // Schema evolution read functions

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::MatRepStd<float,5,5>*)
   {
      ::ROOT::Math::MatRepStd<float,5,5> *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::MatRepStd<float,5,5>));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::MatRepStd<float,5,5>", "Math/MatrixRepresentationsStatic.h", 54,
                  typeid(::ROOT::Math::MatRepStd<float,5,5>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLMatRepStdlEfloatcO5cO5gR_Dictionary, isa_proxy, 4,
                  sizeof(::ROOT::Math::MatRepStd<float,5,5>) );
      instance.SetNew(&new_ROOTcLcLMathcLcLMatRepStdlEfloatcO5cO5gR);
      instance.SetNewArray(&newArray_ROOTcLcLMathcLcLMatRepStdlEfloatcO5cO5gR);
      instance.SetDelete(&delete_ROOTcLcLMathcLcLMatRepStdlEfloatcO5cO5gR);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLMatRepStdlEfloatcO5cO5gR);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLMatRepStdlEfloatcO5cO5gR);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::MatRepStd<float,5,5>","ROOT::Math::MatRepStd<float, 5u, 5u>"));

      ::ROOT::Internal::TSchemaHelper* rule;

      // the io read rules
      std::vector<::ROOT::Internal::TSchemaHelper> readrules(3);
      rule = &readrules[0];
      rule->fSourceClass = "ROOT::Math::MatRepStd<double,5,5>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[1];
      rule->fSourceClass = "ROOT::Math::MatRepStd<Double32_t,5,5>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[2];
      rule->fSourceClass = "ROOT::Math::MatRepStd<Float16_t,5,5>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      instance.SetReadRules( readrules );
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::MatRepStd<float,5,5>*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::MatRepStd<float,5,5>*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::MatRepStd<float,5,5>*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLMatRepStdlEfloatcO5cO5gR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::MatRepStd<float,5,5>*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLMatRepStdlEfloatcO5cO5gR_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLMatRepStdlEfloatcO5cO5gR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLMatRepStdlEfloatcO6cO6gR_Dictionary();
   static void ROOTcLcLMathcLcLMatRepStdlEfloatcO6cO6gR_TClassManip(TClass*);
   static void *new_ROOTcLcLMathcLcLMatRepStdlEfloatcO6cO6gR(void *p = nullptr);
   static void *newArray_ROOTcLcLMathcLcLMatRepStdlEfloatcO6cO6gR(Long_t size, void *p);
   static void delete_ROOTcLcLMathcLcLMatRepStdlEfloatcO6cO6gR(void *p);
   static void deleteArray_ROOTcLcLMathcLcLMatRepStdlEfloatcO6cO6gR(void *p);
   static void destruct_ROOTcLcLMathcLcLMatRepStdlEfloatcO6cO6gR(void *p);

   // Schema evolution read functions

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::MatRepStd<float,6,6>*)
   {
      ::ROOT::Math::MatRepStd<float,6,6> *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::MatRepStd<float,6,6>));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::MatRepStd<float,6,6>", "Math/MatrixRepresentationsStatic.h", 54,
                  typeid(::ROOT::Math::MatRepStd<float,6,6>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLMatRepStdlEfloatcO6cO6gR_Dictionary, isa_proxy, 4,
                  sizeof(::ROOT::Math::MatRepStd<float,6,6>) );
      instance.SetNew(&new_ROOTcLcLMathcLcLMatRepStdlEfloatcO6cO6gR);
      instance.SetNewArray(&newArray_ROOTcLcLMathcLcLMatRepStdlEfloatcO6cO6gR);
      instance.SetDelete(&delete_ROOTcLcLMathcLcLMatRepStdlEfloatcO6cO6gR);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLMatRepStdlEfloatcO6cO6gR);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLMatRepStdlEfloatcO6cO6gR);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::MatRepStd<float,6,6>","ROOT::Math::MatRepStd<float, 6u, 6u>"));

      ::ROOT::Internal::TSchemaHelper* rule;

      // the io read rules
      std::vector<::ROOT::Internal::TSchemaHelper> readrules(3);
      rule = &readrules[0];
      rule->fSourceClass = "ROOT::Math::MatRepStd<double,6,6>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[1];
      rule->fSourceClass = "ROOT::Math::MatRepStd<Double32_t,6,6>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[2];
      rule->fSourceClass = "ROOT::Math::MatRepStd<Float16_t,6,6>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      instance.SetReadRules( readrules );
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::MatRepStd<float,6,6>*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::MatRepStd<float,6,6>*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::MatRepStd<float,6,6>*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLMatRepStdlEfloatcO6cO6gR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::MatRepStd<float,6,6>*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLMatRepStdlEfloatcO6cO6gR_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLMatRepStdlEfloatcO6cO6gR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLMatRepStdlEfloatcO7cO7gR_Dictionary();
   static void ROOTcLcLMathcLcLMatRepStdlEfloatcO7cO7gR_TClassManip(TClass*);
   static void *new_ROOTcLcLMathcLcLMatRepStdlEfloatcO7cO7gR(void *p = nullptr);
   static void *newArray_ROOTcLcLMathcLcLMatRepStdlEfloatcO7cO7gR(Long_t size, void *p);
   static void delete_ROOTcLcLMathcLcLMatRepStdlEfloatcO7cO7gR(void *p);
   static void deleteArray_ROOTcLcLMathcLcLMatRepStdlEfloatcO7cO7gR(void *p);
   static void destruct_ROOTcLcLMathcLcLMatRepStdlEfloatcO7cO7gR(void *p);

   // Schema evolution read functions

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::MatRepStd<float,7,7>*)
   {
      ::ROOT::Math::MatRepStd<float,7,7> *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::MatRepStd<float,7,7>));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::MatRepStd<float,7,7>", "Math/MatrixRepresentationsStatic.h", 54,
                  typeid(::ROOT::Math::MatRepStd<float,7,7>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLMatRepStdlEfloatcO7cO7gR_Dictionary, isa_proxy, 4,
                  sizeof(::ROOT::Math::MatRepStd<float,7,7>) );
      instance.SetNew(&new_ROOTcLcLMathcLcLMatRepStdlEfloatcO7cO7gR);
      instance.SetNewArray(&newArray_ROOTcLcLMathcLcLMatRepStdlEfloatcO7cO7gR);
      instance.SetDelete(&delete_ROOTcLcLMathcLcLMatRepStdlEfloatcO7cO7gR);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLMatRepStdlEfloatcO7cO7gR);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLMatRepStdlEfloatcO7cO7gR);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::MatRepStd<float,7,7>","ROOT::Math::MatRepStd<float, 7u, 7u>"));

      ::ROOT::Internal::TSchemaHelper* rule;

      // the io read rules
      std::vector<::ROOT::Internal::TSchemaHelper> readrules(3);
      rule = &readrules[0];
      rule->fSourceClass = "ROOT::Math::MatRepStd<double,7,7>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[1];
      rule->fSourceClass = "ROOT::Math::MatRepStd<Double32_t,7,7>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[2];
      rule->fSourceClass = "ROOT::Math::MatRepStd<Float16_t,7,7>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      instance.SetReadRules( readrules );
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::MatRepStd<float,7,7>*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::MatRepStd<float,7,7>*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::MatRepStd<float,7,7>*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLMatRepStdlEfloatcO7cO7gR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::MatRepStd<float,7,7>*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLMatRepStdlEfloatcO7cO7gR_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLMatRepStdlEfloatcO7cO7gR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLMatRepStdlEdoublecO4cO3gR_Dictionary();
   static void ROOTcLcLMathcLcLMatRepStdlEdoublecO4cO3gR_TClassManip(TClass*);
   static void *new_ROOTcLcLMathcLcLMatRepStdlEdoublecO4cO3gR(void *p = nullptr);
   static void *newArray_ROOTcLcLMathcLcLMatRepStdlEdoublecO4cO3gR(Long_t size, void *p);
   static void delete_ROOTcLcLMathcLcLMatRepStdlEdoublecO4cO3gR(void *p);
   static void deleteArray_ROOTcLcLMathcLcLMatRepStdlEdoublecO4cO3gR(void *p);
   static void destruct_ROOTcLcLMathcLcLMatRepStdlEdoublecO4cO3gR(void *p);

   // Schema evolution read functions

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::MatRepStd<double,4,3>*)
   {
      ::ROOT::Math::MatRepStd<double,4,3> *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::MatRepStd<double,4,3>));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::MatRepStd<double,4,3>", "Math/MatrixRepresentationsStatic.h", 54,
                  typeid(::ROOT::Math::MatRepStd<double,4,3>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLMatRepStdlEdoublecO4cO3gR_Dictionary, isa_proxy, 4,
                  sizeof(::ROOT::Math::MatRepStd<double,4,3>) );
      instance.SetNew(&new_ROOTcLcLMathcLcLMatRepStdlEdoublecO4cO3gR);
      instance.SetNewArray(&newArray_ROOTcLcLMathcLcLMatRepStdlEdoublecO4cO3gR);
      instance.SetDelete(&delete_ROOTcLcLMathcLcLMatRepStdlEdoublecO4cO3gR);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLMatRepStdlEdoublecO4cO3gR);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLMatRepStdlEdoublecO4cO3gR);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::MatRepStd<double,4,3>","ROOT::Math::MatRepStd<double, 4u, 3u>"));

      ::ROOT::Internal::TSchemaHelper* rule;

      // the io read rules
      std::vector<::ROOT::Internal::TSchemaHelper> readrules(3);
      rule = &readrules[0];
      rule->fSourceClass = "ROOT::Math::MatRepStd<Double32_t,4,3>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[1];
      rule->fSourceClass = "ROOT::Math::MatRepStd<float,4,3>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[2];
      rule->fSourceClass = "ROOT::Math::MatRepStd<Float16_t,4,3>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      instance.SetReadRules( readrules );
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::MatRepStd<double,4,3>*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::MatRepStd<double,4,3>*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::MatRepStd<double,4,3>*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLMatRepStdlEdoublecO4cO3gR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::MatRepStd<double,4,3>*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLMatRepStdlEdoublecO4cO3gR_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLMatRepStdlEdoublecO4cO3gR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLMatRepStdlEdoublecO3cO4gR_Dictionary();
   static void ROOTcLcLMathcLcLMatRepStdlEdoublecO3cO4gR_TClassManip(TClass*);
   static void *new_ROOTcLcLMathcLcLMatRepStdlEdoublecO3cO4gR(void *p = nullptr);
   static void *newArray_ROOTcLcLMathcLcLMatRepStdlEdoublecO3cO4gR(Long_t size, void *p);
   static void delete_ROOTcLcLMathcLcLMatRepStdlEdoublecO3cO4gR(void *p);
   static void deleteArray_ROOTcLcLMathcLcLMatRepStdlEdoublecO3cO4gR(void *p);
   static void destruct_ROOTcLcLMathcLcLMatRepStdlEdoublecO3cO4gR(void *p);

   // Schema evolution read functions

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::MatRepStd<double,3,4>*)
   {
      ::ROOT::Math::MatRepStd<double,3,4> *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::MatRepStd<double,3,4>));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::MatRepStd<double,3,4>", "Math/MatrixRepresentationsStatic.h", 54,
                  typeid(::ROOT::Math::MatRepStd<double,3,4>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLMatRepStdlEdoublecO3cO4gR_Dictionary, isa_proxy, 4,
                  sizeof(::ROOT::Math::MatRepStd<double,3,4>) );
      instance.SetNew(&new_ROOTcLcLMathcLcLMatRepStdlEdoublecO3cO4gR);
      instance.SetNewArray(&newArray_ROOTcLcLMathcLcLMatRepStdlEdoublecO3cO4gR);
      instance.SetDelete(&delete_ROOTcLcLMathcLcLMatRepStdlEdoublecO3cO4gR);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLMatRepStdlEdoublecO3cO4gR);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLMatRepStdlEdoublecO3cO4gR);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::MatRepStd<double,3,4>","ROOT::Math::MatRepStd<double, 3u, 4u>"));

      ::ROOT::Internal::TSchemaHelper* rule;

      // the io read rules
      std::vector<::ROOT::Internal::TSchemaHelper> readrules(3);
      rule = &readrules[0];
      rule->fSourceClass = "ROOT::Math::MatRepStd<Double32_t,3,4>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[1];
      rule->fSourceClass = "ROOT::Math::MatRepStd<float,3,4>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[2];
      rule->fSourceClass = "ROOT::Math::MatRepStd<Float16_t,3,4>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      instance.SetReadRules( readrules );
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::MatRepStd<double,3,4>*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::MatRepStd<double,3,4>*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::MatRepStd<double,3,4>*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLMatRepStdlEdoublecO3cO4gR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::MatRepStd<double,3,4>*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLMatRepStdlEdoublecO3cO4gR_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLMatRepStdlEdoublecO3cO4gR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLMatRepStdlEdoublecO9cO7gR_Dictionary();
   static void ROOTcLcLMathcLcLMatRepStdlEdoublecO9cO7gR_TClassManip(TClass*);
   static void *new_ROOTcLcLMathcLcLMatRepStdlEdoublecO9cO7gR(void *p = nullptr);
   static void *newArray_ROOTcLcLMathcLcLMatRepStdlEdoublecO9cO7gR(Long_t size, void *p);
   static void delete_ROOTcLcLMathcLcLMatRepStdlEdoublecO9cO7gR(void *p);
   static void deleteArray_ROOTcLcLMathcLcLMatRepStdlEdoublecO9cO7gR(void *p);
   static void destruct_ROOTcLcLMathcLcLMatRepStdlEdoublecO9cO7gR(void *p);

   // Schema evolution read functions

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::MatRepStd<double,9,7>*)
   {
      ::ROOT::Math::MatRepStd<double,9,7> *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::MatRepStd<double,9,7>));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::MatRepStd<double,9,7>", "Math/MatrixRepresentationsStatic.h", 54,
                  typeid(::ROOT::Math::MatRepStd<double,9,7>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLMatRepStdlEdoublecO9cO7gR_Dictionary, isa_proxy, 4,
                  sizeof(::ROOT::Math::MatRepStd<double,9,7>) );
      instance.SetNew(&new_ROOTcLcLMathcLcLMatRepStdlEdoublecO9cO7gR);
      instance.SetNewArray(&newArray_ROOTcLcLMathcLcLMatRepStdlEdoublecO9cO7gR);
      instance.SetDelete(&delete_ROOTcLcLMathcLcLMatRepStdlEdoublecO9cO7gR);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLMatRepStdlEdoublecO9cO7gR);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLMatRepStdlEdoublecO9cO7gR);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::MatRepStd<double,9,7>","ROOT::Math::MatRepStd<double, 9u, 7u>"));

      ::ROOT::Internal::TSchemaHelper* rule;

      // the io read rules
      std::vector<::ROOT::Internal::TSchemaHelper> readrules(3);
      rule = &readrules[0];
      rule->fSourceClass = "ROOT::Math::MatRepStd<Double32_t,9,7>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[1];
      rule->fSourceClass = "ROOT::Math::MatRepStd<float,9,7>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[2];
      rule->fSourceClass = "ROOT::Math::MatRepStd<Float16_t,9,7>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      instance.SetReadRules( readrules );
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::MatRepStd<double,9,7>*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::MatRepStd<double,9,7>*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::MatRepStd<double,9,7>*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLMatRepStdlEdoublecO9cO7gR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::MatRepStd<double,9,7>*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLMatRepStdlEdoublecO9cO7gR_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLMatRepStdlEdoublecO9cO7gR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLMatRepStdlEfloatcO4cO3gR_Dictionary();
   static void ROOTcLcLMathcLcLMatRepStdlEfloatcO4cO3gR_TClassManip(TClass*);
   static void *new_ROOTcLcLMathcLcLMatRepStdlEfloatcO4cO3gR(void *p = nullptr);
   static void *newArray_ROOTcLcLMathcLcLMatRepStdlEfloatcO4cO3gR(Long_t size, void *p);
   static void delete_ROOTcLcLMathcLcLMatRepStdlEfloatcO4cO3gR(void *p);
   static void deleteArray_ROOTcLcLMathcLcLMatRepStdlEfloatcO4cO3gR(void *p);
   static void destruct_ROOTcLcLMathcLcLMatRepStdlEfloatcO4cO3gR(void *p);

   // Schema evolution read functions

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::MatRepStd<float,4,3>*)
   {
      ::ROOT::Math::MatRepStd<float,4,3> *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::MatRepStd<float,4,3>));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::MatRepStd<float,4,3>", "Math/MatrixRepresentationsStatic.h", 54,
                  typeid(::ROOT::Math::MatRepStd<float,4,3>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLMatRepStdlEfloatcO4cO3gR_Dictionary, isa_proxy, 4,
                  sizeof(::ROOT::Math::MatRepStd<float,4,3>) );
      instance.SetNew(&new_ROOTcLcLMathcLcLMatRepStdlEfloatcO4cO3gR);
      instance.SetNewArray(&newArray_ROOTcLcLMathcLcLMatRepStdlEfloatcO4cO3gR);
      instance.SetDelete(&delete_ROOTcLcLMathcLcLMatRepStdlEfloatcO4cO3gR);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLMatRepStdlEfloatcO4cO3gR);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLMatRepStdlEfloatcO4cO3gR);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::MatRepStd<float,4,3>","ROOT::Math::MatRepStd<float, 4u, 3u>"));

      ::ROOT::Internal::TSchemaHelper* rule;

      // the io read rules
      std::vector<::ROOT::Internal::TSchemaHelper> readrules(3);
      rule = &readrules[0];
      rule->fSourceClass = "ROOT::Math::MatRepStd<double,4,3>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[1];
      rule->fSourceClass = "ROOT::Math::MatRepStd<Double32_t,4,3>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[2];
      rule->fSourceClass = "ROOT::Math::MatRepStd<Float16_t,4,3>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      instance.SetReadRules( readrules );
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::MatRepStd<float,4,3>*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::MatRepStd<float,4,3>*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::MatRepStd<float,4,3>*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLMatRepStdlEfloatcO4cO3gR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::MatRepStd<float,4,3>*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLMatRepStdlEfloatcO4cO3gR_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLMatRepStdlEfloatcO4cO3gR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLMatRepStdlEfloatcO3cO4gR_Dictionary();
   static void ROOTcLcLMathcLcLMatRepStdlEfloatcO3cO4gR_TClassManip(TClass*);
   static void *new_ROOTcLcLMathcLcLMatRepStdlEfloatcO3cO4gR(void *p = nullptr);
   static void *newArray_ROOTcLcLMathcLcLMatRepStdlEfloatcO3cO4gR(Long_t size, void *p);
   static void delete_ROOTcLcLMathcLcLMatRepStdlEfloatcO3cO4gR(void *p);
   static void deleteArray_ROOTcLcLMathcLcLMatRepStdlEfloatcO3cO4gR(void *p);
   static void destruct_ROOTcLcLMathcLcLMatRepStdlEfloatcO3cO4gR(void *p);

   // Schema evolution read functions

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::MatRepStd<float,3,4>*)
   {
      ::ROOT::Math::MatRepStd<float,3,4> *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::MatRepStd<float,3,4>));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::MatRepStd<float,3,4>", "Math/MatrixRepresentationsStatic.h", 54,
                  typeid(::ROOT::Math::MatRepStd<float,3,4>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLMatRepStdlEfloatcO3cO4gR_Dictionary, isa_proxy, 4,
                  sizeof(::ROOT::Math::MatRepStd<float,3,4>) );
      instance.SetNew(&new_ROOTcLcLMathcLcLMatRepStdlEfloatcO3cO4gR);
      instance.SetNewArray(&newArray_ROOTcLcLMathcLcLMatRepStdlEfloatcO3cO4gR);
      instance.SetDelete(&delete_ROOTcLcLMathcLcLMatRepStdlEfloatcO3cO4gR);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLMatRepStdlEfloatcO3cO4gR);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLMatRepStdlEfloatcO3cO4gR);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::MatRepStd<float,3,4>","ROOT::Math::MatRepStd<float, 3u, 4u>"));

      ::ROOT::Internal::TSchemaHelper* rule;

      // the io read rules
      std::vector<::ROOT::Internal::TSchemaHelper> readrules(3);
      rule = &readrules[0];
      rule->fSourceClass = "ROOT::Math::MatRepStd<double,3,4>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[1];
      rule->fSourceClass = "ROOT::Math::MatRepStd<Double32_t,3,4>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[2];
      rule->fSourceClass = "ROOT::Math::MatRepStd<Float16_t,3,4>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      instance.SetReadRules( readrules );
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::MatRepStd<float,3,4>*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::MatRepStd<float,3,4>*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::MatRepStd<float,3,4>*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLMatRepStdlEfloatcO3cO4gR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::MatRepStd<float,3,4>*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLMatRepStdlEfloatcO3cO4gR_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLMatRepStdlEfloatcO3cO4gR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLMatRepStdlEfloatcO9cO7gR_Dictionary();
   static void ROOTcLcLMathcLcLMatRepStdlEfloatcO9cO7gR_TClassManip(TClass*);
   static void *new_ROOTcLcLMathcLcLMatRepStdlEfloatcO9cO7gR(void *p = nullptr);
   static void *newArray_ROOTcLcLMathcLcLMatRepStdlEfloatcO9cO7gR(Long_t size, void *p);
   static void delete_ROOTcLcLMathcLcLMatRepStdlEfloatcO9cO7gR(void *p);
   static void deleteArray_ROOTcLcLMathcLcLMatRepStdlEfloatcO9cO7gR(void *p);
   static void destruct_ROOTcLcLMathcLcLMatRepStdlEfloatcO9cO7gR(void *p);

   // Schema evolution read functions

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::MatRepStd<float,9,7>*)
   {
      ::ROOT::Math::MatRepStd<float,9,7> *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::MatRepStd<float,9,7>));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::MatRepStd<float,9,7>", "Math/MatrixRepresentationsStatic.h", 54,
                  typeid(::ROOT::Math::MatRepStd<float,9,7>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLMatRepStdlEfloatcO9cO7gR_Dictionary, isa_proxy, 4,
                  sizeof(::ROOT::Math::MatRepStd<float,9,7>) );
      instance.SetNew(&new_ROOTcLcLMathcLcLMatRepStdlEfloatcO9cO7gR);
      instance.SetNewArray(&newArray_ROOTcLcLMathcLcLMatRepStdlEfloatcO9cO7gR);
      instance.SetDelete(&delete_ROOTcLcLMathcLcLMatRepStdlEfloatcO9cO7gR);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLMatRepStdlEfloatcO9cO7gR);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLMatRepStdlEfloatcO9cO7gR);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::MatRepStd<float,9,7>","ROOT::Math::MatRepStd<float, 9u, 7u>"));

      ::ROOT::Internal::TSchemaHelper* rule;

      // the io read rules
      std::vector<::ROOT::Internal::TSchemaHelper> readrules(3);
      rule = &readrules[0];
      rule->fSourceClass = "ROOT::Math::MatRepStd<double,9,7>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[1];
      rule->fSourceClass = "ROOT::Math::MatRepStd<Double32_t,9,7>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[2];
      rule->fSourceClass = "ROOT::Math::MatRepStd<Float16_t,9,7>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      instance.SetReadRules( readrules );
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::MatRepStd<float,9,7>*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::MatRepStd<float,9,7>*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::MatRepStd<float,9,7>*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLMatRepStdlEfloatcO9cO7gR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::MatRepStd<float,9,7>*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLMatRepStdlEfloatcO9cO7gR_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLMatRepStdlEfloatcO9cO7gR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLRowOffsetslE7gR_Dictionary();
   static void ROOTcLcLMathcLcLRowOffsetslE7gR_TClassManip(TClass*);
   static void *new_ROOTcLcLMathcLcLRowOffsetslE7gR(void *p = nullptr);
   static void *newArray_ROOTcLcLMathcLcLRowOffsetslE7gR(Long_t size, void *p);
   static void delete_ROOTcLcLMathcLcLRowOffsetslE7gR(void *p);
   static void deleteArray_ROOTcLcLMathcLcLRowOffsetslE7gR(void *p);
   static void destruct_ROOTcLcLMathcLcLRowOffsetslE7gR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::RowOffsets<7>*)
   {
      ::ROOT::Math::RowOffsets<7> *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::RowOffsets<7>));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::RowOffsets<7>", "Math/MatrixRepresentationsStatic.h", 131,
                  typeid(::ROOT::Math::RowOffsets<7>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLRowOffsetslE7gR_Dictionary, isa_proxy, 0,
                  sizeof(::ROOT::Math::RowOffsets<7>) );
      instance.SetNew(&new_ROOTcLcLMathcLcLRowOffsetslE7gR);
      instance.SetNewArray(&newArray_ROOTcLcLMathcLcLRowOffsetslE7gR);
      instance.SetDelete(&delete_ROOTcLcLMathcLcLRowOffsetslE7gR);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLRowOffsetslE7gR);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLRowOffsetslE7gR);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::RowOffsets<7>","ROOT::Math::RowOffsets<7u>"));
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::RowOffsets<7>*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::RowOffsets<7>*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::RowOffsets<7>*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLRowOffsetslE7gR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::RowOffsets<7>*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLRowOffsetslE7gR_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLRowOffsetslE7gR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLRowOffsetslE6gR_Dictionary();
   static void ROOTcLcLMathcLcLRowOffsetslE6gR_TClassManip(TClass*);
   static void *new_ROOTcLcLMathcLcLRowOffsetslE6gR(void *p = nullptr);
   static void *newArray_ROOTcLcLMathcLcLRowOffsetslE6gR(Long_t size, void *p);
   static void delete_ROOTcLcLMathcLcLRowOffsetslE6gR(void *p);
   static void deleteArray_ROOTcLcLMathcLcLRowOffsetslE6gR(void *p);
   static void destruct_ROOTcLcLMathcLcLRowOffsetslE6gR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::RowOffsets<6>*)
   {
      ::ROOT::Math::RowOffsets<6> *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::RowOffsets<6>));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::RowOffsets<6>", "Math/MatrixRepresentationsStatic.h", 131,
                  typeid(::ROOT::Math::RowOffsets<6>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLRowOffsetslE6gR_Dictionary, isa_proxy, 0,
                  sizeof(::ROOT::Math::RowOffsets<6>) );
      instance.SetNew(&new_ROOTcLcLMathcLcLRowOffsetslE6gR);
      instance.SetNewArray(&newArray_ROOTcLcLMathcLcLRowOffsetslE6gR);
      instance.SetDelete(&delete_ROOTcLcLMathcLcLRowOffsetslE6gR);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLRowOffsetslE6gR);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLRowOffsetslE6gR);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::RowOffsets<6>","ROOT::Math::RowOffsets<6u>"));
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::RowOffsets<6>*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::RowOffsets<6>*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::RowOffsets<6>*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLRowOffsetslE6gR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::RowOffsets<6>*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLRowOffsetslE6gR_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLRowOffsetslE6gR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLRowOffsetslE5gR_Dictionary();
   static void ROOTcLcLMathcLcLRowOffsetslE5gR_TClassManip(TClass*);
   static void *new_ROOTcLcLMathcLcLRowOffsetslE5gR(void *p = nullptr);
   static void *newArray_ROOTcLcLMathcLcLRowOffsetslE5gR(Long_t size, void *p);
   static void delete_ROOTcLcLMathcLcLRowOffsetslE5gR(void *p);
   static void deleteArray_ROOTcLcLMathcLcLRowOffsetslE5gR(void *p);
   static void destruct_ROOTcLcLMathcLcLRowOffsetslE5gR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::RowOffsets<5>*)
   {
      ::ROOT::Math::RowOffsets<5> *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::RowOffsets<5>));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::RowOffsets<5>", "Math/MatrixRepresentationsStatic.h", 131,
                  typeid(::ROOT::Math::RowOffsets<5>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLRowOffsetslE5gR_Dictionary, isa_proxy, 0,
                  sizeof(::ROOT::Math::RowOffsets<5>) );
      instance.SetNew(&new_ROOTcLcLMathcLcLRowOffsetslE5gR);
      instance.SetNewArray(&newArray_ROOTcLcLMathcLcLRowOffsetslE5gR);
      instance.SetDelete(&delete_ROOTcLcLMathcLcLRowOffsetslE5gR);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLRowOffsetslE5gR);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLRowOffsetslE5gR);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::RowOffsets<5>","ROOT::Math::RowOffsets<5u>"));
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::RowOffsets<5>*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::RowOffsets<5>*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::RowOffsets<5>*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLRowOffsetslE5gR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::RowOffsets<5>*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLRowOffsetslE5gR_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLRowOffsetslE5gR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLRowOffsetslE4gR_Dictionary();
   static void ROOTcLcLMathcLcLRowOffsetslE4gR_TClassManip(TClass*);
   static void *new_ROOTcLcLMathcLcLRowOffsetslE4gR(void *p = nullptr);
   static void *newArray_ROOTcLcLMathcLcLRowOffsetslE4gR(Long_t size, void *p);
   static void delete_ROOTcLcLMathcLcLRowOffsetslE4gR(void *p);
   static void deleteArray_ROOTcLcLMathcLcLRowOffsetslE4gR(void *p);
   static void destruct_ROOTcLcLMathcLcLRowOffsetslE4gR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::RowOffsets<4>*)
   {
      ::ROOT::Math::RowOffsets<4> *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::RowOffsets<4>));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::RowOffsets<4>", "Math/MatrixRepresentationsStatic.h", 131,
                  typeid(::ROOT::Math::RowOffsets<4>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLRowOffsetslE4gR_Dictionary, isa_proxy, 0,
                  sizeof(::ROOT::Math::RowOffsets<4>) );
      instance.SetNew(&new_ROOTcLcLMathcLcLRowOffsetslE4gR);
      instance.SetNewArray(&newArray_ROOTcLcLMathcLcLRowOffsetslE4gR);
      instance.SetDelete(&delete_ROOTcLcLMathcLcLRowOffsetslE4gR);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLRowOffsetslE4gR);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLRowOffsetslE4gR);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::RowOffsets<4>","ROOT::Math::RowOffsets<4u>"));
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::RowOffsets<4>*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::RowOffsets<4>*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::RowOffsets<4>*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLRowOffsetslE4gR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::RowOffsets<4>*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLRowOffsetslE4gR_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLRowOffsetslE4gR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLRowOffsetslE3gR_Dictionary();
   static void ROOTcLcLMathcLcLRowOffsetslE3gR_TClassManip(TClass*);
   static void *new_ROOTcLcLMathcLcLRowOffsetslE3gR(void *p = nullptr);
   static void *newArray_ROOTcLcLMathcLcLRowOffsetslE3gR(Long_t size, void *p);
   static void delete_ROOTcLcLMathcLcLRowOffsetslE3gR(void *p);
   static void deleteArray_ROOTcLcLMathcLcLRowOffsetslE3gR(void *p);
   static void destruct_ROOTcLcLMathcLcLRowOffsetslE3gR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::RowOffsets<3>*)
   {
      ::ROOT::Math::RowOffsets<3> *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::RowOffsets<3>));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::RowOffsets<3>", "Math/MatrixRepresentationsStatic.h", 131,
                  typeid(::ROOT::Math::RowOffsets<3>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLRowOffsetslE3gR_Dictionary, isa_proxy, 0,
                  sizeof(::ROOT::Math::RowOffsets<3>) );
      instance.SetNew(&new_ROOTcLcLMathcLcLRowOffsetslE3gR);
      instance.SetNewArray(&newArray_ROOTcLcLMathcLcLRowOffsetslE3gR);
      instance.SetDelete(&delete_ROOTcLcLMathcLcLRowOffsetslE3gR);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLRowOffsetslE3gR);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLRowOffsetslE3gR);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::RowOffsets<3>","ROOT::Math::RowOffsets<3u>"));
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::RowOffsets<3>*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::RowOffsets<3>*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::RowOffsets<3>*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLRowOffsetslE3gR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::RowOffsets<3>*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLRowOffsetslE3gR_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLRowOffsetslE3gR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLRowOffsetslE2gR_Dictionary();
   static void ROOTcLcLMathcLcLRowOffsetslE2gR_TClassManip(TClass*);
   static void *new_ROOTcLcLMathcLcLRowOffsetslE2gR(void *p = nullptr);
   static void *newArray_ROOTcLcLMathcLcLRowOffsetslE2gR(Long_t size, void *p);
   static void delete_ROOTcLcLMathcLcLRowOffsetslE2gR(void *p);
   static void deleteArray_ROOTcLcLMathcLcLRowOffsetslE2gR(void *p);
   static void destruct_ROOTcLcLMathcLcLRowOffsetslE2gR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::RowOffsets<2>*)
   {
      ::ROOT::Math::RowOffsets<2> *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::RowOffsets<2>));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::RowOffsets<2>", "Math/MatrixRepresentationsStatic.h", 131,
                  typeid(::ROOT::Math::RowOffsets<2>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLRowOffsetslE2gR_Dictionary, isa_proxy, 0,
                  sizeof(::ROOT::Math::RowOffsets<2>) );
      instance.SetNew(&new_ROOTcLcLMathcLcLRowOffsetslE2gR);
      instance.SetNewArray(&newArray_ROOTcLcLMathcLcLRowOffsetslE2gR);
      instance.SetDelete(&delete_ROOTcLcLMathcLcLRowOffsetslE2gR);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLRowOffsetslE2gR);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLRowOffsetslE2gR);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::RowOffsets<2>","ROOT::Math::RowOffsets<2u>"));
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::RowOffsets<2>*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::RowOffsets<2>*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::RowOffsets<2>*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLRowOffsetslE2gR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::RowOffsets<2>*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLRowOffsetslE2gR_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLRowOffsetslE2gR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLMatRepSymlEdoublecO2gR_Dictionary();
   static void ROOTcLcLMathcLcLMatRepSymlEdoublecO2gR_TClassManip(TClass*);
   static void *new_ROOTcLcLMathcLcLMatRepSymlEdoublecO2gR(void *p = nullptr);
   static void *newArray_ROOTcLcLMathcLcLMatRepSymlEdoublecO2gR(Long_t size, void *p);
   static void delete_ROOTcLcLMathcLcLMatRepSymlEdoublecO2gR(void *p);
   static void deleteArray_ROOTcLcLMathcLcLMatRepSymlEdoublecO2gR(void *p);
   static void destruct_ROOTcLcLMathcLcLMatRepSymlEdoublecO2gR(void *p);

   // Schema evolution read functions

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::MatRepSym<double,2>*)
   {
      ::ROOT::Math::MatRepSym<double,2> *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::MatRepSym<double,2>));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::MatRepSym<double,2>", "Math/MatrixRepresentationsStatic.h", 213,
                  typeid(::ROOT::Math::MatRepSym<double,2>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLMatRepSymlEdoublecO2gR_Dictionary, isa_proxy, 4,
                  sizeof(::ROOT::Math::MatRepSym<double,2>) );
      instance.SetNew(&new_ROOTcLcLMathcLcLMatRepSymlEdoublecO2gR);
      instance.SetNewArray(&newArray_ROOTcLcLMathcLcLMatRepSymlEdoublecO2gR);
      instance.SetDelete(&delete_ROOTcLcLMathcLcLMatRepSymlEdoublecO2gR);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLMatRepSymlEdoublecO2gR);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLMatRepSymlEdoublecO2gR);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::MatRepSym<double,2>","ROOT::Math::MatRepSym<double, 2u>"));

      ::ROOT::Internal::TSchemaHelper* rule;

      // the io read rules
      std::vector<::ROOT::Internal::TSchemaHelper> readrules(3);
      rule = &readrules[0];
      rule->fSourceClass = "ROOT::Math::MatRepSym<Double32_t,2>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[1];
      rule->fSourceClass = "ROOT::Math::MatRepSym<float,2>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[2];
      rule->fSourceClass = "ROOT::Math::MatRepSym<Float16_t,2>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      instance.SetReadRules( readrules );
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::MatRepSym<double,2>*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::MatRepSym<double,2>*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::MatRepSym<double,2>*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLMatRepSymlEdoublecO2gR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::MatRepSym<double,2>*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLMatRepSymlEdoublecO2gR_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLMatRepSymlEdoublecO2gR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLMatRepSymlEdoublecO3gR_Dictionary();
   static void ROOTcLcLMathcLcLMatRepSymlEdoublecO3gR_TClassManip(TClass*);
   static void *new_ROOTcLcLMathcLcLMatRepSymlEdoublecO3gR(void *p = nullptr);
   static void *newArray_ROOTcLcLMathcLcLMatRepSymlEdoublecO3gR(Long_t size, void *p);
   static void delete_ROOTcLcLMathcLcLMatRepSymlEdoublecO3gR(void *p);
   static void deleteArray_ROOTcLcLMathcLcLMatRepSymlEdoublecO3gR(void *p);
   static void destruct_ROOTcLcLMathcLcLMatRepSymlEdoublecO3gR(void *p);

   // Schema evolution read functions

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::MatRepSym<double,3>*)
   {
      ::ROOT::Math::MatRepSym<double,3> *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::MatRepSym<double,3>));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::MatRepSym<double,3>", "Math/MatrixRepresentationsStatic.h", 213,
                  typeid(::ROOT::Math::MatRepSym<double,3>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLMatRepSymlEdoublecO3gR_Dictionary, isa_proxy, 4,
                  sizeof(::ROOT::Math::MatRepSym<double,3>) );
      instance.SetNew(&new_ROOTcLcLMathcLcLMatRepSymlEdoublecO3gR);
      instance.SetNewArray(&newArray_ROOTcLcLMathcLcLMatRepSymlEdoublecO3gR);
      instance.SetDelete(&delete_ROOTcLcLMathcLcLMatRepSymlEdoublecO3gR);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLMatRepSymlEdoublecO3gR);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLMatRepSymlEdoublecO3gR);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::MatRepSym<double,3>","ROOT::Math::MatRepSym<double, 3u>"));

      ::ROOT::Internal::TSchemaHelper* rule;

      // the io read rules
      std::vector<::ROOT::Internal::TSchemaHelper> readrules(3);
      rule = &readrules[0];
      rule->fSourceClass = "ROOT::Math::MatRepSym<Double32_t,3>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[1];
      rule->fSourceClass = "ROOT::Math::MatRepSym<float,3>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[2];
      rule->fSourceClass = "ROOT::Math::MatRepSym<Float16_t,3>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      instance.SetReadRules( readrules );
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::MatRepSym<double,3>*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::MatRepSym<double,3>*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::MatRepSym<double,3>*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLMatRepSymlEdoublecO3gR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::MatRepSym<double,3>*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLMatRepSymlEdoublecO3gR_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLMatRepSymlEdoublecO3gR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLMatRepSymlEdoublecO4gR_Dictionary();
   static void ROOTcLcLMathcLcLMatRepSymlEdoublecO4gR_TClassManip(TClass*);
   static void *new_ROOTcLcLMathcLcLMatRepSymlEdoublecO4gR(void *p = nullptr);
   static void *newArray_ROOTcLcLMathcLcLMatRepSymlEdoublecO4gR(Long_t size, void *p);
   static void delete_ROOTcLcLMathcLcLMatRepSymlEdoublecO4gR(void *p);
   static void deleteArray_ROOTcLcLMathcLcLMatRepSymlEdoublecO4gR(void *p);
   static void destruct_ROOTcLcLMathcLcLMatRepSymlEdoublecO4gR(void *p);

   // Schema evolution read functions

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::MatRepSym<double,4>*)
   {
      ::ROOT::Math::MatRepSym<double,4> *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::MatRepSym<double,4>));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::MatRepSym<double,4>", "Math/MatrixRepresentationsStatic.h", 213,
                  typeid(::ROOT::Math::MatRepSym<double,4>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLMatRepSymlEdoublecO4gR_Dictionary, isa_proxy, 4,
                  sizeof(::ROOT::Math::MatRepSym<double,4>) );
      instance.SetNew(&new_ROOTcLcLMathcLcLMatRepSymlEdoublecO4gR);
      instance.SetNewArray(&newArray_ROOTcLcLMathcLcLMatRepSymlEdoublecO4gR);
      instance.SetDelete(&delete_ROOTcLcLMathcLcLMatRepSymlEdoublecO4gR);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLMatRepSymlEdoublecO4gR);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLMatRepSymlEdoublecO4gR);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::MatRepSym<double,4>","ROOT::Math::MatRepSym<double, 4u>"));

      ::ROOT::Internal::TSchemaHelper* rule;

      // the io read rules
      std::vector<::ROOT::Internal::TSchemaHelper> readrules(3);
      rule = &readrules[0];
      rule->fSourceClass = "ROOT::Math::MatRepSym<Double32_t,4>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[1];
      rule->fSourceClass = "ROOT::Math::MatRepSym<float,4>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[2];
      rule->fSourceClass = "ROOT::Math::MatRepSym<Float16_t,4>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      instance.SetReadRules( readrules );
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::MatRepSym<double,4>*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::MatRepSym<double,4>*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::MatRepSym<double,4>*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLMatRepSymlEdoublecO4gR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::MatRepSym<double,4>*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLMatRepSymlEdoublecO4gR_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLMatRepSymlEdoublecO4gR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLMatRepSymlEdoublecO5gR_Dictionary();
   static void ROOTcLcLMathcLcLMatRepSymlEdoublecO5gR_TClassManip(TClass*);
   static void *new_ROOTcLcLMathcLcLMatRepSymlEdoublecO5gR(void *p = nullptr);
   static void *newArray_ROOTcLcLMathcLcLMatRepSymlEdoublecO5gR(Long_t size, void *p);
   static void delete_ROOTcLcLMathcLcLMatRepSymlEdoublecO5gR(void *p);
   static void deleteArray_ROOTcLcLMathcLcLMatRepSymlEdoublecO5gR(void *p);
   static void destruct_ROOTcLcLMathcLcLMatRepSymlEdoublecO5gR(void *p);

   // Schema evolution read functions

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::MatRepSym<double,5>*)
   {
      ::ROOT::Math::MatRepSym<double,5> *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::MatRepSym<double,5>));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::MatRepSym<double,5>", "Math/MatrixRepresentationsStatic.h", 213,
                  typeid(::ROOT::Math::MatRepSym<double,5>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLMatRepSymlEdoublecO5gR_Dictionary, isa_proxy, 4,
                  sizeof(::ROOT::Math::MatRepSym<double,5>) );
      instance.SetNew(&new_ROOTcLcLMathcLcLMatRepSymlEdoublecO5gR);
      instance.SetNewArray(&newArray_ROOTcLcLMathcLcLMatRepSymlEdoublecO5gR);
      instance.SetDelete(&delete_ROOTcLcLMathcLcLMatRepSymlEdoublecO5gR);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLMatRepSymlEdoublecO5gR);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLMatRepSymlEdoublecO5gR);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::MatRepSym<double,5>","ROOT::Math::MatRepSym<double, 5u>"));

      ::ROOT::Internal::TSchemaHelper* rule;

      // the io read rules
      std::vector<::ROOT::Internal::TSchemaHelper> readrules(3);
      rule = &readrules[0];
      rule->fSourceClass = "ROOT::Math::MatRepSym<Double32_t,5>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[1];
      rule->fSourceClass = "ROOT::Math::MatRepSym<float,5>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[2];
      rule->fSourceClass = "ROOT::Math::MatRepSym<Float16_t,5>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      instance.SetReadRules( readrules );
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::MatRepSym<double,5>*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::MatRepSym<double,5>*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::MatRepSym<double,5>*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLMatRepSymlEdoublecO5gR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::MatRepSym<double,5>*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLMatRepSymlEdoublecO5gR_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLMatRepSymlEdoublecO5gR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLMatRepSymlEdoublecO6gR_Dictionary();
   static void ROOTcLcLMathcLcLMatRepSymlEdoublecO6gR_TClassManip(TClass*);
   static void *new_ROOTcLcLMathcLcLMatRepSymlEdoublecO6gR(void *p = nullptr);
   static void *newArray_ROOTcLcLMathcLcLMatRepSymlEdoublecO6gR(Long_t size, void *p);
   static void delete_ROOTcLcLMathcLcLMatRepSymlEdoublecO6gR(void *p);
   static void deleteArray_ROOTcLcLMathcLcLMatRepSymlEdoublecO6gR(void *p);
   static void destruct_ROOTcLcLMathcLcLMatRepSymlEdoublecO6gR(void *p);

   // Schema evolution read functions

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::MatRepSym<double,6>*)
   {
      ::ROOT::Math::MatRepSym<double,6> *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::MatRepSym<double,6>));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::MatRepSym<double,6>", "Math/MatrixRepresentationsStatic.h", 213,
                  typeid(::ROOT::Math::MatRepSym<double,6>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLMatRepSymlEdoublecO6gR_Dictionary, isa_proxy, 4,
                  sizeof(::ROOT::Math::MatRepSym<double,6>) );
      instance.SetNew(&new_ROOTcLcLMathcLcLMatRepSymlEdoublecO6gR);
      instance.SetNewArray(&newArray_ROOTcLcLMathcLcLMatRepSymlEdoublecO6gR);
      instance.SetDelete(&delete_ROOTcLcLMathcLcLMatRepSymlEdoublecO6gR);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLMatRepSymlEdoublecO6gR);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLMatRepSymlEdoublecO6gR);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::MatRepSym<double,6>","ROOT::Math::MatRepSym<double, 6u>"));

      ::ROOT::Internal::TSchemaHelper* rule;

      // the io read rules
      std::vector<::ROOT::Internal::TSchemaHelper> readrules(3);
      rule = &readrules[0];
      rule->fSourceClass = "ROOT::Math::MatRepSym<Double32_t,6>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[1];
      rule->fSourceClass = "ROOT::Math::MatRepSym<float,6>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[2];
      rule->fSourceClass = "ROOT::Math::MatRepSym<Float16_t,6>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      instance.SetReadRules( readrules );
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::MatRepSym<double,6>*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::MatRepSym<double,6>*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::MatRepSym<double,6>*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLMatRepSymlEdoublecO6gR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::MatRepSym<double,6>*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLMatRepSymlEdoublecO6gR_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLMatRepSymlEdoublecO6gR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLMatRepSymlEdoublecO7gR_Dictionary();
   static void ROOTcLcLMathcLcLMatRepSymlEdoublecO7gR_TClassManip(TClass*);
   static void *new_ROOTcLcLMathcLcLMatRepSymlEdoublecO7gR(void *p = nullptr);
   static void *newArray_ROOTcLcLMathcLcLMatRepSymlEdoublecO7gR(Long_t size, void *p);
   static void delete_ROOTcLcLMathcLcLMatRepSymlEdoublecO7gR(void *p);
   static void deleteArray_ROOTcLcLMathcLcLMatRepSymlEdoublecO7gR(void *p);
   static void destruct_ROOTcLcLMathcLcLMatRepSymlEdoublecO7gR(void *p);

   // Schema evolution read functions

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::MatRepSym<double,7>*)
   {
      ::ROOT::Math::MatRepSym<double,7> *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::MatRepSym<double,7>));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::MatRepSym<double,7>", "Math/MatrixRepresentationsStatic.h", 213,
                  typeid(::ROOT::Math::MatRepSym<double,7>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLMatRepSymlEdoublecO7gR_Dictionary, isa_proxy, 4,
                  sizeof(::ROOT::Math::MatRepSym<double,7>) );
      instance.SetNew(&new_ROOTcLcLMathcLcLMatRepSymlEdoublecO7gR);
      instance.SetNewArray(&newArray_ROOTcLcLMathcLcLMatRepSymlEdoublecO7gR);
      instance.SetDelete(&delete_ROOTcLcLMathcLcLMatRepSymlEdoublecO7gR);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLMatRepSymlEdoublecO7gR);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLMatRepSymlEdoublecO7gR);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::MatRepSym<double,7>","ROOT::Math::MatRepSym<double, 7u>"));

      ::ROOT::Internal::TSchemaHelper* rule;

      // the io read rules
      std::vector<::ROOT::Internal::TSchemaHelper> readrules(3);
      rule = &readrules[0];
      rule->fSourceClass = "ROOT::Math::MatRepSym<Double32_t,7>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[1];
      rule->fSourceClass = "ROOT::Math::MatRepSym<float,7>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[2];
      rule->fSourceClass = "ROOT::Math::MatRepSym<Float16_t,7>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      instance.SetReadRules( readrules );
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::MatRepSym<double,7>*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::MatRepSym<double,7>*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::MatRepSym<double,7>*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLMatRepSymlEdoublecO7gR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::MatRepSym<double,7>*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLMatRepSymlEdoublecO7gR_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLMatRepSymlEdoublecO7gR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLMatRepSymlEfloatcO2gR_Dictionary();
   static void ROOTcLcLMathcLcLMatRepSymlEfloatcO2gR_TClassManip(TClass*);
   static void *new_ROOTcLcLMathcLcLMatRepSymlEfloatcO2gR(void *p = nullptr);
   static void *newArray_ROOTcLcLMathcLcLMatRepSymlEfloatcO2gR(Long_t size, void *p);
   static void delete_ROOTcLcLMathcLcLMatRepSymlEfloatcO2gR(void *p);
   static void deleteArray_ROOTcLcLMathcLcLMatRepSymlEfloatcO2gR(void *p);
   static void destruct_ROOTcLcLMathcLcLMatRepSymlEfloatcO2gR(void *p);

   // Schema evolution read functions

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::MatRepSym<float,2>*)
   {
      ::ROOT::Math::MatRepSym<float,2> *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::MatRepSym<float,2>));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::MatRepSym<float,2>", "Math/MatrixRepresentationsStatic.h", 213,
                  typeid(::ROOT::Math::MatRepSym<float,2>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLMatRepSymlEfloatcO2gR_Dictionary, isa_proxy, 4,
                  sizeof(::ROOT::Math::MatRepSym<float,2>) );
      instance.SetNew(&new_ROOTcLcLMathcLcLMatRepSymlEfloatcO2gR);
      instance.SetNewArray(&newArray_ROOTcLcLMathcLcLMatRepSymlEfloatcO2gR);
      instance.SetDelete(&delete_ROOTcLcLMathcLcLMatRepSymlEfloatcO2gR);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLMatRepSymlEfloatcO2gR);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLMatRepSymlEfloatcO2gR);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::MatRepSym<float,2>","ROOT::Math::MatRepSym<float, 2u>"));

      ::ROOT::Internal::TSchemaHelper* rule;

      // the io read rules
      std::vector<::ROOT::Internal::TSchemaHelper> readrules(3);
      rule = &readrules[0];
      rule->fSourceClass = "ROOT::Math::MatRepSym<double,2>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[1];
      rule->fSourceClass = "ROOT::Math::MatRepSym<Double32_t,2>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[2];
      rule->fSourceClass = "ROOT::Math::MatRepSym<Float16_t,2>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      instance.SetReadRules( readrules );
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::MatRepSym<float,2>*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::MatRepSym<float,2>*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::MatRepSym<float,2>*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLMatRepSymlEfloatcO2gR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::MatRepSym<float,2>*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLMatRepSymlEfloatcO2gR_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLMatRepSymlEfloatcO2gR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLMatRepSymlEfloatcO3gR_Dictionary();
   static void ROOTcLcLMathcLcLMatRepSymlEfloatcO3gR_TClassManip(TClass*);
   static void *new_ROOTcLcLMathcLcLMatRepSymlEfloatcO3gR(void *p = nullptr);
   static void *newArray_ROOTcLcLMathcLcLMatRepSymlEfloatcO3gR(Long_t size, void *p);
   static void delete_ROOTcLcLMathcLcLMatRepSymlEfloatcO3gR(void *p);
   static void deleteArray_ROOTcLcLMathcLcLMatRepSymlEfloatcO3gR(void *p);
   static void destruct_ROOTcLcLMathcLcLMatRepSymlEfloatcO3gR(void *p);

   // Schema evolution read functions

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::MatRepSym<float,3>*)
   {
      ::ROOT::Math::MatRepSym<float,3> *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::MatRepSym<float,3>));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::MatRepSym<float,3>", "Math/MatrixRepresentationsStatic.h", 213,
                  typeid(::ROOT::Math::MatRepSym<float,3>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLMatRepSymlEfloatcO3gR_Dictionary, isa_proxy, 4,
                  sizeof(::ROOT::Math::MatRepSym<float,3>) );
      instance.SetNew(&new_ROOTcLcLMathcLcLMatRepSymlEfloatcO3gR);
      instance.SetNewArray(&newArray_ROOTcLcLMathcLcLMatRepSymlEfloatcO3gR);
      instance.SetDelete(&delete_ROOTcLcLMathcLcLMatRepSymlEfloatcO3gR);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLMatRepSymlEfloatcO3gR);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLMatRepSymlEfloatcO3gR);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::MatRepSym<float,3>","ROOT::Math::MatRepSym<float, 3u>"));

      ::ROOT::Internal::TSchemaHelper* rule;

      // the io read rules
      std::vector<::ROOT::Internal::TSchemaHelper> readrules(3);
      rule = &readrules[0];
      rule->fSourceClass = "ROOT::Math::MatRepSym<double,3>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[1];
      rule->fSourceClass = "ROOT::Math::MatRepSym<Double32_t,3>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[2];
      rule->fSourceClass = "ROOT::Math::MatRepSym<Float16_t,3>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      instance.SetReadRules( readrules );
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::MatRepSym<float,3>*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::MatRepSym<float,3>*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::MatRepSym<float,3>*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLMatRepSymlEfloatcO3gR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::MatRepSym<float,3>*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLMatRepSymlEfloatcO3gR_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLMatRepSymlEfloatcO3gR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLMatRepSymlEfloatcO4gR_Dictionary();
   static void ROOTcLcLMathcLcLMatRepSymlEfloatcO4gR_TClassManip(TClass*);
   static void *new_ROOTcLcLMathcLcLMatRepSymlEfloatcO4gR(void *p = nullptr);
   static void *newArray_ROOTcLcLMathcLcLMatRepSymlEfloatcO4gR(Long_t size, void *p);
   static void delete_ROOTcLcLMathcLcLMatRepSymlEfloatcO4gR(void *p);
   static void deleteArray_ROOTcLcLMathcLcLMatRepSymlEfloatcO4gR(void *p);
   static void destruct_ROOTcLcLMathcLcLMatRepSymlEfloatcO4gR(void *p);

   // Schema evolution read functions

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::MatRepSym<float,4>*)
   {
      ::ROOT::Math::MatRepSym<float,4> *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::MatRepSym<float,4>));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::MatRepSym<float,4>", "Math/MatrixRepresentationsStatic.h", 213,
                  typeid(::ROOT::Math::MatRepSym<float,4>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLMatRepSymlEfloatcO4gR_Dictionary, isa_proxy, 4,
                  sizeof(::ROOT::Math::MatRepSym<float,4>) );
      instance.SetNew(&new_ROOTcLcLMathcLcLMatRepSymlEfloatcO4gR);
      instance.SetNewArray(&newArray_ROOTcLcLMathcLcLMatRepSymlEfloatcO4gR);
      instance.SetDelete(&delete_ROOTcLcLMathcLcLMatRepSymlEfloatcO4gR);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLMatRepSymlEfloatcO4gR);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLMatRepSymlEfloatcO4gR);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::MatRepSym<float,4>","ROOT::Math::MatRepSym<float, 4u>"));

      ::ROOT::Internal::TSchemaHelper* rule;

      // the io read rules
      std::vector<::ROOT::Internal::TSchemaHelper> readrules(3);
      rule = &readrules[0];
      rule->fSourceClass = "ROOT::Math::MatRepSym<double,4>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[1];
      rule->fSourceClass = "ROOT::Math::MatRepSym<Double32_t,4>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[2];
      rule->fSourceClass = "ROOT::Math::MatRepSym<Float16_t,4>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      instance.SetReadRules( readrules );
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::MatRepSym<float,4>*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::MatRepSym<float,4>*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::MatRepSym<float,4>*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLMatRepSymlEfloatcO4gR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::MatRepSym<float,4>*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLMatRepSymlEfloatcO4gR_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLMatRepSymlEfloatcO4gR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLMatRepSymlEfloatcO5gR_Dictionary();
   static void ROOTcLcLMathcLcLMatRepSymlEfloatcO5gR_TClassManip(TClass*);
   static void *new_ROOTcLcLMathcLcLMatRepSymlEfloatcO5gR(void *p = nullptr);
   static void *newArray_ROOTcLcLMathcLcLMatRepSymlEfloatcO5gR(Long_t size, void *p);
   static void delete_ROOTcLcLMathcLcLMatRepSymlEfloatcO5gR(void *p);
   static void deleteArray_ROOTcLcLMathcLcLMatRepSymlEfloatcO5gR(void *p);
   static void destruct_ROOTcLcLMathcLcLMatRepSymlEfloatcO5gR(void *p);

   // Schema evolution read functions

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::MatRepSym<float,5>*)
   {
      ::ROOT::Math::MatRepSym<float,5> *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::MatRepSym<float,5>));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::MatRepSym<float,5>", "Math/MatrixRepresentationsStatic.h", 213,
                  typeid(::ROOT::Math::MatRepSym<float,5>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLMatRepSymlEfloatcO5gR_Dictionary, isa_proxy, 4,
                  sizeof(::ROOT::Math::MatRepSym<float,5>) );
      instance.SetNew(&new_ROOTcLcLMathcLcLMatRepSymlEfloatcO5gR);
      instance.SetNewArray(&newArray_ROOTcLcLMathcLcLMatRepSymlEfloatcO5gR);
      instance.SetDelete(&delete_ROOTcLcLMathcLcLMatRepSymlEfloatcO5gR);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLMatRepSymlEfloatcO5gR);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLMatRepSymlEfloatcO5gR);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::MatRepSym<float,5>","ROOT::Math::MatRepSym<float, 5u>"));

      ::ROOT::Internal::TSchemaHelper* rule;

      // the io read rules
      std::vector<::ROOT::Internal::TSchemaHelper> readrules(3);
      rule = &readrules[0];
      rule->fSourceClass = "ROOT::Math::MatRepSym<double,5>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[1];
      rule->fSourceClass = "ROOT::Math::MatRepSym<Double32_t,5>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[2];
      rule->fSourceClass = "ROOT::Math::MatRepSym<Float16_t,5>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      instance.SetReadRules( readrules );
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::MatRepSym<float,5>*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::MatRepSym<float,5>*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::MatRepSym<float,5>*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLMatRepSymlEfloatcO5gR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::MatRepSym<float,5>*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLMatRepSymlEfloatcO5gR_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLMatRepSymlEfloatcO5gR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLMatRepSymlEfloatcO6gR_Dictionary();
   static void ROOTcLcLMathcLcLMatRepSymlEfloatcO6gR_TClassManip(TClass*);
   static void *new_ROOTcLcLMathcLcLMatRepSymlEfloatcO6gR(void *p = nullptr);
   static void *newArray_ROOTcLcLMathcLcLMatRepSymlEfloatcO6gR(Long_t size, void *p);
   static void delete_ROOTcLcLMathcLcLMatRepSymlEfloatcO6gR(void *p);
   static void deleteArray_ROOTcLcLMathcLcLMatRepSymlEfloatcO6gR(void *p);
   static void destruct_ROOTcLcLMathcLcLMatRepSymlEfloatcO6gR(void *p);

   // Schema evolution read functions

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::MatRepSym<float,6>*)
   {
      ::ROOT::Math::MatRepSym<float,6> *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::MatRepSym<float,6>));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::MatRepSym<float,6>", "Math/MatrixRepresentationsStatic.h", 213,
                  typeid(::ROOT::Math::MatRepSym<float,6>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLMatRepSymlEfloatcO6gR_Dictionary, isa_proxy, 4,
                  sizeof(::ROOT::Math::MatRepSym<float,6>) );
      instance.SetNew(&new_ROOTcLcLMathcLcLMatRepSymlEfloatcO6gR);
      instance.SetNewArray(&newArray_ROOTcLcLMathcLcLMatRepSymlEfloatcO6gR);
      instance.SetDelete(&delete_ROOTcLcLMathcLcLMatRepSymlEfloatcO6gR);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLMatRepSymlEfloatcO6gR);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLMatRepSymlEfloatcO6gR);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::MatRepSym<float,6>","ROOT::Math::MatRepSym<float, 6u>"));

      ::ROOT::Internal::TSchemaHelper* rule;

      // the io read rules
      std::vector<::ROOT::Internal::TSchemaHelper> readrules(3);
      rule = &readrules[0];
      rule->fSourceClass = "ROOT::Math::MatRepSym<double,6>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[1];
      rule->fSourceClass = "ROOT::Math::MatRepSym<Double32_t,6>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[2];
      rule->fSourceClass = "ROOT::Math::MatRepSym<Float16_t,6>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      instance.SetReadRules( readrules );
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::MatRepSym<float,6>*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::MatRepSym<float,6>*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::MatRepSym<float,6>*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLMatRepSymlEfloatcO6gR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::MatRepSym<float,6>*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLMatRepSymlEfloatcO6gR_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLMatRepSymlEfloatcO6gR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLMatRepSymlEfloatcO7gR_Dictionary();
   static void ROOTcLcLMathcLcLMatRepSymlEfloatcO7gR_TClassManip(TClass*);
   static void *new_ROOTcLcLMathcLcLMatRepSymlEfloatcO7gR(void *p = nullptr);
   static void *newArray_ROOTcLcLMathcLcLMatRepSymlEfloatcO7gR(Long_t size, void *p);
   static void delete_ROOTcLcLMathcLcLMatRepSymlEfloatcO7gR(void *p);
   static void deleteArray_ROOTcLcLMathcLcLMatRepSymlEfloatcO7gR(void *p);
   static void destruct_ROOTcLcLMathcLcLMatRepSymlEfloatcO7gR(void *p);

   // Schema evolution read functions

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::MatRepSym<float,7>*)
   {
      ::ROOT::Math::MatRepSym<float,7> *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::MatRepSym<float,7>));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::MatRepSym<float,7>", "Math/MatrixRepresentationsStatic.h", 213,
                  typeid(::ROOT::Math::MatRepSym<float,7>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLMatRepSymlEfloatcO7gR_Dictionary, isa_proxy, 4,
                  sizeof(::ROOT::Math::MatRepSym<float,7>) );
      instance.SetNew(&new_ROOTcLcLMathcLcLMatRepSymlEfloatcO7gR);
      instance.SetNewArray(&newArray_ROOTcLcLMathcLcLMatRepSymlEfloatcO7gR);
      instance.SetDelete(&delete_ROOTcLcLMathcLcLMatRepSymlEfloatcO7gR);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLMatRepSymlEfloatcO7gR);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLMatRepSymlEfloatcO7gR);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::MatRepSym<float,7>","ROOT::Math::MatRepSym<float, 7u>"));

      ::ROOT::Internal::TSchemaHelper* rule;

      // the io read rules
      std::vector<::ROOT::Internal::TSchemaHelper> readrules(3);
      rule = &readrules[0];
      rule->fSourceClass = "ROOT::Math::MatRepSym<double,7>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[1];
      rule->fSourceClass = "ROOT::Math::MatRepSym<Double32_t,7>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[2];
      rule->fSourceClass = "ROOT::Math::MatRepSym<Float16_t,7>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      instance.SetReadRules( readrules );
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::MatRepSym<float,7>*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::MatRepSym<float,7>*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::MatRepSym<float,7>*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLMatRepSymlEfloatcO7gR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::MatRepSym<float,7>*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLMatRepSymlEfloatcO7gR_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLMatRepSymlEfloatcO7gR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSVectorlEdoublecO2gR_Dictionary();
   static void ROOTcLcLMathcLcLSVectorlEdoublecO2gR_TClassManip(TClass*);
   static void *new_ROOTcLcLMathcLcLSVectorlEdoublecO2gR(void *p = nullptr);
   static void *newArray_ROOTcLcLMathcLcLSVectorlEdoublecO2gR(Long_t size, void *p);
   static void delete_ROOTcLcLMathcLcLSVectorlEdoublecO2gR(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSVectorlEdoublecO2gR(void *p);
   static void destruct_ROOTcLcLMathcLcLSVectorlEdoublecO2gR(void *p);

   // Schema evolution read functions

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SVector<double,2>*)
   {
      ::ROOT::Math::SVector<double,2> *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SVector<double,2>));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SVector<double,2>", "Math/SVector.h", 75,
                  typeid(::ROOT::Math::SVector<double,2>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSVectorlEdoublecO2gR_Dictionary, isa_proxy, 4,
                  sizeof(::ROOT::Math::SVector<double,2>) );
      instance.SetNew(&new_ROOTcLcLMathcLcLSVectorlEdoublecO2gR);
      instance.SetNewArray(&newArray_ROOTcLcLMathcLcLSVectorlEdoublecO2gR);
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSVectorlEdoublecO2gR);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSVectorlEdoublecO2gR);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSVectorlEdoublecO2gR);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SVector<double,2>","ROOT::Math::SVector<double, 2u>"));

      ::ROOT::Internal::TSchemaHelper* rule;

      // the io read rules
      std::vector<::ROOT::Internal::TSchemaHelper> readrules(3);
      rule = &readrules[0];
      rule->fSourceClass = "ROOT::Math::SVector<Double32_t,2>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[1];
      rule->fSourceClass = "ROOT::Math::SVector<float,2>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[2];
      rule->fSourceClass = "ROOT::Math::SVector<Float16_t,2>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      instance.SetReadRules( readrules );
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::SVector<double,2>*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::SVector<double,2>*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SVector<double,2>*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLSVectorlEdoublecO2gR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SVector<double,2>*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLSVectorlEdoublecO2gR_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLSVectorlEdoublecO2gR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSVectorlEdoublecO3gR_Dictionary();
   static void ROOTcLcLMathcLcLSVectorlEdoublecO3gR_TClassManip(TClass*);
   static void *new_ROOTcLcLMathcLcLSVectorlEdoublecO3gR(void *p = nullptr);
   static void *newArray_ROOTcLcLMathcLcLSVectorlEdoublecO3gR(Long_t size, void *p);
   static void delete_ROOTcLcLMathcLcLSVectorlEdoublecO3gR(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSVectorlEdoublecO3gR(void *p);
   static void destruct_ROOTcLcLMathcLcLSVectorlEdoublecO3gR(void *p);

   // Schema evolution read functions

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SVector<double,3>*)
   {
      ::ROOT::Math::SVector<double,3> *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SVector<double,3>));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SVector<double,3>", "Math/SVector.h", 75,
                  typeid(::ROOT::Math::SVector<double,3>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSVectorlEdoublecO3gR_Dictionary, isa_proxy, 4,
                  sizeof(::ROOT::Math::SVector<double,3>) );
      instance.SetNew(&new_ROOTcLcLMathcLcLSVectorlEdoublecO3gR);
      instance.SetNewArray(&newArray_ROOTcLcLMathcLcLSVectorlEdoublecO3gR);
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSVectorlEdoublecO3gR);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSVectorlEdoublecO3gR);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSVectorlEdoublecO3gR);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SVector<double,3>","ROOT::Math::SVector<double, 3u>"));

      ::ROOT::Internal::TSchemaHelper* rule;

      // the io read rules
      std::vector<::ROOT::Internal::TSchemaHelper> readrules(3);
      rule = &readrules[0];
      rule->fSourceClass = "ROOT::Math::SVector<Double32_t,3>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[1];
      rule->fSourceClass = "ROOT::Math::SVector<float,3>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[2];
      rule->fSourceClass = "ROOT::Math::SVector<Float16_t,3>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      instance.SetReadRules( readrules );
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::SVector<double,3>*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::SVector<double,3>*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SVector<double,3>*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLSVectorlEdoublecO3gR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SVector<double,3>*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLSVectorlEdoublecO3gR_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLSVectorlEdoublecO3gR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSVectorlEdoublecO4gR_Dictionary();
   static void ROOTcLcLMathcLcLSVectorlEdoublecO4gR_TClassManip(TClass*);
   static void *new_ROOTcLcLMathcLcLSVectorlEdoublecO4gR(void *p = nullptr);
   static void *newArray_ROOTcLcLMathcLcLSVectorlEdoublecO4gR(Long_t size, void *p);
   static void delete_ROOTcLcLMathcLcLSVectorlEdoublecO4gR(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSVectorlEdoublecO4gR(void *p);
   static void destruct_ROOTcLcLMathcLcLSVectorlEdoublecO4gR(void *p);

   // Schema evolution read functions

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SVector<double,4>*)
   {
      ::ROOT::Math::SVector<double,4> *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SVector<double,4>));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SVector<double,4>", "Math/SVector.h", 75,
                  typeid(::ROOT::Math::SVector<double,4>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSVectorlEdoublecO4gR_Dictionary, isa_proxy, 4,
                  sizeof(::ROOT::Math::SVector<double,4>) );
      instance.SetNew(&new_ROOTcLcLMathcLcLSVectorlEdoublecO4gR);
      instance.SetNewArray(&newArray_ROOTcLcLMathcLcLSVectorlEdoublecO4gR);
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSVectorlEdoublecO4gR);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSVectorlEdoublecO4gR);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSVectorlEdoublecO4gR);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SVector<double,4>","ROOT::Math::SVector<double, 4u>"));

      ::ROOT::Internal::TSchemaHelper* rule;

      // the io read rules
      std::vector<::ROOT::Internal::TSchemaHelper> readrules(3);
      rule = &readrules[0];
      rule->fSourceClass = "ROOT::Math::SVector<Double32_t,4>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[1];
      rule->fSourceClass = "ROOT::Math::SVector<float,4>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[2];
      rule->fSourceClass = "ROOT::Math::SVector<Float16_t,4>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      instance.SetReadRules( readrules );
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::SVector<double,4>*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::SVector<double,4>*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SVector<double,4>*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLSVectorlEdoublecO4gR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SVector<double,4>*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLSVectorlEdoublecO4gR_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLSVectorlEdoublecO4gR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSVectorlEdoublecO5gR_Dictionary();
   static void ROOTcLcLMathcLcLSVectorlEdoublecO5gR_TClassManip(TClass*);
   static void *new_ROOTcLcLMathcLcLSVectorlEdoublecO5gR(void *p = nullptr);
   static void *newArray_ROOTcLcLMathcLcLSVectorlEdoublecO5gR(Long_t size, void *p);
   static void delete_ROOTcLcLMathcLcLSVectorlEdoublecO5gR(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSVectorlEdoublecO5gR(void *p);
   static void destruct_ROOTcLcLMathcLcLSVectorlEdoublecO5gR(void *p);

   // Schema evolution read functions

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SVector<double,5>*)
   {
      ::ROOT::Math::SVector<double,5> *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SVector<double,5>));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SVector<double,5>", "Math/SVector.h", 75,
                  typeid(::ROOT::Math::SVector<double,5>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSVectorlEdoublecO5gR_Dictionary, isa_proxy, 4,
                  sizeof(::ROOT::Math::SVector<double,5>) );
      instance.SetNew(&new_ROOTcLcLMathcLcLSVectorlEdoublecO5gR);
      instance.SetNewArray(&newArray_ROOTcLcLMathcLcLSVectorlEdoublecO5gR);
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSVectorlEdoublecO5gR);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSVectorlEdoublecO5gR);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSVectorlEdoublecO5gR);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SVector<double,5>","ROOT::Math::SVector<double, 5u>"));

      ::ROOT::Internal::TSchemaHelper* rule;

      // the io read rules
      std::vector<::ROOT::Internal::TSchemaHelper> readrules(3);
      rule = &readrules[0];
      rule->fSourceClass = "ROOT::Math::SVector<Double32_t,5>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[1];
      rule->fSourceClass = "ROOT::Math::SVector<float,5>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[2];
      rule->fSourceClass = "ROOT::Math::SVector<Float16_t,5>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      instance.SetReadRules( readrules );
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::SVector<double,5>*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::SVector<double,5>*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SVector<double,5>*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLSVectorlEdoublecO5gR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SVector<double,5>*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLSVectorlEdoublecO5gR_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLSVectorlEdoublecO5gR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSVectorlEdoublecO6gR_Dictionary();
   static void ROOTcLcLMathcLcLSVectorlEdoublecO6gR_TClassManip(TClass*);
   static void *new_ROOTcLcLMathcLcLSVectorlEdoublecO6gR(void *p = nullptr);
   static void *newArray_ROOTcLcLMathcLcLSVectorlEdoublecO6gR(Long_t size, void *p);
   static void delete_ROOTcLcLMathcLcLSVectorlEdoublecO6gR(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSVectorlEdoublecO6gR(void *p);
   static void destruct_ROOTcLcLMathcLcLSVectorlEdoublecO6gR(void *p);

   // Schema evolution read functions

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SVector<double,6>*)
   {
      ::ROOT::Math::SVector<double,6> *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SVector<double,6>));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SVector<double,6>", "Math/SVector.h", 75,
                  typeid(::ROOT::Math::SVector<double,6>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSVectorlEdoublecO6gR_Dictionary, isa_proxy, 4,
                  sizeof(::ROOT::Math::SVector<double,6>) );
      instance.SetNew(&new_ROOTcLcLMathcLcLSVectorlEdoublecO6gR);
      instance.SetNewArray(&newArray_ROOTcLcLMathcLcLSVectorlEdoublecO6gR);
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSVectorlEdoublecO6gR);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSVectorlEdoublecO6gR);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSVectorlEdoublecO6gR);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SVector<double,6>","ROOT::Math::SVector<double, 6u>"));

      ::ROOT::Internal::TSchemaHelper* rule;

      // the io read rules
      std::vector<::ROOT::Internal::TSchemaHelper> readrules(3);
      rule = &readrules[0];
      rule->fSourceClass = "ROOT::Math::SVector<Double32_t,6>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[1];
      rule->fSourceClass = "ROOT::Math::SVector<float,6>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[2];
      rule->fSourceClass = "ROOT::Math::SVector<Float16_t,6>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      instance.SetReadRules( readrules );
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::SVector<double,6>*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::SVector<double,6>*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SVector<double,6>*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLSVectorlEdoublecO6gR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SVector<double,6>*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLSVectorlEdoublecO6gR_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLSVectorlEdoublecO6gR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSVectorlEdoublecO7gR_Dictionary();
   static void ROOTcLcLMathcLcLSVectorlEdoublecO7gR_TClassManip(TClass*);
   static void *new_ROOTcLcLMathcLcLSVectorlEdoublecO7gR(void *p = nullptr);
   static void *newArray_ROOTcLcLMathcLcLSVectorlEdoublecO7gR(Long_t size, void *p);
   static void delete_ROOTcLcLMathcLcLSVectorlEdoublecO7gR(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSVectorlEdoublecO7gR(void *p);
   static void destruct_ROOTcLcLMathcLcLSVectorlEdoublecO7gR(void *p);

   // Schema evolution read functions

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SVector<double,7>*)
   {
      ::ROOT::Math::SVector<double,7> *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SVector<double,7>));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SVector<double,7>", "Math/SVector.h", 75,
                  typeid(::ROOT::Math::SVector<double,7>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSVectorlEdoublecO7gR_Dictionary, isa_proxy, 4,
                  sizeof(::ROOT::Math::SVector<double,7>) );
      instance.SetNew(&new_ROOTcLcLMathcLcLSVectorlEdoublecO7gR);
      instance.SetNewArray(&newArray_ROOTcLcLMathcLcLSVectorlEdoublecO7gR);
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSVectorlEdoublecO7gR);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSVectorlEdoublecO7gR);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSVectorlEdoublecO7gR);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SVector<double,7>","ROOT::Math::SVector<double, 7u>"));

      ::ROOT::Internal::TSchemaHelper* rule;

      // the io read rules
      std::vector<::ROOT::Internal::TSchemaHelper> readrules(3);
      rule = &readrules[0];
      rule->fSourceClass = "ROOT::Math::SVector<Double32_t,7>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[1];
      rule->fSourceClass = "ROOT::Math::SVector<float,7>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[2];
      rule->fSourceClass = "ROOT::Math::SVector<Float16_t,7>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      instance.SetReadRules( readrules );
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::SVector<double,7>*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::SVector<double,7>*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SVector<double,7>*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLSVectorlEdoublecO7gR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SVector<double,7>*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLSVectorlEdoublecO7gR_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLSVectorlEdoublecO7gR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSVectorlEfloatcO2gR_Dictionary();
   static void ROOTcLcLMathcLcLSVectorlEfloatcO2gR_TClassManip(TClass*);
   static void *new_ROOTcLcLMathcLcLSVectorlEfloatcO2gR(void *p = nullptr);
   static void *newArray_ROOTcLcLMathcLcLSVectorlEfloatcO2gR(Long_t size, void *p);
   static void delete_ROOTcLcLMathcLcLSVectorlEfloatcO2gR(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSVectorlEfloatcO2gR(void *p);
   static void destruct_ROOTcLcLMathcLcLSVectorlEfloatcO2gR(void *p);

   // Schema evolution read functions

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SVector<float,2>*)
   {
      ::ROOT::Math::SVector<float,2> *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SVector<float,2>));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SVector<float,2>", "Math/SVector.h", 75,
                  typeid(::ROOT::Math::SVector<float,2>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSVectorlEfloatcO2gR_Dictionary, isa_proxy, 4,
                  sizeof(::ROOT::Math::SVector<float,2>) );
      instance.SetNew(&new_ROOTcLcLMathcLcLSVectorlEfloatcO2gR);
      instance.SetNewArray(&newArray_ROOTcLcLMathcLcLSVectorlEfloatcO2gR);
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSVectorlEfloatcO2gR);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSVectorlEfloatcO2gR);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSVectorlEfloatcO2gR);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SVector<float,2>","ROOT::Math::SVector<float, 2u>"));

      ::ROOT::Internal::TSchemaHelper* rule;

      // the io read rules
      std::vector<::ROOT::Internal::TSchemaHelper> readrules(3);
      rule = &readrules[0];
      rule->fSourceClass = "ROOT::Math::SVector<double,2>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[1];
      rule->fSourceClass = "ROOT::Math::SVector<Double32_t,2>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[2];
      rule->fSourceClass = "ROOT::Math::SVector<Float16_t,2>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      instance.SetReadRules( readrules );
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::SVector<float,2>*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::SVector<float,2>*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SVector<float,2>*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLSVectorlEfloatcO2gR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SVector<float,2>*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLSVectorlEfloatcO2gR_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLSVectorlEfloatcO2gR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSVectorlEfloatcO3gR_Dictionary();
   static void ROOTcLcLMathcLcLSVectorlEfloatcO3gR_TClassManip(TClass*);
   static void *new_ROOTcLcLMathcLcLSVectorlEfloatcO3gR(void *p = nullptr);
   static void *newArray_ROOTcLcLMathcLcLSVectorlEfloatcO3gR(Long_t size, void *p);
   static void delete_ROOTcLcLMathcLcLSVectorlEfloatcO3gR(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSVectorlEfloatcO3gR(void *p);
   static void destruct_ROOTcLcLMathcLcLSVectorlEfloatcO3gR(void *p);

   // Schema evolution read functions

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SVector<float,3>*)
   {
      ::ROOT::Math::SVector<float,3> *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SVector<float,3>));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SVector<float,3>", "Math/SVector.h", 75,
                  typeid(::ROOT::Math::SVector<float,3>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSVectorlEfloatcO3gR_Dictionary, isa_proxy, 4,
                  sizeof(::ROOT::Math::SVector<float,3>) );
      instance.SetNew(&new_ROOTcLcLMathcLcLSVectorlEfloatcO3gR);
      instance.SetNewArray(&newArray_ROOTcLcLMathcLcLSVectorlEfloatcO3gR);
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSVectorlEfloatcO3gR);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSVectorlEfloatcO3gR);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSVectorlEfloatcO3gR);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SVector<float,3>","ROOT::Math::SVector<float, 3u>"));

      ::ROOT::Internal::TSchemaHelper* rule;

      // the io read rules
      std::vector<::ROOT::Internal::TSchemaHelper> readrules(3);
      rule = &readrules[0];
      rule->fSourceClass = "ROOT::Math::SVector<double,3>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[1];
      rule->fSourceClass = "ROOT::Math::SVector<Double32_t,3>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[2];
      rule->fSourceClass = "ROOT::Math::SVector<Float16_t,3>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      instance.SetReadRules( readrules );
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::SVector<float,3>*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::SVector<float,3>*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SVector<float,3>*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLSVectorlEfloatcO3gR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SVector<float,3>*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLSVectorlEfloatcO3gR_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLSVectorlEfloatcO3gR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSVectorlEfloatcO4gR_Dictionary();
   static void ROOTcLcLMathcLcLSVectorlEfloatcO4gR_TClassManip(TClass*);
   static void *new_ROOTcLcLMathcLcLSVectorlEfloatcO4gR(void *p = nullptr);
   static void *newArray_ROOTcLcLMathcLcLSVectorlEfloatcO4gR(Long_t size, void *p);
   static void delete_ROOTcLcLMathcLcLSVectorlEfloatcO4gR(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSVectorlEfloatcO4gR(void *p);
   static void destruct_ROOTcLcLMathcLcLSVectorlEfloatcO4gR(void *p);

   // Schema evolution read functions

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SVector<float,4>*)
   {
      ::ROOT::Math::SVector<float,4> *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SVector<float,4>));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SVector<float,4>", "Math/SVector.h", 75,
                  typeid(::ROOT::Math::SVector<float,4>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSVectorlEfloatcO4gR_Dictionary, isa_proxy, 4,
                  sizeof(::ROOT::Math::SVector<float,4>) );
      instance.SetNew(&new_ROOTcLcLMathcLcLSVectorlEfloatcO4gR);
      instance.SetNewArray(&newArray_ROOTcLcLMathcLcLSVectorlEfloatcO4gR);
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSVectorlEfloatcO4gR);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSVectorlEfloatcO4gR);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSVectorlEfloatcO4gR);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SVector<float,4>","ROOT::Math::SVector<float, 4u>"));

      ::ROOT::Internal::TSchemaHelper* rule;

      // the io read rules
      std::vector<::ROOT::Internal::TSchemaHelper> readrules(3);
      rule = &readrules[0];
      rule->fSourceClass = "ROOT::Math::SVector<double,4>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[1];
      rule->fSourceClass = "ROOT::Math::SVector<Double32_t,4>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[2];
      rule->fSourceClass = "ROOT::Math::SVector<Float16_t,4>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      instance.SetReadRules( readrules );
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::SVector<float,4>*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::SVector<float,4>*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SVector<float,4>*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLSVectorlEfloatcO4gR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SVector<float,4>*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLSVectorlEfloatcO4gR_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLSVectorlEfloatcO4gR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSVectorlEfloatcO5gR_Dictionary();
   static void ROOTcLcLMathcLcLSVectorlEfloatcO5gR_TClassManip(TClass*);
   static void *new_ROOTcLcLMathcLcLSVectorlEfloatcO5gR(void *p = nullptr);
   static void *newArray_ROOTcLcLMathcLcLSVectorlEfloatcO5gR(Long_t size, void *p);
   static void delete_ROOTcLcLMathcLcLSVectorlEfloatcO5gR(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSVectorlEfloatcO5gR(void *p);
   static void destruct_ROOTcLcLMathcLcLSVectorlEfloatcO5gR(void *p);

   // Schema evolution read functions

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SVector<float,5>*)
   {
      ::ROOT::Math::SVector<float,5> *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SVector<float,5>));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SVector<float,5>", "Math/SVector.h", 75,
                  typeid(::ROOT::Math::SVector<float,5>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSVectorlEfloatcO5gR_Dictionary, isa_proxy, 4,
                  sizeof(::ROOT::Math::SVector<float,5>) );
      instance.SetNew(&new_ROOTcLcLMathcLcLSVectorlEfloatcO5gR);
      instance.SetNewArray(&newArray_ROOTcLcLMathcLcLSVectorlEfloatcO5gR);
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSVectorlEfloatcO5gR);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSVectorlEfloatcO5gR);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSVectorlEfloatcO5gR);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SVector<float,5>","ROOT::Math::SVector<float, 5u>"));

      ::ROOT::Internal::TSchemaHelper* rule;

      // the io read rules
      std::vector<::ROOT::Internal::TSchemaHelper> readrules(3);
      rule = &readrules[0];
      rule->fSourceClass = "ROOT::Math::SVector<double,5>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[1];
      rule->fSourceClass = "ROOT::Math::SVector<Double32_t,5>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[2];
      rule->fSourceClass = "ROOT::Math::SVector<Float16_t,5>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      instance.SetReadRules( readrules );
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::SVector<float,5>*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::SVector<float,5>*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SVector<float,5>*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLSVectorlEfloatcO5gR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SVector<float,5>*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLSVectorlEfloatcO5gR_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLSVectorlEfloatcO5gR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSVectorlEfloatcO6gR_Dictionary();
   static void ROOTcLcLMathcLcLSVectorlEfloatcO6gR_TClassManip(TClass*);
   static void *new_ROOTcLcLMathcLcLSVectorlEfloatcO6gR(void *p = nullptr);
   static void *newArray_ROOTcLcLMathcLcLSVectorlEfloatcO6gR(Long_t size, void *p);
   static void delete_ROOTcLcLMathcLcLSVectorlEfloatcO6gR(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSVectorlEfloatcO6gR(void *p);
   static void destruct_ROOTcLcLMathcLcLSVectorlEfloatcO6gR(void *p);

   // Schema evolution read functions

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SVector<float,6>*)
   {
      ::ROOT::Math::SVector<float,6> *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SVector<float,6>));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SVector<float,6>", "Math/SVector.h", 75,
                  typeid(::ROOT::Math::SVector<float,6>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSVectorlEfloatcO6gR_Dictionary, isa_proxy, 4,
                  sizeof(::ROOT::Math::SVector<float,6>) );
      instance.SetNew(&new_ROOTcLcLMathcLcLSVectorlEfloatcO6gR);
      instance.SetNewArray(&newArray_ROOTcLcLMathcLcLSVectorlEfloatcO6gR);
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSVectorlEfloatcO6gR);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSVectorlEfloatcO6gR);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSVectorlEfloatcO6gR);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SVector<float,6>","ROOT::Math::SVector<float, 6u>"));

      ::ROOT::Internal::TSchemaHelper* rule;

      // the io read rules
      std::vector<::ROOT::Internal::TSchemaHelper> readrules(3);
      rule = &readrules[0];
      rule->fSourceClass = "ROOT::Math::SVector<double,6>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[1];
      rule->fSourceClass = "ROOT::Math::SVector<Double32_t,6>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[2];
      rule->fSourceClass = "ROOT::Math::SVector<Float16_t,6>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      instance.SetReadRules( readrules );
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::SVector<float,6>*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::SVector<float,6>*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SVector<float,6>*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLSVectorlEfloatcO6gR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SVector<float,6>*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLSVectorlEfloatcO6gR_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLSVectorlEfloatcO6gR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSVectorlEfloatcO7gR_Dictionary();
   static void ROOTcLcLMathcLcLSVectorlEfloatcO7gR_TClassManip(TClass*);
   static void *new_ROOTcLcLMathcLcLSVectorlEfloatcO7gR(void *p = nullptr);
   static void *newArray_ROOTcLcLMathcLcLSVectorlEfloatcO7gR(Long_t size, void *p);
   static void delete_ROOTcLcLMathcLcLSVectorlEfloatcO7gR(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSVectorlEfloatcO7gR(void *p);
   static void destruct_ROOTcLcLMathcLcLSVectorlEfloatcO7gR(void *p);

   // Schema evolution read functions

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SVector<float,7>*)
   {
      ::ROOT::Math::SVector<float,7> *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SVector<float,7>));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SVector<float,7>", "Math/SVector.h", 75,
                  typeid(::ROOT::Math::SVector<float,7>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSVectorlEfloatcO7gR_Dictionary, isa_proxy, 4,
                  sizeof(::ROOT::Math::SVector<float,7>) );
      instance.SetNew(&new_ROOTcLcLMathcLcLSVectorlEfloatcO7gR);
      instance.SetNewArray(&newArray_ROOTcLcLMathcLcLSVectorlEfloatcO7gR);
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSVectorlEfloatcO7gR);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSVectorlEfloatcO7gR);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSVectorlEfloatcO7gR);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SVector<float,7>","ROOT::Math::SVector<float, 7u>"));

      ::ROOT::Internal::TSchemaHelper* rule;

      // the io read rules
      std::vector<::ROOT::Internal::TSchemaHelper> readrules(3);
      rule = &readrules[0];
      rule->fSourceClass = "ROOT::Math::SVector<double,7>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[1];
      rule->fSourceClass = "ROOT::Math::SVector<Double32_t,7>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[2];
      rule->fSourceClass = "ROOT::Math::SVector<Float16_t,7>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      instance.SetReadRules( readrules );
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::SVector<float,7>*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::SVector<float,7>*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SVector<float,7>*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLSVectorlEfloatcO7gR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SVector<float,7>*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLSVectorlEfloatcO7gR_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLSVectorlEfloatcO7gR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSMatrixlEdoublecO2cO2cOROOTcLcLMathcLcLMatRepStdlEdoublecO2cO2gRsPgR_Dictionary();
   static void ROOTcLcLMathcLcLSMatrixlEdoublecO2cO2cOROOTcLcLMathcLcLMatRepStdlEdoublecO2cO2gRsPgR_TClassManip(TClass*);
   static void *new_ROOTcLcLMathcLcLSMatrixlEdoublecO2cO2cOROOTcLcLMathcLcLMatRepStdlEdoublecO2cO2gRsPgR(void *p = nullptr);
   static void *newArray_ROOTcLcLMathcLcLSMatrixlEdoublecO2cO2cOROOTcLcLMathcLcLMatRepStdlEdoublecO2cO2gRsPgR(Long_t size, void *p);
   static void delete_ROOTcLcLMathcLcLSMatrixlEdoublecO2cO2cOROOTcLcLMathcLcLMatRepStdlEdoublecO2cO2gRsPgR(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO2cO2cOROOTcLcLMathcLcLMatRepStdlEdoublecO2cO2gRsPgR(void *p);
   static void destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO2cO2cOROOTcLcLMathcLcLMatRepStdlEdoublecO2cO2gRsPgR(void *p);

   // Schema evolution read functions

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SMatrix<double,2,2,ROOT::Math::MatRepStd<double,2,2> >*)
   {
      ::ROOT::Math::SMatrix<double,2,2,ROOT::Math::MatRepStd<double,2,2> > *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SMatrix<double,2,2,ROOT::Math::MatRepStd<double,2,2> >));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SMatrix<double,2,2,ROOT::Math::MatRepStd<double,2,2> >", "Math/SMatrix.h", 101,
                  typeid(::ROOT::Math::SMatrix<double,2,2,ROOT::Math::MatRepStd<double,2,2> >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSMatrixlEdoublecO2cO2cOROOTcLcLMathcLcLMatRepStdlEdoublecO2cO2gRsPgR_Dictionary, isa_proxy, 4,
                  sizeof(::ROOT::Math::SMatrix<double,2,2,ROOT::Math::MatRepStd<double,2,2> >) );
      instance.SetNew(&new_ROOTcLcLMathcLcLSMatrixlEdoublecO2cO2cOROOTcLcLMathcLcLMatRepStdlEdoublecO2cO2gRsPgR);
      instance.SetNewArray(&newArray_ROOTcLcLMathcLcLSMatrixlEdoublecO2cO2cOROOTcLcLMathcLcLMatRepStdlEdoublecO2cO2gRsPgR);
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSMatrixlEdoublecO2cO2cOROOTcLcLMathcLcLMatRepStdlEdoublecO2cO2gRsPgR);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO2cO2cOROOTcLcLMathcLcLMatRepStdlEdoublecO2cO2gRsPgR);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO2cO2cOROOTcLcLMathcLcLMatRepStdlEdoublecO2cO2gRsPgR);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<double,2,2,ROOT::Math::MatRepStd<double,2,2> >","ROOT::Math::SMatrix<double,2,2>"));

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<double,2,2,ROOT::Math::MatRepStd<double,2,2> >","ROOT::Math::SMatrix<double, 2u, 2u, ROOT::Math::MatRepStd<double, 2u, 2u> >"));

      ::ROOT::Internal::TSchemaHelper* rule;

      // the io read rules
      std::vector<::ROOT::Internal::TSchemaHelper> readrules(3);
      rule = &readrules[0];
      rule->fSourceClass = "ROOT::Math::SMatrix<Double32_t,2,2>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[1];
      rule->fSourceClass = "ROOT::Math::SMatrix<float,2,2>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[2];
      rule->fSourceClass = "ROOT::Math::SMatrix<Float16_t,2,2>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      instance.SetReadRules( readrules );
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::SMatrix<double,2,2,ROOT::Math::MatRepStd<double,2,2> >*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::SMatrix<double,2,2,ROOT::Math::MatRepStd<double,2,2> >*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<double,2,2,ROOT::Math::MatRepStd<double,2,2> >*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLSMatrixlEdoublecO2cO2cOROOTcLcLMathcLcLMatRepStdlEdoublecO2cO2gRsPgR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<double,2,2,ROOT::Math::MatRepStd<double,2,2> >*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLSMatrixlEdoublecO2cO2cOROOTcLcLMathcLcLMatRepStdlEdoublecO2cO2gRsPgR_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLSMatrixlEdoublecO2cO2cOROOTcLcLMathcLcLMatRepStdlEdoublecO2cO2gRsPgR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSMatrixlEdoublecO2UcO2UcOROOTcLcLMathcLcLMatRepStdlEdoublecO2cO2gRsPgRcLcLSMatrixRow_Dictionary();
   static void ROOTcLcLMathcLcLSMatrixlEdoublecO2UcO2UcOROOTcLcLMathcLcLMatRepStdlEdoublecO2cO2gRsPgRcLcLSMatrixRow_TClassManip(TClass*);
   static void delete_ROOTcLcLMathcLcLSMatrixlEdoublecO2UcO2UcOROOTcLcLMathcLcLMatRepStdlEdoublecO2cO2gRsPgRcLcLSMatrixRow(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO2UcO2UcOROOTcLcLMathcLcLMatRepStdlEdoublecO2cO2gRsPgRcLcLSMatrixRow(void *p);
   static void destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO2UcO2UcOROOTcLcLMathcLcLMatRepStdlEdoublecO2cO2gRsPgRcLcLSMatrixRow(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SMatrix<double,2U,2U,ROOT::Math::MatRepStd<double,2,2> >::SMatrixRow*)
   {
      ::ROOT::Math::SMatrix<double,2U,2U,ROOT::Math::MatRepStd<double,2,2> >::SMatrixRow *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SMatrix<double,2U,2U,ROOT::Math::MatRepStd<double,2,2> >::SMatrixRow));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SMatrix<double,2U,2U,ROOT::Math::MatRepStd<double,2,2> >::SMatrixRow", "Math/SMatrix.h", 371,
                  typeid(::ROOT::Math::SMatrix<double,2U,2U,ROOT::Math::MatRepStd<double,2,2> >::SMatrixRow), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSMatrixlEdoublecO2UcO2UcOROOTcLcLMathcLcLMatRepStdlEdoublecO2cO2gRsPgRcLcLSMatrixRow_Dictionary, isa_proxy, 0,
                  sizeof(::ROOT::Math::SMatrix<double,2U,2U,ROOT::Math::MatRepStd<double,2,2> >::SMatrixRow) );
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSMatrixlEdoublecO2UcO2UcOROOTcLcLMathcLcLMatRepStdlEdoublecO2cO2gRsPgRcLcLSMatrixRow);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO2UcO2UcOROOTcLcLMathcLcLMatRepStdlEdoublecO2cO2gRsPgRcLcLSMatrixRow);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO2UcO2UcOROOTcLcLMathcLcLMatRepStdlEdoublecO2cO2gRsPgRcLcLSMatrixRow);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<double,2U,2U,ROOT::Math::MatRepStd<double,2,2> >::SMatrixRow","ROOT::Math::SMatrix<double,2,2>::SMatrixRow"));

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<double,2U,2U,ROOT::Math::MatRepStd<double,2,2> >::SMatrixRow","ROOT::Math::SMatrix<double, 2u, 2u, ROOT::Math::MatRepStd<double, 2u, 2u> >::SMatrixRow"));
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::SMatrix<double,2U,2U,ROOT::Math::MatRepStd<double,2,2> >::SMatrixRow*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::SMatrix<double,2U,2U,ROOT::Math::MatRepStd<double,2,2> >::SMatrixRow*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<double,2U,2U,ROOT::Math::MatRepStd<double,2,2> >::SMatrixRow*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLSMatrixlEdoublecO2UcO2UcOROOTcLcLMathcLcLMatRepStdlEdoublecO2cO2gRsPgRcLcLSMatrixRow_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<double,2U,2U,ROOT::Math::MatRepStd<double,2,2> >::SMatrixRow*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLSMatrixlEdoublecO2UcO2UcOROOTcLcLMathcLcLMatRepStdlEdoublecO2cO2gRsPgRcLcLSMatrixRow_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLSMatrixlEdoublecO2UcO2UcOROOTcLcLMathcLcLMatRepStdlEdoublecO2cO2gRsPgRcLcLSMatrixRow_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSMatrixlEdoublecO2UcO2UcOROOTcLcLMathcLcLMatRepStdlEdoublecO2cO2gRsPgRcLcLSMatrixRow_const_Dictionary();
   static void ROOTcLcLMathcLcLSMatrixlEdoublecO2UcO2UcOROOTcLcLMathcLcLMatRepStdlEdoublecO2cO2gRsPgRcLcLSMatrixRow_const_TClassManip(TClass*);
   static void delete_ROOTcLcLMathcLcLSMatrixlEdoublecO2UcO2UcOROOTcLcLMathcLcLMatRepStdlEdoublecO2cO2gRsPgRcLcLSMatrixRow_const(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO2UcO2UcOROOTcLcLMathcLcLMatRepStdlEdoublecO2cO2gRsPgRcLcLSMatrixRow_const(void *p);
   static void destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO2UcO2UcOROOTcLcLMathcLcLMatRepStdlEdoublecO2cO2gRsPgRcLcLSMatrixRow_const(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SMatrix<double,2U,2U,ROOT::Math::MatRepStd<double,2,2> >::SMatrixRow_const*)
   {
      ::ROOT::Math::SMatrix<double,2U,2U,ROOT::Math::MatRepStd<double,2,2> >::SMatrixRow_const *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SMatrix<double,2U,2U,ROOT::Math::MatRepStd<double,2,2> >::SMatrixRow_const));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SMatrix<double,2U,2U,ROOT::Math::MatRepStd<double,2,2> >::SMatrixRow_const", "Math/SMatrix.h", 382,
                  typeid(::ROOT::Math::SMatrix<double,2U,2U,ROOT::Math::MatRepStd<double,2,2> >::SMatrixRow_const), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSMatrixlEdoublecO2UcO2UcOROOTcLcLMathcLcLMatRepStdlEdoublecO2cO2gRsPgRcLcLSMatrixRow_const_Dictionary, isa_proxy, 0,
                  sizeof(::ROOT::Math::SMatrix<double,2U,2U,ROOT::Math::MatRepStd<double,2,2> >::SMatrixRow_const) );
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSMatrixlEdoublecO2UcO2UcOROOTcLcLMathcLcLMatRepStdlEdoublecO2cO2gRsPgRcLcLSMatrixRow_const);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO2UcO2UcOROOTcLcLMathcLcLMatRepStdlEdoublecO2cO2gRsPgRcLcLSMatrixRow_const);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO2UcO2UcOROOTcLcLMathcLcLMatRepStdlEdoublecO2cO2gRsPgRcLcLSMatrixRow_const);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<double,2U,2U,ROOT::Math::MatRepStd<double,2,2> >::SMatrixRow_const","ROOT::Math::SMatrix<double,2,2>::SMatrixRow_const"));

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<double,2U,2U,ROOT::Math::MatRepStd<double,2,2> >::SMatrixRow_const","ROOT::Math::SMatrix<double, 2u, 2u, ROOT::Math::MatRepStd<double, 2u, 2u> >::SMatrixRow_const"));
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::SMatrix<double,2U,2U,ROOT::Math::MatRepStd<double,2,2> >::SMatrixRow_const*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::SMatrix<double,2U,2U,ROOT::Math::MatRepStd<double,2,2> >::SMatrixRow_const*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<double,2U,2U,ROOT::Math::MatRepStd<double,2,2> >::SMatrixRow_const*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLSMatrixlEdoublecO2UcO2UcOROOTcLcLMathcLcLMatRepStdlEdoublecO2cO2gRsPgRcLcLSMatrixRow_const_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<double,2U,2U,ROOT::Math::MatRepStd<double,2,2> >::SMatrixRow_const*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLSMatrixlEdoublecO2UcO2UcOROOTcLcLMathcLcLMatRepStdlEdoublecO2cO2gRsPgRcLcLSMatrixRow_const_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLSMatrixlEdoublecO2UcO2UcOROOTcLcLMathcLcLMatRepStdlEdoublecO2cO2gRsPgRcLcLSMatrixRow_const_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSMatrixlEdoublecO3cO3cOROOTcLcLMathcLcLMatRepStdlEdoublecO3cO3gRsPgR_Dictionary();
   static void ROOTcLcLMathcLcLSMatrixlEdoublecO3cO3cOROOTcLcLMathcLcLMatRepStdlEdoublecO3cO3gRsPgR_TClassManip(TClass*);
   static void *new_ROOTcLcLMathcLcLSMatrixlEdoublecO3cO3cOROOTcLcLMathcLcLMatRepStdlEdoublecO3cO3gRsPgR(void *p = nullptr);
   static void *newArray_ROOTcLcLMathcLcLSMatrixlEdoublecO3cO3cOROOTcLcLMathcLcLMatRepStdlEdoublecO3cO3gRsPgR(Long_t size, void *p);
   static void delete_ROOTcLcLMathcLcLSMatrixlEdoublecO3cO3cOROOTcLcLMathcLcLMatRepStdlEdoublecO3cO3gRsPgR(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO3cO3cOROOTcLcLMathcLcLMatRepStdlEdoublecO3cO3gRsPgR(void *p);
   static void destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO3cO3cOROOTcLcLMathcLcLMatRepStdlEdoublecO3cO3gRsPgR(void *p);

   // Schema evolution read functions

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SMatrix<double,3,3,ROOT::Math::MatRepStd<double,3,3> >*)
   {
      ::ROOT::Math::SMatrix<double,3,3,ROOT::Math::MatRepStd<double,3,3> > *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SMatrix<double,3,3,ROOT::Math::MatRepStd<double,3,3> >));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SMatrix<double,3,3,ROOT::Math::MatRepStd<double,3,3> >", "Math/SMatrix.h", 101,
                  typeid(::ROOT::Math::SMatrix<double,3,3,ROOT::Math::MatRepStd<double,3,3> >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSMatrixlEdoublecO3cO3cOROOTcLcLMathcLcLMatRepStdlEdoublecO3cO3gRsPgR_Dictionary, isa_proxy, 4,
                  sizeof(::ROOT::Math::SMatrix<double,3,3,ROOT::Math::MatRepStd<double,3,3> >) );
      instance.SetNew(&new_ROOTcLcLMathcLcLSMatrixlEdoublecO3cO3cOROOTcLcLMathcLcLMatRepStdlEdoublecO3cO3gRsPgR);
      instance.SetNewArray(&newArray_ROOTcLcLMathcLcLSMatrixlEdoublecO3cO3cOROOTcLcLMathcLcLMatRepStdlEdoublecO3cO3gRsPgR);
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSMatrixlEdoublecO3cO3cOROOTcLcLMathcLcLMatRepStdlEdoublecO3cO3gRsPgR);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO3cO3cOROOTcLcLMathcLcLMatRepStdlEdoublecO3cO3gRsPgR);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO3cO3cOROOTcLcLMathcLcLMatRepStdlEdoublecO3cO3gRsPgR);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<double,3,3,ROOT::Math::MatRepStd<double,3,3> >","ROOT::Math::SMatrix<double,3,3>"));

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<double,3,3,ROOT::Math::MatRepStd<double,3,3> >","ROOT::Math::SMatrix<double, 3u, 3u, ROOT::Math::MatRepStd<double, 3u, 3u> >"));

      ::ROOT::Internal::TSchemaHelper* rule;

      // the io read rules
      std::vector<::ROOT::Internal::TSchemaHelper> readrules(3);
      rule = &readrules[0];
      rule->fSourceClass = "ROOT::Math::SMatrix<Double32_t,3,3>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[1];
      rule->fSourceClass = "ROOT::Math::SMatrix<float,3,3>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[2];
      rule->fSourceClass = "ROOT::Math::SMatrix<Float16_t,3,3>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      instance.SetReadRules( readrules );
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::SMatrix<double,3,3,ROOT::Math::MatRepStd<double,3,3> >*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::SMatrix<double,3,3,ROOT::Math::MatRepStd<double,3,3> >*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<double,3,3,ROOT::Math::MatRepStd<double,3,3> >*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLSMatrixlEdoublecO3cO3cOROOTcLcLMathcLcLMatRepStdlEdoublecO3cO3gRsPgR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<double,3,3,ROOT::Math::MatRepStd<double,3,3> >*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLSMatrixlEdoublecO3cO3cOROOTcLcLMathcLcLMatRepStdlEdoublecO3cO3gRsPgR_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLSMatrixlEdoublecO3cO3cOROOTcLcLMathcLcLMatRepStdlEdoublecO3cO3gRsPgR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSMatrixlEdoublecO3UcO3UcOROOTcLcLMathcLcLMatRepStdlEdoublecO3cO3gRsPgRcLcLSMatrixRow_Dictionary();
   static void ROOTcLcLMathcLcLSMatrixlEdoublecO3UcO3UcOROOTcLcLMathcLcLMatRepStdlEdoublecO3cO3gRsPgRcLcLSMatrixRow_TClassManip(TClass*);
   static void delete_ROOTcLcLMathcLcLSMatrixlEdoublecO3UcO3UcOROOTcLcLMathcLcLMatRepStdlEdoublecO3cO3gRsPgRcLcLSMatrixRow(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO3UcO3UcOROOTcLcLMathcLcLMatRepStdlEdoublecO3cO3gRsPgRcLcLSMatrixRow(void *p);
   static void destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO3UcO3UcOROOTcLcLMathcLcLMatRepStdlEdoublecO3cO3gRsPgRcLcLSMatrixRow(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SMatrix<double,3U,3U,ROOT::Math::MatRepStd<double,3,3> >::SMatrixRow*)
   {
      ::ROOT::Math::SMatrix<double,3U,3U,ROOT::Math::MatRepStd<double,3,3> >::SMatrixRow *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SMatrix<double,3U,3U,ROOT::Math::MatRepStd<double,3,3> >::SMatrixRow));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SMatrix<double,3U,3U,ROOT::Math::MatRepStd<double,3,3> >::SMatrixRow", "Math/SMatrix.h", 371,
                  typeid(::ROOT::Math::SMatrix<double,3U,3U,ROOT::Math::MatRepStd<double,3,3> >::SMatrixRow), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSMatrixlEdoublecO3UcO3UcOROOTcLcLMathcLcLMatRepStdlEdoublecO3cO3gRsPgRcLcLSMatrixRow_Dictionary, isa_proxy, 0,
                  sizeof(::ROOT::Math::SMatrix<double,3U,3U,ROOT::Math::MatRepStd<double,3,3> >::SMatrixRow) );
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSMatrixlEdoublecO3UcO3UcOROOTcLcLMathcLcLMatRepStdlEdoublecO3cO3gRsPgRcLcLSMatrixRow);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO3UcO3UcOROOTcLcLMathcLcLMatRepStdlEdoublecO3cO3gRsPgRcLcLSMatrixRow);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO3UcO3UcOROOTcLcLMathcLcLMatRepStdlEdoublecO3cO3gRsPgRcLcLSMatrixRow);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<double,3U,3U,ROOT::Math::MatRepStd<double,3,3> >::SMatrixRow","ROOT::Math::SMatrix<double,3,3>::SMatrixRow"));

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<double,3U,3U,ROOT::Math::MatRepStd<double,3,3> >::SMatrixRow","ROOT::Math::SMatrix<double, 3u, 3u, ROOT::Math::MatRepStd<double, 3u, 3u> >::SMatrixRow"));
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::SMatrix<double,3U,3U,ROOT::Math::MatRepStd<double,3,3> >::SMatrixRow*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::SMatrix<double,3U,3U,ROOT::Math::MatRepStd<double,3,3> >::SMatrixRow*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<double,3U,3U,ROOT::Math::MatRepStd<double,3,3> >::SMatrixRow*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLSMatrixlEdoublecO3UcO3UcOROOTcLcLMathcLcLMatRepStdlEdoublecO3cO3gRsPgRcLcLSMatrixRow_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<double,3U,3U,ROOT::Math::MatRepStd<double,3,3> >::SMatrixRow*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLSMatrixlEdoublecO3UcO3UcOROOTcLcLMathcLcLMatRepStdlEdoublecO3cO3gRsPgRcLcLSMatrixRow_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLSMatrixlEdoublecO3UcO3UcOROOTcLcLMathcLcLMatRepStdlEdoublecO3cO3gRsPgRcLcLSMatrixRow_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSMatrixlEdoublecO3UcO3UcOROOTcLcLMathcLcLMatRepStdlEdoublecO3cO3gRsPgRcLcLSMatrixRow_const_Dictionary();
   static void ROOTcLcLMathcLcLSMatrixlEdoublecO3UcO3UcOROOTcLcLMathcLcLMatRepStdlEdoublecO3cO3gRsPgRcLcLSMatrixRow_const_TClassManip(TClass*);
   static void delete_ROOTcLcLMathcLcLSMatrixlEdoublecO3UcO3UcOROOTcLcLMathcLcLMatRepStdlEdoublecO3cO3gRsPgRcLcLSMatrixRow_const(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO3UcO3UcOROOTcLcLMathcLcLMatRepStdlEdoublecO3cO3gRsPgRcLcLSMatrixRow_const(void *p);
   static void destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO3UcO3UcOROOTcLcLMathcLcLMatRepStdlEdoublecO3cO3gRsPgRcLcLSMatrixRow_const(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SMatrix<double,3U,3U,ROOT::Math::MatRepStd<double,3,3> >::SMatrixRow_const*)
   {
      ::ROOT::Math::SMatrix<double,3U,3U,ROOT::Math::MatRepStd<double,3,3> >::SMatrixRow_const *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SMatrix<double,3U,3U,ROOT::Math::MatRepStd<double,3,3> >::SMatrixRow_const));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SMatrix<double,3U,3U,ROOT::Math::MatRepStd<double,3,3> >::SMatrixRow_const", "Math/SMatrix.h", 382,
                  typeid(::ROOT::Math::SMatrix<double,3U,3U,ROOT::Math::MatRepStd<double,3,3> >::SMatrixRow_const), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSMatrixlEdoublecO3UcO3UcOROOTcLcLMathcLcLMatRepStdlEdoublecO3cO3gRsPgRcLcLSMatrixRow_const_Dictionary, isa_proxy, 0,
                  sizeof(::ROOT::Math::SMatrix<double,3U,3U,ROOT::Math::MatRepStd<double,3,3> >::SMatrixRow_const) );
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSMatrixlEdoublecO3UcO3UcOROOTcLcLMathcLcLMatRepStdlEdoublecO3cO3gRsPgRcLcLSMatrixRow_const);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO3UcO3UcOROOTcLcLMathcLcLMatRepStdlEdoublecO3cO3gRsPgRcLcLSMatrixRow_const);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO3UcO3UcOROOTcLcLMathcLcLMatRepStdlEdoublecO3cO3gRsPgRcLcLSMatrixRow_const);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<double,3U,3U,ROOT::Math::MatRepStd<double,3,3> >::SMatrixRow_const","ROOT::Math::SMatrix<double,3,3>::SMatrixRow_const"));

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<double,3U,3U,ROOT::Math::MatRepStd<double,3,3> >::SMatrixRow_const","ROOT::Math::SMatrix<double, 3u, 3u, ROOT::Math::MatRepStd<double, 3u, 3u> >::SMatrixRow_const"));
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::SMatrix<double,3U,3U,ROOT::Math::MatRepStd<double,3,3> >::SMatrixRow_const*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::SMatrix<double,3U,3U,ROOT::Math::MatRepStd<double,3,3> >::SMatrixRow_const*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<double,3U,3U,ROOT::Math::MatRepStd<double,3,3> >::SMatrixRow_const*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLSMatrixlEdoublecO3UcO3UcOROOTcLcLMathcLcLMatRepStdlEdoublecO3cO3gRsPgRcLcLSMatrixRow_const_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<double,3U,3U,ROOT::Math::MatRepStd<double,3,3> >::SMatrixRow_const*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLSMatrixlEdoublecO3UcO3UcOROOTcLcLMathcLcLMatRepStdlEdoublecO3cO3gRsPgRcLcLSMatrixRow_const_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLSMatrixlEdoublecO3UcO3UcOROOTcLcLMathcLcLMatRepStdlEdoublecO3cO3gRsPgRcLcLSMatrixRow_const_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSMatrixlEdoublecO4cO4cOROOTcLcLMathcLcLMatRepStdlEdoublecO4cO4gRsPgR_Dictionary();
   static void ROOTcLcLMathcLcLSMatrixlEdoublecO4cO4cOROOTcLcLMathcLcLMatRepStdlEdoublecO4cO4gRsPgR_TClassManip(TClass*);
   static void *new_ROOTcLcLMathcLcLSMatrixlEdoublecO4cO4cOROOTcLcLMathcLcLMatRepStdlEdoublecO4cO4gRsPgR(void *p = nullptr);
   static void *newArray_ROOTcLcLMathcLcLSMatrixlEdoublecO4cO4cOROOTcLcLMathcLcLMatRepStdlEdoublecO4cO4gRsPgR(Long_t size, void *p);
   static void delete_ROOTcLcLMathcLcLSMatrixlEdoublecO4cO4cOROOTcLcLMathcLcLMatRepStdlEdoublecO4cO4gRsPgR(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO4cO4cOROOTcLcLMathcLcLMatRepStdlEdoublecO4cO4gRsPgR(void *p);
   static void destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO4cO4cOROOTcLcLMathcLcLMatRepStdlEdoublecO4cO4gRsPgR(void *p);

   // Schema evolution read functions

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SMatrix<double,4,4,ROOT::Math::MatRepStd<double,4,4> >*)
   {
      ::ROOT::Math::SMatrix<double,4,4,ROOT::Math::MatRepStd<double,4,4> > *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SMatrix<double,4,4,ROOT::Math::MatRepStd<double,4,4> >));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SMatrix<double,4,4,ROOT::Math::MatRepStd<double,4,4> >", "Math/SMatrix.h", 101,
                  typeid(::ROOT::Math::SMatrix<double,4,4,ROOT::Math::MatRepStd<double,4,4> >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSMatrixlEdoublecO4cO4cOROOTcLcLMathcLcLMatRepStdlEdoublecO4cO4gRsPgR_Dictionary, isa_proxy, 4,
                  sizeof(::ROOT::Math::SMatrix<double,4,4,ROOT::Math::MatRepStd<double,4,4> >) );
      instance.SetNew(&new_ROOTcLcLMathcLcLSMatrixlEdoublecO4cO4cOROOTcLcLMathcLcLMatRepStdlEdoublecO4cO4gRsPgR);
      instance.SetNewArray(&newArray_ROOTcLcLMathcLcLSMatrixlEdoublecO4cO4cOROOTcLcLMathcLcLMatRepStdlEdoublecO4cO4gRsPgR);
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSMatrixlEdoublecO4cO4cOROOTcLcLMathcLcLMatRepStdlEdoublecO4cO4gRsPgR);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO4cO4cOROOTcLcLMathcLcLMatRepStdlEdoublecO4cO4gRsPgR);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO4cO4cOROOTcLcLMathcLcLMatRepStdlEdoublecO4cO4gRsPgR);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<double,4,4,ROOT::Math::MatRepStd<double,4,4> >","ROOT::Math::SMatrix<double,4,4>"));

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<double,4,4,ROOT::Math::MatRepStd<double,4,4> >","ROOT::Math::SMatrix<double, 4u, 4u, ROOT::Math::MatRepStd<double, 4u, 4u> >"));

      ::ROOT::Internal::TSchemaHelper* rule;

      // the io read rules
      std::vector<::ROOT::Internal::TSchemaHelper> readrules(3);
      rule = &readrules[0];
      rule->fSourceClass = "ROOT::Math::SMatrix<Double32_t,4,4>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[1];
      rule->fSourceClass = "ROOT::Math::SMatrix<float,4,4>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[2];
      rule->fSourceClass = "ROOT::Math::SMatrix<Float16_t,4,4>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      instance.SetReadRules( readrules );
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::SMatrix<double,4,4,ROOT::Math::MatRepStd<double,4,4> >*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::SMatrix<double,4,4,ROOT::Math::MatRepStd<double,4,4> >*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<double,4,4,ROOT::Math::MatRepStd<double,4,4> >*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLSMatrixlEdoublecO4cO4cOROOTcLcLMathcLcLMatRepStdlEdoublecO4cO4gRsPgR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<double,4,4,ROOT::Math::MatRepStd<double,4,4> >*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLSMatrixlEdoublecO4cO4cOROOTcLcLMathcLcLMatRepStdlEdoublecO4cO4gRsPgR_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLSMatrixlEdoublecO4cO4cOROOTcLcLMathcLcLMatRepStdlEdoublecO4cO4gRsPgR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSMatrixlEdoublecO4UcO4UcOROOTcLcLMathcLcLMatRepStdlEdoublecO4cO4gRsPgRcLcLSMatrixRow_Dictionary();
   static void ROOTcLcLMathcLcLSMatrixlEdoublecO4UcO4UcOROOTcLcLMathcLcLMatRepStdlEdoublecO4cO4gRsPgRcLcLSMatrixRow_TClassManip(TClass*);
   static void delete_ROOTcLcLMathcLcLSMatrixlEdoublecO4UcO4UcOROOTcLcLMathcLcLMatRepStdlEdoublecO4cO4gRsPgRcLcLSMatrixRow(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO4UcO4UcOROOTcLcLMathcLcLMatRepStdlEdoublecO4cO4gRsPgRcLcLSMatrixRow(void *p);
   static void destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO4UcO4UcOROOTcLcLMathcLcLMatRepStdlEdoublecO4cO4gRsPgRcLcLSMatrixRow(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SMatrix<double,4U,4U,ROOT::Math::MatRepStd<double,4,4> >::SMatrixRow*)
   {
      ::ROOT::Math::SMatrix<double,4U,4U,ROOT::Math::MatRepStd<double,4,4> >::SMatrixRow *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SMatrix<double,4U,4U,ROOT::Math::MatRepStd<double,4,4> >::SMatrixRow));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SMatrix<double,4U,4U,ROOT::Math::MatRepStd<double,4,4> >::SMatrixRow", "Math/SMatrix.h", 371,
                  typeid(::ROOT::Math::SMatrix<double,4U,4U,ROOT::Math::MatRepStd<double,4,4> >::SMatrixRow), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSMatrixlEdoublecO4UcO4UcOROOTcLcLMathcLcLMatRepStdlEdoublecO4cO4gRsPgRcLcLSMatrixRow_Dictionary, isa_proxy, 0,
                  sizeof(::ROOT::Math::SMatrix<double,4U,4U,ROOT::Math::MatRepStd<double,4,4> >::SMatrixRow) );
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSMatrixlEdoublecO4UcO4UcOROOTcLcLMathcLcLMatRepStdlEdoublecO4cO4gRsPgRcLcLSMatrixRow);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO4UcO4UcOROOTcLcLMathcLcLMatRepStdlEdoublecO4cO4gRsPgRcLcLSMatrixRow);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO4UcO4UcOROOTcLcLMathcLcLMatRepStdlEdoublecO4cO4gRsPgRcLcLSMatrixRow);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<double,4U,4U,ROOT::Math::MatRepStd<double,4,4> >::SMatrixRow","ROOT::Math::SMatrix<double,4,4>::SMatrixRow"));

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<double,4U,4U,ROOT::Math::MatRepStd<double,4,4> >::SMatrixRow","ROOT::Math::SMatrix<double, 4u, 4u, ROOT::Math::MatRepStd<double, 4u, 4u> >::SMatrixRow"));
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::SMatrix<double,4U,4U,ROOT::Math::MatRepStd<double,4,4> >::SMatrixRow*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::SMatrix<double,4U,4U,ROOT::Math::MatRepStd<double,4,4> >::SMatrixRow*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<double,4U,4U,ROOT::Math::MatRepStd<double,4,4> >::SMatrixRow*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLSMatrixlEdoublecO4UcO4UcOROOTcLcLMathcLcLMatRepStdlEdoublecO4cO4gRsPgRcLcLSMatrixRow_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<double,4U,4U,ROOT::Math::MatRepStd<double,4,4> >::SMatrixRow*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLSMatrixlEdoublecO4UcO4UcOROOTcLcLMathcLcLMatRepStdlEdoublecO4cO4gRsPgRcLcLSMatrixRow_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLSMatrixlEdoublecO4UcO4UcOROOTcLcLMathcLcLMatRepStdlEdoublecO4cO4gRsPgRcLcLSMatrixRow_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSMatrixlEdoublecO4UcO4UcOROOTcLcLMathcLcLMatRepStdlEdoublecO4cO4gRsPgRcLcLSMatrixRow_const_Dictionary();
   static void ROOTcLcLMathcLcLSMatrixlEdoublecO4UcO4UcOROOTcLcLMathcLcLMatRepStdlEdoublecO4cO4gRsPgRcLcLSMatrixRow_const_TClassManip(TClass*);
   static void delete_ROOTcLcLMathcLcLSMatrixlEdoublecO4UcO4UcOROOTcLcLMathcLcLMatRepStdlEdoublecO4cO4gRsPgRcLcLSMatrixRow_const(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO4UcO4UcOROOTcLcLMathcLcLMatRepStdlEdoublecO4cO4gRsPgRcLcLSMatrixRow_const(void *p);
   static void destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO4UcO4UcOROOTcLcLMathcLcLMatRepStdlEdoublecO4cO4gRsPgRcLcLSMatrixRow_const(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SMatrix<double,4U,4U,ROOT::Math::MatRepStd<double,4,4> >::SMatrixRow_const*)
   {
      ::ROOT::Math::SMatrix<double,4U,4U,ROOT::Math::MatRepStd<double,4,4> >::SMatrixRow_const *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SMatrix<double,4U,4U,ROOT::Math::MatRepStd<double,4,4> >::SMatrixRow_const));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SMatrix<double,4U,4U,ROOT::Math::MatRepStd<double,4,4> >::SMatrixRow_const", "Math/SMatrix.h", 382,
                  typeid(::ROOT::Math::SMatrix<double,4U,4U,ROOT::Math::MatRepStd<double,4,4> >::SMatrixRow_const), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSMatrixlEdoublecO4UcO4UcOROOTcLcLMathcLcLMatRepStdlEdoublecO4cO4gRsPgRcLcLSMatrixRow_const_Dictionary, isa_proxy, 0,
                  sizeof(::ROOT::Math::SMatrix<double,4U,4U,ROOT::Math::MatRepStd<double,4,4> >::SMatrixRow_const) );
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSMatrixlEdoublecO4UcO4UcOROOTcLcLMathcLcLMatRepStdlEdoublecO4cO4gRsPgRcLcLSMatrixRow_const);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO4UcO4UcOROOTcLcLMathcLcLMatRepStdlEdoublecO4cO4gRsPgRcLcLSMatrixRow_const);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO4UcO4UcOROOTcLcLMathcLcLMatRepStdlEdoublecO4cO4gRsPgRcLcLSMatrixRow_const);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<double,4U,4U,ROOT::Math::MatRepStd<double,4,4> >::SMatrixRow_const","ROOT::Math::SMatrix<double,4,4>::SMatrixRow_const"));

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<double,4U,4U,ROOT::Math::MatRepStd<double,4,4> >::SMatrixRow_const","ROOT::Math::SMatrix<double, 4u, 4u, ROOT::Math::MatRepStd<double, 4u, 4u> >::SMatrixRow_const"));
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::SMatrix<double,4U,4U,ROOT::Math::MatRepStd<double,4,4> >::SMatrixRow_const*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::SMatrix<double,4U,4U,ROOT::Math::MatRepStd<double,4,4> >::SMatrixRow_const*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<double,4U,4U,ROOT::Math::MatRepStd<double,4,4> >::SMatrixRow_const*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLSMatrixlEdoublecO4UcO4UcOROOTcLcLMathcLcLMatRepStdlEdoublecO4cO4gRsPgRcLcLSMatrixRow_const_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<double,4U,4U,ROOT::Math::MatRepStd<double,4,4> >::SMatrixRow_const*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLSMatrixlEdoublecO4UcO4UcOROOTcLcLMathcLcLMatRepStdlEdoublecO4cO4gRsPgRcLcLSMatrixRow_const_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLSMatrixlEdoublecO4UcO4UcOROOTcLcLMathcLcLMatRepStdlEdoublecO4cO4gRsPgRcLcLSMatrixRow_const_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSMatrixlEdoublecO5cO5cOROOTcLcLMathcLcLMatRepStdlEdoublecO5cO5gRsPgR_Dictionary();
   static void ROOTcLcLMathcLcLSMatrixlEdoublecO5cO5cOROOTcLcLMathcLcLMatRepStdlEdoublecO5cO5gRsPgR_TClassManip(TClass*);
   static void *new_ROOTcLcLMathcLcLSMatrixlEdoublecO5cO5cOROOTcLcLMathcLcLMatRepStdlEdoublecO5cO5gRsPgR(void *p = nullptr);
   static void *newArray_ROOTcLcLMathcLcLSMatrixlEdoublecO5cO5cOROOTcLcLMathcLcLMatRepStdlEdoublecO5cO5gRsPgR(Long_t size, void *p);
   static void delete_ROOTcLcLMathcLcLSMatrixlEdoublecO5cO5cOROOTcLcLMathcLcLMatRepStdlEdoublecO5cO5gRsPgR(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO5cO5cOROOTcLcLMathcLcLMatRepStdlEdoublecO5cO5gRsPgR(void *p);
   static void destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO5cO5cOROOTcLcLMathcLcLMatRepStdlEdoublecO5cO5gRsPgR(void *p);

   // Schema evolution read functions

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SMatrix<double,5,5,ROOT::Math::MatRepStd<double,5,5> >*)
   {
      ::ROOT::Math::SMatrix<double,5,5,ROOT::Math::MatRepStd<double,5,5> > *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SMatrix<double,5,5,ROOT::Math::MatRepStd<double,5,5> >));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SMatrix<double,5,5,ROOT::Math::MatRepStd<double,5,5> >", "Math/SMatrix.h", 101,
                  typeid(::ROOT::Math::SMatrix<double,5,5,ROOT::Math::MatRepStd<double,5,5> >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSMatrixlEdoublecO5cO5cOROOTcLcLMathcLcLMatRepStdlEdoublecO5cO5gRsPgR_Dictionary, isa_proxy, 4,
                  sizeof(::ROOT::Math::SMatrix<double,5,5,ROOT::Math::MatRepStd<double,5,5> >) );
      instance.SetNew(&new_ROOTcLcLMathcLcLSMatrixlEdoublecO5cO5cOROOTcLcLMathcLcLMatRepStdlEdoublecO5cO5gRsPgR);
      instance.SetNewArray(&newArray_ROOTcLcLMathcLcLSMatrixlEdoublecO5cO5cOROOTcLcLMathcLcLMatRepStdlEdoublecO5cO5gRsPgR);
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSMatrixlEdoublecO5cO5cOROOTcLcLMathcLcLMatRepStdlEdoublecO5cO5gRsPgR);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO5cO5cOROOTcLcLMathcLcLMatRepStdlEdoublecO5cO5gRsPgR);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO5cO5cOROOTcLcLMathcLcLMatRepStdlEdoublecO5cO5gRsPgR);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<double,5,5,ROOT::Math::MatRepStd<double,5,5> >","ROOT::Math::SMatrix<double,5,5>"));

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<double,5,5,ROOT::Math::MatRepStd<double,5,5> >","ROOT::Math::SMatrix<double, 5u, 5u, ROOT::Math::MatRepStd<double, 5u, 5u> >"));

      ::ROOT::Internal::TSchemaHelper* rule;

      // the io read rules
      std::vector<::ROOT::Internal::TSchemaHelper> readrules(3);
      rule = &readrules[0];
      rule->fSourceClass = "ROOT::Math::SMatrix<Double32_t,5,5>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[1];
      rule->fSourceClass = "ROOT::Math::SMatrix<float,5,5>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[2];
      rule->fSourceClass = "ROOT::Math::SMatrix<Float16_t,5,5>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      instance.SetReadRules( readrules );
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::SMatrix<double,5,5,ROOT::Math::MatRepStd<double,5,5> >*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::SMatrix<double,5,5,ROOT::Math::MatRepStd<double,5,5> >*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<double,5,5,ROOT::Math::MatRepStd<double,5,5> >*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLSMatrixlEdoublecO5cO5cOROOTcLcLMathcLcLMatRepStdlEdoublecO5cO5gRsPgR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<double,5,5,ROOT::Math::MatRepStd<double,5,5> >*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLSMatrixlEdoublecO5cO5cOROOTcLcLMathcLcLMatRepStdlEdoublecO5cO5gRsPgR_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLSMatrixlEdoublecO5cO5cOROOTcLcLMathcLcLMatRepStdlEdoublecO5cO5gRsPgR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSMatrixlEdoublecO5UcO5UcOROOTcLcLMathcLcLMatRepStdlEdoublecO5cO5gRsPgRcLcLSMatrixRow_Dictionary();
   static void ROOTcLcLMathcLcLSMatrixlEdoublecO5UcO5UcOROOTcLcLMathcLcLMatRepStdlEdoublecO5cO5gRsPgRcLcLSMatrixRow_TClassManip(TClass*);
   static void delete_ROOTcLcLMathcLcLSMatrixlEdoublecO5UcO5UcOROOTcLcLMathcLcLMatRepStdlEdoublecO5cO5gRsPgRcLcLSMatrixRow(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO5UcO5UcOROOTcLcLMathcLcLMatRepStdlEdoublecO5cO5gRsPgRcLcLSMatrixRow(void *p);
   static void destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO5UcO5UcOROOTcLcLMathcLcLMatRepStdlEdoublecO5cO5gRsPgRcLcLSMatrixRow(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SMatrix<double,5U,5U,ROOT::Math::MatRepStd<double,5,5> >::SMatrixRow*)
   {
      ::ROOT::Math::SMatrix<double,5U,5U,ROOT::Math::MatRepStd<double,5,5> >::SMatrixRow *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SMatrix<double,5U,5U,ROOT::Math::MatRepStd<double,5,5> >::SMatrixRow));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SMatrix<double,5U,5U,ROOT::Math::MatRepStd<double,5,5> >::SMatrixRow", "Math/SMatrix.h", 371,
                  typeid(::ROOT::Math::SMatrix<double,5U,5U,ROOT::Math::MatRepStd<double,5,5> >::SMatrixRow), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSMatrixlEdoublecO5UcO5UcOROOTcLcLMathcLcLMatRepStdlEdoublecO5cO5gRsPgRcLcLSMatrixRow_Dictionary, isa_proxy, 0,
                  sizeof(::ROOT::Math::SMatrix<double,5U,5U,ROOT::Math::MatRepStd<double,5,5> >::SMatrixRow) );
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSMatrixlEdoublecO5UcO5UcOROOTcLcLMathcLcLMatRepStdlEdoublecO5cO5gRsPgRcLcLSMatrixRow);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO5UcO5UcOROOTcLcLMathcLcLMatRepStdlEdoublecO5cO5gRsPgRcLcLSMatrixRow);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO5UcO5UcOROOTcLcLMathcLcLMatRepStdlEdoublecO5cO5gRsPgRcLcLSMatrixRow);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<double,5U,5U,ROOT::Math::MatRepStd<double,5,5> >::SMatrixRow","ROOT::Math::SMatrix<double,5,5>::SMatrixRow"));

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<double,5U,5U,ROOT::Math::MatRepStd<double,5,5> >::SMatrixRow","ROOT::Math::SMatrix<double, 5u, 5u, ROOT::Math::MatRepStd<double, 5u, 5u> >::SMatrixRow"));
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::SMatrix<double,5U,5U,ROOT::Math::MatRepStd<double,5,5> >::SMatrixRow*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::SMatrix<double,5U,5U,ROOT::Math::MatRepStd<double,5,5> >::SMatrixRow*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<double,5U,5U,ROOT::Math::MatRepStd<double,5,5> >::SMatrixRow*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLSMatrixlEdoublecO5UcO5UcOROOTcLcLMathcLcLMatRepStdlEdoublecO5cO5gRsPgRcLcLSMatrixRow_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<double,5U,5U,ROOT::Math::MatRepStd<double,5,5> >::SMatrixRow*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLSMatrixlEdoublecO5UcO5UcOROOTcLcLMathcLcLMatRepStdlEdoublecO5cO5gRsPgRcLcLSMatrixRow_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLSMatrixlEdoublecO5UcO5UcOROOTcLcLMathcLcLMatRepStdlEdoublecO5cO5gRsPgRcLcLSMatrixRow_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSMatrixlEdoublecO5UcO5UcOROOTcLcLMathcLcLMatRepStdlEdoublecO5cO5gRsPgRcLcLSMatrixRow_const_Dictionary();
   static void ROOTcLcLMathcLcLSMatrixlEdoublecO5UcO5UcOROOTcLcLMathcLcLMatRepStdlEdoublecO5cO5gRsPgRcLcLSMatrixRow_const_TClassManip(TClass*);
   static void delete_ROOTcLcLMathcLcLSMatrixlEdoublecO5UcO5UcOROOTcLcLMathcLcLMatRepStdlEdoublecO5cO5gRsPgRcLcLSMatrixRow_const(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO5UcO5UcOROOTcLcLMathcLcLMatRepStdlEdoublecO5cO5gRsPgRcLcLSMatrixRow_const(void *p);
   static void destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO5UcO5UcOROOTcLcLMathcLcLMatRepStdlEdoublecO5cO5gRsPgRcLcLSMatrixRow_const(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SMatrix<double,5U,5U,ROOT::Math::MatRepStd<double,5,5> >::SMatrixRow_const*)
   {
      ::ROOT::Math::SMatrix<double,5U,5U,ROOT::Math::MatRepStd<double,5,5> >::SMatrixRow_const *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SMatrix<double,5U,5U,ROOT::Math::MatRepStd<double,5,5> >::SMatrixRow_const));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SMatrix<double,5U,5U,ROOT::Math::MatRepStd<double,5,5> >::SMatrixRow_const", "Math/SMatrix.h", 382,
                  typeid(::ROOT::Math::SMatrix<double,5U,5U,ROOT::Math::MatRepStd<double,5,5> >::SMatrixRow_const), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSMatrixlEdoublecO5UcO5UcOROOTcLcLMathcLcLMatRepStdlEdoublecO5cO5gRsPgRcLcLSMatrixRow_const_Dictionary, isa_proxy, 0,
                  sizeof(::ROOT::Math::SMatrix<double,5U,5U,ROOT::Math::MatRepStd<double,5,5> >::SMatrixRow_const) );
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSMatrixlEdoublecO5UcO5UcOROOTcLcLMathcLcLMatRepStdlEdoublecO5cO5gRsPgRcLcLSMatrixRow_const);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO5UcO5UcOROOTcLcLMathcLcLMatRepStdlEdoublecO5cO5gRsPgRcLcLSMatrixRow_const);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO5UcO5UcOROOTcLcLMathcLcLMatRepStdlEdoublecO5cO5gRsPgRcLcLSMatrixRow_const);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<double,5U,5U,ROOT::Math::MatRepStd<double,5,5> >::SMatrixRow_const","ROOT::Math::SMatrix<double,5,5>::SMatrixRow_const"));

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<double,5U,5U,ROOT::Math::MatRepStd<double,5,5> >::SMatrixRow_const","ROOT::Math::SMatrix<double, 5u, 5u, ROOT::Math::MatRepStd<double, 5u, 5u> >::SMatrixRow_const"));
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::SMatrix<double,5U,5U,ROOT::Math::MatRepStd<double,5,5> >::SMatrixRow_const*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::SMatrix<double,5U,5U,ROOT::Math::MatRepStd<double,5,5> >::SMatrixRow_const*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<double,5U,5U,ROOT::Math::MatRepStd<double,5,5> >::SMatrixRow_const*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLSMatrixlEdoublecO5UcO5UcOROOTcLcLMathcLcLMatRepStdlEdoublecO5cO5gRsPgRcLcLSMatrixRow_const_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<double,5U,5U,ROOT::Math::MatRepStd<double,5,5> >::SMatrixRow_const*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLSMatrixlEdoublecO5UcO5UcOROOTcLcLMathcLcLMatRepStdlEdoublecO5cO5gRsPgRcLcLSMatrixRow_const_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLSMatrixlEdoublecO5UcO5UcOROOTcLcLMathcLcLMatRepStdlEdoublecO5cO5gRsPgRcLcLSMatrixRow_const_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSMatrixlEdoublecO6cO6cOROOTcLcLMathcLcLMatRepStdlEdoublecO6cO6gRsPgR_Dictionary();
   static void ROOTcLcLMathcLcLSMatrixlEdoublecO6cO6cOROOTcLcLMathcLcLMatRepStdlEdoublecO6cO6gRsPgR_TClassManip(TClass*);
   static void *new_ROOTcLcLMathcLcLSMatrixlEdoublecO6cO6cOROOTcLcLMathcLcLMatRepStdlEdoublecO6cO6gRsPgR(void *p = nullptr);
   static void *newArray_ROOTcLcLMathcLcLSMatrixlEdoublecO6cO6cOROOTcLcLMathcLcLMatRepStdlEdoublecO6cO6gRsPgR(Long_t size, void *p);
   static void delete_ROOTcLcLMathcLcLSMatrixlEdoublecO6cO6cOROOTcLcLMathcLcLMatRepStdlEdoublecO6cO6gRsPgR(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO6cO6cOROOTcLcLMathcLcLMatRepStdlEdoublecO6cO6gRsPgR(void *p);
   static void destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO6cO6cOROOTcLcLMathcLcLMatRepStdlEdoublecO6cO6gRsPgR(void *p);

   // Schema evolution read functions

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SMatrix<double,6,6,ROOT::Math::MatRepStd<double,6,6> >*)
   {
      ::ROOT::Math::SMatrix<double,6,6,ROOT::Math::MatRepStd<double,6,6> > *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SMatrix<double,6,6,ROOT::Math::MatRepStd<double,6,6> >));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SMatrix<double,6,6,ROOT::Math::MatRepStd<double,6,6> >", "Math/SMatrix.h", 101,
                  typeid(::ROOT::Math::SMatrix<double,6,6,ROOT::Math::MatRepStd<double,6,6> >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSMatrixlEdoublecO6cO6cOROOTcLcLMathcLcLMatRepStdlEdoublecO6cO6gRsPgR_Dictionary, isa_proxy, 4,
                  sizeof(::ROOT::Math::SMatrix<double,6,6,ROOT::Math::MatRepStd<double,6,6> >) );
      instance.SetNew(&new_ROOTcLcLMathcLcLSMatrixlEdoublecO6cO6cOROOTcLcLMathcLcLMatRepStdlEdoublecO6cO6gRsPgR);
      instance.SetNewArray(&newArray_ROOTcLcLMathcLcLSMatrixlEdoublecO6cO6cOROOTcLcLMathcLcLMatRepStdlEdoublecO6cO6gRsPgR);
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSMatrixlEdoublecO6cO6cOROOTcLcLMathcLcLMatRepStdlEdoublecO6cO6gRsPgR);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO6cO6cOROOTcLcLMathcLcLMatRepStdlEdoublecO6cO6gRsPgR);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO6cO6cOROOTcLcLMathcLcLMatRepStdlEdoublecO6cO6gRsPgR);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<double,6,6,ROOT::Math::MatRepStd<double,6,6> >","ROOT::Math::SMatrix<double,6,6>"));

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<double,6,6,ROOT::Math::MatRepStd<double,6,6> >","ROOT::Math::SMatrix<double, 6u, 6u, ROOT::Math::MatRepStd<double, 6u, 6u> >"));

      ::ROOT::Internal::TSchemaHelper* rule;

      // the io read rules
      std::vector<::ROOT::Internal::TSchemaHelper> readrules(3);
      rule = &readrules[0];
      rule->fSourceClass = "ROOT::Math::SMatrix<Double32_t,6,6>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[1];
      rule->fSourceClass = "ROOT::Math::SMatrix<float,6,6>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[2];
      rule->fSourceClass = "ROOT::Math::SMatrix<Float16_t,6,6>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      instance.SetReadRules( readrules );
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::SMatrix<double,6,6,ROOT::Math::MatRepStd<double,6,6> >*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::SMatrix<double,6,6,ROOT::Math::MatRepStd<double,6,6> >*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<double,6,6,ROOT::Math::MatRepStd<double,6,6> >*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLSMatrixlEdoublecO6cO6cOROOTcLcLMathcLcLMatRepStdlEdoublecO6cO6gRsPgR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<double,6,6,ROOT::Math::MatRepStd<double,6,6> >*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLSMatrixlEdoublecO6cO6cOROOTcLcLMathcLcLMatRepStdlEdoublecO6cO6gRsPgR_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLSMatrixlEdoublecO6cO6cOROOTcLcLMathcLcLMatRepStdlEdoublecO6cO6gRsPgR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSMatrixlEdoublecO6UcO6UcOROOTcLcLMathcLcLMatRepStdlEdoublecO6cO6gRsPgRcLcLSMatrixRow_Dictionary();
   static void ROOTcLcLMathcLcLSMatrixlEdoublecO6UcO6UcOROOTcLcLMathcLcLMatRepStdlEdoublecO6cO6gRsPgRcLcLSMatrixRow_TClassManip(TClass*);
   static void delete_ROOTcLcLMathcLcLSMatrixlEdoublecO6UcO6UcOROOTcLcLMathcLcLMatRepStdlEdoublecO6cO6gRsPgRcLcLSMatrixRow(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO6UcO6UcOROOTcLcLMathcLcLMatRepStdlEdoublecO6cO6gRsPgRcLcLSMatrixRow(void *p);
   static void destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO6UcO6UcOROOTcLcLMathcLcLMatRepStdlEdoublecO6cO6gRsPgRcLcLSMatrixRow(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SMatrix<double,6U,6U,ROOT::Math::MatRepStd<double,6,6> >::SMatrixRow*)
   {
      ::ROOT::Math::SMatrix<double,6U,6U,ROOT::Math::MatRepStd<double,6,6> >::SMatrixRow *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SMatrix<double,6U,6U,ROOT::Math::MatRepStd<double,6,6> >::SMatrixRow));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SMatrix<double,6U,6U,ROOT::Math::MatRepStd<double,6,6> >::SMatrixRow", "Math/SMatrix.h", 371,
                  typeid(::ROOT::Math::SMatrix<double,6U,6U,ROOT::Math::MatRepStd<double,6,6> >::SMatrixRow), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSMatrixlEdoublecO6UcO6UcOROOTcLcLMathcLcLMatRepStdlEdoublecO6cO6gRsPgRcLcLSMatrixRow_Dictionary, isa_proxy, 0,
                  sizeof(::ROOT::Math::SMatrix<double,6U,6U,ROOT::Math::MatRepStd<double,6,6> >::SMatrixRow) );
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSMatrixlEdoublecO6UcO6UcOROOTcLcLMathcLcLMatRepStdlEdoublecO6cO6gRsPgRcLcLSMatrixRow);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO6UcO6UcOROOTcLcLMathcLcLMatRepStdlEdoublecO6cO6gRsPgRcLcLSMatrixRow);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO6UcO6UcOROOTcLcLMathcLcLMatRepStdlEdoublecO6cO6gRsPgRcLcLSMatrixRow);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<double,6U,6U,ROOT::Math::MatRepStd<double,6,6> >::SMatrixRow","ROOT::Math::SMatrix<double,6,6>::SMatrixRow"));

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<double,6U,6U,ROOT::Math::MatRepStd<double,6,6> >::SMatrixRow","ROOT::Math::SMatrix<double, 6u, 6u, ROOT::Math::MatRepStd<double, 6u, 6u> >::SMatrixRow"));
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::SMatrix<double,6U,6U,ROOT::Math::MatRepStd<double,6,6> >::SMatrixRow*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::SMatrix<double,6U,6U,ROOT::Math::MatRepStd<double,6,6> >::SMatrixRow*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<double,6U,6U,ROOT::Math::MatRepStd<double,6,6> >::SMatrixRow*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLSMatrixlEdoublecO6UcO6UcOROOTcLcLMathcLcLMatRepStdlEdoublecO6cO6gRsPgRcLcLSMatrixRow_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<double,6U,6U,ROOT::Math::MatRepStd<double,6,6> >::SMatrixRow*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLSMatrixlEdoublecO6UcO6UcOROOTcLcLMathcLcLMatRepStdlEdoublecO6cO6gRsPgRcLcLSMatrixRow_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLSMatrixlEdoublecO6UcO6UcOROOTcLcLMathcLcLMatRepStdlEdoublecO6cO6gRsPgRcLcLSMatrixRow_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSMatrixlEdoublecO6UcO6UcOROOTcLcLMathcLcLMatRepStdlEdoublecO6cO6gRsPgRcLcLSMatrixRow_const_Dictionary();
   static void ROOTcLcLMathcLcLSMatrixlEdoublecO6UcO6UcOROOTcLcLMathcLcLMatRepStdlEdoublecO6cO6gRsPgRcLcLSMatrixRow_const_TClassManip(TClass*);
   static void delete_ROOTcLcLMathcLcLSMatrixlEdoublecO6UcO6UcOROOTcLcLMathcLcLMatRepStdlEdoublecO6cO6gRsPgRcLcLSMatrixRow_const(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO6UcO6UcOROOTcLcLMathcLcLMatRepStdlEdoublecO6cO6gRsPgRcLcLSMatrixRow_const(void *p);
   static void destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO6UcO6UcOROOTcLcLMathcLcLMatRepStdlEdoublecO6cO6gRsPgRcLcLSMatrixRow_const(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SMatrix<double,6U,6U,ROOT::Math::MatRepStd<double,6,6> >::SMatrixRow_const*)
   {
      ::ROOT::Math::SMatrix<double,6U,6U,ROOT::Math::MatRepStd<double,6,6> >::SMatrixRow_const *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SMatrix<double,6U,6U,ROOT::Math::MatRepStd<double,6,6> >::SMatrixRow_const));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SMatrix<double,6U,6U,ROOT::Math::MatRepStd<double,6,6> >::SMatrixRow_const", "Math/SMatrix.h", 382,
                  typeid(::ROOT::Math::SMatrix<double,6U,6U,ROOT::Math::MatRepStd<double,6,6> >::SMatrixRow_const), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSMatrixlEdoublecO6UcO6UcOROOTcLcLMathcLcLMatRepStdlEdoublecO6cO6gRsPgRcLcLSMatrixRow_const_Dictionary, isa_proxy, 0,
                  sizeof(::ROOT::Math::SMatrix<double,6U,6U,ROOT::Math::MatRepStd<double,6,6> >::SMatrixRow_const) );
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSMatrixlEdoublecO6UcO6UcOROOTcLcLMathcLcLMatRepStdlEdoublecO6cO6gRsPgRcLcLSMatrixRow_const);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO6UcO6UcOROOTcLcLMathcLcLMatRepStdlEdoublecO6cO6gRsPgRcLcLSMatrixRow_const);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO6UcO6UcOROOTcLcLMathcLcLMatRepStdlEdoublecO6cO6gRsPgRcLcLSMatrixRow_const);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<double,6U,6U,ROOT::Math::MatRepStd<double,6,6> >::SMatrixRow_const","ROOT::Math::SMatrix<double,6,6>::SMatrixRow_const"));

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<double,6U,6U,ROOT::Math::MatRepStd<double,6,6> >::SMatrixRow_const","ROOT::Math::SMatrix<double, 6u, 6u, ROOT::Math::MatRepStd<double, 6u, 6u> >::SMatrixRow_const"));
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::SMatrix<double,6U,6U,ROOT::Math::MatRepStd<double,6,6> >::SMatrixRow_const*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::SMatrix<double,6U,6U,ROOT::Math::MatRepStd<double,6,6> >::SMatrixRow_const*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<double,6U,6U,ROOT::Math::MatRepStd<double,6,6> >::SMatrixRow_const*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLSMatrixlEdoublecO6UcO6UcOROOTcLcLMathcLcLMatRepStdlEdoublecO6cO6gRsPgRcLcLSMatrixRow_const_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<double,6U,6U,ROOT::Math::MatRepStd<double,6,6> >::SMatrixRow_const*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLSMatrixlEdoublecO6UcO6UcOROOTcLcLMathcLcLMatRepStdlEdoublecO6cO6gRsPgRcLcLSMatrixRow_const_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLSMatrixlEdoublecO6UcO6UcOROOTcLcLMathcLcLMatRepStdlEdoublecO6cO6gRsPgRcLcLSMatrixRow_const_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSMatrixlEdoublecO7cO7cOROOTcLcLMathcLcLMatRepStdlEdoublecO7cO7gRsPgR_Dictionary();
   static void ROOTcLcLMathcLcLSMatrixlEdoublecO7cO7cOROOTcLcLMathcLcLMatRepStdlEdoublecO7cO7gRsPgR_TClassManip(TClass*);
   static void *new_ROOTcLcLMathcLcLSMatrixlEdoublecO7cO7cOROOTcLcLMathcLcLMatRepStdlEdoublecO7cO7gRsPgR(void *p = nullptr);
   static void *newArray_ROOTcLcLMathcLcLSMatrixlEdoublecO7cO7cOROOTcLcLMathcLcLMatRepStdlEdoublecO7cO7gRsPgR(Long_t size, void *p);
   static void delete_ROOTcLcLMathcLcLSMatrixlEdoublecO7cO7cOROOTcLcLMathcLcLMatRepStdlEdoublecO7cO7gRsPgR(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO7cO7cOROOTcLcLMathcLcLMatRepStdlEdoublecO7cO7gRsPgR(void *p);
   static void destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO7cO7cOROOTcLcLMathcLcLMatRepStdlEdoublecO7cO7gRsPgR(void *p);

   // Schema evolution read functions

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SMatrix<double,7,7,ROOT::Math::MatRepStd<double,7,7> >*)
   {
      ::ROOT::Math::SMatrix<double,7,7,ROOT::Math::MatRepStd<double,7,7> > *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SMatrix<double,7,7,ROOT::Math::MatRepStd<double,7,7> >));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SMatrix<double,7,7,ROOT::Math::MatRepStd<double,7,7> >", "Math/SMatrix.h", 101,
                  typeid(::ROOT::Math::SMatrix<double,7,7,ROOT::Math::MatRepStd<double,7,7> >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSMatrixlEdoublecO7cO7cOROOTcLcLMathcLcLMatRepStdlEdoublecO7cO7gRsPgR_Dictionary, isa_proxy, 4,
                  sizeof(::ROOT::Math::SMatrix<double,7,7,ROOT::Math::MatRepStd<double,7,7> >) );
      instance.SetNew(&new_ROOTcLcLMathcLcLSMatrixlEdoublecO7cO7cOROOTcLcLMathcLcLMatRepStdlEdoublecO7cO7gRsPgR);
      instance.SetNewArray(&newArray_ROOTcLcLMathcLcLSMatrixlEdoublecO7cO7cOROOTcLcLMathcLcLMatRepStdlEdoublecO7cO7gRsPgR);
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSMatrixlEdoublecO7cO7cOROOTcLcLMathcLcLMatRepStdlEdoublecO7cO7gRsPgR);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO7cO7cOROOTcLcLMathcLcLMatRepStdlEdoublecO7cO7gRsPgR);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO7cO7cOROOTcLcLMathcLcLMatRepStdlEdoublecO7cO7gRsPgR);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<double,7,7,ROOT::Math::MatRepStd<double,7,7> >","ROOT::Math::SMatrix<double,7,7>"));

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<double,7,7,ROOT::Math::MatRepStd<double,7,7> >","ROOT::Math::SMatrix<double, 7u, 7u, ROOT::Math::MatRepStd<double, 7u, 7u> >"));

      ::ROOT::Internal::TSchemaHelper* rule;

      // the io read rules
      std::vector<::ROOT::Internal::TSchemaHelper> readrules(3);
      rule = &readrules[0];
      rule->fSourceClass = "ROOT::Math::SMatrix<Double32_t,7,7>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[1];
      rule->fSourceClass = "ROOT::Math::SMatrix<float,7,7>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[2];
      rule->fSourceClass = "ROOT::Math::SMatrix<Float16_t,7,7>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      instance.SetReadRules( readrules );
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::SMatrix<double,7,7,ROOT::Math::MatRepStd<double,7,7> >*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::SMatrix<double,7,7,ROOT::Math::MatRepStd<double,7,7> >*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<double,7,7,ROOT::Math::MatRepStd<double,7,7> >*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLSMatrixlEdoublecO7cO7cOROOTcLcLMathcLcLMatRepStdlEdoublecO7cO7gRsPgR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<double,7,7,ROOT::Math::MatRepStd<double,7,7> >*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLSMatrixlEdoublecO7cO7cOROOTcLcLMathcLcLMatRepStdlEdoublecO7cO7gRsPgR_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLSMatrixlEdoublecO7cO7cOROOTcLcLMathcLcLMatRepStdlEdoublecO7cO7gRsPgR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSMatrixlEdoublecO7UcO7UcOROOTcLcLMathcLcLMatRepStdlEdoublecO7cO7gRsPgRcLcLSMatrixRow_Dictionary();
   static void ROOTcLcLMathcLcLSMatrixlEdoublecO7UcO7UcOROOTcLcLMathcLcLMatRepStdlEdoublecO7cO7gRsPgRcLcLSMatrixRow_TClassManip(TClass*);
   static void delete_ROOTcLcLMathcLcLSMatrixlEdoublecO7UcO7UcOROOTcLcLMathcLcLMatRepStdlEdoublecO7cO7gRsPgRcLcLSMatrixRow(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO7UcO7UcOROOTcLcLMathcLcLMatRepStdlEdoublecO7cO7gRsPgRcLcLSMatrixRow(void *p);
   static void destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO7UcO7UcOROOTcLcLMathcLcLMatRepStdlEdoublecO7cO7gRsPgRcLcLSMatrixRow(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SMatrix<double,7U,7U,ROOT::Math::MatRepStd<double,7,7> >::SMatrixRow*)
   {
      ::ROOT::Math::SMatrix<double,7U,7U,ROOT::Math::MatRepStd<double,7,7> >::SMatrixRow *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SMatrix<double,7U,7U,ROOT::Math::MatRepStd<double,7,7> >::SMatrixRow));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SMatrix<double,7U,7U,ROOT::Math::MatRepStd<double,7,7> >::SMatrixRow", "Math/SMatrix.h", 371,
                  typeid(::ROOT::Math::SMatrix<double,7U,7U,ROOT::Math::MatRepStd<double,7,7> >::SMatrixRow), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSMatrixlEdoublecO7UcO7UcOROOTcLcLMathcLcLMatRepStdlEdoublecO7cO7gRsPgRcLcLSMatrixRow_Dictionary, isa_proxy, 0,
                  sizeof(::ROOT::Math::SMatrix<double,7U,7U,ROOT::Math::MatRepStd<double,7,7> >::SMatrixRow) );
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSMatrixlEdoublecO7UcO7UcOROOTcLcLMathcLcLMatRepStdlEdoublecO7cO7gRsPgRcLcLSMatrixRow);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO7UcO7UcOROOTcLcLMathcLcLMatRepStdlEdoublecO7cO7gRsPgRcLcLSMatrixRow);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO7UcO7UcOROOTcLcLMathcLcLMatRepStdlEdoublecO7cO7gRsPgRcLcLSMatrixRow);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<double,7U,7U,ROOT::Math::MatRepStd<double,7,7> >::SMatrixRow","ROOT::Math::SMatrix<double,7,7>::SMatrixRow"));

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<double,7U,7U,ROOT::Math::MatRepStd<double,7,7> >::SMatrixRow","ROOT::Math::SMatrix<double, 7u, 7u, ROOT::Math::MatRepStd<double, 7u, 7u> >::SMatrixRow"));
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::SMatrix<double,7U,7U,ROOT::Math::MatRepStd<double,7,7> >::SMatrixRow*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::SMatrix<double,7U,7U,ROOT::Math::MatRepStd<double,7,7> >::SMatrixRow*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<double,7U,7U,ROOT::Math::MatRepStd<double,7,7> >::SMatrixRow*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLSMatrixlEdoublecO7UcO7UcOROOTcLcLMathcLcLMatRepStdlEdoublecO7cO7gRsPgRcLcLSMatrixRow_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<double,7U,7U,ROOT::Math::MatRepStd<double,7,7> >::SMatrixRow*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLSMatrixlEdoublecO7UcO7UcOROOTcLcLMathcLcLMatRepStdlEdoublecO7cO7gRsPgRcLcLSMatrixRow_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLSMatrixlEdoublecO7UcO7UcOROOTcLcLMathcLcLMatRepStdlEdoublecO7cO7gRsPgRcLcLSMatrixRow_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSMatrixlEdoublecO7UcO7UcOROOTcLcLMathcLcLMatRepStdlEdoublecO7cO7gRsPgRcLcLSMatrixRow_const_Dictionary();
   static void ROOTcLcLMathcLcLSMatrixlEdoublecO7UcO7UcOROOTcLcLMathcLcLMatRepStdlEdoublecO7cO7gRsPgRcLcLSMatrixRow_const_TClassManip(TClass*);
   static void delete_ROOTcLcLMathcLcLSMatrixlEdoublecO7UcO7UcOROOTcLcLMathcLcLMatRepStdlEdoublecO7cO7gRsPgRcLcLSMatrixRow_const(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO7UcO7UcOROOTcLcLMathcLcLMatRepStdlEdoublecO7cO7gRsPgRcLcLSMatrixRow_const(void *p);
   static void destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO7UcO7UcOROOTcLcLMathcLcLMatRepStdlEdoublecO7cO7gRsPgRcLcLSMatrixRow_const(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SMatrix<double,7U,7U,ROOT::Math::MatRepStd<double,7,7> >::SMatrixRow_const*)
   {
      ::ROOT::Math::SMatrix<double,7U,7U,ROOT::Math::MatRepStd<double,7,7> >::SMatrixRow_const *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SMatrix<double,7U,7U,ROOT::Math::MatRepStd<double,7,7> >::SMatrixRow_const));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SMatrix<double,7U,7U,ROOT::Math::MatRepStd<double,7,7> >::SMatrixRow_const", "Math/SMatrix.h", 382,
                  typeid(::ROOT::Math::SMatrix<double,7U,7U,ROOT::Math::MatRepStd<double,7,7> >::SMatrixRow_const), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSMatrixlEdoublecO7UcO7UcOROOTcLcLMathcLcLMatRepStdlEdoublecO7cO7gRsPgRcLcLSMatrixRow_const_Dictionary, isa_proxy, 0,
                  sizeof(::ROOT::Math::SMatrix<double,7U,7U,ROOT::Math::MatRepStd<double,7,7> >::SMatrixRow_const) );
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSMatrixlEdoublecO7UcO7UcOROOTcLcLMathcLcLMatRepStdlEdoublecO7cO7gRsPgRcLcLSMatrixRow_const);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO7UcO7UcOROOTcLcLMathcLcLMatRepStdlEdoublecO7cO7gRsPgRcLcLSMatrixRow_const);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO7UcO7UcOROOTcLcLMathcLcLMatRepStdlEdoublecO7cO7gRsPgRcLcLSMatrixRow_const);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<double,7U,7U,ROOT::Math::MatRepStd<double,7,7> >::SMatrixRow_const","ROOT::Math::SMatrix<double,7,7>::SMatrixRow_const"));

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<double,7U,7U,ROOT::Math::MatRepStd<double,7,7> >::SMatrixRow_const","ROOT::Math::SMatrix<double, 7u, 7u, ROOT::Math::MatRepStd<double, 7u, 7u> >::SMatrixRow_const"));
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::SMatrix<double,7U,7U,ROOT::Math::MatRepStd<double,7,7> >::SMatrixRow_const*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::SMatrix<double,7U,7U,ROOT::Math::MatRepStd<double,7,7> >::SMatrixRow_const*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<double,7U,7U,ROOT::Math::MatRepStd<double,7,7> >::SMatrixRow_const*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLSMatrixlEdoublecO7UcO7UcOROOTcLcLMathcLcLMatRepStdlEdoublecO7cO7gRsPgRcLcLSMatrixRow_const_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<double,7U,7U,ROOT::Math::MatRepStd<double,7,7> >::SMatrixRow_const*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLSMatrixlEdoublecO7UcO7UcOROOTcLcLMathcLcLMatRepStdlEdoublecO7cO7gRsPgRcLcLSMatrixRow_const_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLSMatrixlEdoublecO7UcO7UcOROOTcLcLMathcLcLMatRepStdlEdoublecO7cO7gRsPgRcLcLSMatrixRow_const_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSMatrixlEdoublecO2cO2cOROOTcLcLMathcLcLMatRepSymlEdoublecO2gRsPgR_Dictionary();
   static void ROOTcLcLMathcLcLSMatrixlEdoublecO2cO2cOROOTcLcLMathcLcLMatRepSymlEdoublecO2gRsPgR_TClassManip(TClass*);
   static void *new_ROOTcLcLMathcLcLSMatrixlEdoublecO2cO2cOROOTcLcLMathcLcLMatRepSymlEdoublecO2gRsPgR(void *p = nullptr);
   static void *newArray_ROOTcLcLMathcLcLSMatrixlEdoublecO2cO2cOROOTcLcLMathcLcLMatRepSymlEdoublecO2gRsPgR(Long_t size, void *p);
   static void delete_ROOTcLcLMathcLcLSMatrixlEdoublecO2cO2cOROOTcLcLMathcLcLMatRepSymlEdoublecO2gRsPgR(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO2cO2cOROOTcLcLMathcLcLMatRepSymlEdoublecO2gRsPgR(void *p);
   static void destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO2cO2cOROOTcLcLMathcLcLMatRepSymlEdoublecO2gRsPgR(void *p);

   // Schema evolution read functions

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SMatrix<double,2,2,ROOT::Math::MatRepSym<double,2> >*)
   {
      ::ROOT::Math::SMatrix<double,2,2,ROOT::Math::MatRepSym<double,2> > *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SMatrix<double,2,2,ROOT::Math::MatRepSym<double,2> >));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SMatrix<double,2,2,ROOT::Math::MatRepSym<double,2> >", "Math/SMatrix.h", 101,
                  typeid(::ROOT::Math::SMatrix<double,2,2,ROOT::Math::MatRepSym<double,2> >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSMatrixlEdoublecO2cO2cOROOTcLcLMathcLcLMatRepSymlEdoublecO2gRsPgR_Dictionary, isa_proxy, 4,
                  sizeof(::ROOT::Math::SMatrix<double,2,2,ROOT::Math::MatRepSym<double,2> >) );
      instance.SetNew(&new_ROOTcLcLMathcLcLSMatrixlEdoublecO2cO2cOROOTcLcLMathcLcLMatRepSymlEdoublecO2gRsPgR);
      instance.SetNewArray(&newArray_ROOTcLcLMathcLcLSMatrixlEdoublecO2cO2cOROOTcLcLMathcLcLMatRepSymlEdoublecO2gRsPgR);
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSMatrixlEdoublecO2cO2cOROOTcLcLMathcLcLMatRepSymlEdoublecO2gRsPgR);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO2cO2cOROOTcLcLMathcLcLMatRepSymlEdoublecO2gRsPgR);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO2cO2cOROOTcLcLMathcLcLMatRepSymlEdoublecO2gRsPgR);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<double,2,2,ROOT::Math::MatRepSym<double,2> >","ROOT::Math::SMatrix<double, 2u, 2u, ROOT::Math::MatRepSym<double, 2u> >"));

      ::ROOT::Internal::TSchemaHelper* rule;

      // the io read rules
      std::vector<::ROOT::Internal::TSchemaHelper> readrules(3);
      rule = &readrules[0];
      rule->fSourceClass = "ROOT::Math::SMatrix<double,2,2,ROOT::Math::MatRepSym<Double32_t,2> >";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[1];
      rule->fSourceClass = "ROOT::Math::SMatrix<double,2,2,ROOT::Math::MatRepSym<float,2> >";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[2];
      rule->fSourceClass = "ROOT::Math::SMatrix<double,2,2,ROOT::Math::MatRepSym<Float16_t,2> >";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      instance.SetReadRules( readrules );
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::SMatrix<double,2,2,ROOT::Math::MatRepSym<double,2> >*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::SMatrix<double,2,2,ROOT::Math::MatRepSym<double,2> >*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<double,2,2,ROOT::Math::MatRepSym<double,2> >*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLSMatrixlEdoublecO2cO2cOROOTcLcLMathcLcLMatRepSymlEdoublecO2gRsPgR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<double,2,2,ROOT::Math::MatRepSym<double,2> >*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLSMatrixlEdoublecO2cO2cOROOTcLcLMathcLcLMatRepSymlEdoublecO2gRsPgR_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLSMatrixlEdoublecO2cO2cOROOTcLcLMathcLcLMatRepSymlEdoublecO2gRsPgR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSMatrixlEdoublecO2UcO2UcOROOTcLcLMathcLcLMatRepSymlEdoublecO2gRsPgRcLcLSMatrixRow_Dictionary();
   static void ROOTcLcLMathcLcLSMatrixlEdoublecO2UcO2UcOROOTcLcLMathcLcLMatRepSymlEdoublecO2gRsPgRcLcLSMatrixRow_TClassManip(TClass*);
   static void delete_ROOTcLcLMathcLcLSMatrixlEdoublecO2UcO2UcOROOTcLcLMathcLcLMatRepSymlEdoublecO2gRsPgRcLcLSMatrixRow(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO2UcO2UcOROOTcLcLMathcLcLMatRepSymlEdoublecO2gRsPgRcLcLSMatrixRow(void *p);
   static void destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO2UcO2UcOROOTcLcLMathcLcLMatRepSymlEdoublecO2gRsPgRcLcLSMatrixRow(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SMatrix<double,2U,2U,ROOT::Math::MatRepSym<double,2> >::SMatrixRow*)
   {
      ::ROOT::Math::SMatrix<double,2U,2U,ROOT::Math::MatRepSym<double,2> >::SMatrixRow *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SMatrix<double,2U,2U,ROOT::Math::MatRepSym<double,2> >::SMatrixRow));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SMatrix<double,2U,2U,ROOT::Math::MatRepSym<double,2> >::SMatrixRow", "Math/SMatrix.h", 371,
                  typeid(::ROOT::Math::SMatrix<double,2U,2U,ROOT::Math::MatRepSym<double,2> >::SMatrixRow), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSMatrixlEdoublecO2UcO2UcOROOTcLcLMathcLcLMatRepSymlEdoublecO2gRsPgRcLcLSMatrixRow_Dictionary, isa_proxy, 0,
                  sizeof(::ROOT::Math::SMatrix<double,2U,2U,ROOT::Math::MatRepSym<double,2> >::SMatrixRow) );
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSMatrixlEdoublecO2UcO2UcOROOTcLcLMathcLcLMatRepSymlEdoublecO2gRsPgRcLcLSMatrixRow);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO2UcO2UcOROOTcLcLMathcLcLMatRepSymlEdoublecO2gRsPgRcLcLSMatrixRow);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO2UcO2UcOROOTcLcLMathcLcLMatRepSymlEdoublecO2gRsPgRcLcLSMatrixRow);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<double,2U,2U,ROOT::Math::MatRepSym<double,2> >::SMatrixRow","ROOT::Math::SMatrix<double,2,2,ROOT::Math::MatRepSym<double,2> >::SMatrixRow"));

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<double,2U,2U,ROOT::Math::MatRepSym<double,2> >::SMatrixRow","ROOT::Math::SMatrix<double, 2u, 2u, ROOT::Math::MatRepSym<double, 2u> >::SMatrixRow"));
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::SMatrix<double,2U,2U,ROOT::Math::MatRepSym<double,2> >::SMatrixRow*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::SMatrix<double,2U,2U,ROOT::Math::MatRepSym<double,2> >::SMatrixRow*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<double,2U,2U,ROOT::Math::MatRepSym<double,2> >::SMatrixRow*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLSMatrixlEdoublecO2UcO2UcOROOTcLcLMathcLcLMatRepSymlEdoublecO2gRsPgRcLcLSMatrixRow_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<double,2U,2U,ROOT::Math::MatRepSym<double,2> >::SMatrixRow*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLSMatrixlEdoublecO2UcO2UcOROOTcLcLMathcLcLMatRepSymlEdoublecO2gRsPgRcLcLSMatrixRow_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLSMatrixlEdoublecO2UcO2UcOROOTcLcLMathcLcLMatRepSymlEdoublecO2gRsPgRcLcLSMatrixRow_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSMatrixlEdoublecO2UcO2UcOROOTcLcLMathcLcLMatRepSymlEdoublecO2gRsPgRcLcLSMatrixRow_const_Dictionary();
   static void ROOTcLcLMathcLcLSMatrixlEdoublecO2UcO2UcOROOTcLcLMathcLcLMatRepSymlEdoublecO2gRsPgRcLcLSMatrixRow_const_TClassManip(TClass*);
   static void delete_ROOTcLcLMathcLcLSMatrixlEdoublecO2UcO2UcOROOTcLcLMathcLcLMatRepSymlEdoublecO2gRsPgRcLcLSMatrixRow_const(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO2UcO2UcOROOTcLcLMathcLcLMatRepSymlEdoublecO2gRsPgRcLcLSMatrixRow_const(void *p);
   static void destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO2UcO2UcOROOTcLcLMathcLcLMatRepSymlEdoublecO2gRsPgRcLcLSMatrixRow_const(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SMatrix<double,2U,2U,ROOT::Math::MatRepSym<double,2> >::SMatrixRow_const*)
   {
      ::ROOT::Math::SMatrix<double,2U,2U,ROOT::Math::MatRepSym<double,2> >::SMatrixRow_const *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SMatrix<double,2U,2U,ROOT::Math::MatRepSym<double,2> >::SMatrixRow_const));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SMatrix<double,2U,2U,ROOT::Math::MatRepSym<double,2> >::SMatrixRow_const", "Math/SMatrix.h", 382,
                  typeid(::ROOT::Math::SMatrix<double,2U,2U,ROOT::Math::MatRepSym<double,2> >::SMatrixRow_const), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSMatrixlEdoublecO2UcO2UcOROOTcLcLMathcLcLMatRepSymlEdoublecO2gRsPgRcLcLSMatrixRow_const_Dictionary, isa_proxy, 0,
                  sizeof(::ROOT::Math::SMatrix<double,2U,2U,ROOT::Math::MatRepSym<double,2> >::SMatrixRow_const) );
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSMatrixlEdoublecO2UcO2UcOROOTcLcLMathcLcLMatRepSymlEdoublecO2gRsPgRcLcLSMatrixRow_const);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO2UcO2UcOROOTcLcLMathcLcLMatRepSymlEdoublecO2gRsPgRcLcLSMatrixRow_const);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO2UcO2UcOROOTcLcLMathcLcLMatRepSymlEdoublecO2gRsPgRcLcLSMatrixRow_const);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<double,2U,2U,ROOT::Math::MatRepSym<double,2> >::SMatrixRow_const","ROOT::Math::SMatrix<double,2,2,ROOT::Math::MatRepSym<double,2> >::SMatrixRow_const"));

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<double,2U,2U,ROOT::Math::MatRepSym<double,2> >::SMatrixRow_const","ROOT::Math::SMatrix<double, 2u, 2u, ROOT::Math::MatRepSym<double, 2u> >::SMatrixRow_const"));
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::SMatrix<double,2U,2U,ROOT::Math::MatRepSym<double,2> >::SMatrixRow_const*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::SMatrix<double,2U,2U,ROOT::Math::MatRepSym<double,2> >::SMatrixRow_const*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<double,2U,2U,ROOT::Math::MatRepSym<double,2> >::SMatrixRow_const*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLSMatrixlEdoublecO2UcO2UcOROOTcLcLMathcLcLMatRepSymlEdoublecO2gRsPgRcLcLSMatrixRow_const_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<double,2U,2U,ROOT::Math::MatRepSym<double,2> >::SMatrixRow_const*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLSMatrixlEdoublecO2UcO2UcOROOTcLcLMathcLcLMatRepSymlEdoublecO2gRsPgRcLcLSMatrixRow_const_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLSMatrixlEdoublecO2UcO2UcOROOTcLcLMathcLcLMatRepSymlEdoublecO2gRsPgRcLcLSMatrixRow_const_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSMatrixlEdoublecO3cO3cOROOTcLcLMathcLcLMatRepSymlEdoublecO3gRsPgR_Dictionary();
   static void ROOTcLcLMathcLcLSMatrixlEdoublecO3cO3cOROOTcLcLMathcLcLMatRepSymlEdoublecO3gRsPgR_TClassManip(TClass*);
   static void *new_ROOTcLcLMathcLcLSMatrixlEdoublecO3cO3cOROOTcLcLMathcLcLMatRepSymlEdoublecO3gRsPgR(void *p = nullptr);
   static void *newArray_ROOTcLcLMathcLcLSMatrixlEdoublecO3cO3cOROOTcLcLMathcLcLMatRepSymlEdoublecO3gRsPgR(Long_t size, void *p);
   static void delete_ROOTcLcLMathcLcLSMatrixlEdoublecO3cO3cOROOTcLcLMathcLcLMatRepSymlEdoublecO3gRsPgR(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO3cO3cOROOTcLcLMathcLcLMatRepSymlEdoublecO3gRsPgR(void *p);
   static void destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO3cO3cOROOTcLcLMathcLcLMatRepSymlEdoublecO3gRsPgR(void *p);

   // Schema evolution read functions

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SMatrix<double,3,3,ROOT::Math::MatRepSym<double,3> >*)
   {
      ::ROOT::Math::SMatrix<double,3,3,ROOT::Math::MatRepSym<double,3> > *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SMatrix<double,3,3,ROOT::Math::MatRepSym<double,3> >));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SMatrix<double,3,3,ROOT::Math::MatRepSym<double,3> >", "Math/SMatrix.h", 101,
                  typeid(::ROOT::Math::SMatrix<double,3,3,ROOT::Math::MatRepSym<double,3> >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSMatrixlEdoublecO3cO3cOROOTcLcLMathcLcLMatRepSymlEdoublecO3gRsPgR_Dictionary, isa_proxy, 4,
                  sizeof(::ROOT::Math::SMatrix<double,3,3,ROOT::Math::MatRepSym<double,3> >) );
      instance.SetNew(&new_ROOTcLcLMathcLcLSMatrixlEdoublecO3cO3cOROOTcLcLMathcLcLMatRepSymlEdoublecO3gRsPgR);
      instance.SetNewArray(&newArray_ROOTcLcLMathcLcLSMatrixlEdoublecO3cO3cOROOTcLcLMathcLcLMatRepSymlEdoublecO3gRsPgR);
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSMatrixlEdoublecO3cO3cOROOTcLcLMathcLcLMatRepSymlEdoublecO3gRsPgR);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO3cO3cOROOTcLcLMathcLcLMatRepSymlEdoublecO3gRsPgR);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO3cO3cOROOTcLcLMathcLcLMatRepSymlEdoublecO3gRsPgR);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<double,3,3,ROOT::Math::MatRepSym<double,3> >","ROOT::Math::SMatrix<double, 3u, 3u, ROOT::Math::MatRepSym<double, 3u> >"));

      ::ROOT::Internal::TSchemaHelper* rule;

      // the io read rules
      std::vector<::ROOT::Internal::TSchemaHelper> readrules(3);
      rule = &readrules[0];
      rule->fSourceClass = "ROOT::Math::SMatrix<double,3,3,ROOT::Math::MatRepSym<Double32_t,3> >";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[1];
      rule->fSourceClass = "ROOT::Math::SMatrix<double,3,3,ROOT::Math::MatRepSym<float,3> >";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[2];
      rule->fSourceClass = "ROOT::Math::SMatrix<double,3,3,ROOT::Math::MatRepSym<Float16_t,3> >";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      instance.SetReadRules( readrules );
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::SMatrix<double,3,3,ROOT::Math::MatRepSym<double,3> >*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::SMatrix<double,3,3,ROOT::Math::MatRepSym<double,3> >*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<double,3,3,ROOT::Math::MatRepSym<double,3> >*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLSMatrixlEdoublecO3cO3cOROOTcLcLMathcLcLMatRepSymlEdoublecO3gRsPgR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<double,3,3,ROOT::Math::MatRepSym<double,3> >*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLSMatrixlEdoublecO3cO3cOROOTcLcLMathcLcLMatRepSymlEdoublecO3gRsPgR_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLSMatrixlEdoublecO3cO3cOROOTcLcLMathcLcLMatRepSymlEdoublecO3gRsPgR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSMatrixlEdoublecO3UcO3UcOROOTcLcLMathcLcLMatRepSymlEdoublecO3gRsPgRcLcLSMatrixRow_Dictionary();
   static void ROOTcLcLMathcLcLSMatrixlEdoublecO3UcO3UcOROOTcLcLMathcLcLMatRepSymlEdoublecO3gRsPgRcLcLSMatrixRow_TClassManip(TClass*);
   static void delete_ROOTcLcLMathcLcLSMatrixlEdoublecO3UcO3UcOROOTcLcLMathcLcLMatRepSymlEdoublecO3gRsPgRcLcLSMatrixRow(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO3UcO3UcOROOTcLcLMathcLcLMatRepSymlEdoublecO3gRsPgRcLcLSMatrixRow(void *p);
   static void destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO3UcO3UcOROOTcLcLMathcLcLMatRepSymlEdoublecO3gRsPgRcLcLSMatrixRow(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SMatrix<double,3U,3U,ROOT::Math::MatRepSym<double,3> >::SMatrixRow*)
   {
      ::ROOT::Math::SMatrix<double,3U,3U,ROOT::Math::MatRepSym<double,3> >::SMatrixRow *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SMatrix<double,3U,3U,ROOT::Math::MatRepSym<double,3> >::SMatrixRow));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SMatrix<double,3U,3U,ROOT::Math::MatRepSym<double,3> >::SMatrixRow", "Math/SMatrix.h", 371,
                  typeid(::ROOT::Math::SMatrix<double,3U,3U,ROOT::Math::MatRepSym<double,3> >::SMatrixRow), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSMatrixlEdoublecO3UcO3UcOROOTcLcLMathcLcLMatRepSymlEdoublecO3gRsPgRcLcLSMatrixRow_Dictionary, isa_proxy, 0,
                  sizeof(::ROOT::Math::SMatrix<double,3U,3U,ROOT::Math::MatRepSym<double,3> >::SMatrixRow) );
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSMatrixlEdoublecO3UcO3UcOROOTcLcLMathcLcLMatRepSymlEdoublecO3gRsPgRcLcLSMatrixRow);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO3UcO3UcOROOTcLcLMathcLcLMatRepSymlEdoublecO3gRsPgRcLcLSMatrixRow);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO3UcO3UcOROOTcLcLMathcLcLMatRepSymlEdoublecO3gRsPgRcLcLSMatrixRow);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<double,3U,3U,ROOT::Math::MatRepSym<double,3> >::SMatrixRow","ROOT::Math::SMatrix<double,3,3,ROOT::Math::MatRepSym<double,3> >::SMatrixRow"));

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<double,3U,3U,ROOT::Math::MatRepSym<double,3> >::SMatrixRow","ROOT::Math::SMatrix<double, 3u, 3u, ROOT::Math::MatRepSym<double, 3u> >::SMatrixRow"));
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::SMatrix<double,3U,3U,ROOT::Math::MatRepSym<double,3> >::SMatrixRow*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::SMatrix<double,3U,3U,ROOT::Math::MatRepSym<double,3> >::SMatrixRow*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<double,3U,3U,ROOT::Math::MatRepSym<double,3> >::SMatrixRow*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLSMatrixlEdoublecO3UcO3UcOROOTcLcLMathcLcLMatRepSymlEdoublecO3gRsPgRcLcLSMatrixRow_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<double,3U,3U,ROOT::Math::MatRepSym<double,3> >::SMatrixRow*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLSMatrixlEdoublecO3UcO3UcOROOTcLcLMathcLcLMatRepSymlEdoublecO3gRsPgRcLcLSMatrixRow_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLSMatrixlEdoublecO3UcO3UcOROOTcLcLMathcLcLMatRepSymlEdoublecO3gRsPgRcLcLSMatrixRow_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSMatrixlEdoublecO3UcO3UcOROOTcLcLMathcLcLMatRepSymlEdoublecO3gRsPgRcLcLSMatrixRow_const_Dictionary();
   static void ROOTcLcLMathcLcLSMatrixlEdoublecO3UcO3UcOROOTcLcLMathcLcLMatRepSymlEdoublecO3gRsPgRcLcLSMatrixRow_const_TClassManip(TClass*);
   static void delete_ROOTcLcLMathcLcLSMatrixlEdoublecO3UcO3UcOROOTcLcLMathcLcLMatRepSymlEdoublecO3gRsPgRcLcLSMatrixRow_const(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO3UcO3UcOROOTcLcLMathcLcLMatRepSymlEdoublecO3gRsPgRcLcLSMatrixRow_const(void *p);
   static void destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO3UcO3UcOROOTcLcLMathcLcLMatRepSymlEdoublecO3gRsPgRcLcLSMatrixRow_const(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SMatrix<double,3U,3U,ROOT::Math::MatRepSym<double,3> >::SMatrixRow_const*)
   {
      ::ROOT::Math::SMatrix<double,3U,3U,ROOT::Math::MatRepSym<double,3> >::SMatrixRow_const *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SMatrix<double,3U,3U,ROOT::Math::MatRepSym<double,3> >::SMatrixRow_const));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SMatrix<double,3U,3U,ROOT::Math::MatRepSym<double,3> >::SMatrixRow_const", "Math/SMatrix.h", 382,
                  typeid(::ROOT::Math::SMatrix<double,3U,3U,ROOT::Math::MatRepSym<double,3> >::SMatrixRow_const), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSMatrixlEdoublecO3UcO3UcOROOTcLcLMathcLcLMatRepSymlEdoublecO3gRsPgRcLcLSMatrixRow_const_Dictionary, isa_proxy, 0,
                  sizeof(::ROOT::Math::SMatrix<double,3U,3U,ROOT::Math::MatRepSym<double,3> >::SMatrixRow_const) );
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSMatrixlEdoublecO3UcO3UcOROOTcLcLMathcLcLMatRepSymlEdoublecO3gRsPgRcLcLSMatrixRow_const);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO3UcO3UcOROOTcLcLMathcLcLMatRepSymlEdoublecO3gRsPgRcLcLSMatrixRow_const);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO3UcO3UcOROOTcLcLMathcLcLMatRepSymlEdoublecO3gRsPgRcLcLSMatrixRow_const);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<double,3U,3U,ROOT::Math::MatRepSym<double,3> >::SMatrixRow_const","ROOT::Math::SMatrix<double,3,3,ROOT::Math::MatRepSym<double,3> >::SMatrixRow_const"));

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<double,3U,3U,ROOT::Math::MatRepSym<double,3> >::SMatrixRow_const","ROOT::Math::SMatrix<double, 3u, 3u, ROOT::Math::MatRepSym<double, 3u> >::SMatrixRow_const"));
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::SMatrix<double,3U,3U,ROOT::Math::MatRepSym<double,3> >::SMatrixRow_const*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::SMatrix<double,3U,3U,ROOT::Math::MatRepSym<double,3> >::SMatrixRow_const*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<double,3U,3U,ROOT::Math::MatRepSym<double,3> >::SMatrixRow_const*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLSMatrixlEdoublecO3UcO3UcOROOTcLcLMathcLcLMatRepSymlEdoublecO3gRsPgRcLcLSMatrixRow_const_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<double,3U,3U,ROOT::Math::MatRepSym<double,3> >::SMatrixRow_const*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLSMatrixlEdoublecO3UcO3UcOROOTcLcLMathcLcLMatRepSymlEdoublecO3gRsPgRcLcLSMatrixRow_const_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLSMatrixlEdoublecO3UcO3UcOROOTcLcLMathcLcLMatRepSymlEdoublecO3gRsPgRcLcLSMatrixRow_const_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSMatrixlEdoublecO4cO4cOROOTcLcLMathcLcLMatRepSymlEdoublecO4gRsPgR_Dictionary();
   static void ROOTcLcLMathcLcLSMatrixlEdoublecO4cO4cOROOTcLcLMathcLcLMatRepSymlEdoublecO4gRsPgR_TClassManip(TClass*);
   static void *new_ROOTcLcLMathcLcLSMatrixlEdoublecO4cO4cOROOTcLcLMathcLcLMatRepSymlEdoublecO4gRsPgR(void *p = nullptr);
   static void *newArray_ROOTcLcLMathcLcLSMatrixlEdoublecO4cO4cOROOTcLcLMathcLcLMatRepSymlEdoublecO4gRsPgR(Long_t size, void *p);
   static void delete_ROOTcLcLMathcLcLSMatrixlEdoublecO4cO4cOROOTcLcLMathcLcLMatRepSymlEdoublecO4gRsPgR(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO4cO4cOROOTcLcLMathcLcLMatRepSymlEdoublecO4gRsPgR(void *p);
   static void destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO4cO4cOROOTcLcLMathcLcLMatRepSymlEdoublecO4gRsPgR(void *p);

   // Schema evolution read functions

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SMatrix<double,4,4,ROOT::Math::MatRepSym<double,4> >*)
   {
      ::ROOT::Math::SMatrix<double,4,4,ROOT::Math::MatRepSym<double,4> > *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SMatrix<double,4,4,ROOT::Math::MatRepSym<double,4> >));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SMatrix<double,4,4,ROOT::Math::MatRepSym<double,4> >", "Math/SMatrix.h", 101,
                  typeid(::ROOT::Math::SMatrix<double,4,4,ROOT::Math::MatRepSym<double,4> >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSMatrixlEdoublecO4cO4cOROOTcLcLMathcLcLMatRepSymlEdoublecO4gRsPgR_Dictionary, isa_proxy, 4,
                  sizeof(::ROOT::Math::SMatrix<double,4,4,ROOT::Math::MatRepSym<double,4> >) );
      instance.SetNew(&new_ROOTcLcLMathcLcLSMatrixlEdoublecO4cO4cOROOTcLcLMathcLcLMatRepSymlEdoublecO4gRsPgR);
      instance.SetNewArray(&newArray_ROOTcLcLMathcLcLSMatrixlEdoublecO4cO4cOROOTcLcLMathcLcLMatRepSymlEdoublecO4gRsPgR);
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSMatrixlEdoublecO4cO4cOROOTcLcLMathcLcLMatRepSymlEdoublecO4gRsPgR);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO4cO4cOROOTcLcLMathcLcLMatRepSymlEdoublecO4gRsPgR);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO4cO4cOROOTcLcLMathcLcLMatRepSymlEdoublecO4gRsPgR);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<double,4,4,ROOT::Math::MatRepSym<double,4> >","ROOT::Math::SMatrix<double, 4u, 4u, ROOT::Math::MatRepSym<double, 4u> >"));

      ::ROOT::Internal::TSchemaHelper* rule;

      // the io read rules
      std::vector<::ROOT::Internal::TSchemaHelper> readrules(3);
      rule = &readrules[0];
      rule->fSourceClass = "ROOT::Math::SMatrix<double,4,4,ROOT::Math::MatRepSym<Double32_t,4> >";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[1];
      rule->fSourceClass = "ROOT::Math::SMatrix<double,4,4,ROOT::Math::MatRepSym<float,4> >";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[2];
      rule->fSourceClass = "ROOT::Math::SMatrix<double,4,4,ROOT::Math::MatRepSym<Float16_t,4> >";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      instance.SetReadRules( readrules );
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::SMatrix<double,4,4,ROOT::Math::MatRepSym<double,4> >*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::SMatrix<double,4,4,ROOT::Math::MatRepSym<double,4> >*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<double,4,4,ROOT::Math::MatRepSym<double,4> >*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLSMatrixlEdoublecO4cO4cOROOTcLcLMathcLcLMatRepSymlEdoublecO4gRsPgR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<double,4,4,ROOT::Math::MatRepSym<double,4> >*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLSMatrixlEdoublecO4cO4cOROOTcLcLMathcLcLMatRepSymlEdoublecO4gRsPgR_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLSMatrixlEdoublecO4cO4cOROOTcLcLMathcLcLMatRepSymlEdoublecO4gRsPgR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSMatrixlEdoublecO4UcO4UcOROOTcLcLMathcLcLMatRepSymlEdoublecO4gRsPgRcLcLSMatrixRow_Dictionary();
   static void ROOTcLcLMathcLcLSMatrixlEdoublecO4UcO4UcOROOTcLcLMathcLcLMatRepSymlEdoublecO4gRsPgRcLcLSMatrixRow_TClassManip(TClass*);
   static void delete_ROOTcLcLMathcLcLSMatrixlEdoublecO4UcO4UcOROOTcLcLMathcLcLMatRepSymlEdoublecO4gRsPgRcLcLSMatrixRow(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO4UcO4UcOROOTcLcLMathcLcLMatRepSymlEdoublecO4gRsPgRcLcLSMatrixRow(void *p);
   static void destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO4UcO4UcOROOTcLcLMathcLcLMatRepSymlEdoublecO4gRsPgRcLcLSMatrixRow(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SMatrix<double,4U,4U,ROOT::Math::MatRepSym<double,4> >::SMatrixRow*)
   {
      ::ROOT::Math::SMatrix<double,4U,4U,ROOT::Math::MatRepSym<double,4> >::SMatrixRow *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SMatrix<double,4U,4U,ROOT::Math::MatRepSym<double,4> >::SMatrixRow));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SMatrix<double,4U,4U,ROOT::Math::MatRepSym<double,4> >::SMatrixRow", "Math/SMatrix.h", 371,
                  typeid(::ROOT::Math::SMatrix<double,4U,4U,ROOT::Math::MatRepSym<double,4> >::SMatrixRow), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSMatrixlEdoublecO4UcO4UcOROOTcLcLMathcLcLMatRepSymlEdoublecO4gRsPgRcLcLSMatrixRow_Dictionary, isa_proxy, 0,
                  sizeof(::ROOT::Math::SMatrix<double,4U,4U,ROOT::Math::MatRepSym<double,4> >::SMatrixRow) );
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSMatrixlEdoublecO4UcO4UcOROOTcLcLMathcLcLMatRepSymlEdoublecO4gRsPgRcLcLSMatrixRow);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO4UcO4UcOROOTcLcLMathcLcLMatRepSymlEdoublecO4gRsPgRcLcLSMatrixRow);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO4UcO4UcOROOTcLcLMathcLcLMatRepSymlEdoublecO4gRsPgRcLcLSMatrixRow);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<double,4U,4U,ROOT::Math::MatRepSym<double,4> >::SMatrixRow","ROOT::Math::SMatrix<double,4,4,ROOT::Math::MatRepSym<double,4> >::SMatrixRow"));

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<double,4U,4U,ROOT::Math::MatRepSym<double,4> >::SMatrixRow","ROOT::Math::SMatrix<double, 4u, 4u, ROOT::Math::MatRepSym<double, 4u> >::SMatrixRow"));
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::SMatrix<double,4U,4U,ROOT::Math::MatRepSym<double,4> >::SMatrixRow*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::SMatrix<double,4U,4U,ROOT::Math::MatRepSym<double,4> >::SMatrixRow*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<double,4U,4U,ROOT::Math::MatRepSym<double,4> >::SMatrixRow*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLSMatrixlEdoublecO4UcO4UcOROOTcLcLMathcLcLMatRepSymlEdoublecO4gRsPgRcLcLSMatrixRow_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<double,4U,4U,ROOT::Math::MatRepSym<double,4> >::SMatrixRow*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLSMatrixlEdoublecO4UcO4UcOROOTcLcLMathcLcLMatRepSymlEdoublecO4gRsPgRcLcLSMatrixRow_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLSMatrixlEdoublecO4UcO4UcOROOTcLcLMathcLcLMatRepSymlEdoublecO4gRsPgRcLcLSMatrixRow_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSMatrixlEdoublecO4UcO4UcOROOTcLcLMathcLcLMatRepSymlEdoublecO4gRsPgRcLcLSMatrixRow_const_Dictionary();
   static void ROOTcLcLMathcLcLSMatrixlEdoublecO4UcO4UcOROOTcLcLMathcLcLMatRepSymlEdoublecO4gRsPgRcLcLSMatrixRow_const_TClassManip(TClass*);
   static void delete_ROOTcLcLMathcLcLSMatrixlEdoublecO4UcO4UcOROOTcLcLMathcLcLMatRepSymlEdoublecO4gRsPgRcLcLSMatrixRow_const(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO4UcO4UcOROOTcLcLMathcLcLMatRepSymlEdoublecO4gRsPgRcLcLSMatrixRow_const(void *p);
   static void destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO4UcO4UcOROOTcLcLMathcLcLMatRepSymlEdoublecO4gRsPgRcLcLSMatrixRow_const(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SMatrix<double,4U,4U,ROOT::Math::MatRepSym<double,4> >::SMatrixRow_const*)
   {
      ::ROOT::Math::SMatrix<double,4U,4U,ROOT::Math::MatRepSym<double,4> >::SMatrixRow_const *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SMatrix<double,4U,4U,ROOT::Math::MatRepSym<double,4> >::SMatrixRow_const));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SMatrix<double,4U,4U,ROOT::Math::MatRepSym<double,4> >::SMatrixRow_const", "Math/SMatrix.h", 382,
                  typeid(::ROOT::Math::SMatrix<double,4U,4U,ROOT::Math::MatRepSym<double,4> >::SMatrixRow_const), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSMatrixlEdoublecO4UcO4UcOROOTcLcLMathcLcLMatRepSymlEdoublecO4gRsPgRcLcLSMatrixRow_const_Dictionary, isa_proxy, 0,
                  sizeof(::ROOT::Math::SMatrix<double,4U,4U,ROOT::Math::MatRepSym<double,4> >::SMatrixRow_const) );
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSMatrixlEdoublecO4UcO4UcOROOTcLcLMathcLcLMatRepSymlEdoublecO4gRsPgRcLcLSMatrixRow_const);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO4UcO4UcOROOTcLcLMathcLcLMatRepSymlEdoublecO4gRsPgRcLcLSMatrixRow_const);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO4UcO4UcOROOTcLcLMathcLcLMatRepSymlEdoublecO4gRsPgRcLcLSMatrixRow_const);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<double,4U,4U,ROOT::Math::MatRepSym<double,4> >::SMatrixRow_const","ROOT::Math::SMatrix<double,4,4,ROOT::Math::MatRepSym<double,4> >::SMatrixRow_const"));

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<double,4U,4U,ROOT::Math::MatRepSym<double,4> >::SMatrixRow_const","ROOT::Math::SMatrix<double, 4u, 4u, ROOT::Math::MatRepSym<double, 4u> >::SMatrixRow_const"));
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::SMatrix<double,4U,4U,ROOT::Math::MatRepSym<double,4> >::SMatrixRow_const*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::SMatrix<double,4U,4U,ROOT::Math::MatRepSym<double,4> >::SMatrixRow_const*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<double,4U,4U,ROOT::Math::MatRepSym<double,4> >::SMatrixRow_const*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLSMatrixlEdoublecO4UcO4UcOROOTcLcLMathcLcLMatRepSymlEdoublecO4gRsPgRcLcLSMatrixRow_const_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<double,4U,4U,ROOT::Math::MatRepSym<double,4> >::SMatrixRow_const*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLSMatrixlEdoublecO4UcO4UcOROOTcLcLMathcLcLMatRepSymlEdoublecO4gRsPgRcLcLSMatrixRow_const_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLSMatrixlEdoublecO4UcO4UcOROOTcLcLMathcLcLMatRepSymlEdoublecO4gRsPgRcLcLSMatrixRow_const_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSMatrixlEdoublecO5cO5cOROOTcLcLMathcLcLMatRepSymlEdoublecO5gRsPgR_Dictionary();
   static void ROOTcLcLMathcLcLSMatrixlEdoublecO5cO5cOROOTcLcLMathcLcLMatRepSymlEdoublecO5gRsPgR_TClassManip(TClass*);
   static void *new_ROOTcLcLMathcLcLSMatrixlEdoublecO5cO5cOROOTcLcLMathcLcLMatRepSymlEdoublecO5gRsPgR(void *p = nullptr);
   static void *newArray_ROOTcLcLMathcLcLSMatrixlEdoublecO5cO5cOROOTcLcLMathcLcLMatRepSymlEdoublecO5gRsPgR(Long_t size, void *p);
   static void delete_ROOTcLcLMathcLcLSMatrixlEdoublecO5cO5cOROOTcLcLMathcLcLMatRepSymlEdoublecO5gRsPgR(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO5cO5cOROOTcLcLMathcLcLMatRepSymlEdoublecO5gRsPgR(void *p);
   static void destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO5cO5cOROOTcLcLMathcLcLMatRepSymlEdoublecO5gRsPgR(void *p);

   // Schema evolution read functions

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SMatrix<double,5,5,ROOT::Math::MatRepSym<double,5> >*)
   {
      ::ROOT::Math::SMatrix<double,5,5,ROOT::Math::MatRepSym<double,5> > *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SMatrix<double,5,5,ROOT::Math::MatRepSym<double,5> >));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SMatrix<double,5,5,ROOT::Math::MatRepSym<double,5> >", "Math/SMatrix.h", 101,
                  typeid(::ROOT::Math::SMatrix<double,5,5,ROOT::Math::MatRepSym<double,5> >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSMatrixlEdoublecO5cO5cOROOTcLcLMathcLcLMatRepSymlEdoublecO5gRsPgR_Dictionary, isa_proxy, 4,
                  sizeof(::ROOT::Math::SMatrix<double,5,5,ROOT::Math::MatRepSym<double,5> >) );
      instance.SetNew(&new_ROOTcLcLMathcLcLSMatrixlEdoublecO5cO5cOROOTcLcLMathcLcLMatRepSymlEdoublecO5gRsPgR);
      instance.SetNewArray(&newArray_ROOTcLcLMathcLcLSMatrixlEdoublecO5cO5cOROOTcLcLMathcLcLMatRepSymlEdoublecO5gRsPgR);
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSMatrixlEdoublecO5cO5cOROOTcLcLMathcLcLMatRepSymlEdoublecO5gRsPgR);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO5cO5cOROOTcLcLMathcLcLMatRepSymlEdoublecO5gRsPgR);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO5cO5cOROOTcLcLMathcLcLMatRepSymlEdoublecO5gRsPgR);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<double,5,5,ROOT::Math::MatRepSym<double,5> >","ROOT::Math::SMatrix<double, 5u, 5u, ROOT::Math::MatRepSym<double, 5u> >"));

      ::ROOT::Internal::TSchemaHelper* rule;

      // the io read rules
      std::vector<::ROOT::Internal::TSchemaHelper> readrules(3);
      rule = &readrules[0];
      rule->fSourceClass = "ROOT::Math::SMatrix<double,5,5,ROOT::Math::MatRepSym<Double32_t,5> >";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[1];
      rule->fSourceClass = "ROOT::Math::SMatrix<double,5,5,ROOT::Math::MatRepSym<float,5> >";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[2];
      rule->fSourceClass = "ROOT::Math::SMatrix<double,5,5,ROOT::Math::MatRepSym<Float16_t,5> >";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      instance.SetReadRules( readrules );
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::SMatrix<double,5,5,ROOT::Math::MatRepSym<double,5> >*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::SMatrix<double,5,5,ROOT::Math::MatRepSym<double,5> >*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<double,5,5,ROOT::Math::MatRepSym<double,5> >*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLSMatrixlEdoublecO5cO5cOROOTcLcLMathcLcLMatRepSymlEdoublecO5gRsPgR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<double,5,5,ROOT::Math::MatRepSym<double,5> >*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLSMatrixlEdoublecO5cO5cOROOTcLcLMathcLcLMatRepSymlEdoublecO5gRsPgR_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLSMatrixlEdoublecO5cO5cOROOTcLcLMathcLcLMatRepSymlEdoublecO5gRsPgR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSMatrixlEdoublecO5UcO5UcOROOTcLcLMathcLcLMatRepSymlEdoublecO5gRsPgRcLcLSMatrixRow_Dictionary();
   static void ROOTcLcLMathcLcLSMatrixlEdoublecO5UcO5UcOROOTcLcLMathcLcLMatRepSymlEdoublecO5gRsPgRcLcLSMatrixRow_TClassManip(TClass*);
   static void delete_ROOTcLcLMathcLcLSMatrixlEdoublecO5UcO5UcOROOTcLcLMathcLcLMatRepSymlEdoublecO5gRsPgRcLcLSMatrixRow(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO5UcO5UcOROOTcLcLMathcLcLMatRepSymlEdoublecO5gRsPgRcLcLSMatrixRow(void *p);
   static void destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO5UcO5UcOROOTcLcLMathcLcLMatRepSymlEdoublecO5gRsPgRcLcLSMatrixRow(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SMatrix<double,5U,5U,ROOT::Math::MatRepSym<double,5> >::SMatrixRow*)
   {
      ::ROOT::Math::SMatrix<double,5U,5U,ROOT::Math::MatRepSym<double,5> >::SMatrixRow *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SMatrix<double,5U,5U,ROOT::Math::MatRepSym<double,5> >::SMatrixRow));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SMatrix<double,5U,5U,ROOT::Math::MatRepSym<double,5> >::SMatrixRow", "Math/SMatrix.h", 371,
                  typeid(::ROOT::Math::SMatrix<double,5U,5U,ROOT::Math::MatRepSym<double,5> >::SMatrixRow), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSMatrixlEdoublecO5UcO5UcOROOTcLcLMathcLcLMatRepSymlEdoublecO5gRsPgRcLcLSMatrixRow_Dictionary, isa_proxy, 0,
                  sizeof(::ROOT::Math::SMatrix<double,5U,5U,ROOT::Math::MatRepSym<double,5> >::SMatrixRow) );
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSMatrixlEdoublecO5UcO5UcOROOTcLcLMathcLcLMatRepSymlEdoublecO5gRsPgRcLcLSMatrixRow);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO5UcO5UcOROOTcLcLMathcLcLMatRepSymlEdoublecO5gRsPgRcLcLSMatrixRow);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO5UcO5UcOROOTcLcLMathcLcLMatRepSymlEdoublecO5gRsPgRcLcLSMatrixRow);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<double,5U,5U,ROOT::Math::MatRepSym<double,5> >::SMatrixRow","ROOT::Math::SMatrix<double,5,5,ROOT::Math::MatRepSym<double,5> >::SMatrixRow"));

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<double,5U,5U,ROOT::Math::MatRepSym<double,5> >::SMatrixRow","ROOT::Math::SMatrix<double, 5u, 5u, ROOT::Math::MatRepSym<double, 5u> >::SMatrixRow"));
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::SMatrix<double,5U,5U,ROOT::Math::MatRepSym<double,5> >::SMatrixRow*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::SMatrix<double,5U,5U,ROOT::Math::MatRepSym<double,5> >::SMatrixRow*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<double,5U,5U,ROOT::Math::MatRepSym<double,5> >::SMatrixRow*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLSMatrixlEdoublecO5UcO5UcOROOTcLcLMathcLcLMatRepSymlEdoublecO5gRsPgRcLcLSMatrixRow_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<double,5U,5U,ROOT::Math::MatRepSym<double,5> >::SMatrixRow*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLSMatrixlEdoublecO5UcO5UcOROOTcLcLMathcLcLMatRepSymlEdoublecO5gRsPgRcLcLSMatrixRow_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLSMatrixlEdoublecO5UcO5UcOROOTcLcLMathcLcLMatRepSymlEdoublecO5gRsPgRcLcLSMatrixRow_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSMatrixlEdoublecO5UcO5UcOROOTcLcLMathcLcLMatRepSymlEdoublecO5gRsPgRcLcLSMatrixRow_const_Dictionary();
   static void ROOTcLcLMathcLcLSMatrixlEdoublecO5UcO5UcOROOTcLcLMathcLcLMatRepSymlEdoublecO5gRsPgRcLcLSMatrixRow_const_TClassManip(TClass*);
   static void delete_ROOTcLcLMathcLcLSMatrixlEdoublecO5UcO5UcOROOTcLcLMathcLcLMatRepSymlEdoublecO5gRsPgRcLcLSMatrixRow_const(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO5UcO5UcOROOTcLcLMathcLcLMatRepSymlEdoublecO5gRsPgRcLcLSMatrixRow_const(void *p);
   static void destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO5UcO5UcOROOTcLcLMathcLcLMatRepSymlEdoublecO5gRsPgRcLcLSMatrixRow_const(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SMatrix<double,5U,5U,ROOT::Math::MatRepSym<double,5> >::SMatrixRow_const*)
   {
      ::ROOT::Math::SMatrix<double,5U,5U,ROOT::Math::MatRepSym<double,5> >::SMatrixRow_const *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SMatrix<double,5U,5U,ROOT::Math::MatRepSym<double,5> >::SMatrixRow_const));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SMatrix<double,5U,5U,ROOT::Math::MatRepSym<double,5> >::SMatrixRow_const", "Math/SMatrix.h", 382,
                  typeid(::ROOT::Math::SMatrix<double,5U,5U,ROOT::Math::MatRepSym<double,5> >::SMatrixRow_const), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSMatrixlEdoublecO5UcO5UcOROOTcLcLMathcLcLMatRepSymlEdoublecO5gRsPgRcLcLSMatrixRow_const_Dictionary, isa_proxy, 0,
                  sizeof(::ROOT::Math::SMatrix<double,5U,5U,ROOT::Math::MatRepSym<double,5> >::SMatrixRow_const) );
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSMatrixlEdoublecO5UcO5UcOROOTcLcLMathcLcLMatRepSymlEdoublecO5gRsPgRcLcLSMatrixRow_const);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO5UcO5UcOROOTcLcLMathcLcLMatRepSymlEdoublecO5gRsPgRcLcLSMatrixRow_const);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO5UcO5UcOROOTcLcLMathcLcLMatRepSymlEdoublecO5gRsPgRcLcLSMatrixRow_const);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<double,5U,5U,ROOT::Math::MatRepSym<double,5> >::SMatrixRow_const","ROOT::Math::SMatrix<double,5,5,ROOT::Math::MatRepSym<double,5> >::SMatrixRow_const"));

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<double,5U,5U,ROOT::Math::MatRepSym<double,5> >::SMatrixRow_const","ROOT::Math::SMatrix<double, 5u, 5u, ROOT::Math::MatRepSym<double, 5u> >::SMatrixRow_const"));
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::SMatrix<double,5U,5U,ROOT::Math::MatRepSym<double,5> >::SMatrixRow_const*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::SMatrix<double,5U,5U,ROOT::Math::MatRepSym<double,5> >::SMatrixRow_const*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<double,5U,5U,ROOT::Math::MatRepSym<double,5> >::SMatrixRow_const*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLSMatrixlEdoublecO5UcO5UcOROOTcLcLMathcLcLMatRepSymlEdoublecO5gRsPgRcLcLSMatrixRow_const_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<double,5U,5U,ROOT::Math::MatRepSym<double,5> >::SMatrixRow_const*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLSMatrixlEdoublecO5UcO5UcOROOTcLcLMathcLcLMatRepSymlEdoublecO5gRsPgRcLcLSMatrixRow_const_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLSMatrixlEdoublecO5UcO5UcOROOTcLcLMathcLcLMatRepSymlEdoublecO5gRsPgRcLcLSMatrixRow_const_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSMatrixlEdoublecO6cO6cOROOTcLcLMathcLcLMatRepSymlEdoublecO6gRsPgR_Dictionary();
   static void ROOTcLcLMathcLcLSMatrixlEdoublecO6cO6cOROOTcLcLMathcLcLMatRepSymlEdoublecO6gRsPgR_TClassManip(TClass*);
   static void *new_ROOTcLcLMathcLcLSMatrixlEdoublecO6cO6cOROOTcLcLMathcLcLMatRepSymlEdoublecO6gRsPgR(void *p = nullptr);
   static void *newArray_ROOTcLcLMathcLcLSMatrixlEdoublecO6cO6cOROOTcLcLMathcLcLMatRepSymlEdoublecO6gRsPgR(Long_t size, void *p);
   static void delete_ROOTcLcLMathcLcLSMatrixlEdoublecO6cO6cOROOTcLcLMathcLcLMatRepSymlEdoublecO6gRsPgR(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO6cO6cOROOTcLcLMathcLcLMatRepSymlEdoublecO6gRsPgR(void *p);
   static void destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO6cO6cOROOTcLcLMathcLcLMatRepSymlEdoublecO6gRsPgR(void *p);

   // Schema evolution read functions

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SMatrix<double,6,6,ROOT::Math::MatRepSym<double,6> >*)
   {
      ::ROOT::Math::SMatrix<double,6,6,ROOT::Math::MatRepSym<double,6> > *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SMatrix<double,6,6,ROOT::Math::MatRepSym<double,6> >));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SMatrix<double,6,6,ROOT::Math::MatRepSym<double,6> >", "Math/SMatrix.h", 101,
                  typeid(::ROOT::Math::SMatrix<double,6,6,ROOT::Math::MatRepSym<double,6> >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSMatrixlEdoublecO6cO6cOROOTcLcLMathcLcLMatRepSymlEdoublecO6gRsPgR_Dictionary, isa_proxy, 4,
                  sizeof(::ROOT::Math::SMatrix<double,6,6,ROOT::Math::MatRepSym<double,6> >) );
      instance.SetNew(&new_ROOTcLcLMathcLcLSMatrixlEdoublecO6cO6cOROOTcLcLMathcLcLMatRepSymlEdoublecO6gRsPgR);
      instance.SetNewArray(&newArray_ROOTcLcLMathcLcLSMatrixlEdoublecO6cO6cOROOTcLcLMathcLcLMatRepSymlEdoublecO6gRsPgR);
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSMatrixlEdoublecO6cO6cOROOTcLcLMathcLcLMatRepSymlEdoublecO6gRsPgR);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO6cO6cOROOTcLcLMathcLcLMatRepSymlEdoublecO6gRsPgR);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO6cO6cOROOTcLcLMathcLcLMatRepSymlEdoublecO6gRsPgR);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<double,6,6,ROOT::Math::MatRepSym<double,6> >","ROOT::Math::SMatrix<double, 6u, 6u, ROOT::Math::MatRepSym<double, 6u> >"));

      ::ROOT::Internal::TSchemaHelper* rule;

      // the io read rules
      std::vector<::ROOT::Internal::TSchemaHelper> readrules(3);
      rule = &readrules[0];
      rule->fSourceClass = "ROOT::Math::SMatrix<double,6,6,ROOT::Math::MatRepSym<Double32_t,6> >";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[1];
      rule->fSourceClass = "ROOT::Math::SMatrix<double,6,6,ROOT::Math::MatRepSym<float,6> >";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[2];
      rule->fSourceClass = "ROOT::Math::SMatrix<double,6,6,ROOT::Math::MatRepSym<Float16_t,6> >";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      instance.SetReadRules( readrules );
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::SMatrix<double,6,6,ROOT::Math::MatRepSym<double,6> >*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::SMatrix<double,6,6,ROOT::Math::MatRepSym<double,6> >*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<double,6,6,ROOT::Math::MatRepSym<double,6> >*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLSMatrixlEdoublecO6cO6cOROOTcLcLMathcLcLMatRepSymlEdoublecO6gRsPgR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<double,6,6,ROOT::Math::MatRepSym<double,6> >*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLSMatrixlEdoublecO6cO6cOROOTcLcLMathcLcLMatRepSymlEdoublecO6gRsPgR_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLSMatrixlEdoublecO6cO6cOROOTcLcLMathcLcLMatRepSymlEdoublecO6gRsPgR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSMatrixlEdoublecO6UcO6UcOROOTcLcLMathcLcLMatRepSymlEdoublecO6gRsPgRcLcLSMatrixRow_Dictionary();
   static void ROOTcLcLMathcLcLSMatrixlEdoublecO6UcO6UcOROOTcLcLMathcLcLMatRepSymlEdoublecO6gRsPgRcLcLSMatrixRow_TClassManip(TClass*);
   static void delete_ROOTcLcLMathcLcLSMatrixlEdoublecO6UcO6UcOROOTcLcLMathcLcLMatRepSymlEdoublecO6gRsPgRcLcLSMatrixRow(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO6UcO6UcOROOTcLcLMathcLcLMatRepSymlEdoublecO6gRsPgRcLcLSMatrixRow(void *p);
   static void destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO6UcO6UcOROOTcLcLMathcLcLMatRepSymlEdoublecO6gRsPgRcLcLSMatrixRow(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SMatrix<double,6U,6U,ROOT::Math::MatRepSym<double,6> >::SMatrixRow*)
   {
      ::ROOT::Math::SMatrix<double,6U,6U,ROOT::Math::MatRepSym<double,6> >::SMatrixRow *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SMatrix<double,6U,6U,ROOT::Math::MatRepSym<double,6> >::SMatrixRow));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SMatrix<double,6U,6U,ROOT::Math::MatRepSym<double,6> >::SMatrixRow", "Math/SMatrix.h", 371,
                  typeid(::ROOT::Math::SMatrix<double,6U,6U,ROOT::Math::MatRepSym<double,6> >::SMatrixRow), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSMatrixlEdoublecO6UcO6UcOROOTcLcLMathcLcLMatRepSymlEdoublecO6gRsPgRcLcLSMatrixRow_Dictionary, isa_proxy, 0,
                  sizeof(::ROOT::Math::SMatrix<double,6U,6U,ROOT::Math::MatRepSym<double,6> >::SMatrixRow) );
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSMatrixlEdoublecO6UcO6UcOROOTcLcLMathcLcLMatRepSymlEdoublecO6gRsPgRcLcLSMatrixRow);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO6UcO6UcOROOTcLcLMathcLcLMatRepSymlEdoublecO6gRsPgRcLcLSMatrixRow);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO6UcO6UcOROOTcLcLMathcLcLMatRepSymlEdoublecO6gRsPgRcLcLSMatrixRow);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<double,6U,6U,ROOT::Math::MatRepSym<double,6> >::SMatrixRow","ROOT::Math::SMatrix<double,6,6,ROOT::Math::MatRepSym<double,6> >::SMatrixRow"));

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<double,6U,6U,ROOT::Math::MatRepSym<double,6> >::SMatrixRow","ROOT::Math::SMatrix<double, 6u, 6u, ROOT::Math::MatRepSym<double, 6u> >::SMatrixRow"));
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::SMatrix<double,6U,6U,ROOT::Math::MatRepSym<double,6> >::SMatrixRow*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::SMatrix<double,6U,6U,ROOT::Math::MatRepSym<double,6> >::SMatrixRow*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<double,6U,6U,ROOT::Math::MatRepSym<double,6> >::SMatrixRow*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLSMatrixlEdoublecO6UcO6UcOROOTcLcLMathcLcLMatRepSymlEdoublecO6gRsPgRcLcLSMatrixRow_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<double,6U,6U,ROOT::Math::MatRepSym<double,6> >::SMatrixRow*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLSMatrixlEdoublecO6UcO6UcOROOTcLcLMathcLcLMatRepSymlEdoublecO6gRsPgRcLcLSMatrixRow_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLSMatrixlEdoublecO6UcO6UcOROOTcLcLMathcLcLMatRepSymlEdoublecO6gRsPgRcLcLSMatrixRow_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSMatrixlEdoublecO6UcO6UcOROOTcLcLMathcLcLMatRepSymlEdoublecO6gRsPgRcLcLSMatrixRow_const_Dictionary();
   static void ROOTcLcLMathcLcLSMatrixlEdoublecO6UcO6UcOROOTcLcLMathcLcLMatRepSymlEdoublecO6gRsPgRcLcLSMatrixRow_const_TClassManip(TClass*);
   static void delete_ROOTcLcLMathcLcLSMatrixlEdoublecO6UcO6UcOROOTcLcLMathcLcLMatRepSymlEdoublecO6gRsPgRcLcLSMatrixRow_const(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO6UcO6UcOROOTcLcLMathcLcLMatRepSymlEdoublecO6gRsPgRcLcLSMatrixRow_const(void *p);
   static void destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO6UcO6UcOROOTcLcLMathcLcLMatRepSymlEdoublecO6gRsPgRcLcLSMatrixRow_const(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SMatrix<double,6U,6U,ROOT::Math::MatRepSym<double,6> >::SMatrixRow_const*)
   {
      ::ROOT::Math::SMatrix<double,6U,6U,ROOT::Math::MatRepSym<double,6> >::SMatrixRow_const *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SMatrix<double,6U,6U,ROOT::Math::MatRepSym<double,6> >::SMatrixRow_const));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SMatrix<double,6U,6U,ROOT::Math::MatRepSym<double,6> >::SMatrixRow_const", "Math/SMatrix.h", 382,
                  typeid(::ROOT::Math::SMatrix<double,6U,6U,ROOT::Math::MatRepSym<double,6> >::SMatrixRow_const), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSMatrixlEdoublecO6UcO6UcOROOTcLcLMathcLcLMatRepSymlEdoublecO6gRsPgRcLcLSMatrixRow_const_Dictionary, isa_proxy, 0,
                  sizeof(::ROOT::Math::SMatrix<double,6U,6U,ROOT::Math::MatRepSym<double,6> >::SMatrixRow_const) );
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSMatrixlEdoublecO6UcO6UcOROOTcLcLMathcLcLMatRepSymlEdoublecO6gRsPgRcLcLSMatrixRow_const);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO6UcO6UcOROOTcLcLMathcLcLMatRepSymlEdoublecO6gRsPgRcLcLSMatrixRow_const);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO6UcO6UcOROOTcLcLMathcLcLMatRepSymlEdoublecO6gRsPgRcLcLSMatrixRow_const);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<double,6U,6U,ROOT::Math::MatRepSym<double,6> >::SMatrixRow_const","ROOT::Math::SMatrix<double,6,6,ROOT::Math::MatRepSym<double,6> >::SMatrixRow_const"));

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<double,6U,6U,ROOT::Math::MatRepSym<double,6> >::SMatrixRow_const","ROOT::Math::SMatrix<double, 6u, 6u, ROOT::Math::MatRepSym<double, 6u> >::SMatrixRow_const"));
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::SMatrix<double,6U,6U,ROOT::Math::MatRepSym<double,6> >::SMatrixRow_const*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::SMatrix<double,6U,6U,ROOT::Math::MatRepSym<double,6> >::SMatrixRow_const*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<double,6U,6U,ROOT::Math::MatRepSym<double,6> >::SMatrixRow_const*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLSMatrixlEdoublecO6UcO6UcOROOTcLcLMathcLcLMatRepSymlEdoublecO6gRsPgRcLcLSMatrixRow_const_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<double,6U,6U,ROOT::Math::MatRepSym<double,6> >::SMatrixRow_const*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLSMatrixlEdoublecO6UcO6UcOROOTcLcLMathcLcLMatRepSymlEdoublecO6gRsPgRcLcLSMatrixRow_const_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLSMatrixlEdoublecO6UcO6UcOROOTcLcLMathcLcLMatRepSymlEdoublecO6gRsPgRcLcLSMatrixRow_const_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSMatrixlEdoublecO7cO7cOROOTcLcLMathcLcLMatRepSymlEdoublecO7gRsPgR_Dictionary();
   static void ROOTcLcLMathcLcLSMatrixlEdoublecO7cO7cOROOTcLcLMathcLcLMatRepSymlEdoublecO7gRsPgR_TClassManip(TClass*);
   static void *new_ROOTcLcLMathcLcLSMatrixlEdoublecO7cO7cOROOTcLcLMathcLcLMatRepSymlEdoublecO7gRsPgR(void *p = nullptr);
   static void *newArray_ROOTcLcLMathcLcLSMatrixlEdoublecO7cO7cOROOTcLcLMathcLcLMatRepSymlEdoublecO7gRsPgR(Long_t size, void *p);
   static void delete_ROOTcLcLMathcLcLSMatrixlEdoublecO7cO7cOROOTcLcLMathcLcLMatRepSymlEdoublecO7gRsPgR(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO7cO7cOROOTcLcLMathcLcLMatRepSymlEdoublecO7gRsPgR(void *p);
   static void destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO7cO7cOROOTcLcLMathcLcLMatRepSymlEdoublecO7gRsPgR(void *p);

   // Schema evolution read functions

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SMatrix<double,7,7,ROOT::Math::MatRepSym<double,7> >*)
   {
      ::ROOT::Math::SMatrix<double,7,7,ROOT::Math::MatRepSym<double,7> > *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SMatrix<double,7,7,ROOT::Math::MatRepSym<double,7> >));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SMatrix<double,7,7,ROOT::Math::MatRepSym<double,7> >", "Math/SMatrix.h", 101,
                  typeid(::ROOT::Math::SMatrix<double,7,7,ROOT::Math::MatRepSym<double,7> >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSMatrixlEdoublecO7cO7cOROOTcLcLMathcLcLMatRepSymlEdoublecO7gRsPgR_Dictionary, isa_proxy, 4,
                  sizeof(::ROOT::Math::SMatrix<double,7,7,ROOT::Math::MatRepSym<double,7> >) );
      instance.SetNew(&new_ROOTcLcLMathcLcLSMatrixlEdoublecO7cO7cOROOTcLcLMathcLcLMatRepSymlEdoublecO7gRsPgR);
      instance.SetNewArray(&newArray_ROOTcLcLMathcLcLSMatrixlEdoublecO7cO7cOROOTcLcLMathcLcLMatRepSymlEdoublecO7gRsPgR);
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSMatrixlEdoublecO7cO7cOROOTcLcLMathcLcLMatRepSymlEdoublecO7gRsPgR);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO7cO7cOROOTcLcLMathcLcLMatRepSymlEdoublecO7gRsPgR);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO7cO7cOROOTcLcLMathcLcLMatRepSymlEdoublecO7gRsPgR);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<double,7,7,ROOT::Math::MatRepSym<double,7> >","ROOT::Math::SMatrix<double, 7u, 7u, ROOT::Math::MatRepSym<double, 7u> >"));

      ::ROOT::Internal::TSchemaHelper* rule;

      // the io read rules
      std::vector<::ROOT::Internal::TSchemaHelper> readrules(3);
      rule = &readrules[0];
      rule->fSourceClass = "ROOT::Math::SMatrix<double,7,7,ROOT::Math::MatRepSym<Double32_t,7> >";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[1];
      rule->fSourceClass = "ROOT::Math::SMatrix<double,7,7,ROOT::Math::MatRepSym<float,7> >";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[2];
      rule->fSourceClass = "ROOT::Math::SMatrix<double,7,7,ROOT::Math::MatRepSym<Float16_t,7> >";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      instance.SetReadRules( readrules );
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::SMatrix<double,7,7,ROOT::Math::MatRepSym<double,7> >*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::SMatrix<double,7,7,ROOT::Math::MatRepSym<double,7> >*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<double,7,7,ROOT::Math::MatRepSym<double,7> >*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLSMatrixlEdoublecO7cO7cOROOTcLcLMathcLcLMatRepSymlEdoublecO7gRsPgR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<double,7,7,ROOT::Math::MatRepSym<double,7> >*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLSMatrixlEdoublecO7cO7cOROOTcLcLMathcLcLMatRepSymlEdoublecO7gRsPgR_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLSMatrixlEdoublecO7cO7cOROOTcLcLMathcLcLMatRepSymlEdoublecO7gRsPgR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSMatrixlEdoublecO7UcO7UcOROOTcLcLMathcLcLMatRepSymlEdoublecO7gRsPgRcLcLSMatrixRow_Dictionary();
   static void ROOTcLcLMathcLcLSMatrixlEdoublecO7UcO7UcOROOTcLcLMathcLcLMatRepSymlEdoublecO7gRsPgRcLcLSMatrixRow_TClassManip(TClass*);
   static void delete_ROOTcLcLMathcLcLSMatrixlEdoublecO7UcO7UcOROOTcLcLMathcLcLMatRepSymlEdoublecO7gRsPgRcLcLSMatrixRow(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO7UcO7UcOROOTcLcLMathcLcLMatRepSymlEdoublecO7gRsPgRcLcLSMatrixRow(void *p);
   static void destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO7UcO7UcOROOTcLcLMathcLcLMatRepSymlEdoublecO7gRsPgRcLcLSMatrixRow(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SMatrix<double,7U,7U,ROOT::Math::MatRepSym<double,7> >::SMatrixRow*)
   {
      ::ROOT::Math::SMatrix<double,7U,7U,ROOT::Math::MatRepSym<double,7> >::SMatrixRow *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SMatrix<double,7U,7U,ROOT::Math::MatRepSym<double,7> >::SMatrixRow));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SMatrix<double,7U,7U,ROOT::Math::MatRepSym<double,7> >::SMatrixRow", "Math/SMatrix.h", 371,
                  typeid(::ROOT::Math::SMatrix<double,7U,7U,ROOT::Math::MatRepSym<double,7> >::SMatrixRow), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSMatrixlEdoublecO7UcO7UcOROOTcLcLMathcLcLMatRepSymlEdoublecO7gRsPgRcLcLSMatrixRow_Dictionary, isa_proxy, 0,
                  sizeof(::ROOT::Math::SMatrix<double,7U,7U,ROOT::Math::MatRepSym<double,7> >::SMatrixRow) );
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSMatrixlEdoublecO7UcO7UcOROOTcLcLMathcLcLMatRepSymlEdoublecO7gRsPgRcLcLSMatrixRow);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO7UcO7UcOROOTcLcLMathcLcLMatRepSymlEdoublecO7gRsPgRcLcLSMatrixRow);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO7UcO7UcOROOTcLcLMathcLcLMatRepSymlEdoublecO7gRsPgRcLcLSMatrixRow);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<double,7U,7U,ROOT::Math::MatRepSym<double,7> >::SMatrixRow","ROOT::Math::SMatrix<double,7,7,ROOT::Math::MatRepSym<double,7> >::SMatrixRow"));

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<double,7U,7U,ROOT::Math::MatRepSym<double,7> >::SMatrixRow","ROOT::Math::SMatrix<double, 7u, 7u, ROOT::Math::MatRepSym<double, 7u> >::SMatrixRow"));
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::SMatrix<double,7U,7U,ROOT::Math::MatRepSym<double,7> >::SMatrixRow*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::SMatrix<double,7U,7U,ROOT::Math::MatRepSym<double,7> >::SMatrixRow*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<double,7U,7U,ROOT::Math::MatRepSym<double,7> >::SMatrixRow*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLSMatrixlEdoublecO7UcO7UcOROOTcLcLMathcLcLMatRepSymlEdoublecO7gRsPgRcLcLSMatrixRow_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<double,7U,7U,ROOT::Math::MatRepSym<double,7> >::SMatrixRow*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLSMatrixlEdoublecO7UcO7UcOROOTcLcLMathcLcLMatRepSymlEdoublecO7gRsPgRcLcLSMatrixRow_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLSMatrixlEdoublecO7UcO7UcOROOTcLcLMathcLcLMatRepSymlEdoublecO7gRsPgRcLcLSMatrixRow_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSMatrixlEdoublecO7UcO7UcOROOTcLcLMathcLcLMatRepSymlEdoublecO7gRsPgRcLcLSMatrixRow_const_Dictionary();
   static void ROOTcLcLMathcLcLSMatrixlEdoublecO7UcO7UcOROOTcLcLMathcLcLMatRepSymlEdoublecO7gRsPgRcLcLSMatrixRow_const_TClassManip(TClass*);
   static void delete_ROOTcLcLMathcLcLSMatrixlEdoublecO7UcO7UcOROOTcLcLMathcLcLMatRepSymlEdoublecO7gRsPgRcLcLSMatrixRow_const(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO7UcO7UcOROOTcLcLMathcLcLMatRepSymlEdoublecO7gRsPgRcLcLSMatrixRow_const(void *p);
   static void destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO7UcO7UcOROOTcLcLMathcLcLMatRepSymlEdoublecO7gRsPgRcLcLSMatrixRow_const(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SMatrix<double,7U,7U,ROOT::Math::MatRepSym<double,7> >::SMatrixRow_const*)
   {
      ::ROOT::Math::SMatrix<double,7U,7U,ROOT::Math::MatRepSym<double,7> >::SMatrixRow_const *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SMatrix<double,7U,7U,ROOT::Math::MatRepSym<double,7> >::SMatrixRow_const));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SMatrix<double,7U,7U,ROOT::Math::MatRepSym<double,7> >::SMatrixRow_const", "Math/SMatrix.h", 382,
                  typeid(::ROOT::Math::SMatrix<double,7U,7U,ROOT::Math::MatRepSym<double,7> >::SMatrixRow_const), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSMatrixlEdoublecO7UcO7UcOROOTcLcLMathcLcLMatRepSymlEdoublecO7gRsPgRcLcLSMatrixRow_const_Dictionary, isa_proxy, 0,
                  sizeof(::ROOT::Math::SMatrix<double,7U,7U,ROOT::Math::MatRepSym<double,7> >::SMatrixRow_const) );
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSMatrixlEdoublecO7UcO7UcOROOTcLcLMathcLcLMatRepSymlEdoublecO7gRsPgRcLcLSMatrixRow_const);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO7UcO7UcOROOTcLcLMathcLcLMatRepSymlEdoublecO7gRsPgRcLcLSMatrixRow_const);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO7UcO7UcOROOTcLcLMathcLcLMatRepSymlEdoublecO7gRsPgRcLcLSMatrixRow_const);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<double,7U,7U,ROOT::Math::MatRepSym<double,7> >::SMatrixRow_const","ROOT::Math::SMatrix<double,7,7,ROOT::Math::MatRepSym<double,7> >::SMatrixRow_const"));

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<double,7U,7U,ROOT::Math::MatRepSym<double,7> >::SMatrixRow_const","ROOT::Math::SMatrix<double, 7u, 7u, ROOT::Math::MatRepSym<double, 7u> >::SMatrixRow_const"));
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::SMatrix<double,7U,7U,ROOT::Math::MatRepSym<double,7> >::SMatrixRow_const*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::SMatrix<double,7U,7U,ROOT::Math::MatRepSym<double,7> >::SMatrixRow_const*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<double,7U,7U,ROOT::Math::MatRepSym<double,7> >::SMatrixRow_const*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLSMatrixlEdoublecO7UcO7UcOROOTcLcLMathcLcLMatRepSymlEdoublecO7gRsPgRcLcLSMatrixRow_const_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<double,7U,7U,ROOT::Math::MatRepSym<double,7> >::SMatrixRow_const*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLSMatrixlEdoublecO7UcO7UcOROOTcLcLMathcLcLMatRepSymlEdoublecO7gRsPgRcLcLSMatrixRow_const_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLSMatrixlEdoublecO7UcO7UcOROOTcLcLMathcLcLMatRepSymlEdoublecO7gRsPgRcLcLSMatrixRow_const_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSMatrixlEfloatcO2cO2cOROOTcLcLMathcLcLMatRepStdlEfloatcO2cO2gRsPgR_Dictionary();
   static void ROOTcLcLMathcLcLSMatrixlEfloatcO2cO2cOROOTcLcLMathcLcLMatRepStdlEfloatcO2cO2gRsPgR_TClassManip(TClass*);
   static void *new_ROOTcLcLMathcLcLSMatrixlEfloatcO2cO2cOROOTcLcLMathcLcLMatRepStdlEfloatcO2cO2gRsPgR(void *p = nullptr);
   static void *newArray_ROOTcLcLMathcLcLSMatrixlEfloatcO2cO2cOROOTcLcLMathcLcLMatRepStdlEfloatcO2cO2gRsPgR(Long_t size, void *p);
   static void delete_ROOTcLcLMathcLcLSMatrixlEfloatcO2cO2cOROOTcLcLMathcLcLMatRepStdlEfloatcO2cO2gRsPgR(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO2cO2cOROOTcLcLMathcLcLMatRepStdlEfloatcO2cO2gRsPgR(void *p);
   static void destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO2cO2cOROOTcLcLMathcLcLMatRepStdlEfloatcO2cO2gRsPgR(void *p);

   // Schema evolution read functions

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SMatrix<float,2,2,ROOT::Math::MatRepStd<float,2,2> >*)
   {
      ::ROOT::Math::SMatrix<float,2,2,ROOT::Math::MatRepStd<float,2,2> > *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SMatrix<float,2,2,ROOT::Math::MatRepStd<float,2,2> >));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SMatrix<float,2,2,ROOT::Math::MatRepStd<float,2,2> >", "Math/SMatrix.h", 101,
                  typeid(::ROOT::Math::SMatrix<float,2,2,ROOT::Math::MatRepStd<float,2,2> >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSMatrixlEfloatcO2cO2cOROOTcLcLMathcLcLMatRepStdlEfloatcO2cO2gRsPgR_Dictionary, isa_proxy, 4,
                  sizeof(::ROOT::Math::SMatrix<float,2,2,ROOT::Math::MatRepStd<float,2,2> >) );
      instance.SetNew(&new_ROOTcLcLMathcLcLSMatrixlEfloatcO2cO2cOROOTcLcLMathcLcLMatRepStdlEfloatcO2cO2gRsPgR);
      instance.SetNewArray(&newArray_ROOTcLcLMathcLcLSMatrixlEfloatcO2cO2cOROOTcLcLMathcLcLMatRepStdlEfloatcO2cO2gRsPgR);
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSMatrixlEfloatcO2cO2cOROOTcLcLMathcLcLMatRepStdlEfloatcO2cO2gRsPgR);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO2cO2cOROOTcLcLMathcLcLMatRepStdlEfloatcO2cO2gRsPgR);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO2cO2cOROOTcLcLMathcLcLMatRepStdlEfloatcO2cO2gRsPgR);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<float,2,2,ROOT::Math::MatRepStd<float,2,2> >","ROOT::Math::SMatrix<float,2,2>"));

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<float,2,2,ROOT::Math::MatRepStd<float,2,2> >","ROOT::Math::SMatrix<float, 2u, 2u, ROOT::Math::MatRepStd<float, 2u, 2u> >"));

      ::ROOT::Internal::TSchemaHelper* rule;

      // the io read rules
      std::vector<::ROOT::Internal::TSchemaHelper> readrules(3);
      rule = &readrules[0];
      rule->fSourceClass = "ROOT::Math::SMatrix<double,2,2>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[1];
      rule->fSourceClass = "ROOT::Math::SMatrix<Double32_t,2,2>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[2];
      rule->fSourceClass = "ROOT::Math::SMatrix<Float16_t,2,2>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      instance.SetReadRules( readrules );
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::SMatrix<float,2,2,ROOT::Math::MatRepStd<float,2,2> >*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::SMatrix<float,2,2,ROOT::Math::MatRepStd<float,2,2> >*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<float,2,2,ROOT::Math::MatRepStd<float,2,2> >*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLSMatrixlEfloatcO2cO2cOROOTcLcLMathcLcLMatRepStdlEfloatcO2cO2gRsPgR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<float,2,2,ROOT::Math::MatRepStd<float,2,2> >*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLSMatrixlEfloatcO2cO2cOROOTcLcLMathcLcLMatRepStdlEfloatcO2cO2gRsPgR_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLSMatrixlEfloatcO2cO2cOROOTcLcLMathcLcLMatRepStdlEfloatcO2cO2gRsPgR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSMatrixlEfloatcO2UcO2UcOROOTcLcLMathcLcLMatRepStdlEfloatcO2cO2gRsPgRcLcLSMatrixRow_Dictionary();
   static void ROOTcLcLMathcLcLSMatrixlEfloatcO2UcO2UcOROOTcLcLMathcLcLMatRepStdlEfloatcO2cO2gRsPgRcLcLSMatrixRow_TClassManip(TClass*);
   static void delete_ROOTcLcLMathcLcLSMatrixlEfloatcO2UcO2UcOROOTcLcLMathcLcLMatRepStdlEfloatcO2cO2gRsPgRcLcLSMatrixRow(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO2UcO2UcOROOTcLcLMathcLcLMatRepStdlEfloatcO2cO2gRsPgRcLcLSMatrixRow(void *p);
   static void destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO2UcO2UcOROOTcLcLMathcLcLMatRepStdlEfloatcO2cO2gRsPgRcLcLSMatrixRow(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SMatrix<float,2U,2U,ROOT::Math::MatRepStd<float,2,2> >::SMatrixRow*)
   {
      ::ROOT::Math::SMatrix<float,2U,2U,ROOT::Math::MatRepStd<float,2,2> >::SMatrixRow *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SMatrix<float,2U,2U,ROOT::Math::MatRepStd<float,2,2> >::SMatrixRow));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SMatrix<float,2U,2U,ROOT::Math::MatRepStd<float,2,2> >::SMatrixRow", "Math/SMatrix.h", 371,
                  typeid(::ROOT::Math::SMatrix<float,2U,2U,ROOT::Math::MatRepStd<float,2,2> >::SMatrixRow), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSMatrixlEfloatcO2UcO2UcOROOTcLcLMathcLcLMatRepStdlEfloatcO2cO2gRsPgRcLcLSMatrixRow_Dictionary, isa_proxy, 0,
                  sizeof(::ROOT::Math::SMatrix<float,2U,2U,ROOT::Math::MatRepStd<float,2,2> >::SMatrixRow) );
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSMatrixlEfloatcO2UcO2UcOROOTcLcLMathcLcLMatRepStdlEfloatcO2cO2gRsPgRcLcLSMatrixRow);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO2UcO2UcOROOTcLcLMathcLcLMatRepStdlEfloatcO2cO2gRsPgRcLcLSMatrixRow);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO2UcO2UcOROOTcLcLMathcLcLMatRepStdlEfloatcO2cO2gRsPgRcLcLSMatrixRow);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<float,2U,2U,ROOT::Math::MatRepStd<float,2,2> >::SMatrixRow","ROOT::Math::SMatrix<float,2,2>::SMatrixRow"));

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<float,2U,2U,ROOT::Math::MatRepStd<float,2,2> >::SMatrixRow","ROOT::Math::SMatrix<float, 2u, 2u, ROOT::Math::MatRepStd<float, 2u, 2u> >::SMatrixRow"));
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::SMatrix<float,2U,2U,ROOT::Math::MatRepStd<float,2,2> >::SMatrixRow*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::SMatrix<float,2U,2U,ROOT::Math::MatRepStd<float,2,2> >::SMatrixRow*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<float,2U,2U,ROOT::Math::MatRepStd<float,2,2> >::SMatrixRow*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLSMatrixlEfloatcO2UcO2UcOROOTcLcLMathcLcLMatRepStdlEfloatcO2cO2gRsPgRcLcLSMatrixRow_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<float,2U,2U,ROOT::Math::MatRepStd<float,2,2> >::SMatrixRow*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLSMatrixlEfloatcO2UcO2UcOROOTcLcLMathcLcLMatRepStdlEfloatcO2cO2gRsPgRcLcLSMatrixRow_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLSMatrixlEfloatcO2UcO2UcOROOTcLcLMathcLcLMatRepStdlEfloatcO2cO2gRsPgRcLcLSMatrixRow_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSMatrixlEfloatcO2UcO2UcOROOTcLcLMathcLcLMatRepStdlEfloatcO2cO2gRsPgRcLcLSMatrixRow_const_Dictionary();
   static void ROOTcLcLMathcLcLSMatrixlEfloatcO2UcO2UcOROOTcLcLMathcLcLMatRepStdlEfloatcO2cO2gRsPgRcLcLSMatrixRow_const_TClassManip(TClass*);
   static void delete_ROOTcLcLMathcLcLSMatrixlEfloatcO2UcO2UcOROOTcLcLMathcLcLMatRepStdlEfloatcO2cO2gRsPgRcLcLSMatrixRow_const(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO2UcO2UcOROOTcLcLMathcLcLMatRepStdlEfloatcO2cO2gRsPgRcLcLSMatrixRow_const(void *p);
   static void destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO2UcO2UcOROOTcLcLMathcLcLMatRepStdlEfloatcO2cO2gRsPgRcLcLSMatrixRow_const(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SMatrix<float,2U,2U,ROOT::Math::MatRepStd<float,2,2> >::SMatrixRow_const*)
   {
      ::ROOT::Math::SMatrix<float,2U,2U,ROOT::Math::MatRepStd<float,2,2> >::SMatrixRow_const *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SMatrix<float,2U,2U,ROOT::Math::MatRepStd<float,2,2> >::SMatrixRow_const));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SMatrix<float,2U,2U,ROOT::Math::MatRepStd<float,2,2> >::SMatrixRow_const", "Math/SMatrix.h", 382,
                  typeid(::ROOT::Math::SMatrix<float,2U,2U,ROOT::Math::MatRepStd<float,2,2> >::SMatrixRow_const), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSMatrixlEfloatcO2UcO2UcOROOTcLcLMathcLcLMatRepStdlEfloatcO2cO2gRsPgRcLcLSMatrixRow_const_Dictionary, isa_proxy, 0,
                  sizeof(::ROOT::Math::SMatrix<float,2U,2U,ROOT::Math::MatRepStd<float,2,2> >::SMatrixRow_const) );
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSMatrixlEfloatcO2UcO2UcOROOTcLcLMathcLcLMatRepStdlEfloatcO2cO2gRsPgRcLcLSMatrixRow_const);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO2UcO2UcOROOTcLcLMathcLcLMatRepStdlEfloatcO2cO2gRsPgRcLcLSMatrixRow_const);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO2UcO2UcOROOTcLcLMathcLcLMatRepStdlEfloatcO2cO2gRsPgRcLcLSMatrixRow_const);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<float,2U,2U,ROOT::Math::MatRepStd<float,2,2> >::SMatrixRow_const","ROOT::Math::SMatrix<float,2,2>::SMatrixRow_const"));

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<float,2U,2U,ROOT::Math::MatRepStd<float,2,2> >::SMatrixRow_const","ROOT::Math::SMatrix<float, 2u, 2u, ROOT::Math::MatRepStd<float, 2u, 2u> >::SMatrixRow_const"));
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::SMatrix<float,2U,2U,ROOT::Math::MatRepStd<float,2,2> >::SMatrixRow_const*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::SMatrix<float,2U,2U,ROOT::Math::MatRepStd<float,2,2> >::SMatrixRow_const*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<float,2U,2U,ROOT::Math::MatRepStd<float,2,2> >::SMatrixRow_const*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLSMatrixlEfloatcO2UcO2UcOROOTcLcLMathcLcLMatRepStdlEfloatcO2cO2gRsPgRcLcLSMatrixRow_const_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<float,2U,2U,ROOT::Math::MatRepStd<float,2,2> >::SMatrixRow_const*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLSMatrixlEfloatcO2UcO2UcOROOTcLcLMathcLcLMatRepStdlEfloatcO2cO2gRsPgRcLcLSMatrixRow_const_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLSMatrixlEfloatcO2UcO2UcOROOTcLcLMathcLcLMatRepStdlEfloatcO2cO2gRsPgRcLcLSMatrixRow_const_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSMatrixlEfloatcO3cO3cOROOTcLcLMathcLcLMatRepStdlEfloatcO3cO3gRsPgR_Dictionary();
   static void ROOTcLcLMathcLcLSMatrixlEfloatcO3cO3cOROOTcLcLMathcLcLMatRepStdlEfloatcO3cO3gRsPgR_TClassManip(TClass*);
   static void *new_ROOTcLcLMathcLcLSMatrixlEfloatcO3cO3cOROOTcLcLMathcLcLMatRepStdlEfloatcO3cO3gRsPgR(void *p = nullptr);
   static void *newArray_ROOTcLcLMathcLcLSMatrixlEfloatcO3cO3cOROOTcLcLMathcLcLMatRepStdlEfloatcO3cO3gRsPgR(Long_t size, void *p);
   static void delete_ROOTcLcLMathcLcLSMatrixlEfloatcO3cO3cOROOTcLcLMathcLcLMatRepStdlEfloatcO3cO3gRsPgR(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO3cO3cOROOTcLcLMathcLcLMatRepStdlEfloatcO3cO3gRsPgR(void *p);
   static void destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO3cO3cOROOTcLcLMathcLcLMatRepStdlEfloatcO3cO3gRsPgR(void *p);

   // Schema evolution read functions

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SMatrix<float,3,3,ROOT::Math::MatRepStd<float,3,3> >*)
   {
      ::ROOT::Math::SMatrix<float,3,3,ROOT::Math::MatRepStd<float,3,3> > *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SMatrix<float,3,3,ROOT::Math::MatRepStd<float,3,3> >));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SMatrix<float,3,3,ROOT::Math::MatRepStd<float,3,3> >", "Math/SMatrix.h", 101,
                  typeid(::ROOT::Math::SMatrix<float,3,3,ROOT::Math::MatRepStd<float,3,3> >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSMatrixlEfloatcO3cO3cOROOTcLcLMathcLcLMatRepStdlEfloatcO3cO3gRsPgR_Dictionary, isa_proxy, 4,
                  sizeof(::ROOT::Math::SMatrix<float,3,3,ROOT::Math::MatRepStd<float,3,3> >) );
      instance.SetNew(&new_ROOTcLcLMathcLcLSMatrixlEfloatcO3cO3cOROOTcLcLMathcLcLMatRepStdlEfloatcO3cO3gRsPgR);
      instance.SetNewArray(&newArray_ROOTcLcLMathcLcLSMatrixlEfloatcO3cO3cOROOTcLcLMathcLcLMatRepStdlEfloatcO3cO3gRsPgR);
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSMatrixlEfloatcO3cO3cOROOTcLcLMathcLcLMatRepStdlEfloatcO3cO3gRsPgR);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO3cO3cOROOTcLcLMathcLcLMatRepStdlEfloatcO3cO3gRsPgR);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO3cO3cOROOTcLcLMathcLcLMatRepStdlEfloatcO3cO3gRsPgR);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<float,3,3,ROOT::Math::MatRepStd<float,3,3> >","ROOT::Math::SMatrix<float,3,3>"));

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<float,3,3,ROOT::Math::MatRepStd<float,3,3> >","ROOT::Math::SMatrix<float, 3u, 3u, ROOT::Math::MatRepStd<float, 3u, 3u> >"));

      ::ROOT::Internal::TSchemaHelper* rule;

      // the io read rules
      std::vector<::ROOT::Internal::TSchemaHelper> readrules(3);
      rule = &readrules[0];
      rule->fSourceClass = "ROOT::Math::SMatrix<double,3,3>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[1];
      rule->fSourceClass = "ROOT::Math::SMatrix<Double32_t,3,3>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[2];
      rule->fSourceClass = "ROOT::Math::SMatrix<Float16_t,3,3>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      instance.SetReadRules( readrules );
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::SMatrix<float,3,3,ROOT::Math::MatRepStd<float,3,3> >*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::SMatrix<float,3,3,ROOT::Math::MatRepStd<float,3,3> >*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<float,3,3,ROOT::Math::MatRepStd<float,3,3> >*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLSMatrixlEfloatcO3cO3cOROOTcLcLMathcLcLMatRepStdlEfloatcO3cO3gRsPgR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<float,3,3,ROOT::Math::MatRepStd<float,3,3> >*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLSMatrixlEfloatcO3cO3cOROOTcLcLMathcLcLMatRepStdlEfloatcO3cO3gRsPgR_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLSMatrixlEfloatcO3cO3cOROOTcLcLMathcLcLMatRepStdlEfloatcO3cO3gRsPgR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSMatrixlEfloatcO3UcO3UcOROOTcLcLMathcLcLMatRepStdlEfloatcO3cO3gRsPgRcLcLSMatrixRow_Dictionary();
   static void ROOTcLcLMathcLcLSMatrixlEfloatcO3UcO3UcOROOTcLcLMathcLcLMatRepStdlEfloatcO3cO3gRsPgRcLcLSMatrixRow_TClassManip(TClass*);
   static void delete_ROOTcLcLMathcLcLSMatrixlEfloatcO3UcO3UcOROOTcLcLMathcLcLMatRepStdlEfloatcO3cO3gRsPgRcLcLSMatrixRow(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO3UcO3UcOROOTcLcLMathcLcLMatRepStdlEfloatcO3cO3gRsPgRcLcLSMatrixRow(void *p);
   static void destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO3UcO3UcOROOTcLcLMathcLcLMatRepStdlEfloatcO3cO3gRsPgRcLcLSMatrixRow(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SMatrix<float,3U,3U,ROOT::Math::MatRepStd<float,3,3> >::SMatrixRow*)
   {
      ::ROOT::Math::SMatrix<float,3U,3U,ROOT::Math::MatRepStd<float,3,3> >::SMatrixRow *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SMatrix<float,3U,3U,ROOT::Math::MatRepStd<float,3,3> >::SMatrixRow));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SMatrix<float,3U,3U,ROOT::Math::MatRepStd<float,3,3> >::SMatrixRow", "Math/SMatrix.h", 371,
                  typeid(::ROOT::Math::SMatrix<float,3U,3U,ROOT::Math::MatRepStd<float,3,3> >::SMatrixRow), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSMatrixlEfloatcO3UcO3UcOROOTcLcLMathcLcLMatRepStdlEfloatcO3cO3gRsPgRcLcLSMatrixRow_Dictionary, isa_proxy, 0,
                  sizeof(::ROOT::Math::SMatrix<float,3U,3U,ROOT::Math::MatRepStd<float,3,3> >::SMatrixRow) );
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSMatrixlEfloatcO3UcO3UcOROOTcLcLMathcLcLMatRepStdlEfloatcO3cO3gRsPgRcLcLSMatrixRow);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO3UcO3UcOROOTcLcLMathcLcLMatRepStdlEfloatcO3cO3gRsPgRcLcLSMatrixRow);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO3UcO3UcOROOTcLcLMathcLcLMatRepStdlEfloatcO3cO3gRsPgRcLcLSMatrixRow);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<float,3U,3U,ROOT::Math::MatRepStd<float,3,3> >::SMatrixRow","ROOT::Math::SMatrix<float,3,3>::SMatrixRow"));

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<float,3U,3U,ROOT::Math::MatRepStd<float,3,3> >::SMatrixRow","ROOT::Math::SMatrix<float, 3u, 3u, ROOT::Math::MatRepStd<float, 3u, 3u> >::SMatrixRow"));
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::SMatrix<float,3U,3U,ROOT::Math::MatRepStd<float,3,3> >::SMatrixRow*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::SMatrix<float,3U,3U,ROOT::Math::MatRepStd<float,3,3> >::SMatrixRow*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<float,3U,3U,ROOT::Math::MatRepStd<float,3,3> >::SMatrixRow*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLSMatrixlEfloatcO3UcO3UcOROOTcLcLMathcLcLMatRepStdlEfloatcO3cO3gRsPgRcLcLSMatrixRow_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<float,3U,3U,ROOT::Math::MatRepStd<float,3,3> >::SMatrixRow*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLSMatrixlEfloatcO3UcO3UcOROOTcLcLMathcLcLMatRepStdlEfloatcO3cO3gRsPgRcLcLSMatrixRow_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLSMatrixlEfloatcO3UcO3UcOROOTcLcLMathcLcLMatRepStdlEfloatcO3cO3gRsPgRcLcLSMatrixRow_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSMatrixlEfloatcO3UcO3UcOROOTcLcLMathcLcLMatRepStdlEfloatcO3cO3gRsPgRcLcLSMatrixRow_const_Dictionary();
   static void ROOTcLcLMathcLcLSMatrixlEfloatcO3UcO3UcOROOTcLcLMathcLcLMatRepStdlEfloatcO3cO3gRsPgRcLcLSMatrixRow_const_TClassManip(TClass*);
   static void delete_ROOTcLcLMathcLcLSMatrixlEfloatcO3UcO3UcOROOTcLcLMathcLcLMatRepStdlEfloatcO3cO3gRsPgRcLcLSMatrixRow_const(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO3UcO3UcOROOTcLcLMathcLcLMatRepStdlEfloatcO3cO3gRsPgRcLcLSMatrixRow_const(void *p);
   static void destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO3UcO3UcOROOTcLcLMathcLcLMatRepStdlEfloatcO3cO3gRsPgRcLcLSMatrixRow_const(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SMatrix<float,3U,3U,ROOT::Math::MatRepStd<float,3,3> >::SMatrixRow_const*)
   {
      ::ROOT::Math::SMatrix<float,3U,3U,ROOT::Math::MatRepStd<float,3,3> >::SMatrixRow_const *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SMatrix<float,3U,3U,ROOT::Math::MatRepStd<float,3,3> >::SMatrixRow_const));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SMatrix<float,3U,3U,ROOT::Math::MatRepStd<float,3,3> >::SMatrixRow_const", "Math/SMatrix.h", 382,
                  typeid(::ROOT::Math::SMatrix<float,3U,3U,ROOT::Math::MatRepStd<float,3,3> >::SMatrixRow_const), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSMatrixlEfloatcO3UcO3UcOROOTcLcLMathcLcLMatRepStdlEfloatcO3cO3gRsPgRcLcLSMatrixRow_const_Dictionary, isa_proxy, 0,
                  sizeof(::ROOT::Math::SMatrix<float,3U,3U,ROOT::Math::MatRepStd<float,3,3> >::SMatrixRow_const) );
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSMatrixlEfloatcO3UcO3UcOROOTcLcLMathcLcLMatRepStdlEfloatcO3cO3gRsPgRcLcLSMatrixRow_const);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO3UcO3UcOROOTcLcLMathcLcLMatRepStdlEfloatcO3cO3gRsPgRcLcLSMatrixRow_const);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO3UcO3UcOROOTcLcLMathcLcLMatRepStdlEfloatcO3cO3gRsPgRcLcLSMatrixRow_const);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<float,3U,3U,ROOT::Math::MatRepStd<float,3,3> >::SMatrixRow_const","ROOT::Math::SMatrix<float,3,3>::SMatrixRow_const"));

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<float,3U,3U,ROOT::Math::MatRepStd<float,3,3> >::SMatrixRow_const","ROOT::Math::SMatrix<float, 3u, 3u, ROOT::Math::MatRepStd<float, 3u, 3u> >::SMatrixRow_const"));
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::SMatrix<float,3U,3U,ROOT::Math::MatRepStd<float,3,3> >::SMatrixRow_const*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::SMatrix<float,3U,3U,ROOT::Math::MatRepStd<float,3,3> >::SMatrixRow_const*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<float,3U,3U,ROOT::Math::MatRepStd<float,3,3> >::SMatrixRow_const*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLSMatrixlEfloatcO3UcO3UcOROOTcLcLMathcLcLMatRepStdlEfloatcO3cO3gRsPgRcLcLSMatrixRow_const_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<float,3U,3U,ROOT::Math::MatRepStd<float,3,3> >::SMatrixRow_const*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLSMatrixlEfloatcO3UcO3UcOROOTcLcLMathcLcLMatRepStdlEfloatcO3cO3gRsPgRcLcLSMatrixRow_const_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLSMatrixlEfloatcO3UcO3UcOROOTcLcLMathcLcLMatRepStdlEfloatcO3cO3gRsPgRcLcLSMatrixRow_const_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSMatrixlEfloatcO4cO4cOROOTcLcLMathcLcLMatRepStdlEfloatcO4cO4gRsPgR_Dictionary();
   static void ROOTcLcLMathcLcLSMatrixlEfloatcO4cO4cOROOTcLcLMathcLcLMatRepStdlEfloatcO4cO4gRsPgR_TClassManip(TClass*);
   static void *new_ROOTcLcLMathcLcLSMatrixlEfloatcO4cO4cOROOTcLcLMathcLcLMatRepStdlEfloatcO4cO4gRsPgR(void *p = nullptr);
   static void *newArray_ROOTcLcLMathcLcLSMatrixlEfloatcO4cO4cOROOTcLcLMathcLcLMatRepStdlEfloatcO4cO4gRsPgR(Long_t size, void *p);
   static void delete_ROOTcLcLMathcLcLSMatrixlEfloatcO4cO4cOROOTcLcLMathcLcLMatRepStdlEfloatcO4cO4gRsPgR(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO4cO4cOROOTcLcLMathcLcLMatRepStdlEfloatcO4cO4gRsPgR(void *p);
   static void destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO4cO4cOROOTcLcLMathcLcLMatRepStdlEfloatcO4cO4gRsPgR(void *p);

   // Schema evolution read functions

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SMatrix<float,4,4,ROOT::Math::MatRepStd<float,4,4> >*)
   {
      ::ROOT::Math::SMatrix<float,4,4,ROOT::Math::MatRepStd<float,4,4> > *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SMatrix<float,4,4,ROOT::Math::MatRepStd<float,4,4> >));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SMatrix<float,4,4,ROOT::Math::MatRepStd<float,4,4> >", "Math/SMatrix.h", 101,
                  typeid(::ROOT::Math::SMatrix<float,4,4,ROOT::Math::MatRepStd<float,4,4> >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSMatrixlEfloatcO4cO4cOROOTcLcLMathcLcLMatRepStdlEfloatcO4cO4gRsPgR_Dictionary, isa_proxy, 4,
                  sizeof(::ROOT::Math::SMatrix<float,4,4,ROOT::Math::MatRepStd<float,4,4> >) );
      instance.SetNew(&new_ROOTcLcLMathcLcLSMatrixlEfloatcO4cO4cOROOTcLcLMathcLcLMatRepStdlEfloatcO4cO4gRsPgR);
      instance.SetNewArray(&newArray_ROOTcLcLMathcLcLSMatrixlEfloatcO4cO4cOROOTcLcLMathcLcLMatRepStdlEfloatcO4cO4gRsPgR);
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSMatrixlEfloatcO4cO4cOROOTcLcLMathcLcLMatRepStdlEfloatcO4cO4gRsPgR);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO4cO4cOROOTcLcLMathcLcLMatRepStdlEfloatcO4cO4gRsPgR);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO4cO4cOROOTcLcLMathcLcLMatRepStdlEfloatcO4cO4gRsPgR);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<float,4,4,ROOT::Math::MatRepStd<float,4,4> >","ROOT::Math::SMatrix<float,4,4>"));

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<float,4,4,ROOT::Math::MatRepStd<float,4,4> >","ROOT::Math::SMatrix<float, 4u, 4u, ROOT::Math::MatRepStd<float, 4u, 4u> >"));

      ::ROOT::Internal::TSchemaHelper* rule;

      // the io read rules
      std::vector<::ROOT::Internal::TSchemaHelper> readrules(3);
      rule = &readrules[0];
      rule->fSourceClass = "ROOT::Math::SMatrix<double,4,4>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[1];
      rule->fSourceClass = "ROOT::Math::SMatrix<Double32_t,4,4>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[2];
      rule->fSourceClass = "ROOT::Math::SMatrix<Float16_t,4,4>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      instance.SetReadRules( readrules );
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::SMatrix<float,4,4,ROOT::Math::MatRepStd<float,4,4> >*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::SMatrix<float,4,4,ROOT::Math::MatRepStd<float,4,4> >*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<float,4,4,ROOT::Math::MatRepStd<float,4,4> >*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLSMatrixlEfloatcO4cO4cOROOTcLcLMathcLcLMatRepStdlEfloatcO4cO4gRsPgR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<float,4,4,ROOT::Math::MatRepStd<float,4,4> >*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLSMatrixlEfloatcO4cO4cOROOTcLcLMathcLcLMatRepStdlEfloatcO4cO4gRsPgR_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLSMatrixlEfloatcO4cO4cOROOTcLcLMathcLcLMatRepStdlEfloatcO4cO4gRsPgR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSMatrixlEfloatcO4UcO4UcOROOTcLcLMathcLcLMatRepStdlEfloatcO4cO4gRsPgRcLcLSMatrixRow_Dictionary();
   static void ROOTcLcLMathcLcLSMatrixlEfloatcO4UcO4UcOROOTcLcLMathcLcLMatRepStdlEfloatcO4cO4gRsPgRcLcLSMatrixRow_TClassManip(TClass*);
   static void delete_ROOTcLcLMathcLcLSMatrixlEfloatcO4UcO4UcOROOTcLcLMathcLcLMatRepStdlEfloatcO4cO4gRsPgRcLcLSMatrixRow(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO4UcO4UcOROOTcLcLMathcLcLMatRepStdlEfloatcO4cO4gRsPgRcLcLSMatrixRow(void *p);
   static void destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO4UcO4UcOROOTcLcLMathcLcLMatRepStdlEfloatcO4cO4gRsPgRcLcLSMatrixRow(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SMatrix<float,4U,4U,ROOT::Math::MatRepStd<float,4,4> >::SMatrixRow*)
   {
      ::ROOT::Math::SMatrix<float,4U,4U,ROOT::Math::MatRepStd<float,4,4> >::SMatrixRow *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SMatrix<float,4U,4U,ROOT::Math::MatRepStd<float,4,4> >::SMatrixRow));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SMatrix<float,4U,4U,ROOT::Math::MatRepStd<float,4,4> >::SMatrixRow", "Math/SMatrix.h", 371,
                  typeid(::ROOT::Math::SMatrix<float,4U,4U,ROOT::Math::MatRepStd<float,4,4> >::SMatrixRow), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSMatrixlEfloatcO4UcO4UcOROOTcLcLMathcLcLMatRepStdlEfloatcO4cO4gRsPgRcLcLSMatrixRow_Dictionary, isa_proxy, 0,
                  sizeof(::ROOT::Math::SMatrix<float,4U,4U,ROOT::Math::MatRepStd<float,4,4> >::SMatrixRow) );
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSMatrixlEfloatcO4UcO4UcOROOTcLcLMathcLcLMatRepStdlEfloatcO4cO4gRsPgRcLcLSMatrixRow);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO4UcO4UcOROOTcLcLMathcLcLMatRepStdlEfloatcO4cO4gRsPgRcLcLSMatrixRow);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO4UcO4UcOROOTcLcLMathcLcLMatRepStdlEfloatcO4cO4gRsPgRcLcLSMatrixRow);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<float,4U,4U,ROOT::Math::MatRepStd<float,4,4> >::SMatrixRow","ROOT::Math::SMatrix<float,4,4>::SMatrixRow"));

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<float,4U,4U,ROOT::Math::MatRepStd<float,4,4> >::SMatrixRow","ROOT::Math::SMatrix<float, 4u, 4u, ROOT::Math::MatRepStd<float, 4u, 4u> >::SMatrixRow"));
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::SMatrix<float,4U,4U,ROOT::Math::MatRepStd<float,4,4> >::SMatrixRow*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::SMatrix<float,4U,4U,ROOT::Math::MatRepStd<float,4,4> >::SMatrixRow*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<float,4U,4U,ROOT::Math::MatRepStd<float,4,4> >::SMatrixRow*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLSMatrixlEfloatcO4UcO4UcOROOTcLcLMathcLcLMatRepStdlEfloatcO4cO4gRsPgRcLcLSMatrixRow_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<float,4U,4U,ROOT::Math::MatRepStd<float,4,4> >::SMatrixRow*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLSMatrixlEfloatcO4UcO4UcOROOTcLcLMathcLcLMatRepStdlEfloatcO4cO4gRsPgRcLcLSMatrixRow_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLSMatrixlEfloatcO4UcO4UcOROOTcLcLMathcLcLMatRepStdlEfloatcO4cO4gRsPgRcLcLSMatrixRow_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSMatrixlEfloatcO4UcO4UcOROOTcLcLMathcLcLMatRepStdlEfloatcO4cO4gRsPgRcLcLSMatrixRow_const_Dictionary();
   static void ROOTcLcLMathcLcLSMatrixlEfloatcO4UcO4UcOROOTcLcLMathcLcLMatRepStdlEfloatcO4cO4gRsPgRcLcLSMatrixRow_const_TClassManip(TClass*);
   static void delete_ROOTcLcLMathcLcLSMatrixlEfloatcO4UcO4UcOROOTcLcLMathcLcLMatRepStdlEfloatcO4cO4gRsPgRcLcLSMatrixRow_const(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO4UcO4UcOROOTcLcLMathcLcLMatRepStdlEfloatcO4cO4gRsPgRcLcLSMatrixRow_const(void *p);
   static void destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO4UcO4UcOROOTcLcLMathcLcLMatRepStdlEfloatcO4cO4gRsPgRcLcLSMatrixRow_const(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SMatrix<float,4U,4U,ROOT::Math::MatRepStd<float,4,4> >::SMatrixRow_const*)
   {
      ::ROOT::Math::SMatrix<float,4U,4U,ROOT::Math::MatRepStd<float,4,4> >::SMatrixRow_const *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SMatrix<float,4U,4U,ROOT::Math::MatRepStd<float,4,4> >::SMatrixRow_const));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SMatrix<float,4U,4U,ROOT::Math::MatRepStd<float,4,4> >::SMatrixRow_const", "Math/SMatrix.h", 382,
                  typeid(::ROOT::Math::SMatrix<float,4U,4U,ROOT::Math::MatRepStd<float,4,4> >::SMatrixRow_const), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSMatrixlEfloatcO4UcO4UcOROOTcLcLMathcLcLMatRepStdlEfloatcO4cO4gRsPgRcLcLSMatrixRow_const_Dictionary, isa_proxy, 0,
                  sizeof(::ROOT::Math::SMatrix<float,4U,4U,ROOT::Math::MatRepStd<float,4,4> >::SMatrixRow_const) );
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSMatrixlEfloatcO4UcO4UcOROOTcLcLMathcLcLMatRepStdlEfloatcO4cO4gRsPgRcLcLSMatrixRow_const);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO4UcO4UcOROOTcLcLMathcLcLMatRepStdlEfloatcO4cO4gRsPgRcLcLSMatrixRow_const);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO4UcO4UcOROOTcLcLMathcLcLMatRepStdlEfloatcO4cO4gRsPgRcLcLSMatrixRow_const);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<float,4U,4U,ROOT::Math::MatRepStd<float,4,4> >::SMatrixRow_const","ROOT::Math::SMatrix<float,4,4>::SMatrixRow_const"));

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<float,4U,4U,ROOT::Math::MatRepStd<float,4,4> >::SMatrixRow_const","ROOT::Math::SMatrix<float, 4u, 4u, ROOT::Math::MatRepStd<float, 4u, 4u> >::SMatrixRow_const"));
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::SMatrix<float,4U,4U,ROOT::Math::MatRepStd<float,4,4> >::SMatrixRow_const*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::SMatrix<float,4U,4U,ROOT::Math::MatRepStd<float,4,4> >::SMatrixRow_const*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<float,4U,4U,ROOT::Math::MatRepStd<float,4,4> >::SMatrixRow_const*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLSMatrixlEfloatcO4UcO4UcOROOTcLcLMathcLcLMatRepStdlEfloatcO4cO4gRsPgRcLcLSMatrixRow_const_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<float,4U,4U,ROOT::Math::MatRepStd<float,4,4> >::SMatrixRow_const*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLSMatrixlEfloatcO4UcO4UcOROOTcLcLMathcLcLMatRepStdlEfloatcO4cO4gRsPgRcLcLSMatrixRow_const_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLSMatrixlEfloatcO4UcO4UcOROOTcLcLMathcLcLMatRepStdlEfloatcO4cO4gRsPgRcLcLSMatrixRow_const_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSMatrixlEfloatcO5cO5cOROOTcLcLMathcLcLMatRepStdlEfloatcO5cO5gRsPgR_Dictionary();
   static void ROOTcLcLMathcLcLSMatrixlEfloatcO5cO5cOROOTcLcLMathcLcLMatRepStdlEfloatcO5cO5gRsPgR_TClassManip(TClass*);
   static void *new_ROOTcLcLMathcLcLSMatrixlEfloatcO5cO5cOROOTcLcLMathcLcLMatRepStdlEfloatcO5cO5gRsPgR(void *p = nullptr);
   static void *newArray_ROOTcLcLMathcLcLSMatrixlEfloatcO5cO5cOROOTcLcLMathcLcLMatRepStdlEfloatcO5cO5gRsPgR(Long_t size, void *p);
   static void delete_ROOTcLcLMathcLcLSMatrixlEfloatcO5cO5cOROOTcLcLMathcLcLMatRepStdlEfloatcO5cO5gRsPgR(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO5cO5cOROOTcLcLMathcLcLMatRepStdlEfloatcO5cO5gRsPgR(void *p);
   static void destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO5cO5cOROOTcLcLMathcLcLMatRepStdlEfloatcO5cO5gRsPgR(void *p);

   // Schema evolution read functions

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SMatrix<float,5,5,ROOT::Math::MatRepStd<float,5,5> >*)
   {
      ::ROOT::Math::SMatrix<float,5,5,ROOT::Math::MatRepStd<float,5,5> > *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SMatrix<float,5,5,ROOT::Math::MatRepStd<float,5,5> >));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SMatrix<float,5,5,ROOT::Math::MatRepStd<float,5,5> >", "Math/SMatrix.h", 101,
                  typeid(::ROOT::Math::SMatrix<float,5,5,ROOT::Math::MatRepStd<float,5,5> >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSMatrixlEfloatcO5cO5cOROOTcLcLMathcLcLMatRepStdlEfloatcO5cO5gRsPgR_Dictionary, isa_proxy, 4,
                  sizeof(::ROOT::Math::SMatrix<float,5,5,ROOT::Math::MatRepStd<float,5,5> >) );
      instance.SetNew(&new_ROOTcLcLMathcLcLSMatrixlEfloatcO5cO5cOROOTcLcLMathcLcLMatRepStdlEfloatcO5cO5gRsPgR);
      instance.SetNewArray(&newArray_ROOTcLcLMathcLcLSMatrixlEfloatcO5cO5cOROOTcLcLMathcLcLMatRepStdlEfloatcO5cO5gRsPgR);
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSMatrixlEfloatcO5cO5cOROOTcLcLMathcLcLMatRepStdlEfloatcO5cO5gRsPgR);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO5cO5cOROOTcLcLMathcLcLMatRepStdlEfloatcO5cO5gRsPgR);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO5cO5cOROOTcLcLMathcLcLMatRepStdlEfloatcO5cO5gRsPgR);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<float,5,5,ROOT::Math::MatRepStd<float,5,5> >","ROOT::Math::SMatrix<float,5,5>"));

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<float,5,5,ROOT::Math::MatRepStd<float,5,5> >","ROOT::Math::SMatrix<float, 5u, 5u, ROOT::Math::MatRepStd<float, 5u, 5u> >"));

      ::ROOT::Internal::TSchemaHelper* rule;

      // the io read rules
      std::vector<::ROOT::Internal::TSchemaHelper> readrules(3);
      rule = &readrules[0];
      rule->fSourceClass = "ROOT::Math::SMatrix<double,5,5>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[1];
      rule->fSourceClass = "ROOT::Math::SMatrix<Double32_t,5,5>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[2];
      rule->fSourceClass = "ROOT::Math::SMatrix<Float16_t,5,5>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      instance.SetReadRules( readrules );
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::SMatrix<float,5,5,ROOT::Math::MatRepStd<float,5,5> >*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::SMatrix<float,5,5,ROOT::Math::MatRepStd<float,5,5> >*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<float,5,5,ROOT::Math::MatRepStd<float,5,5> >*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLSMatrixlEfloatcO5cO5cOROOTcLcLMathcLcLMatRepStdlEfloatcO5cO5gRsPgR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<float,5,5,ROOT::Math::MatRepStd<float,5,5> >*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLSMatrixlEfloatcO5cO5cOROOTcLcLMathcLcLMatRepStdlEfloatcO5cO5gRsPgR_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLSMatrixlEfloatcO5cO5cOROOTcLcLMathcLcLMatRepStdlEfloatcO5cO5gRsPgR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSMatrixlEfloatcO5UcO5UcOROOTcLcLMathcLcLMatRepStdlEfloatcO5cO5gRsPgRcLcLSMatrixRow_Dictionary();
   static void ROOTcLcLMathcLcLSMatrixlEfloatcO5UcO5UcOROOTcLcLMathcLcLMatRepStdlEfloatcO5cO5gRsPgRcLcLSMatrixRow_TClassManip(TClass*);
   static void delete_ROOTcLcLMathcLcLSMatrixlEfloatcO5UcO5UcOROOTcLcLMathcLcLMatRepStdlEfloatcO5cO5gRsPgRcLcLSMatrixRow(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO5UcO5UcOROOTcLcLMathcLcLMatRepStdlEfloatcO5cO5gRsPgRcLcLSMatrixRow(void *p);
   static void destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO5UcO5UcOROOTcLcLMathcLcLMatRepStdlEfloatcO5cO5gRsPgRcLcLSMatrixRow(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SMatrix<float,5U,5U,ROOT::Math::MatRepStd<float,5,5> >::SMatrixRow*)
   {
      ::ROOT::Math::SMatrix<float,5U,5U,ROOT::Math::MatRepStd<float,5,5> >::SMatrixRow *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SMatrix<float,5U,5U,ROOT::Math::MatRepStd<float,5,5> >::SMatrixRow));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SMatrix<float,5U,5U,ROOT::Math::MatRepStd<float,5,5> >::SMatrixRow", "Math/SMatrix.h", 371,
                  typeid(::ROOT::Math::SMatrix<float,5U,5U,ROOT::Math::MatRepStd<float,5,5> >::SMatrixRow), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSMatrixlEfloatcO5UcO5UcOROOTcLcLMathcLcLMatRepStdlEfloatcO5cO5gRsPgRcLcLSMatrixRow_Dictionary, isa_proxy, 0,
                  sizeof(::ROOT::Math::SMatrix<float,5U,5U,ROOT::Math::MatRepStd<float,5,5> >::SMatrixRow) );
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSMatrixlEfloatcO5UcO5UcOROOTcLcLMathcLcLMatRepStdlEfloatcO5cO5gRsPgRcLcLSMatrixRow);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO5UcO5UcOROOTcLcLMathcLcLMatRepStdlEfloatcO5cO5gRsPgRcLcLSMatrixRow);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO5UcO5UcOROOTcLcLMathcLcLMatRepStdlEfloatcO5cO5gRsPgRcLcLSMatrixRow);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<float,5U,5U,ROOT::Math::MatRepStd<float,5,5> >::SMatrixRow","ROOT::Math::SMatrix<float,5,5>::SMatrixRow"));

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<float,5U,5U,ROOT::Math::MatRepStd<float,5,5> >::SMatrixRow","ROOT::Math::SMatrix<float, 5u, 5u, ROOT::Math::MatRepStd<float, 5u, 5u> >::SMatrixRow"));
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::SMatrix<float,5U,5U,ROOT::Math::MatRepStd<float,5,5> >::SMatrixRow*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::SMatrix<float,5U,5U,ROOT::Math::MatRepStd<float,5,5> >::SMatrixRow*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<float,5U,5U,ROOT::Math::MatRepStd<float,5,5> >::SMatrixRow*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLSMatrixlEfloatcO5UcO5UcOROOTcLcLMathcLcLMatRepStdlEfloatcO5cO5gRsPgRcLcLSMatrixRow_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<float,5U,5U,ROOT::Math::MatRepStd<float,5,5> >::SMatrixRow*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLSMatrixlEfloatcO5UcO5UcOROOTcLcLMathcLcLMatRepStdlEfloatcO5cO5gRsPgRcLcLSMatrixRow_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLSMatrixlEfloatcO5UcO5UcOROOTcLcLMathcLcLMatRepStdlEfloatcO5cO5gRsPgRcLcLSMatrixRow_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSMatrixlEfloatcO5UcO5UcOROOTcLcLMathcLcLMatRepStdlEfloatcO5cO5gRsPgRcLcLSMatrixRow_const_Dictionary();
   static void ROOTcLcLMathcLcLSMatrixlEfloatcO5UcO5UcOROOTcLcLMathcLcLMatRepStdlEfloatcO5cO5gRsPgRcLcLSMatrixRow_const_TClassManip(TClass*);
   static void delete_ROOTcLcLMathcLcLSMatrixlEfloatcO5UcO5UcOROOTcLcLMathcLcLMatRepStdlEfloatcO5cO5gRsPgRcLcLSMatrixRow_const(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO5UcO5UcOROOTcLcLMathcLcLMatRepStdlEfloatcO5cO5gRsPgRcLcLSMatrixRow_const(void *p);
   static void destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO5UcO5UcOROOTcLcLMathcLcLMatRepStdlEfloatcO5cO5gRsPgRcLcLSMatrixRow_const(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SMatrix<float,5U,5U,ROOT::Math::MatRepStd<float,5,5> >::SMatrixRow_const*)
   {
      ::ROOT::Math::SMatrix<float,5U,5U,ROOT::Math::MatRepStd<float,5,5> >::SMatrixRow_const *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SMatrix<float,5U,5U,ROOT::Math::MatRepStd<float,5,5> >::SMatrixRow_const));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SMatrix<float,5U,5U,ROOT::Math::MatRepStd<float,5,5> >::SMatrixRow_const", "Math/SMatrix.h", 382,
                  typeid(::ROOT::Math::SMatrix<float,5U,5U,ROOT::Math::MatRepStd<float,5,5> >::SMatrixRow_const), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSMatrixlEfloatcO5UcO5UcOROOTcLcLMathcLcLMatRepStdlEfloatcO5cO5gRsPgRcLcLSMatrixRow_const_Dictionary, isa_proxy, 0,
                  sizeof(::ROOT::Math::SMatrix<float,5U,5U,ROOT::Math::MatRepStd<float,5,5> >::SMatrixRow_const) );
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSMatrixlEfloatcO5UcO5UcOROOTcLcLMathcLcLMatRepStdlEfloatcO5cO5gRsPgRcLcLSMatrixRow_const);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO5UcO5UcOROOTcLcLMathcLcLMatRepStdlEfloatcO5cO5gRsPgRcLcLSMatrixRow_const);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO5UcO5UcOROOTcLcLMathcLcLMatRepStdlEfloatcO5cO5gRsPgRcLcLSMatrixRow_const);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<float,5U,5U,ROOT::Math::MatRepStd<float,5,5> >::SMatrixRow_const","ROOT::Math::SMatrix<float,5,5>::SMatrixRow_const"));

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<float,5U,5U,ROOT::Math::MatRepStd<float,5,5> >::SMatrixRow_const","ROOT::Math::SMatrix<float, 5u, 5u, ROOT::Math::MatRepStd<float, 5u, 5u> >::SMatrixRow_const"));
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::SMatrix<float,5U,5U,ROOT::Math::MatRepStd<float,5,5> >::SMatrixRow_const*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::SMatrix<float,5U,5U,ROOT::Math::MatRepStd<float,5,5> >::SMatrixRow_const*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<float,5U,5U,ROOT::Math::MatRepStd<float,5,5> >::SMatrixRow_const*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLSMatrixlEfloatcO5UcO5UcOROOTcLcLMathcLcLMatRepStdlEfloatcO5cO5gRsPgRcLcLSMatrixRow_const_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<float,5U,5U,ROOT::Math::MatRepStd<float,5,5> >::SMatrixRow_const*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLSMatrixlEfloatcO5UcO5UcOROOTcLcLMathcLcLMatRepStdlEfloatcO5cO5gRsPgRcLcLSMatrixRow_const_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLSMatrixlEfloatcO5UcO5UcOROOTcLcLMathcLcLMatRepStdlEfloatcO5cO5gRsPgRcLcLSMatrixRow_const_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSMatrixlEfloatcO6cO6cOROOTcLcLMathcLcLMatRepStdlEfloatcO6cO6gRsPgR_Dictionary();
   static void ROOTcLcLMathcLcLSMatrixlEfloatcO6cO6cOROOTcLcLMathcLcLMatRepStdlEfloatcO6cO6gRsPgR_TClassManip(TClass*);
   static void *new_ROOTcLcLMathcLcLSMatrixlEfloatcO6cO6cOROOTcLcLMathcLcLMatRepStdlEfloatcO6cO6gRsPgR(void *p = nullptr);
   static void *newArray_ROOTcLcLMathcLcLSMatrixlEfloatcO6cO6cOROOTcLcLMathcLcLMatRepStdlEfloatcO6cO6gRsPgR(Long_t size, void *p);
   static void delete_ROOTcLcLMathcLcLSMatrixlEfloatcO6cO6cOROOTcLcLMathcLcLMatRepStdlEfloatcO6cO6gRsPgR(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO6cO6cOROOTcLcLMathcLcLMatRepStdlEfloatcO6cO6gRsPgR(void *p);
   static void destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO6cO6cOROOTcLcLMathcLcLMatRepStdlEfloatcO6cO6gRsPgR(void *p);

   // Schema evolution read functions

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SMatrix<float,6,6,ROOT::Math::MatRepStd<float,6,6> >*)
   {
      ::ROOT::Math::SMatrix<float,6,6,ROOT::Math::MatRepStd<float,6,6> > *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SMatrix<float,6,6,ROOT::Math::MatRepStd<float,6,6> >));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SMatrix<float,6,6,ROOT::Math::MatRepStd<float,6,6> >", "Math/SMatrix.h", 101,
                  typeid(::ROOT::Math::SMatrix<float,6,6,ROOT::Math::MatRepStd<float,6,6> >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSMatrixlEfloatcO6cO6cOROOTcLcLMathcLcLMatRepStdlEfloatcO6cO6gRsPgR_Dictionary, isa_proxy, 4,
                  sizeof(::ROOT::Math::SMatrix<float,6,6,ROOT::Math::MatRepStd<float,6,6> >) );
      instance.SetNew(&new_ROOTcLcLMathcLcLSMatrixlEfloatcO6cO6cOROOTcLcLMathcLcLMatRepStdlEfloatcO6cO6gRsPgR);
      instance.SetNewArray(&newArray_ROOTcLcLMathcLcLSMatrixlEfloatcO6cO6cOROOTcLcLMathcLcLMatRepStdlEfloatcO6cO6gRsPgR);
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSMatrixlEfloatcO6cO6cOROOTcLcLMathcLcLMatRepStdlEfloatcO6cO6gRsPgR);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO6cO6cOROOTcLcLMathcLcLMatRepStdlEfloatcO6cO6gRsPgR);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO6cO6cOROOTcLcLMathcLcLMatRepStdlEfloatcO6cO6gRsPgR);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<float,6,6,ROOT::Math::MatRepStd<float,6,6> >","ROOT::Math::SMatrix<float,6,6>"));

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<float,6,6,ROOT::Math::MatRepStd<float,6,6> >","ROOT::Math::SMatrix<float, 6u, 6u, ROOT::Math::MatRepStd<float, 6u, 6u> >"));

      ::ROOT::Internal::TSchemaHelper* rule;

      // the io read rules
      std::vector<::ROOT::Internal::TSchemaHelper> readrules(3);
      rule = &readrules[0];
      rule->fSourceClass = "ROOT::Math::SMatrix<double,6,6>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[1];
      rule->fSourceClass = "ROOT::Math::SMatrix<Double32_t,6,6>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[2];
      rule->fSourceClass = "ROOT::Math::SMatrix<Float16_t,6,6>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      instance.SetReadRules( readrules );
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::SMatrix<float,6,6,ROOT::Math::MatRepStd<float,6,6> >*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::SMatrix<float,6,6,ROOT::Math::MatRepStd<float,6,6> >*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<float,6,6,ROOT::Math::MatRepStd<float,6,6> >*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLSMatrixlEfloatcO6cO6cOROOTcLcLMathcLcLMatRepStdlEfloatcO6cO6gRsPgR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<float,6,6,ROOT::Math::MatRepStd<float,6,6> >*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLSMatrixlEfloatcO6cO6cOROOTcLcLMathcLcLMatRepStdlEfloatcO6cO6gRsPgR_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLSMatrixlEfloatcO6cO6cOROOTcLcLMathcLcLMatRepStdlEfloatcO6cO6gRsPgR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSMatrixlEfloatcO6UcO6UcOROOTcLcLMathcLcLMatRepStdlEfloatcO6cO6gRsPgRcLcLSMatrixRow_Dictionary();
   static void ROOTcLcLMathcLcLSMatrixlEfloatcO6UcO6UcOROOTcLcLMathcLcLMatRepStdlEfloatcO6cO6gRsPgRcLcLSMatrixRow_TClassManip(TClass*);
   static void delete_ROOTcLcLMathcLcLSMatrixlEfloatcO6UcO6UcOROOTcLcLMathcLcLMatRepStdlEfloatcO6cO6gRsPgRcLcLSMatrixRow(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO6UcO6UcOROOTcLcLMathcLcLMatRepStdlEfloatcO6cO6gRsPgRcLcLSMatrixRow(void *p);
   static void destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO6UcO6UcOROOTcLcLMathcLcLMatRepStdlEfloatcO6cO6gRsPgRcLcLSMatrixRow(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SMatrix<float,6U,6U,ROOT::Math::MatRepStd<float,6,6> >::SMatrixRow*)
   {
      ::ROOT::Math::SMatrix<float,6U,6U,ROOT::Math::MatRepStd<float,6,6> >::SMatrixRow *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SMatrix<float,6U,6U,ROOT::Math::MatRepStd<float,6,6> >::SMatrixRow));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SMatrix<float,6U,6U,ROOT::Math::MatRepStd<float,6,6> >::SMatrixRow", "Math/SMatrix.h", 371,
                  typeid(::ROOT::Math::SMatrix<float,6U,6U,ROOT::Math::MatRepStd<float,6,6> >::SMatrixRow), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSMatrixlEfloatcO6UcO6UcOROOTcLcLMathcLcLMatRepStdlEfloatcO6cO6gRsPgRcLcLSMatrixRow_Dictionary, isa_proxy, 0,
                  sizeof(::ROOT::Math::SMatrix<float,6U,6U,ROOT::Math::MatRepStd<float,6,6> >::SMatrixRow) );
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSMatrixlEfloatcO6UcO6UcOROOTcLcLMathcLcLMatRepStdlEfloatcO6cO6gRsPgRcLcLSMatrixRow);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO6UcO6UcOROOTcLcLMathcLcLMatRepStdlEfloatcO6cO6gRsPgRcLcLSMatrixRow);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO6UcO6UcOROOTcLcLMathcLcLMatRepStdlEfloatcO6cO6gRsPgRcLcLSMatrixRow);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<float,6U,6U,ROOT::Math::MatRepStd<float,6,6> >::SMatrixRow","ROOT::Math::SMatrix<float,6,6>::SMatrixRow"));

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<float,6U,6U,ROOT::Math::MatRepStd<float,6,6> >::SMatrixRow","ROOT::Math::SMatrix<float, 6u, 6u, ROOT::Math::MatRepStd<float, 6u, 6u> >::SMatrixRow"));
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::SMatrix<float,6U,6U,ROOT::Math::MatRepStd<float,6,6> >::SMatrixRow*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::SMatrix<float,6U,6U,ROOT::Math::MatRepStd<float,6,6> >::SMatrixRow*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<float,6U,6U,ROOT::Math::MatRepStd<float,6,6> >::SMatrixRow*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLSMatrixlEfloatcO6UcO6UcOROOTcLcLMathcLcLMatRepStdlEfloatcO6cO6gRsPgRcLcLSMatrixRow_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<float,6U,6U,ROOT::Math::MatRepStd<float,6,6> >::SMatrixRow*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLSMatrixlEfloatcO6UcO6UcOROOTcLcLMathcLcLMatRepStdlEfloatcO6cO6gRsPgRcLcLSMatrixRow_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLSMatrixlEfloatcO6UcO6UcOROOTcLcLMathcLcLMatRepStdlEfloatcO6cO6gRsPgRcLcLSMatrixRow_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSMatrixlEfloatcO6UcO6UcOROOTcLcLMathcLcLMatRepStdlEfloatcO6cO6gRsPgRcLcLSMatrixRow_const_Dictionary();
   static void ROOTcLcLMathcLcLSMatrixlEfloatcO6UcO6UcOROOTcLcLMathcLcLMatRepStdlEfloatcO6cO6gRsPgRcLcLSMatrixRow_const_TClassManip(TClass*);
   static void delete_ROOTcLcLMathcLcLSMatrixlEfloatcO6UcO6UcOROOTcLcLMathcLcLMatRepStdlEfloatcO6cO6gRsPgRcLcLSMatrixRow_const(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO6UcO6UcOROOTcLcLMathcLcLMatRepStdlEfloatcO6cO6gRsPgRcLcLSMatrixRow_const(void *p);
   static void destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO6UcO6UcOROOTcLcLMathcLcLMatRepStdlEfloatcO6cO6gRsPgRcLcLSMatrixRow_const(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SMatrix<float,6U,6U,ROOT::Math::MatRepStd<float,6,6> >::SMatrixRow_const*)
   {
      ::ROOT::Math::SMatrix<float,6U,6U,ROOT::Math::MatRepStd<float,6,6> >::SMatrixRow_const *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SMatrix<float,6U,6U,ROOT::Math::MatRepStd<float,6,6> >::SMatrixRow_const));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SMatrix<float,6U,6U,ROOT::Math::MatRepStd<float,6,6> >::SMatrixRow_const", "Math/SMatrix.h", 382,
                  typeid(::ROOT::Math::SMatrix<float,6U,6U,ROOT::Math::MatRepStd<float,6,6> >::SMatrixRow_const), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSMatrixlEfloatcO6UcO6UcOROOTcLcLMathcLcLMatRepStdlEfloatcO6cO6gRsPgRcLcLSMatrixRow_const_Dictionary, isa_proxy, 0,
                  sizeof(::ROOT::Math::SMatrix<float,6U,6U,ROOT::Math::MatRepStd<float,6,6> >::SMatrixRow_const) );
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSMatrixlEfloatcO6UcO6UcOROOTcLcLMathcLcLMatRepStdlEfloatcO6cO6gRsPgRcLcLSMatrixRow_const);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO6UcO6UcOROOTcLcLMathcLcLMatRepStdlEfloatcO6cO6gRsPgRcLcLSMatrixRow_const);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO6UcO6UcOROOTcLcLMathcLcLMatRepStdlEfloatcO6cO6gRsPgRcLcLSMatrixRow_const);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<float,6U,6U,ROOT::Math::MatRepStd<float,6,6> >::SMatrixRow_const","ROOT::Math::SMatrix<float,6,6>::SMatrixRow_const"));

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<float,6U,6U,ROOT::Math::MatRepStd<float,6,6> >::SMatrixRow_const","ROOT::Math::SMatrix<float, 6u, 6u, ROOT::Math::MatRepStd<float, 6u, 6u> >::SMatrixRow_const"));
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::SMatrix<float,6U,6U,ROOT::Math::MatRepStd<float,6,6> >::SMatrixRow_const*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::SMatrix<float,6U,6U,ROOT::Math::MatRepStd<float,6,6> >::SMatrixRow_const*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<float,6U,6U,ROOT::Math::MatRepStd<float,6,6> >::SMatrixRow_const*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLSMatrixlEfloatcO6UcO6UcOROOTcLcLMathcLcLMatRepStdlEfloatcO6cO6gRsPgRcLcLSMatrixRow_const_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<float,6U,6U,ROOT::Math::MatRepStd<float,6,6> >::SMatrixRow_const*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLSMatrixlEfloatcO6UcO6UcOROOTcLcLMathcLcLMatRepStdlEfloatcO6cO6gRsPgRcLcLSMatrixRow_const_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLSMatrixlEfloatcO6UcO6UcOROOTcLcLMathcLcLMatRepStdlEfloatcO6cO6gRsPgRcLcLSMatrixRow_const_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSMatrixlEfloatcO7cO7cOROOTcLcLMathcLcLMatRepStdlEfloatcO7cO7gRsPgR_Dictionary();
   static void ROOTcLcLMathcLcLSMatrixlEfloatcO7cO7cOROOTcLcLMathcLcLMatRepStdlEfloatcO7cO7gRsPgR_TClassManip(TClass*);
   static void *new_ROOTcLcLMathcLcLSMatrixlEfloatcO7cO7cOROOTcLcLMathcLcLMatRepStdlEfloatcO7cO7gRsPgR(void *p = nullptr);
   static void *newArray_ROOTcLcLMathcLcLSMatrixlEfloatcO7cO7cOROOTcLcLMathcLcLMatRepStdlEfloatcO7cO7gRsPgR(Long_t size, void *p);
   static void delete_ROOTcLcLMathcLcLSMatrixlEfloatcO7cO7cOROOTcLcLMathcLcLMatRepStdlEfloatcO7cO7gRsPgR(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO7cO7cOROOTcLcLMathcLcLMatRepStdlEfloatcO7cO7gRsPgR(void *p);
   static void destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO7cO7cOROOTcLcLMathcLcLMatRepStdlEfloatcO7cO7gRsPgR(void *p);

   // Schema evolution read functions

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SMatrix<float,7,7,ROOT::Math::MatRepStd<float,7,7> >*)
   {
      ::ROOT::Math::SMatrix<float,7,7,ROOT::Math::MatRepStd<float,7,7> > *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SMatrix<float,7,7,ROOT::Math::MatRepStd<float,7,7> >));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SMatrix<float,7,7,ROOT::Math::MatRepStd<float,7,7> >", "Math/SMatrix.h", 101,
                  typeid(::ROOT::Math::SMatrix<float,7,7,ROOT::Math::MatRepStd<float,7,7> >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSMatrixlEfloatcO7cO7cOROOTcLcLMathcLcLMatRepStdlEfloatcO7cO7gRsPgR_Dictionary, isa_proxy, 4,
                  sizeof(::ROOT::Math::SMatrix<float,7,7,ROOT::Math::MatRepStd<float,7,7> >) );
      instance.SetNew(&new_ROOTcLcLMathcLcLSMatrixlEfloatcO7cO7cOROOTcLcLMathcLcLMatRepStdlEfloatcO7cO7gRsPgR);
      instance.SetNewArray(&newArray_ROOTcLcLMathcLcLSMatrixlEfloatcO7cO7cOROOTcLcLMathcLcLMatRepStdlEfloatcO7cO7gRsPgR);
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSMatrixlEfloatcO7cO7cOROOTcLcLMathcLcLMatRepStdlEfloatcO7cO7gRsPgR);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO7cO7cOROOTcLcLMathcLcLMatRepStdlEfloatcO7cO7gRsPgR);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO7cO7cOROOTcLcLMathcLcLMatRepStdlEfloatcO7cO7gRsPgR);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<float,7,7,ROOT::Math::MatRepStd<float,7,7> >","ROOT::Math::SMatrix<float,7,7>"));

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<float,7,7,ROOT::Math::MatRepStd<float,7,7> >","ROOT::Math::SMatrix<float, 7u, 7u, ROOT::Math::MatRepStd<float, 7u, 7u> >"));

      ::ROOT::Internal::TSchemaHelper* rule;

      // the io read rules
      std::vector<::ROOT::Internal::TSchemaHelper> readrules(3);
      rule = &readrules[0];
      rule->fSourceClass = "ROOT::Math::SMatrix<double,7,7>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[1];
      rule->fSourceClass = "ROOT::Math::SMatrix<Double32_t,7,7>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[2];
      rule->fSourceClass = "ROOT::Math::SMatrix<Float16_t,7,7>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      instance.SetReadRules( readrules );
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::SMatrix<float,7,7,ROOT::Math::MatRepStd<float,7,7> >*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::SMatrix<float,7,7,ROOT::Math::MatRepStd<float,7,7> >*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<float,7,7,ROOT::Math::MatRepStd<float,7,7> >*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLSMatrixlEfloatcO7cO7cOROOTcLcLMathcLcLMatRepStdlEfloatcO7cO7gRsPgR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<float,7,7,ROOT::Math::MatRepStd<float,7,7> >*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLSMatrixlEfloatcO7cO7cOROOTcLcLMathcLcLMatRepStdlEfloatcO7cO7gRsPgR_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLSMatrixlEfloatcO7cO7cOROOTcLcLMathcLcLMatRepStdlEfloatcO7cO7gRsPgR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSMatrixlEfloatcO7UcO7UcOROOTcLcLMathcLcLMatRepStdlEfloatcO7cO7gRsPgRcLcLSMatrixRow_Dictionary();
   static void ROOTcLcLMathcLcLSMatrixlEfloatcO7UcO7UcOROOTcLcLMathcLcLMatRepStdlEfloatcO7cO7gRsPgRcLcLSMatrixRow_TClassManip(TClass*);
   static void delete_ROOTcLcLMathcLcLSMatrixlEfloatcO7UcO7UcOROOTcLcLMathcLcLMatRepStdlEfloatcO7cO7gRsPgRcLcLSMatrixRow(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO7UcO7UcOROOTcLcLMathcLcLMatRepStdlEfloatcO7cO7gRsPgRcLcLSMatrixRow(void *p);
   static void destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO7UcO7UcOROOTcLcLMathcLcLMatRepStdlEfloatcO7cO7gRsPgRcLcLSMatrixRow(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SMatrix<float,7U,7U,ROOT::Math::MatRepStd<float,7,7> >::SMatrixRow*)
   {
      ::ROOT::Math::SMatrix<float,7U,7U,ROOT::Math::MatRepStd<float,7,7> >::SMatrixRow *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SMatrix<float,7U,7U,ROOT::Math::MatRepStd<float,7,7> >::SMatrixRow));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SMatrix<float,7U,7U,ROOT::Math::MatRepStd<float,7,7> >::SMatrixRow", "Math/SMatrix.h", 371,
                  typeid(::ROOT::Math::SMatrix<float,7U,7U,ROOT::Math::MatRepStd<float,7,7> >::SMatrixRow), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSMatrixlEfloatcO7UcO7UcOROOTcLcLMathcLcLMatRepStdlEfloatcO7cO7gRsPgRcLcLSMatrixRow_Dictionary, isa_proxy, 0,
                  sizeof(::ROOT::Math::SMatrix<float,7U,7U,ROOT::Math::MatRepStd<float,7,7> >::SMatrixRow) );
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSMatrixlEfloatcO7UcO7UcOROOTcLcLMathcLcLMatRepStdlEfloatcO7cO7gRsPgRcLcLSMatrixRow);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO7UcO7UcOROOTcLcLMathcLcLMatRepStdlEfloatcO7cO7gRsPgRcLcLSMatrixRow);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO7UcO7UcOROOTcLcLMathcLcLMatRepStdlEfloatcO7cO7gRsPgRcLcLSMatrixRow);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<float,7U,7U,ROOT::Math::MatRepStd<float,7,7> >::SMatrixRow","ROOT::Math::SMatrix<float,7,7>::SMatrixRow"));

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<float,7U,7U,ROOT::Math::MatRepStd<float,7,7> >::SMatrixRow","ROOT::Math::SMatrix<float, 7u, 7u, ROOT::Math::MatRepStd<float, 7u, 7u> >::SMatrixRow"));
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::SMatrix<float,7U,7U,ROOT::Math::MatRepStd<float,7,7> >::SMatrixRow*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::SMatrix<float,7U,7U,ROOT::Math::MatRepStd<float,7,7> >::SMatrixRow*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<float,7U,7U,ROOT::Math::MatRepStd<float,7,7> >::SMatrixRow*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLSMatrixlEfloatcO7UcO7UcOROOTcLcLMathcLcLMatRepStdlEfloatcO7cO7gRsPgRcLcLSMatrixRow_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<float,7U,7U,ROOT::Math::MatRepStd<float,7,7> >::SMatrixRow*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLSMatrixlEfloatcO7UcO7UcOROOTcLcLMathcLcLMatRepStdlEfloatcO7cO7gRsPgRcLcLSMatrixRow_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLSMatrixlEfloatcO7UcO7UcOROOTcLcLMathcLcLMatRepStdlEfloatcO7cO7gRsPgRcLcLSMatrixRow_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSMatrixlEfloatcO7UcO7UcOROOTcLcLMathcLcLMatRepStdlEfloatcO7cO7gRsPgRcLcLSMatrixRow_const_Dictionary();
   static void ROOTcLcLMathcLcLSMatrixlEfloatcO7UcO7UcOROOTcLcLMathcLcLMatRepStdlEfloatcO7cO7gRsPgRcLcLSMatrixRow_const_TClassManip(TClass*);
   static void delete_ROOTcLcLMathcLcLSMatrixlEfloatcO7UcO7UcOROOTcLcLMathcLcLMatRepStdlEfloatcO7cO7gRsPgRcLcLSMatrixRow_const(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO7UcO7UcOROOTcLcLMathcLcLMatRepStdlEfloatcO7cO7gRsPgRcLcLSMatrixRow_const(void *p);
   static void destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO7UcO7UcOROOTcLcLMathcLcLMatRepStdlEfloatcO7cO7gRsPgRcLcLSMatrixRow_const(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SMatrix<float,7U,7U,ROOT::Math::MatRepStd<float,7,7> >::SMatrixRow_const*)
   {
      ::ROOT::Math::SMatrix<float,7U,7U,ROOT::Math::MatRepStd<float,7,7> >::SMatrixRow_const *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SMatrix<float,7U,7U,ROOT::Math::MatRepStd<float,7,7> >::SMatrixRow_const));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SMatrix<float,7U,7U,ROOT::Math::MatRepStd<float,7,7> >::SMatrixRow_const", "Math/SMatrix.h", 382,
                  typeid(::ROOT::Math::SMatrix<float,7U,7U,ROOT::Math::MatRepStd<float,7,7> >::SMatrixRow_const), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSMatrixlEfloatcO7UcO7UcOROOTcLcLMathcLcLMatRepStdlEfloatcO7cO7gRsPgRcLcLSMatrixRow_const_Dictionary, isa_proxy, 0,
                  sizeof(::ROOT::Math::SMatrix<float,7U,7U,ROOT::Math::MatRepStd<float,7,7> >::SMatrixRow_const) );
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSMatrixlEfloatcO7UcO7UcOROOTcLcLMathcLcLMatRepStdlEfloatcO7cO7gRsPgRcLcLSMatrixRow_const);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO7UcO7UcOROOTcLcLMathcLcLMatRepStdlEfloatcO7cO7gRsPgRcLcLSMatrixRow_const);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO7UcO7UcOROOTcLcLMathcLcLMatRepStdlEfloatcO7cO7gRsPgRcLcLSMatrixRow_const);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<float,7U,7U,ROOT::Math::MatRepStd<float,7,7> >::SMatrixRow_const","ROOT::Math::SMatrix<float,7,7>::SMatrixRow_const"));

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<float,7U,7U,ROOT::Math::MatRepStd<float,7,7> >::SMatrixRow_const","ROOT::Math::SMatrix<float, 7u, 7u, ROOT::Math::MatRepStd<float, 7u, 7u> >::SMatrixRow_const"));
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::SMatrix<float,7U,7U,ROOT::Math::MatRepStd<float,7,7> >::SMatrixRow_const*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::SMatrix<float,7U,7U,ROOT::Math::MatRepStd<float,7,7> >::SMatrixRow_const*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<float,7U,7U,ROOT::Math::MatRepStd<float,7,7> >::SMatrixRow_const*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLSMatrixlEfloatcO7UcO7UcOROOTcLcLMathcLcLMatRepStdlEfloatcO7cO7gRsPgRcLcLSMatrixRow_const_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<float,7U,7U,ROOT::Math::MatRepStd<float,7,7> >::SMatrixRow_const*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLSMatrixlEfloatcO7UcO7UcOROOTcLcLMathcLcLMatRepStdlEfloatcO7cO7gRsPgRcLcLSMatrixRow_const_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLSMatrixlEfloatcO7UcO7UcOROOTcLcLMathcLcLMatRepStdlEfloatcO7cO7gRsPgRcLcLSMatrixRow_const_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSMatrixlEfloatcO2cO2cOROOTcLcLMathcLcLMatRepSymlEfloatcO2gRsPgR_Dictionary();
   static void ROOTcLcLMathcLcLSMatrixlEfloatcO2cO2cOROOTcLcLMathcLcLMatRepSymlEfloatcO2gRsPgR_TClassManip(TClass*);
   static void *new_ROOTcLcLMathcLcLSMatrixlEfloatcO2cO2cOROOTcLcLMathcLcLMatRepSymlEfloatcO2gRsPgR(void *p = nullptr);
   static void *newArray_ROOTcLcLMathcLcLSMatrixlEfloatcO2cO2cOROOTcLcLMathcLcLMatRepSymlEfloatcO2gRsPgR(Long_t size, void *p);
   static void delete_ROOTcLcLMathcLcLSMatrixlEfloatcO2cO2cOROOTcLcLMathcLcLMatRepSymlEfloatcO2gRsPgR(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO2cO2cOROOTcLcLMathcLcLMatRepSymlEfloatcO2gRsPgR(void *p);
   static void destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO2cO2cOROOTcLcLMathcLcLMatRepSymlEfloatcO2gRsPgR(void *p);

   // Schema evolution read functions

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SMatrix<float,2,2,ROOT::Math::MatRepSym<float,2> >*)
   {
      ::ROOT::Math::SMatrix<float,2,2,ROOT::Math::MatRepSym<float,2> > *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SMatrix<float,2,2,ROOT::Math::MatRepSym<float,2> >));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SMatrix<float,2,2,ROOT::Math::MatRepSym<float,2> >", "Math/SMatrix.h", 101,
                  typeid(::ROOT::Math::SMatrix<float,2,2,ROOT::Math::MatRepSym<float,2> >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSMatrixlEfloatcO2cO2cOROOTcLcLMathcLcLMatRepSymlEfloatcO2gRsPgR_Dictionary, isa_proxy, 4,
                  sizeof(::ROOT::Math::SMatrix<float,2,2,ROOT::Math::MatRepSym<float,2> >) );
      instance.SetNew(&new_ROOTcLcLMathcLcLSMatrixlEfloatcO2cO2cOROOTcLcLMathcLcLMatRepSymlEfloatcO2gRsPgR);
      instance.SetNewArray(&newArray_ROOTcLcLMathcLcLSMatrixlEfloatcO2cO2cOROOTcLcLMathcLcLMatRepSymlEfloatcO2gRsPgR);
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSMatrixlEfloatcO2cO2cOROOTcLcLMathcLcLMatRepSymlEfloatcO2gRsPgR);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO2cO2cOROOTcLcLMathcLcLMatRepSymlEfloatcO2gRsPgR);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO2cO2cOROOTcLcLMathcLcLMatRepSymlEfloatcO2gRsPgR);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<float,2,2,ROOT::Math::MatRepSym<float,2> >","ROOT::Math::SMatrix<float, 2u, 2u, ROOT::Math::MatRepSym<float, 2u> >"));

      ::ROOT::Internal::TSchemaHelper* rule;

      // the io read rules
      std::vector<::ROOT::Internal::TSchemaHelper> readrules(3);
      rule = &readrules[0];
      rule->fSourceClass = "ROOT::Math::SMatrix<float,2,2,ROOT::Math::MatRepSym<double,2> >";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[1];
      rule->fSourceClass = "ROOT::Math::SMatrix<float,2,2,ROOT::Math::MatRepSym<Double32_t,2> >";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[2];
      rule->fSourceClass = "ROOT::Math::SMatrix<float,2,2,ROOT::Math::MatRepSym<Float16_t,2> >";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      instance.SetReadRules( readrules );
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::SMatrix<float,2,2,ROOT::Math::MatRepSym<float,2> >*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::SMatrix<float,2,2,ROOT::Math::MatRepSym<float,2> >*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<float,2,2,ROOT::Math::MatRepSym<float,2> >*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLSMatrixlEfloatcO2cO2cOROOTcLcLMathcLcLMatRepSymlEfloatcO2gRsPgR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<float,2,2,ROOT::Math::MatRepSym<float,2> >*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLSMatrixlEfloatcO2cO2cOROOTcLcLMathcLcLMatRepSymlEfloatcO2gRsPgR_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLSMatrixlEfloatcO2cO2cOROOTcLcLMathcLcLMatRepSymlEfloatcO2gRsPgR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSMatrixlEfloatcO2UcO2UcOROOTcLcLMathcLcLMatRepSymlEfloatcO2gRsPgRcLcLSMatrixRow_Dictionary();
   static void ROOTcLcLMathcLcLSMatrixlEfloatcO2UcO2UcOROOTcLcLMathcLcLMatRepSymlEfloatcO2gRsPgRcLcLSMatrixRow_TClassManip(TClass*);
   static void delete_ROOTcLcLMathcLcLSMatrixlEfloatcO2UcO2UcOROOTcLcLMathcLcLMatRepSymlEfloatcO2gRsPgRcLcLSMatrixRow(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO2UcO2UcOROOTcLcLMathcLcLMatRepSymlEfloatcO2gRsPgRcLcLSMatrixRow(void *p);
   static void destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO2UcO2UcOROOTcLcLMathcLcLMatRepSymlEfloatcO2gRsPgRcLcLSMatrixRow(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SMatrix<float,2U,2U,ROOT::Math::MatRepSym<float,2> >::SMatrixRow*)
   {
      ::ROOT::Math::SMatrix<float,2U,2U,ROOT::Math::MatRepSym<float,2> >::SMatrixRow *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SMatrix<float,2U,2U,ROOT::Math::MatRepSym<float,2> >::SMatrixRow));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SMatrix<float,2U,2U,ROOT::Math::MatRepSym<float,2> >::SMatrixRow", "Math/SMatrix.h", 371,
                  typeid(::ROOT::Math::SMatrix<float,2U,2U,ROOT::Math::MatRepSym<float,2> >::SMatrixRow), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSMatrixlEfloatcO2UcO2UcOROOTcLcLMathcLcLMatRepSymlEfloatcO2gRsPgRcLcLSMatrixRow_Dictionary, isa_proxy, 0,
                  sizeof(::ROOT::Math::SMatrix<float,2U,2U,ROOT::Math::MatRepSym<float,2> >::SMatrixRow) );
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSMatrixlEfloatcO2UcO2UcOROOTcLcLMathcLcLMatRepSymlEfloatcO2gRsPgRcLcLSMatrixRow);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO2UcO2UcOROOTcLcLMathcLcLMatRepSymlEfloatcO2gRsPgRcLcLSMatrixRow);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO2UcO2UcOROOTcLcLMathcLcLMatRepSymlEfloatcO2gRsPgRcLcLSMatrixRow);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<float,2U,2U,ROOT::Math::MatRepSym<float,2> >::SMatrixRow","ROOT::Math::SMatrix<float,2,2,ROOT::Math::MatRepSym<float,2> >::SMatrixRow"));

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<float,2U,2U,ROOT::Math::MatRepSym<float,2> >::SMatrixRow","ROOT::Math::SMatrix<float, 2u, 2u, ROOT::Math::MatRepSym<float, 2u> >::SMatrixRow"));
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::SMatrix<float,2U,2U,ROOT::Math::MatRepSym<float,2> >::SMatrixRow*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::SMatrix<float,2U,2U,ROOT::Math::MatRepSym<float,2> >::SMatrixRow*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<float,2U,2U,ROOT::Math::MatRepSym<float,2> >::SMatrixRow*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLSMatrixlEfloatcO2UcO2UcOROOTcLcLMathcLcLMatRepSymlEfloatcO2gRsPgRcLcLSMatrixRow_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<float,2U,2U,ROOT::Math::MatRepSym<float,2> >::SMatrixRow*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLSMatrixlEfloatcO2UcO2UcOROOTcLcLMathcLcLMatRepSymlEfloatcO2gRsPgRcLcLSMatrixRow_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLSMatrixlEfloatcO2UcO2UcOROOTcLcLMathcLcLMatRepSymlEfloatcO2gRsPgRcLcLSMatrixRow_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSMatrixlEfloatcO2UcO2UcOROOTcLcLMathcLcLMatRepSymlEfloatcO2gRsPgRcLcLSMatrixRow_const_Dictionary();
   static void ROOTcLcLMathcLcLSMatrixlEfloatcO2UcO2UcOROOTcLcLMathcLcLMatRepSymlEfloatcO2gRsPgRcLcLSMatrixRow_const_TClassManip(TClass*);
   static void delete_ROOTcLcLMathcLcLSMatrixlEfloatcO2UcO2UcOROOTcLcLMathcLcLMatRepSymlEfloatcO2gRsPgRcLcLSMatrixRow_const(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO2UcO2UcOROOTcLcLMathcLcLMatRepSymlEfloatcO2gRsPgRcLcLSMatrixRow_const(void *p);
   static void destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO2UcO2UcOROOTcLcLMathcLcLMatRepSymlEfloatcO2gRsPgRcLcLSMatrixRow_const(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SMatrix<float,2U,2U,ROOT::Math::MatRepSym<float,2> >::SMatrixRow_const*)
   {
      ::ROOT::Math::SMatrix<float,2U,2U,ROOT::Math::MatRepSym<float,2> >::SMatrixRow_const *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SMatrix<float,2U,2U,ROOT::Math::MatRepSym<float,2> >::SMatrixRow_const));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SMatrix<float,2U,2U,ROOT::Math::MatRepSym<float,2> >::SMatrixRow_const", "Math/SMatrix.h", 382,
                  typeid(::ROOT::Math::SMatrix<float,2U,2U,ROOT::Math::MatRepSym<float,2> >::SMatrixRow_const), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSMatrixlEfloatcO2UcO2UcOROOTcLcLMathcLcLMatRepSymlEfloatcO2gRsPgRcLcLSMatrixRow_const_Dictionary, isa_proxy, 0,
                  sizeof(::ROOT::Math::SMatrix<float,2U,2U,ROOT::Math::MatRepSym<float,2> >::SMatrixRow_const) );
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSMatrixlEfloatcO2UcO2UcOROOTcLcLMathcLcLMatRepSymlEfloatcO2gRsPgRcLcLSMatrixRow_const);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO2UcO2UcOROOTcLcLMathcLcLMatRepSymlEfloatcO2gRsPgRcLcLSMatrixRow_const);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO2UcO2UcOROOTcLcLMathcLcLMatRepSymlEfloatcO2gRsPgRcLcLSMatrixRow_const);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<float,2U,2U,ROOT::Math::MatRepSym<float,2> >::SMatrixRow_const","ROOT::Math::SMatrix<float,2,2,ROOT::Math::MatRepSym<float,2> >::SMatrixRow_const"));

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<float,2U,2U,ROOT::Math::MatRepSym<float,2> >::SMatrixRow_const","ROOT::Math::SMatrix<float, 2u, 2u, ROOT::Math::MatRepSym<float, 2u> >::SMatrixRow_const"));
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::SMatrix<float,2U,2U,ROOT::Math::MatRepSym<float,2> >::SMatrixRow_const*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::SMatrix<float,2U,2U,ROOT::Math::MatRepSym<float,2> >::SMatrixRow_const*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<float,2U,2U,ROOT::Math::MatRepSym<float,2> >::SMatrixRow_const*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLSMatrixlEfloatcO2UcO2UcOROOTcLcLMathcLcLMatRepSymlEfloatcO2gRsPgRcLcLSMatrixRow_const_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<float,2U,2U,ROOT::Math::MatRepSym<float,2> >::SMatrixRow_const*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLSMatrixlEfloatcO2UcO2UcOROOTcLcLMathcLcLMatRepSymlEfloatcO2gRsPgRcLcLSMatrixRow_const_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLSMatrixlEfloatcO2UcO2UcOROOTcLcLMathcLcLMatRepSymlEfloatcO2gRsPgRcLcLSMatrixRow_const_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSMatrixlEfloatcO3cO3cOROOTcLcLMathcLcLMatRepSymlEfloatcO3gRsPgR_Dictionary();
   static void ROOTcLcLMathcLcLSMatrixlEfloatcO3cO3cOROOTcLcLMathcLcLMatRepSymlEfloatcO3gRsPgR_TClassManip(TClass*);
   static void *new_ROOTcLcLMathcLcLSMatrixlEfloatcO3cO3cOROOTcLcLMathcLcLMatRepSymlEfloatcO3gRsPgR(void *p = nullptr);
   static void *newArray_ROOTcLcLMathcLcLSMatrixlEfloatcO3cO3cOROOTcLcLMathcLcLMatRepSymlEfloatcO3gRsPgR(Long_t size, void *p);
   static void delete_ROOTcLcLMathcLcLSMatrixlEfloatcO3cO3cOROOTcLcLMathcLcLMatRepSymlEfloatcO3gRsPgR(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO3cO3cOROOTcLcLMathcLcLMatRepSymlEfloatcO3gRsPgR(void *p);
   static void destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO3cO3cOROOTcLcLMathcLcLMatRepSymlEfloatcO3gRsPgR(void *p);

   // Schema evolution read functions

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SMatrix<float,3,3,ROOT::Math::MatRepSym<float,3> >*)
   {
      ::ROOT::Math::SMatrix<float,3,3,ROOT::Math::MatRepSym<float,3> > *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SMatrix<float,3,3,ROOT::Math::MatRepSym<float,3> >));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SMatrix<float,3,3,ROOT::Math::MatRepSym<float,3> >", "Math/SMatrix.h", 101,
                  typeid(::ROOT::Math::SMatrix<float,3,3,ROOT::Math::MatRepSym<float,3> >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSMatrixlEfloatcO3cO3cOROOTcLcLMathcLcLMatRepSymlEfloatcO3gRsPgR_Dictionary, isa_proxy, 4,
                  sizeof(::ROOT::Math::SMatrix<float,3,3,ROOT::Math::MatRepSym<float,3> >) );
      instance.SetNew(&new_ROOTcLcLMathcLcLSMatrixlEfloatcO3cO3cOROOTcLcLMathcLcLMatRepSymlEfloatcO3gRsPgR);
      instance.SetNewArray(&newArray_ROOTcLcLMathcLcLSMatrixlEfloatcO3cO3cOROOTcLcLMathcLcLMatRepSymlEfloatcO3gRsPgR);
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSMatrixlEfloatcO3cO3cOROOTcLcLMathcLcLMatRepSymlEfloatcO3gRsPgR);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO3cO3cOROOTcLcLMathcLcLMatRepSymlEfloatcO3gRsPgR);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO3cO3cOROOTcLcLMathcLcLMatRepSymlEfloatcO3gRsPgR);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<float,3,3,ROOT::Math::MatRepSym<float,3> >","ROOT::Math::SMatrix<float, 3u, 3u, ROOT::Math::MatRepSym<float, 3u> >"));

      ::ROOT::Internal::TSchemaHelper* rule;

      // the io read rules
      std::vector<::ROOT::Internal::TSchemaHelper> readrules(3);
      rule = &readrules[0];
      rule->fSourceClass = "ROOT::Math::SMatrix<float,3,3,ROOT::Math::MatRepSym<double,3> >";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[1];
      rule->fSourceClass = "ROOT::Math::SMatrix<float,3,3,ROOT::Math::MatRepSym<Double32_t,3> >";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[2];
      rule->fSourceClass = "ROOT::Math::SMatrix<float,3,3,ROOT::Math::MatRepSym<Float16_t,3> >";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      instance.SetReadRules( readrules );
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::SMatrix<float,3,3,ROOT::Math::MatRepSym<float,3> >*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::SMatrix<float,3,3,ROOT::Math::MatRepSym<float,3> >*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<float,3,3,ROOT::Math::MatRepSym<float,3> >*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLSMatrixlEfloatcO3cO3cOROOTcLcLMathcLcLMatRepSymlEfloatcO3gRsPgR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<float,3,3,ROOT::Math::MatRepSym<float,3> >*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLSMatrixlEfloatcO3cO3cOROOTcLcLMathcLcLMatRepSymlEfloatcO3gRsPgR_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLSMatrixlEfloatcO3cO3cOROOTcLcLMathcLcLMatRepSymlEfloatcO3gRsPgR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSMatrixlEfloatcO3UcO3UcOROOTcLcLMathcLcLMatRepSymlEfloatcO3gRsPgRcLcLSMatrixRow_Dictionary();
   static void ROOTcLcLMathcLcLSMatrixlEfloatcO3UcO3UcOROOTcLcLMathcLcLMatRepSymlEfloatcO3gRsPgRcLcLSMatrixRow_TClassManip(TClass*);
   static void delete_ROOTcLcLMathcLcLSMatrixlEfloatcO3UcO3UcOROOTcLcLMathcLcLMatRepSymlEfloatcO3gRsPgRcLcLSMatrixRow(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO3UcO3UcOROOTcLcLMathcLcLMatRepSymlEfloatcO3gRsPgRcLcLSMatrixRow(void *p);
   static void destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO3UcO3UcOROOTcLcLMathcLcLMatRepSymlEfloatcO3gRsPgRcLcLSMatrixRow(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SMatrix<float,3U,3U,ROOT::Math::MatRepSym<float,3> >::SMatrixRow*)
   {
      ::ROOT::Math::SMatrix<float,3U,3U,ROOT::Math::MatRepSym<float,3> >::SMatrixRow *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SMatrix<float,3U,3U,ROOT::Math::MatRepSym<float,3> >::SMatrixRow));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SMatrix<float,3U,3U,ROOT::Math::MatRepSym<float,3> >::SMatrixRow", "Math/SMatrix.h", 371,
                  typeid(::ROOT::Math::SMatrix<float,3U,3U,ROOT::Math::MatRepSym<float,3> >::SMatrixRow), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSMatrixlEfloatcO3UcO3UcOROOTcLcLMathcLcLMatRepSymlEfloatcO3gRsPgRcLcLSMatrixRow_Dictionary, isa_proxy, 0,
                  sizeof(::ROOT::Math::SMatrix<float,3U,3U,ROOT::Math::MatRepSym<float,3> >::SMatrixRow) );
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSMatrixlEfloatcO3UcO3UcOROOTcLcLMathcLcLMatRepSymlEfloatcO3gRsPgRcLcLSMatrixRow);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO3UcO3UcOROOTcLcLMathcLcLMatRepSymlEfloatcO3gRsPgRcLcLSMatrixRow);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO3UcO3UcOROOTcLcLMathcLcLMatRepSymlEfloatcO3gRsPgRcLcLSMatrixRow);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<float,3U,3U,ROOT::Math::MatRepSym<float,3> >::SMatrixRow","ROOT::Math::SMatrix<float,3,3,ROOT::Math::MatRepSym<float,3> >::SMatrixRow"));

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<float,3U,3U,ROOT::Math::MatRepSym<float,3> >::SMatrixRow","ROOT::Math::SMatrix<float, 3u, 3u, ROOT::Math::MatRepSym<float, 3u> >::SMatrixRow"));
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::SMatrix<float,3U,3U,ROOT::Math::MatRepSym<float,3> >::SMatrixRow*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::SMatrix<float,3U,3U,ROOT::Math::MatRepSym<float,3> >::SMatrixRow*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<float,3U,3U,ROOT::Math::MatRepSym<float,3> >::SMatrixRow*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLSMatrixlEfloatcO3UcO3UcOROOTcLcLMathcLcLMatRepSymlEfloatcO3gRsPgRcLcLSMatrixRow_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<float,3U,3U,ROOT::Math::MatRepSym<float,3> >::SMatrixRow*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLSMatrixlEfloatcO3UcO3UcOROOTcLcLMathcLcLMatRepSymlEfloatcO3gRsPgRcLcLSMatrixRow_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLSMatrixlEfloatcO3UcO3UcOROOTcLcLMathcLcLMatRepSymlEfloatcO3gRsPgRcLcLSMatrixRow_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSMatrixlEfloatcO3UcO3UcOROOTcLcLMathcLcLMatRepSymlEfloatcO3gRsPgRcLcLSMatrixRow_const_Dictionary();
   static void ROOTcLcLMathcLcLSMatrixlEfloatcO3UcO3UcOROOTcLcLMathcLcLMatRepSymlEfloatcO3gRsPgRcLcLSMatrixRow_const_TClassManip(TClass*);
   static void delete_ROOTcLcLMathcLcLSMatrixlEfloatcO3UcO3UcOROOTcLcLMathcLcLMatRepSymlEfloatcO3gRsPgRcLcLSMatrixRow_const(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO3UcO3UcOROOTcLcLMathcLcLMatRepSymlEfloatcO3gRsPgRcLcLSMatrixRow_const(void *p);
   static void destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO3UcO3UcOROOTcLcLMathcLcLMatRepSymlEfloatcO3gRsPgRcLcLSMatrixRow_const(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SMatrix<float,3U,3U,ROOT::Math::MatRepSym<float,3> >::SMatrixRow_const*)
   {
      ::ROOT::Math::SMatrix<float,3U,3U,ROOT::Math::MatRepSym<float,3> >::SMatrixRow_const *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SMatrix<float,3U,3U,ROOT::Math::MatRepSym<float,3> >::SMatrixRow_const));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SMatrix<float,3U,3U,ROOT::Math::MatRepSym<float,3> >::SMatrixRow_const", "Math/SMatrix.h", 382,
                  typeid(::ROOT::Math::SMatrix<float,3U,3U,ROOT::Math::MatRepSym<float,3> >::SMatrixRow_const), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSMatrixlEfloatcO3UcO3UcOROOTcLcLMathcLcLMatRepSymlEfloatcO3gRsPgRcLcLSMatrixRow_const_Dictionary, isa_proxy, 0,
                  sizeof(::ROOT::Math::SMatrix<float,3U,3U,ROOT::Math::MatRepSym<float,3> >::SMatrixRow_const) );
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSMatrixlEfloatcO3UcO3UcOROOTcLcLMathcLcLMatRepSymlEfloatcO3gRsPgRcLcLSMatrixRow_const);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO3UcO3UcOROOTcLcLMathcLcLMatRepSymlEfloatcO3gRsPgRcLcLSMatrixRow_const);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO3UcO3UcOROOTcLcLMathcLcLMatRepSymlEfloatcO3gRsPgRcLcLSMatrixRow_const);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<float,3U,3U,ROOT::Math::MatRepSym<float,3> >::SMatrixRow_const","ROOT::Math::SMatrix<float,3,3,ROOT::Math::MatRepSym<float,3> >::SMatrixRow_const"));

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<float,3U,3U,ROOT::Math::MatRepSym<float,3> >::SMatrixRow_const","ROOT::Math::SMatrix<float, 3u, 3u, ROOT::Math::MatRepSym<float, 3u> >::SMatrixRow_const"));
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::SMatrix<float,3U,3U,ROOT::Math::MatRepSym<float,3> >::SMatrixRow_const*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::SMatrix<float,3U,3U,ROOT::Math::MatRepSym<float,3> >::SMatrixRow_const*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<float,3U,3U,ROOT::Math::MatRepSym<float,3> >::SMatrixRow_const*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLSMatrixlEfloatcO3UcO3UcOROOTcLcLMathcLcLMatRepSymlEfloatcO3gRsPgRcLcLSMatrixRow_const_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<float,3U,3U,ROOT::Math::MatRepSym<float,3> >::SMatrixRow_const*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLSMatrixlEfloatcO3UcO3UcOROOTcLcLMathcLcLMatRepSymlEfloatcO3gRsPgRcLcLSMatrixRow_const_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLSMatrixlEfloatcO3UcO3UcOROOTcLcLMathcLcLMatRepSymlEfloatcO3gRsPgRcLcLSMatrixRow_const_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSMatrixlEfloatcO4cO4cOROOTcLcLMathcLcLMatRepSymlEfloatcO4gRsPgR_Dictionary();
   static void ROOTcLcLMathcLcLSMatrixlEfloatcO4cO4cOROOTcLcLMathcLcLMatRepSymlEfloatcO4gRsPgR_TClassManip(TClass*);
   static void *new_ROOTcLcLMathcLcLSMatrixlEfloatcO4cO4cOROOTcLcLMathcLcLMatRepSymlEfloatcO4gRsPgR(void *p = nullptr);
   static void *newArray_ROOTcLcLMathcLcLSMatrixlEfloatcO4cO4cOROOTcLcLMathcLcLMatRepSymlEfloatcO4gRsPgR(Long_t size, void *p);
   static void delete_ROOTcLcLMathcLcLSMatrixlEfloatcO4cO4cOROOTcLcLMathcLcLMatRepSymlEfloatcO4gRsPgR(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO4cO4cOROOTcLcLMathcLcLMatRepSymlEfloatcO4gRsPgR(void *p);
   static void destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO4cO4cOROOTcLcLMathcLcLMatRepSymlEfloatcO4gRsPgR(void *p);

   // Schema evolution read functions

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SMatrix<float,4,4,ROOT::Math::MatRepSym<float,4> >*)
   {
      ::ROOT::Math::SMatrix<float,4,4,ROOT::Math::MatRepSym<float,4> > *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SMatrix<float,4,4,ROOT::Math::MatRepSym<float,4> >));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SMatrix<float,4,4,ROOT::Math::MatRepSym<float,4> >", "Math/SMatrix.h", 101,
                  typeid(::ROOT::Math::SMatrix<float,4,4,ROOT::Math::MatRepSym<float,4> >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSMatrixlEfloatcO4cO4cOROOTcLcLMathcLcLMatRepSymlEfloatcO4gRsPgR_Dictionary, isa_proxy, 4,
                  sizeof(::ROOT::Math::SMatrix<float,4,4,ROOT::Math::MatRepSym<float,4> >) );
      instance.SetNew(&new_ROOTcLcLMathcLcLSMatrixlEfloatcO4cO4cOROOTcLcLMathcLcLMatRepSymlEfloatcO4gRsPgR);
      instance.SetNewArray(&newArray_ROOTcLcLMathcLcLSMatrixlEfloatcO4cO4cOROOTcLcLMathcLcLMatRepSymlEfloatcO4gRsPgR);
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSMatrixlEfloatcO4cO4cOROOTcLcLMathcLcLMatRepSymlEfloatcO4gRsPgR);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO4cO4cOROOTcLcLMathcLcLMatRepSymlEfloatcO4gRsPgR);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO4cO4cOROOTcLcLMathcLcLMatRepSymlEfloatcO4gRsPgR);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<float,4,4,ROOT::Math::MatRepSym<float,4> >","ROOT::Math::SMatrix<float, 4u, 4u, ROOT::Math::MatRepSym<float, 4u> >"));

      ::ROOT::Internal::TSchemaHelper* rule;

      // the io read rules
      std::vector<::ROOT::Internal::TSchemaHelper> readrules(3);
      rule = &readrules[0];
      rule->fSourceClass = "ROOT::Math::SMatrix<float,4,4,ROOT::Math::MatRepSym<double,4> >";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[1];
      rule->fSourceClass = "ROOT::Math::SMatrix<float,4,4,ROOT::Math::MatRepSym<Double32_t,4> >";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[2];
      rule->fSourceClass = "ROOT::Math::SMatrix<float,4,4,ROOT::Math::MatRepSym<Float16_t,4> >";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      instance.SetReadRules( readrules );
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::SMatrix<float,4,4,ROOT::Math::MatRepSym<float,4> >*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::SMatrix<float,4,4,ROOT::Math::MatRepSym<float,4> >*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<float,4,4,ROOT::Math::MatRepSym<float,4> >*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLSMatrixlEfloatcO4cO4cOROOTcLcLMathcLcLMatRepSymlEfloatcO4gRsPgR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<float,4,4,ROOT::Math::MatRepSym<float,4> >*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLSMatrixlEfloatcO4cO4cOROOTcLcLMathcLcLMatRepSymlEfloatcO4gRsPgR_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLSMatrixlEfloatcO4cO4cOROOTcLcLMathcLcLMatRepSymlEfloatcO4gRsPgR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSMatrixlEfloatcO4UcO4UcOROOTcLcLMathcLcLMatRepSymlEfloatcO4gRsPgRcLcLSMatrixRow_Dictionary();
   static void ROOTcLcLMathcLcLSMatrixlEfloatcO4UcO4UcOROOTcLcLMathcLcLMatRepSymlEfloatcO4gRsPgRcLcLSMatrixRow_TClassManip(TClass*);
   static void delete_ROOTcLcLMathcLcLSMatrixlEfloatcO4UcO4UcOROOTcLcLMathcLcLMatRepSymlEfloatcO4gRsPgRcLcLSMatrixRow(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO4UcO4UcOROOTcLcLMathcLcLMatRepSymlEfloatcO4gRsPgRcLcLSMatrixRow(void *p);
   static void destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO4UcO4UcOROOTcLcLMathcLcLMatRepSymlEfloatcO4gRsPgRcLcLSMatrixRow(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SMatrix<float,4U,4U,ROOT::Math::MatRepSym<float,4> >::SMatrixRow*)
   {
      ::ROOT::Math::SMatrix<float,4U,4U,ROOT::Math::MatRepSym<float,4> >::SMatrixRow *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SMatrix<float,4U,4U,ROOT::Math::MatRepSym<float,4> >::SMatrixRow));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SMatrix<float,4U,4U,ROOT::Math::MatRepSym<float,4> >::SMatrixRow", "Math/SMatrix.h", 371,
                  typeid(::ROOT::Math::SMatrix<float,4U,4U,ROOT::Math::MatRepSym<float,4> >::SMatrixRow), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSMatrixlEfloatcO4UcO4UcOROOTcLcLMathcLcLMatRepSymlEfloatcO4gRsPgRcLcLSMatrixRow_Dictionary, isa_proxy, 0,
                  sizeof(::ROOT::Math::SMatrix<float,4U,4U,ROOT::Math::MatRepSym<float,4> >::SMatrixRow) );
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSMatrixlEfloatcO4UcO4UcOROOTcLcLMathcLcLMatRepSymlEfloatcO4gRsPgRcLcLSMatrixRow);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO4UcO4UcOROOTcLcLMathcLcLMatRepSymlEfloatcO4gRsPgRcLcLSMatrixRow);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO4UcO4UcOROOTcLcLMathcLcLMatRepSymlEfloatcO4gRsPgRcLcLSMatrixRow);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<float,4U,4U,ROOT::Math::MatRepSym<float,4> >::SMatrixRow","ROOT::Math::SMatrix<float,4,4,ROOT::Math::MatRepSym<float,4> >::SMatrixRow"));

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<float,4U,4U,ROOT::Math::MatRepSym<float,4> >::SMatrixRow","ROOT::Math::SMatrix<float, 4u, 4u, ROOT::Math::MatRepSym<float, 4u> >::SMatrixRow"));
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::SMatrix<float,4U,4U,ROOT::Math::MatRepSym<float,4> >::SMatrixRow*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::SMatrix<float,4U,4U,ROOT::Math::MatRepSym<float,4> >::SMatrixRow*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<float,4U,4U,ROOT::Math::MatRepSym<float,4> >::SMatrixRow*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLSMatrixlEfloatcO4UcO4UcOROOTcLcLMathcLcLMatRepSymlEfloatcO4gRsPgRcLcLSMatrixRow_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<float,4U,4U,ROOT::Math::MatRepSym<float,4> >::SMatrixRow*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLSMatrixlEfloatcO4UcO4UcOROOTcLcLMathcLcLMatRepSymlEfloatcO4gRsPgRcLcLSMatrixRow_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLSMatrixlEfloatcO4UcO4UcOROOTcLcLMathcLcLMatRepSymlEfloatcO4gRsPgRcLcLSMatrixRow_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSMatrixlEfloatcO4UcO4UcOROOTcLcLMathcLcLMatRepSymlEfloatcO4gRsPgRcLcLSMatrixRow_const_Dictionary();
   static void ROOTcLcLMathcLcLSMatrixlEfloatcO4UcO4UcOROOTcLcLMathcLcLMatRepSymlEfloatcO4gRsPgRcLcLSMatrixRow_const_TClassManip(TClass*);
   static void delete_ROOTcLcLMathcLcLSMatrixlEfloatcO4UcO4UcOROOTcLcLMathcLcLMatRepSymlEfloatcO4gRsPgRcLcLSMatrixRow_const(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO4UcO4UcOROOTcLcLMathcLcLMatRepSymlEfloatcO4gRsPgRcLcLSMatrixRow_const(void *p);
   static void destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO4UcO4UcOROOTcLcLMathcLcLMatRepSymlEfloatcO4gRsPgRcLcLSMatrixRow_const(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SMatrix<float,4U,4U,ROOT::Math::MatRepSym<float,4> >::SMatrixRow_const*)
   {
      ::ROOT::Math::SMatrix<float,4U,4U,ROOT::Math::MatRepSym<float,4> >::SMatrixRow_const *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SMatrix<float,4U,4U,ROOT::Math::MatRepSym<float,4> >::SMatrixRow_const));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SMatrix<float,4U,4U,ROOT::Math::MatRepSym<float,4> >::SMatrixRow_const", "Math/SMatrix.h", 382,
                  typeid(::ROOT::Math::SMatrix<float,4U,4U,ROOT::Math::MatRepSym<float,4> >::SMatrixRow_const), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSMatrixlEfloatcO4UcO4UcOROOTcLcLMathcLcLMatRepSymlEfloatcO4gRsPgRcLcLSMatrixRow_const_Dictionary, isa_proxy, 0,
                  sizeof(::ROOT::Math::SMatrix<float,4U,4U,ROOT::Math::MatRepSym<float,4> >::SMatrixRow_const) );
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSMatrixlEfloatcO4UcO4UcOROOTcLcLMathcLcLMatRepSymlEfloatcO4gRsPgRcLcLSMatrixRow_const);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO4UcO4UcOROOTcLcLMathcLcLMatRepSymlEfloatcO4gRsPgRcLcLSMatrixRow_const);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO4UcO4UcOROOTcLcLMathcLcLMatRepSymlEfloatcO4gRsPgRcLcLSMatrixRow_const);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<float,4U,4U,ROOT::Math::MatRepSym<float,4> >::SMatrixRow_const","ROOT::Math::SMatrix<float,4,4,ROOT::Math::MatRepSym<float,4> >::SMatrixRow_const"));

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<float,4U,4U,ROOT::Math::MatRepSym<float,4> >::SMatrixRow_const","ROOT::Math::SMatrix<float, 4u, 4u, ROOT::Math::MatRepSym<float, 4u> >::SMatrixRow_const"));
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::SMatrix<float,4U,4U,ROOT::Math::MatRepSym<float,4> >::SMatrixRow_const*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::SMatrix<float,4U,4U,ROOT::Math::MatRepSym<float,4> >::SMatrixRow_const*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<float,4U,4U,ROOT::Math::MatRepSym<float,4> >::SMatrixRow_const*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLSMatrixlEfloatcO4UcO4UcOROOTcLcLMathcLcLMatRepSymlEfloatcO4gRsPgRcLcLSMatrixRow_const_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<float,4U,4U,ROOT::Math::MatRepSym<float,4> >::SMatrixRow_const*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLSMatrixlEfloatcO4UcO4UcOROOTcLcLMathcLcLMatRepSymlEfloatcO4gRsPgRcLcLSMatrixRow_const_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLSMatrixlEfloatcO4UcO4UcOROOTcLcLMathcLcLMatRepSymlEfloatcO4gRsPgRcLcLSMatrixRow_const_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSMatrixlEfloatcO5cO5cOROOTcLcLMathcLcLMatRepSymlEfloatcO5gRsPgR_Dictionary();
   static void ROOTcLcLMathcLcLSMatrixlEfloatcO5cO5cOROOTcLcLMathcLcLMatRepSymlEfloatcO5gRsPgR_TClassManip(TClass*);
   static void *new_ROOTcLcLMathcLcLSMatrixlEfloatcO5cO5cOROOTcLcLMathcLcLMatRepSymlEfloatcO5gRsPgR(void *p = nullptr);
   static void *newArray_ROOTcLcLMathcLcLSMatrixlEfloatcO5cO5cOROOTcLcLMathcLcLMatRepSymlEfloatcO5gRsPgR(Long_t size, void *p);
   static void delete_ROOTcLcLMathcLcLSMatrixlEfloatcO5cO5cOROOTcLcLMathcLcLMatRepSymlEfloatcO5gRsPgR(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO5cO5cOROOTcLcLMathcLcLMatRepSymlEfloatcO5gRsPgR(void *p);
   static void destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO5cO5cOROOTcLcLMathcLcLMatRepSymlEfloatcO5gRsPgR(void *p);

   // Schema evolution read functions

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SMatrix<float,5,5,ROOT::Math::MatRepSym<float,5> >*)
   {
      ::ROOT::Math::SMatrix<float,5,5,ROOT::Math::MatRepSym<float,5> > *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SMatrix<float,5,5,ROOT::Math::MatRepSym<float,5> >));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SMatrix<float,5,5,ROOT::Math::MatRepSym<float,5> >", "Math/SMatrix.h", 101,
                  typeid(::ROOT::Math::SMatrix<float,5,5,ROOT::Math::MatRepSym<float,5> >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSMatrixlEfloatcO5cO5cOROOTcLcLMathcLcLMatRepSymlEfloatcO5gRsPgR_Dictionary, isa_proxy, 4,
                  sizeof(::ROOT::Math::SMatrix<float,5,5,ROOT::Math::MatRepSym<float,5> >) );
      instance.SetNew(&new_ROOTcLcLMathcLcLSMatrixlEfloatcO5cO5cOROOTcLcLMathcLcLMatRepSymlEfloatcO5gRsPgR);
      instance.SetNewArray(&newArray_ROOTcLcLMathcLcLSMatrixlEfloatcO5cO5cOROOTcLcLMathcLcLMatRepSymlEfloatcO5gRsPgR);
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSMatrixlEfloatcO5cO5cOROOTcLcLMathcLcLMatRepSymlEfloatcO5gRsPgR);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO5cO5cOROOTcLcLMathcLcLMatRepSymlEfloatcO5gRsPgR);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO5cO5cOROOTcLcLMathcLcLMatRepSymlEfloatcO5gRsPgR);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<float,5,5,ROOT::Math::MatRepSym<float,5> >","ROOT::Math::SMatrix<float, 5u, 5u, ROOT::Math::MatRepSym<float, 5u> >"));

      ::ROOT::Internal::TSchemaHelper* rule;

      // the io read rules
      std::vector<::ROOT::Internal::TSchemaHelper> readrules(3);
      rule = &readrules[0];
      rule->fSourceClass = "ROOT::Math::SMatrix<float,5,5,ROOT::Math::MatRepSym<double,5> >";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[1];
      rule->fSourceClass = "ROOT::Math::SMatrix<float,5,5,ROOT::Math::MatRepSym<Double32_t,5> >";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[2];
      rule->fSourceClass = "ROOT::Math::SMatrix<float,5,5,ROOT::Math::MatRepSym<Float16_t,5> >";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      instance.SetReadRules( readrules );
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::SMatrix<float,5,5,ROOT::Math::MatRepSym<float,5> >*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::SMatrix<float,5,5,ROOT::Math::MatRepSym<float,5> >*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<float,5,5,ROOT::Math::MatRepSym<float,5> >*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLSMatrixlEfloatcO5cO5cOROOTcLcLMathcLcLMatRepSymlEfloatcO5gRsPgR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<float,5,5,ROOT::Math::MatRepSym<float,5> >*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLSMatrixlEfloatcO5cO5cOROOTcLcLMathcLcLMatRepSymlEfloatcO5gRsPgR_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLSMatrixlEfloatcO5cO5cOROOTcLcLMathcLcLMatRepSymlEfloatcO5gRsPgR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSMatrixlEfloatcO5UcO5UcOROOTcLcLMathcLcLMatRepSymlEfloatcO5gRsPgRcLcLSMatrixRow_Dictionary();
   static void ROOTcLcLMathcLcLSMatrixlEfloatcO5UcO5UcOROOTcLcLMathcLcLMatRepSymlEfloatcO5gRsPgRcLcLSMatrixRow_TClassManip(TClass*);
   static void delete_ROOTcLcLMathcLcLSMatrixlEfloatcO5UcO5UcOROOTcLcLMathcLcLMatRepSymlEfloatcO5gRsPgRcLcLSMatrixRow(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO5UcO5UcOROOTcLcLMathcLcLMatRepSymlEfloatcO5gRsPgRcLcLSMatrixRow(void *p);
   static void destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO5UcO5UcOROOTcLcLMathcLcLMatRepSymlEfloatcO5gRsPgRcLcLSMatrixRow(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SMatrix<float,5U,5U,ROOT::Math::MatRepSym<float,5> >::SMatrixRow*)
   {
      ::ROOT::Math::SMatrix<float,5U,5U,ROOT::Math::MatRepSym<float,5> >::SMatrixRow *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SMatrix<float,5U,5U,ROOT::Math::MatRepSym<float,5> >::SMatrixRow));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SMatrix<float,5U,5U,ROOT::Math::MatRepSym<float,5> >::SMatrixRow", "Math/SMatrix.h", 371,
                  typeid(::ROOT::Math::SMatrix<float,5U,5U,ROOT::Math::MatRepSym<float,5> >::SMatrixRow), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSMatrixlEfloatcO5UcO5UcOROOTcLcLMathcLcLMatRepSymlEfloatcO5gRsPgRcLcLSMatrixRow_Dictionary, isa_proxy, 0,
                  sizeof(::ROOT::Math::SMatrix<float,5U,5U,ROOT::Math::MatRepSym<float,5> >::SMatrixRow) );
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSMatrixlEfloatcO5UcO5UcOROOTcLcLMathcLcLMatRepSymlEfloatcO5gRsPgRcLcLSMatrixRow);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO5UcO5UcOROOTcLcLMathcLcLMatRepSymlEfloatcO5gRsPgRcLcLSMatrixRow);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO5UcO5UcOROOTcLcLMathcLcLMatRepSymlEfloatcO5gRsPgRcLcLSMatrixRow);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<float,5U,5U,ROOT::Math::MatRepSym<float,5> >::SMatrixRow","ROOT::Math::SMatrix<float,5,5,ROOT::Math::MatRepSym<float,5> >::SMatrixRow"));

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<float,5U,5U,ROOT::Math::MatRepSym<float,5> >::SMatrixRow","ROOT::Math::SMatrix<float, 5u, 5u, ROOT::Math::MatRepSym<float, 5u> >::SMatrixRow"));
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::SMatrix<float,5U,5U,ROOT::Math::MatRepSym<float,5> >::SMatrixRow*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::SMatrix<float,5U,5U,ROOT::Math::MatRepSym<float,5> >::SMatrixRow*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<float,5U,5U,ROOT::Math::MatRepSym<float,5> >::SMatrixRow*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLSMatrixlEfloatcO5UcO5UcOROOTcLcLMathcLcLMatRepSymlEfloatcO5gRsPgRcLcLSMatrixRow_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<float,5U,5U,ROOT::Math::MatRepSym<float,5> >::SMatrixRow*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLSMatrixlEfloatcO5UcO5UcOROOTcLcLMathcLcLMatRepSymlEfloatcO5gRsPgRcLcLSMatrixRow_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLSMatrixlEfloatcO5UcO5UcOROOTcLcLMathcLcLMatRepSymlEfloatcO5gRsPgRcLcLSMatrixRow_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSMatrixlEfloatcO5UcO5UcOROOTcLcLMathcLcLMatRepSymlEfloatcO5gRsPgRcLcLSMatrixRow_const_Dictionary();
   static void ROOTcLcLMathcLcLSMatrixlEfloatcO5UcO5UcOROOTcLcLMathcLcLMatRepSymlEfloatcO5gRsPgRcLcLSMatrixRow_const_TClassManip(TClass*);
   static void delete_ROOTcLcLMathcLcLSMatrixlEfloatcO5UcO5UcOROOTcLcLMathcLcLMatRepSymlEfloatcO5gRsPgRcLcLSMatrixRow_const(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO5UcO5UcOROOTcLcLMathcLcLMatRepSymlEfloatcO5gRsPgRcLcLSMatrixRow_const(void *p);
   static void destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO5UcO5UcOROOTcLcLMathcLcLMatRepSymlEfloatcO5gRsPgRcLcLSMatrixRow_const(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SMatrix<float,5U,5U,ROOT::Math::MatRepSym<float,5> >::SMatrixRow_const*)
   {
      ::ROOT::Math::SMatrix<float,5U,5U,ROOT::Math::MatRepSym<float,5> >::SMatrixRow_const *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SMatrix<float,5U,5U,ROOT::Math::MatRepSym<float,5> >::SMatrixRow_const));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SMatrix<float,5U,5U,ROOT::Math::MatRepSym<float,5> >::SMatrixRow_const", "Math/SMatrix.h", 382,
                  typeid(::ROOT::Math::SMatrix<float,5U,5U,ROOT::Math::MatRepSym<float,5> >::SMatrixRow_const), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSMatrixlEfloatcO5UcO5UcOROOTcLcLMathcLcLMatRepSymlEfloatcO5gRsPgRcLcLSMatrixRow_const_Dictionary, isa_proxy, 0,
                  sizeof(::ROOT::Math::SMatrix<float,5U,5U,ROOT::Math::MatRepSym<float,5> >::SMatrixRow_const) );
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSMatrixlEfloatcO5UcO5UcOROOTcLcLMathcLcLMatRepSymlEfloatcO5gRsPgRcLcLSMatrixRow_const);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO5UcO5UcOROOTcLcLMathcLcLMatRepSymlEfloatcO5gRsPgRcLcLSMatrixRow_const);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO5UcO5UcOROOTcLcLMathcLcLMatRepSymlEfloatcO5gRsPgRcLcLSMatrixRow_const);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<float,5U,5U,ROOT::Math::MatRepSym<float,5> >::SMatrixRow_const","ROOT::Math::SMatrix<float,5,5,ROOT::Math::MatRepSym<float,5> >::SMatrixRow_const"));

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<float,5U,5U,ROOT::Math::MatRepSym<float,5> >::SMatrixRow_const","ROOT::Math::SMatrix<float, 5u, 5u, ROOT::Math::MatRepSym<float, 5u> >::SMatrixRow_const"));
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::SMatrix<float,5U,5U,ROOT::Math::MatRepSym<float,5> >::SMatrixRow_const*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::SMatrix<float,5U,5U,ROOT::Math::MatRepSym<float,5> >::SMatrixRow_const*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<float,5U,5U,ROOT::Math::MatRepSym<float,5> >::SMatrixRow_const*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLSMatrixlEfloatcO5UcO5UcOROOTcLcLMathcLcLMatRepSymlEfloatcO5gRsPgRcLcLSMatrixRow_const_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<float,5U,5U,ROOT::Math::MatRepSym<float,5> >::SMatrixRow_const*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLSMatrixlEfloatcO5UcO5UcOROOTcLcLMathcLcLMatRepSymlEfloatcO5gRsPgRcLcLSMatrixRow_const_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLSMatrixlEfloatcO5UcO5UcOROOTcLcLMathcLcLMatRepSymlEfloatcO5gRsPgRcLcLSMatrixRow_const_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSMatrixlEfloatcO6cO6cOROOTcLcLMathcLcLMatRepSymlEfloatcO6gRsPgR_Dictionary();
   static void ROOTcLcLMathcLcLSMatrixlEfloatcO6cO6cOROOTcLcLMathcLcLMatRepSymlEfloatcO6gRsPgR_TClassManip(TClass*);
   static void *new_ROOTcLcLMathcLcLSMatrixlEfloatcO6cO6cOROOTcLcLMathcLcLMatRepSymlEfloatcO6gRsPgR(void *p = nullptr);
   static void *newArray_ROOTcLcLMathcLcLSMatrixlEfloatcO6cO6cOROOTcLcLMathcLcLMatRepSymlEfloatcO6gRsPgR(Long_t size, void *p);
   static void delete_ROOTcLcLMathcLcLSMatrixlEfloatcO6cO6cOROOTcLcLMathcLcLMatRepSymlEfloatcO6gRsPgR(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO6cO6cOROOTcLcLMathcLcLMatRepSymlEfloatcO6gRsPgR(void *p);
   static void destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO6cO6cOROOTcLcLMathcLcLMatRepSymlEfloatcO6gRsPgR(void *p);

   // Schema evolution read functions

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SMatrix<float,6,6,ROOT::Math::MatRepSym<float,6> >*)
   {
      ::ROOT::Math::SMatrix<float,6,6,ROOT::Math::MatRepSym<float,6> > *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SMatrix<float,6,6,ROOT::Math::MatRepSym<float,6> >));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SMatrix<float,6,6,ROOT::Math::MatRepSym<float,6> >", "Math/SMatrix.h", 101,
                  typeid(::ROOT::Math::SMatrix<float,6,6,ROOT::Math::MatRepSym<float,6> >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSMatrixlEfloatcO6cO6cOROOTcLcLMathcLcLMatRepSymlEfloatcO6gRsPgR_Dictionary, isa_proxy, 4,
                  sizeof(::ROOT::Math::SMatrix<float,6,6,ROOT::Math::MatRepSym<float,6> >) );
      instance.SetNew(&new_ROOTcLcLMathcLcLSMatrixlEfloatcO6cO6cOROOTcLcLMathcLcLMatRepSymlEfloatcO6gRsPgR);
      instance.SetNewArray(&newArray_ROOTcLcLMathcLcLSMatrixlEfloatcO6cO6cOROOTcLcLMathcLcLMatRepSymlEfloatcO6gRsPgR);
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSMatrixlEfloatcO6cO6cOROOTcLcLMathcLcLMatRepSymlEfloatcO6gRsPgR);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO6cO6cOROOTcLcLMathcLcLMatRepSymlEfloatcO6gRsPgR);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO6cO6cOROOTcLcLMathcLcLMatRepSymlEfloatcO6gRsPgR);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<float,6,6,ROOT::Math::MatRepSym<float,6> >","ROOT::Math::SMatrix<float, 6u, 6u, ROOT::Math::MatRepSym<float, 6u> >"));

      ::ROOT::Internal::TSchemaHelper* rule;

      // the io read rules
      std::vector<::ROOT::Internal::TSchemaHelper> readrules(3);
      rule = &readrules[0];
      rule->fSourceClass = "ROOT::Math::SMatrix<float,6,6,ROOT::Math::MatRepSym<double,6> >";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[1];
      rule->fSourceClass = "ROOT::Math::SMatrix<float,6,6,ROOT::Math::MatRepSym<Double32_t,6> >";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[2];
      rule->fSourceClass = "ROOT::Math::SMatrix<float,6,6,ROOT::Math::MatRepSym<Float16_t,6> >";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      instance.SetReadRules( readrules );
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::SMatrix<float,6,6,ROOT::Math::MatRepSym<float,6> >*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::SMatrix<float,6,6,ROOT::Math::MatRepSym<float,6> >*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<float,6,6,ROOT::Math::MatRepSym<float,6> >*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLSMatrixlEfloatcO6cO6cOROOTcLcLMathcLcLMatRepSymlEfloatcO6gRsPgR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<float,6,6,ROOT::Math::MatRepSym<float,6> >*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLSMatrixlEfloatcO6cO6cOROOTcLcLMathcLcLMatRepSymlEfloatcO6gRsPgR_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLSMatrixlEfloatcO6cO6cOROOTcLcLMathcLcLMatRepSymlEfloatcO6gRsPgR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSMatrixlEfloatcO6UcO6UcOROOTcLcLMathcLcLMatRepSymlEfloatcO6gRsPgRcLcLSMatrixRow_Dictionary();
   static void ROOTcLcLMathcLcLSMatrixlEfloatcO6UcO6UcOROOTcLcLMathcLcLMatRepSymlEfloatcO6gRsPgRcLcLSMatrixRow_TClassManip(TClass*);
   static void delete_ROOTcLcLMathcLcLSMatrixlEfloatcO6UcO6UcOROOTcLcLMathcLcLMatRepSymlEfloatcO6gRsPgRcLcLSMatrixRow(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO6UcO6UcOROOTcLcLMathcLcLMatRepSymlEfloatcO6gRsPgRcLcLSMatrixRow(void *p);
   static void destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO6UcO6UcOROOTcLcLMathcLcLMatRepSymlEfloatcO6gRsPgRcLcLSMatrixRow(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SMatrix<float,6U,6U,ROOT::Math::MatRepSym<float,6> >::SMatrixRow*)
   {
      ::ROOT::Math::SMatrix<float,6U,6U,ROOT::Math::MatRepSym<float,6> >::SMatrixRow *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SMatrix<float,6U,6U,ROOT::Math::MatRepSym<float,6> >::SMatrixRow));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SMatrix<float,6U,6U,ROOT::Math::MatRepSym<float,6> >::SMatrixRow", "Math/SMatrix.h", 371,
                  typeid(::ROOT::Math::SMatrix<float,6U,6U,ROOT::Math::MatRepSym<float,6> >::SMatrixRow), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSMatrixlEfloatcO6UcO6UcOROOTcLcLMathcLcLMatRepSymlEfloatcO6gRsPgRcLcLSMatrixRow_Dictionary, isa_proxy, 0,
                  sizeof(::ROOT::Math::SMatrix<float,6U,6U,ROOT::Math::MatRepSym<float,6> >::SMatrixRow) );
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSMatrixlEfloatcO6UcO6UcOROOTcLcLMathcLcLMatRepSymlEfloatcO6gRsPgRcLcLSMatrixRow);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO6UcO6UcOROOTcLcLMathcLcLMatRepSymlEfloatcO6gRsPgRcLcLSMatrixRow);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO6UcO6UcOROOTcLcLMathcLcLMatRepSymlEfloatcO6gRsPgRcLcLSMatrixRow);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<float,6U,6U,ROOT::Math::MatRepSym<float,6> >::SMatrixRow","ROOT::Math::SMatrix<float,6,6,ROOT::Math::MatRepSym<float,6> >::SMatrixRow"));

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<float,6U,6U,ROOT::Math::MatRepSym<float,6> >::SMatrixRow","ROOT::Math::SMatrix<float, 6u, 6u, ROOT::Math::MatRepSym<float, 6u> >::SMatrixRow"));
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::SMatrix<float,6U,6U,ROOT::Math::MatRepSym<float,6> >::SMatrixRow*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::SMatrix<float,6U,6U,ROOT::Math::MatRepSym<float,6> >::SMatrixRow*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<float,6U,6U,ROOT::Math::MatRepSym<float,6> >::SMatrixRow*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLSMatrixlEfloatcO6UcO6UcOROOTcLcLMathcLcLMatRepSymlEfloatcO6gRsPgRcLcLSMatrixRow_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<float,6U,6U,ROOT::Math::MatRepSym<float,6> >::SMatrixRow*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLSMatrixlEfloatcO6UcO6UcOROOTcLcLMathcLcLMatRepSymlEfloatcO6gRsPgRcLcLSMatrixRow_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLSMatrixlEfloatcO6UcO6UcOROOTcLcLMathcLcLMatRepSymlEfloatcO6gRsPgRcLcLSMatrixRow_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSMatrixlEfloatcO6UcO6UcOROOTcLcLMathcLcLMatRepSymlEfloatcO6gRsPgRcLcLSMatrixRow_const_Dictionary();
   static void ROOTcLcLMathcLcLSMatrixlEfloatcO6UcO6UcOROOTcLcLMathcLcLMatRepSymlEfloatcO6gRsPgRcLcLSMatrixRow_const_TClassManip(TClass*);
   static void delete_ROOTcLcLMathcLcLSMatrixlEfloatcO6UcO6UcOROOTcLcLMathcLcLMatRepSymlEfloatcO6gRsPgRcLcLSMatrixRow_const(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO6UcO6UcOROOTcLcLMathcLcLMatRepSymlEfloatcO6gRsPgRcLcLSMatrixRow_const(void *p);
   static void destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO6UcO6UcOROOTcLcLMathcLcLMatRepSymlEfloatcO6gRsPgRcLcLSMatrixRow_const(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SMatrix<float,6U,6U,ROOT::Math::MatRepSym<float,6> >::SMatrixRow_const*)
   {
      ::ROOT::Math::SMatrix<float,6U,6U,ROOT::Math::MatRepSym<float,6> >::SMatrixRow_const *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SMatrix<float,6U,6U,ROOT::Math::MatRepSym<float,6> >::SMatrixRow_const));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SMatrix<float,6U,6U,ROOT::Math::MatRepSym<float,6> >::SMatrixRow_const", "Math/SMatrix.h", 382,
                  typeid(::ROOT::Math::SMatrix<float,6U,6U,ROOT::Math::MatRepSym<float,6> >::SMatrixRow_const), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSMatrixlEfloatcO6UcO6UcOROOTcLcLMathcLcLMatRepSymlEfloatcO6gRsPgRcLcLSMatrixRow_const_Dictionary, isa_proxy, 0,
                  sizeof(::ROOT::Math::SMatrix<float,6U,6U,ROOT::Math::MatRepSym<float,6> >::SMatrixRow_const) );
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSMatrixlEfloatcO6UcO6UcOROOTcLcLMathcLcLMatRepSymlEfloatcO6gRsPgRcLcLSMatrixRow_const);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO6UcO6UcOROOTcLcLMathcLcLMatRepSymlEfloatcO6gRsPgRcLcLSMatrixRow_const);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO6UcO6UcOROOTcLcLMathcLcLMatRepSymlEfloatcO6gRsPgRcLcLSMatrixRow_const);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<float,6U,6U,ROOT::Math::MatRepSym<float,6> >::SMatrixRow_const","ROOT::Math::SMatrix<float,6,6,ROOT::Math::MatRepSym<float,6> >::SMatrixRow_const"));

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<float,6U,6U,ROOT::Math::MatRepSym<float,6> >::SMatrixRow_const","ROOT::Math::SMatrix<float, 6u, 6u, ROOT::Math::MatRepSym<float, 6u> >::SMatrixRow_const"));
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::SMatrix<float,6U,6U,ROOT::Math::MatRepSym<float,6> >::SMatrixRow_const*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::SMatrix<float,6U,6U,ROOT::Math::MatRepSym<float,6> >::SMatrixRow_const*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<float,6U,6U,ROOT::Math::MatRepSym<float,6> >::SMatrixRow_const*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLSMatrixlEfloatcO6UcO6UcOROOTcLcLMathcLcLMatRepSymlEfloatcO6gRsPgRcLcLSMatrixRow_const_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<float,6U,6U,ROOT::Math::MatRepSym<float,6> >::SMatrixRow_const*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLSMatrixlEfloatcO6UcO6UcOROOTcLcLMathcLcLMatRepSymlEfloatcO6gRsPgRcLcLSMatrixRow_const_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLSMatrixlEfloatcO6UcO6UcOROOTcLcLMathcLcLMatRepSymlEfloatcO6gRsPgRcLcLSMatrixRow_const_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSMatrixlEfloatcO7cO7cOROOTcLcLMathcLcLMatRepSymlEfloatcO7gRsPgR_Dictionary();
   static void ROOTcLcLMathcLcLSMatrixlEfloatcO7cO7cOROOTcLcLMathcLcLMatRepSymlEfloatcO7gRsPgR_TClassManip(TClass*);
   static void *new_ROOTcLcLMathcLcLSMatrixlEfloatcO7cO7cOROOTcLcLMathcLcLMatRepSymlEfloatcO7gRsPgR(void *p = nullptr);
   static void *newArray_ROOTcLcLMathcLcLSMatrixlEfloatcO7cO7cOROOTcLcLMathcLcLMatRepSymlEfloatcO7gRsPgR(Long_t size, void *p);
   static void delete_ROOTcLcLMathcLcLSMatrixlEfloatcO7cO7cOROOTcLcLMathcLcLMatRepSymlEfloatcO7gRsPgR(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO7cO7cOROOTcLcLMathcLcLMatRepSymlEfloatcO7gRsPgR(void *p);
   static void destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO7cO7cOROOTcLcLMathcLcLMatRepSymlEfloatcO7gRsPgR(void *p);

   // Schema evolution read functions

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SMatrix<float,7,7,ROOT::Math::MatRepSym<float,7> >*)
   {
      ::ROOT::Math::SMatrix<float,7,7,ROOT::Math::MatRepSym<float,7> > *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SMatrix<float,7,7,ROOT::Math::MatRepSym<float,7> >));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SMatrix<float,7,7,ROOT::Math::MatRepSym<float,7> >", "Math/SMatrix.h", 101,
                  typeid(::ROOT::Math::SMatrix<float,7,7,ROOT::Math::MatRepSym<float,7> >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSMatrixlEfloatcO7cO7cOROOTcLcLMathcLcLMatRepSymlEfloatcO7gRsPgR_Dictionary, isa_proxy, 4,
                  sizeof(::ROOT::Math::SMatrix<float,7,7,ROOT::Math::MatRepSym<float,7> >) );
      instance.SetNew(&new_ROOTcLcLMathcLcLSMatrixlEfloatcO7cO7cOROOTcLcLMathcLcLMatRepSymlEfloatcO7gRsPgR);
      instance.SetNewArray(&newArray_ROOTcLcLMathcLcLSMatrixlEfloatcO7cO7cOROOTcLcLMathcLcLMatRepSymlEfloatcO7gRsPgR);
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSMatrixlEfloatcO7cO7cOROOTcLcLMathcLcLMatRepSymlEfloatcO7gRsPgR);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO7cO7cOROOTcLcLMathcLcLMatRepSymlEfloatcO7gRsPgR);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO7cO7cOROOTcLcLMathcLcLMatRepSymlEfloatcO7gRsPgR);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<float,7,7,ROOT::Math::MatRepSym<float,7> >","ROOT::Math::SMatrix<float, 7u, 7u, ROOT::Math::MatRepSym<float, 7u> >"));

      ::ROOT::Internal::TSchemaHelper* rule;

      // the io read rules
      std::vector<::ROOT::Internal::TSchemaHelper> readrules(3);
      rule = &readrules[0];
      rule->fSourceClass = "ROOT::Math::SMatrix<float,7,7,ROOT::Math::MatRepSym<double,7> >";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[1];
      rule->fSourceClass = "ROOT::Math::SMatrix<float,7,7,ROOT::Math::MatRepSym<Double32_t,7> >";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[2];
      rule->fSourceClass = "ROOT::Math::SMatrix<float,7,7,ROOT::Math::MatRepSym<Float16_t,7> >";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      instance.SetReadRules( readrules );
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::SMatrix<float,7,7,ROOT::Math::MatRepSym<float,7> >*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::SMatrix<float,7,7,ROOT::Math::MatRepSym<float,7> >*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<float,7,7,ROOT::Math::MatRepSym<float,7> >*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLSMatrixlEfloatcO7cO7cOROOTcLcLMathcLcLMatRepSymlEfloatcO7gRsPgR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<float,7,7,ROOT::Math::MatRepSym<float,7> >*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLSMatrixlEfloatcO7cO7cOROOTcLcLMathcLcLMatRepSymlEfloatcO7gRsPgR_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLSMatrixlEfloatcO7cO7cOROOTcLcLMathcLcLMatRepSymlEfloatcO7gRsPgR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSMatrixlEfloatcO7UcO7UcOROOTcLcLMathcLcLMatRepSymlEfloatcO7gRsPgRcLcLSMatrixRow_Dictionary();
   static void ROOTcLcLMathcLcLSMatrixlEfloatcO7UcO7UcOROOTcLcLMathcLcLMatRepSymlEfloatcO7gRsPgRcLcLSMatrixRow_TClassManip(TClass*);
   static void delete_ROOTcLcLMathcLcLSMatrixlEfloatcO7UcO7UcOROOTcLcLMathcLcLMatRepSymlEfloatcO7gRsPgRcLcLSMatrixRow(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO7UcO7UcOROOTcLcLMathcLcLMatRepSymlEfloatcO7gRsPgRcLcLSMatrixRow(void *p);
   static void destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO7UcO7UcOROOTcLcLMathcLcLMatRepSymlEfloatcO7gRsPgRcLcLSMatrixRow(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SMatrix<float,7U,7U,ROOT::Math::MatRepSym<float,7> >::SMatrixRow*)
   {
      ::ROOT::Math::SMatrix<float,7U,7U,ROOT::Math::MatRepSym<float,7> >::SMatrixRow *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SMatrix<float,7U,7U,ROOT::Math::MatRepSym<float,7> >::SMatrixRow));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SMatrix<float,7U,7U,ROOT::Math::MatRepSym<float,7> >::SMatrixRow", "Math/SMatrix.h", 371,
                  typeid(::ROOT::Math::SMatrix<float,7U,7U,ROOT::Math::MatRepSym<float,7> >::SMatrixRow), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSMatrixlEfloatcO7UcO7UcOROOTcLcLMathcLcLMatRepSymlEfloatcO7gRsPgRcLcLSMatrixRow_Dictionary, isa_proxy, 0,
                  sizeof(::ROOT::Math::SMatrix<float,7U,7U,ROOT::Math::MatRepSym<float,7> >::SMatrixRow) );
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSMatrixlEfloatcO7UcO7UcOROOTcLcLMathcLcLMatRepSymlEfloatcO7gRsPgRcLcLSMatrixRow);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO7UcO7UcOROOTcLcLMathcLcLMatRepSymlEfloatcO7gRsPgRcLcLSMatrixRow);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO7UcO7UcOROOTcLcLMathcLcLMatRepSymlEfloatcO7gRsPgRcLcLSMatrixRow);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<float,7U,7U,ROOT::Math::MatRepSym<float,7> >::SMatrixRow","ROOT::Math::SMatrix<float,7,7,ROOT::Math::MatRepSym<float,7> >::SMatrixRow"));

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<float,7U,7U,ROOT::Math::MatRepSym<float,7> >::SMatrixRow","ROOT::Math::SMatrix<float, 7u, 7u, ROOT::Math::MatRepSym<float, 7u> >::SMatrixRow"));
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::SMatrix<float,7U,7U,ROOT::Math::MatRepSym<float,7> >::SMatrixRow*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::SMatrix<float,7U,7U,ROOT::Math::MatRepSym<float,7> >::SMatrixRow*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<float,7U,7U,ROOT::Math::MatRepSym<float,7> >::SMatrixRow*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLSMatrixlEfloatcO7UcO7UcOROOTcLcLMathcLcLMatRepSymlEfloatcO7gRsPgRcLcLSMatrixRow_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<float,7U,7U,ROOT::Math::MatRepSym<float,7> >::SMatrixRow*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLSMatrixlEfloatcO7UcO7UcOROOTcLcLMathcLcLMatRepSymlEfloatcO7gRsPgRcLcLSMatrixRow_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLSMatrixlEfloatcO7UcO7UcOROOTcLcLMathcLcLMatRepSymlEfloatcO7gRsPgRcLcLSMatrixRow_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSMatrixlEfloatcO7UcO7UcOROOTcLcLMathcLcLMatRepSymlEfloatcO7gRsPgRcLcLSMatrixRow_const_Dictionary();
   static void ROOTcLcLMathcLcLSMatrixlEfloatcO7UcO7UcOROOTcLcLMathcLcLMatRepSymlEfloatcO7gRsPgRcLcLSMatrixRow_const_TClassManip(TClass*);
   static void delete_ROOTcLcLMathcLcLSMatrixlEfloatcO7UcO7UcOROOTcLcLMathcLcLMatRepSymlEfloatcO7gRsPgRcLcLSMatrixRow_const(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO7UcO7UcOROOTcLcLMathcLcLMatRepSymlEfloatcO7gRsPgRcLcLSMatrixRow_const(void *p);
   static void destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO7UcO7UcOROOTcLcLMathcLcLMatRepSymlEfloatcO7gRsPgRcLcLSMatrixRow_const(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SMatrix<float,7U,7U,ROOT::Math::MatRepSym<float,7> >::SMatrixRow_const*)
   {
      ::ROOT::Math::SMatrix<float,7U,7U,ROOT::Math::MatRepSym<float,7> >::SMatrixRow_const *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SMatrix<float,7U,7U,ROOT::Math::MatRepSym<float,7> >::SMatrixRow_const));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SMatrix<float,7U,7U,ROOT::Math::MatRepSym<float,7> >::SMatrixRow_const", "Math/SMatrix.h", 382,
                  typeid(::ROOT::Math::SMatrix<float,7U,7U,ROOT::Math::MatRepSym<float,7> >::SMatrixRow_const), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSMatrixlEfloatcO7UcO7UcOROOTcLcLMathcLcLMatRepSymlEfloatcO7gRsPgRcLcLSMatrixRow_const_Dictionary, isa_proxy, 0,
                  sizeof(::ROOT::Math::SMatrix<float,7U,7U,ROOT::Math::MatRepSym<float,7> >::SMatrixRow_const) );
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSMatrixlEfloatcO7UcO7UcOROOTcLcLMathcLcLMatRepSymlEfloatcO7gRsPgRcLcLSMatrixRow_const);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO7UcO7UcOROOTcLcLMathcLcLMatRepSymlEfloatcO7gRsPgRcLcLSMatrixRow_const);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO7UcO7UcOROOTcLcLMathcLcLMatRepSymlEfloatcO7gRsPgRcLcLSMatrixRow_const);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<float,7U,7U,ROOT::Math::MatRepSym<float,7> >::SMatrixRow_const","ROOT::Math::SMatrix<float,7,7,ROOT::Math::MatRepSym<float,7> >::SMatrixRow_const"));

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<float,7U,7U,ROOT::Math::MatRepSym<float,7> >::SMatrixRow_const","ROOT::Math::SMatrix<float, 7u, 7u, ROOT::Math::MatRepSym<float, 7u> >::SMatrixRow_const"));
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::SMatrix<float,7U,7U,ROOT::Math::MatRepSym<float,7> >::SMatrixRow_const*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::SMatrix<float,7U,7U,ROOT::Math::MatRepSym<float,7> >::SMatrixRow_const*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<float,7U,7U,ROOT::Math::MatRepSym<float,7> >::SMatrixRow_const*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLSMatrixlEfloatcO7UcO7UcOROOTcLcLMathcLcLMatRepSymlEfloatcO7gRsPgRcLcLSMatrixRow_const_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<float,7U,7U,ROOT::Math::MatRepSym<float,7> >::SMatrixRow_const*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLSMatrixlEfloatcO7UcO7UcOROOTcLcLMathcLcLMatRepSymlEfloatcO7gRsPgRcLcLSMatrixRow_const_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLSMatrixlEfloatcO7UcO7UcOROOTcLcLMathcLcLMatRepSymlEfloatcO7gRsPgRcLcLSMatrixRow_const_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSMatrixlEdoublecO4cO3cOROOTcLcLMathcLcLMatRepStdlEdoublecO4cO3gRsPgR_Dictionary();
   static void ROOTcLcLMathcLcLSMatrixlEdoublecO4cO3cOROOTcLcLMathcLcLMatRepStdlEdoublecO4cO3gRsPgR_TClassManip(TClass*);
   static void *new_ROOTcLcLMathcLcLSMatrixlEdoublecO4cO3cOROOTcLcLMathcLcLMatRepStdlEdoublecO4cO3gRsPgR(void *p = nullptr);
   static void *newArray_ROOTcLcLMathcLcLSMatrixlEdoublecO4cO3cOROOTcLcLMathcLcLMatRepStdlEdoublecO4cO3gRsPgR(Long_t size, void *p);
   static void delete_ROOTcLcLMathcLcLSMatrixlEdoublecO4cO3cOROOTcLcLMathcLcLMatRepStdlEdoublecO4cO3gRsPgR(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO4cO3cOROOTcLcLMathcLcLMatRepStdlEdoublecO4cO3gRsPgR(void *p);
   static void destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO4cO3cOROOTcLcLMathcLcLMatRepStdlEdoublecO4cO3gRsPgR(void *p);

   // Schema evolution read functions

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SMatrix<double,4,3,ROOT::Math::MatRepStd<double,4,3> >*)
   {
      ::ROOT::Math::SMatrix<double,4,3,ROOT::Math::MatRepStd<double,4,3> > *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SMatrix<double,4,3,ROOT::Math::MatRepStd<double,4,3> >));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SMatrix<double,4,3,ROOT::Math::MatRepStd<double,4,3> >", "Math/SMatrix.h", 101,
                  typeid(::ROOT::Math::SMatrix<double,4,3,ROOT::Math::MatRepStd<double,4,3> >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSMatrixlEdoublecO4cO3cOROOTcLcLMathcLcLMatRepStdlEdoublecO4cO3gRsPgR_Dictionary, isa_proxy, 4,
                  sizeof(::ROOT::Math::SMatrix<double,4,3,ROOT::Math::MatRepStd<double,4,3> >) );
      instance.SetNew(&new_ROOTcLcLMathcLcLSMatrixlEdoublecO4cO3cOROOTcLcLMathcLcLMatRepStdlEdoublecO4cO3gRsPgR);
      instance.SetNewArray(&newArray_ROOTcLcLMathcLcLSMatrixlEdoublecO4cO3cOROOTcLcLMathcLcLMatRepStdlEdoublecO4cO3gRsPgR);
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSMatrixlEdoublecO4cO3cOROOTcLcLMathcLcLMatRepStdlEdoublecO4cO3gRsPgR);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO4cO3cOROOTcLcLMathcLcLMatRepStdlEdoublecO4cO3gRsPgR);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO4cO3cOROOTcLcLMathcLcLMatRepStdlEdoublecO4cO3gRsPgR);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<double,4,3,ROOT::Math::MatRepStd<double,4,3> >","ROOT::Math::SMatrix<double,4,3>"));

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<double,4,3,ROOT::Math::MatRepStd<double,4,3> >","ROOT::Math::SMatrix<double, 4u, 3u, ROOT::Math::MatRepStd<double, 4u, 3u> >"));

      ::ROOT::Internal::TSchemaHelper* rule;

      // the io read rules
      std::vector<::ROOT::Internal::TSchemaHelper> readrules(3);
      rule = &readrules[0];
      rule->fSourceClass = "ROOT::Math::SMatrix<Double32_t,4,3>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[1];
      rule->fSourceClass = "ROOT::Math::SMatrix<float,4,3>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[2];
      rule->fSourceClass = "ROOT::Math::SMatrix<Float16_t,4,3>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      instance.SetReadRules( readrules );
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::SMatrix<double,4,3,ROOT::Math::MatRepStd<double,4,3> >*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::SMatrix<double,4,3,ROOT::Math::MatRepStd<double,4,3> >*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<double,4,3,ROOT::Math::MatRepStd<double,4,3> >*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLSMatrixlEdoublecO4cO3cOROOTcLcLMathcLcLMatRepStdlEdoublecO4cO3gRsPgR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<double,4,3,ROOT::Math::MatRepStd<double,4,3> >*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLSMatrixlEdoublecO4cO3cOROOTcLcLMathcLcLMatRepStdlEdoublecO4cO3gRsPgR_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLSMatrixlEdoublecO4cO3cOROOTcLcLMathcLcLMatRepStdlEdoublecO4cO3gRsPgR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSMatrixlEdoublecO4UcO3UcOROOTcLcLMathcLcLMatRepStdlEdoublecO4cO3gRsPgRcLcLSMatrixRow_Dictionary();
   static void ROOTcLcLMathcLcLSMatrixlEdoublecO4UcO3UcOROOTcLcLMathcLcLMatRepStdlEdoublecO4cO3gRsPgRcLcLSMatrixRow_TClassManip(TClass*);
   static void delete_ROOTcLcLMathcLcLSMatrixlEdoublecO4UcO3UcOROOTcLcLMathcLcLMatRepStdlEdoublecO4cO3gRsPgRcLcLSMatrixRow(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO4UcO3UcOROOTcLcLMathcLcLMatRepStdlEdoublecO4cO3gRsPgRcLcLSMatrixRow(void *p);
   static void destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO4UcO3UcOROOTcLcLMathcLcLMatRepStdlEdoublecO4cO3gRsPgRcLcLSMatrixRow(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SMatrix<double,4U,3U,ROOT::Math::MatRepStd<double,4,3> >::SMatrixRow*)
   {
      ::ROOT::Math::SMatrix<double,4U,3U,ROOT::Math::MatRepStd<double,4,3> >::SMatrixRow *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SMatrix<double,4U,3U,ROOT::Math::MatRepStd<double,4,3> >::SMatrixRow));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SMatrix<double,4U,3U,ROOT::Math::MatRepStd<double,4,3> >::SMatrixRow", "Math/SMatrix.h", 371,
                  typeid(::ROOT::Math::SMatrix<double,4U,3U,ROOT::Math::MatRepStd<double,4,3> >::SMatrixRow), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSMatrixlEdoublecO4UcO3UcOROOTcLcLMathcLcLMatRepStdlEdoublecO4cO3gRsPgRcLcLSMatrixRow_Dictionary, isa_proxy, 0,
                  sizeof(::ROOT::Math::SMatrix<double,4U,3U,ROOT::Math::MatRepStd<double,4,3> >::SMatrixRow) );
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSMatrixlEdoublecO4UcO3UcOROOTcLcLMathcLcLMatRepStdlEdoublecO4cO3gRsPgRcLcLSMatrixRow);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO4UcO3UcOROOTcLcLMathcLcLMatRepStdlEdoublecO4cO3gRsPgRcLcLSMatrixRow);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO4UcO3UcOROOTcLcLMathcLcLMatRepStdlEdoublecO4cO3gRsPgRcLcLSMatrixRow);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<double,4U,3U,ROOT::Math::MatRepStd<double,4,3> >::SMatrixRow","ROOT::Math::SMatrix<double,4,3>::SMatrixRow"));

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<double,4U,3U,ROOT::Math::MatRepStd<double,4,3> >::SMatrixRow","ROOT::Math::SMatrix<double, 4u, 3u, ROOT::Math::MatRepStd<double, 4u, 3u> >::SMatrixRow"));
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::SMatrix<double,4U,3U,ROOT::Math::MatRepStd<double,4,3> >::SMatrixRow*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::SMatrix<double,4U,3U,ROOT::Math::MatRepStd<double,4,3> >::SMatrixRow*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<double,4U,3U,ROOT::Math::MatRepStd<double,4,3> >::SMatrixRow*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLSMatrixlEdoublecO4UcO3UcOROOTcLcLMathcLcLMatRepStdlEdoublecO4cO3gRsPgRcLcLSMatrixRow_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<double,4U,3U,ROOT::Math::MatRepStd<double,4,3> >::SMatrixRow*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLSMatrixlEdoublecO4UcO3UcOROOTcLcLMathcLcLMatRepStdlEdoublecO4cO3gRsPgRcLcLSMatrixRow_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLSMatrixlEdoublecO4UcO3UcOROOTcLcLMathcLcLMatRepStdlEdoublecO4cO3gRsPgRcLcLSMatrixRow_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSMatrixlEdoublecO4UcO3UcOROOTcLcLMathcLcLMatRepStdlEdoublecO4cO3gRsPgRcLcLSMatrixRow_const_Dictionary();
   static void ROOTcLcLMathcLcLSMatrixlEdoublecO4UcO3UcOROOTcLcLMathcLcLMatRepStdlEdoublecO4cO3gRsPgRcLcLSMatrixRow_const_TClassManip(TClass*);
   static void delete_ROOTcLcLMathcLcLSMatrixlEdoublecO4UcO3UcOROOTcLcLMathcLcLMatRepStdlEdoublecO4cO3gRsPgRcLcLSMatrixRow_const(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO4UcO3UcOROOTcLcLMathcLcLMatRepStdlEdoublecO4cO3gRsPgRcLcLSMatrixRow_const(void *p);
   static void destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO4UcO3UcOROOTcLcLMathcLcLMatRepStdlEdoublecO4cO3gRsPgRcLcLSMatrixRow_const(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SMatrix<double,4U,3U,ROOT::Math::MatRepStd<double,4,3> >::SMatrixRow_const*)
   {
      ::ROOT::Math::SMatrix<double,4U,3U,ROOT::Math::MatRepStd<double,4,3> >::SMatrixRow_const *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SMatrix<double,4U,3U,ROOT::Math::MatRepStd<double,4,3> >::SMatrixRow_const));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SMatrix<double,4U,3U,ROOT::Math::MatRepStd<double,4,3> >::SMatrixRow_const", "Math/SMatrix.h", 382,
                  typeid(::ROOT::Math::SMatrix<double,4U,3U,ROOT::Math::MatRepStd<double,4,3> >::SMatrixRow_const), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSMatrixlEdoublecO4UcO3UcOROOTcLcLMathcLcLMatRepStdlEdoublecO4cO3gRsPgRcLcLSMatrixRow_const_Dictionary, isa_proxy, 0,
                  sizeof(::ROOT::Math::SMatrix<double,4U,3U,ROOT::Math::MatRepStd<double,4,3> >::SMatrixRow_const) );
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSMatrixlEdoublecO4UcO3UcOROOTcLcLMathcLcLMatRepStdlEdoublecO4cO3gRsPgRcLcLSMatrixRow_const);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO4UcO3UcOROOTcLcLMathcLcLMatRepStdlEdoublecO4cO3gRsPgRcLcLSMatrixRow_const);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO4UcO3UcOROOTcLcLMathcLcLMatRepStdlEdoublecO4cO3gRsPgRcLcLSMatrixRow_const);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<double,4U,3U,ROOT::Math::MatRepStd<double,4,3> >::SMatrixRow_const","ROOT::Math::SMatrix<double,4,3>::SMatrixRow_const"));

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<double,4U,3U,ROOT::Math::MatRepStd<double,4,3> >::SMatrixRow_const","ROOT::Math::SMatrix<double, 4u, 3u, ROOT::Math::MatRepStd<double, 4u, 3u> >::SMatrixRow_const"));
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::SMatrix<double,4U,3U,ROOT::Math::MatRepStd<double,4,3> >::SMatrixRow_const*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::SMatrix<double,4U,3U,ROOT::Math::MatRepStd<double,4,3> >::SMatrixRow_const*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<double,4U,3U,ROOT::Math::MatRepStd<double,4,3> >::SMatrixRow_const*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLSMatrixlEdoublecO4UcO3UcOROOTcLcLMathcLcLMatRepStdlEdoublecO4cO3gRsPgRcLcLSMatrixRow_const_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<double,4U,3U,ROOT::Math::MatRepStd<double,4,3> >::SMatrixRow_const*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLSMatrixlEdoublecO4UcO3UcOROOTcLcLMathcLcLMatRepStdlEdoublecO4cO3gRsPgRcLcLSMatrixRow_const_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLSMatrixlEdoublecO4UcO3UcOROOTcLcLMathcLcLMatRepStdlEdoublecO4cO3gRsPgRcLcLSMatrixRow_const_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSMatrixlEdoublecO3cO4cOROOTcLcLMathcLcLMatRepStdlEdoublecO3cO4gRsPgR_Dictionary();
   static void ROOTcLcLMathcLcLSMatrixlEdoublecO3cO4cOROOTcLcLMathcLcLMatRepStdlEdoublecO3cO4gRsPgR_TClassManip(TClass*);
   static void *new_ROOTcLcLMathcLcLSMatrixlEdoublecO3cO4cOROOTcLcLMathcLcLMatRepStdlEdoublecO3cO4gRsPgR(void *p = nullptr);
   static void *newArray_ROOTcLcLMathcLcLSMatrixlEdoublecO3cO4cOROOTcLcLMathcLcLMatRepStdlEdoublecO3cO4gRsPgR(Long_t size, void *p);
   static void delete_ROOTcLcLMathcLcLSMatrixlEdoublecO3cO4cOROOTcLcLMathcLcLMatRepStdlEdoublecO3cO4gRsPgR(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO3cO4cOROOTcLcLMathcLcLMatRepStdlEdoublecO3cO4gRsPgR(void *p);
   static void destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO3cO4cOROOTcLcLMathcLcLMatRepStdlEdoublecO3cO4gRsPgR(void *p);

   // Schema evolution read functions

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SMatrix<double,3,4,ROOT::Math::MatRepStd<double,3,4> >*)
   {
      ::ROOT::Math::SMatrix<double,3,4,ROOT::Math::MatRepStd<double,3,4> > *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SMatrix<double,3,4,ROOT::Math::MatRepStd<double,3,4> >));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SMatrix<double,3,4,ROOT::Math::MatRepStd<double,3,4> >", "Math/SMatrix.h", 101,
                  typeid(::ROOT::Math::SMatrix<double,3,4,ROOT::Math::MatRepStd<double,3,4> >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSMatrixlEdoublecO3cO4cOROOTcLcLMathcLcLMatRepStdlEdoublecO3cO4gRsPgR_Dictionary, isa_proxy, 4,
                  sizeof(::ROOT::Math::SMatrix<double,3,4,ROOT::Math::MatRepStd<double,3,4> >) );
      instance.SetNew(&new_ROOTcLcLMathcLcLSMatrixlEdoublecO3cO4cOROOTcLcLMathcLcLMatRepStdlEdoublecO3cO4gRsPgR);
      instance.SetNewArray(&newArray_ROOTcLcLMathcLcLSMatrixlEdoublecO3cO4cOROOTcLcLMathcLcLMatRepStdlEdoublecO3cO4gRsPgR);
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSMatrixlEdoublecO3cO4cOROOTcLcLMathcLcLMatRepStdlEdoublecO3cO4gRsPgR);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO3cO4cOROOTcLcLMathcLcLMatRepStdlEdoublecO3cO4gRsPgR);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO3cO4cOROOTcLcLMathcLcLMatRepStdlEdoublecO3cO4gRsPgR);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<double,3,4,ROOT::Math::MatRepStd<double,3,4> >","ROOT::Math::SMatrix<double,3,4>"));

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<double,3,4,ROOT::Math::MatRepStd<double,3,4> >","ROOT::Math::SMatrix<double, 3u, 4u, ROOT::Math::MatRepStd<double, 3u, 4u> >"));

      ::ROOT::Internal::TSchemaHelper* rule;

      // the io read rules
      std::vector<::ROOT::Internal::TSchemaHelper> readrules(3);
      rule = &readrules[0];
      rule->fSourceClass = "ROOT::Math::SMatrix<Double32_t,3,4>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[1];
      rule->fSourceClass = "ROOT::Math::SMatrix<float,3,4>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[2];
      rule->fSourceClass = "ROOT::Math::SMatrix<Float16_t,3,4>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      instance.SetReadRules( readrules );
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::SMatrix<double,3,4,ROOT::Math::MatRepStd<double,3,4> >*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::SMatrix<double,3,4,ROOT::Math::MatRepStd<double,3,4> >*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<double,3,4,ROOT::Math::MatRepStd<double,3,4> >*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLSMatrixlEdoublecO3cO4cOROOTcLcLMathcLcLMatRepStdlEdoublecO3cO4gRsPgR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<double,3,4,ROOT::Math::MatRepStd<double,3,4> >*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLSMatrixlEdoublecO3cO4cOROOTcLcLMathcLcLMatRepStdlEdoublecO3cO4gRsPgR_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLSMatrixlEdoublecO3cO4cOROOTcLcLMathcLcLMatRepStdlEdoublecO3cO4gRsPgR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSMatrixlEdoublecO3UcO4UcOROOTcLcLMathcLcLMatRepStdlEdoublecO3cO4gRsPgRcLcLSMatrixRow_Dictionary();
   static void ROOTcLcLMathcLcLSMatrixlEdoublecO3UcO4UcOROOTcLcLMathcLcLMatRepStdlEdoublecO3cO4gRsPgRcLcLSMatrixRow_TClassManip(TClass*);
   static void delete_ROOTcLcLMathcLcLSMatrixlEdoublecO3UcO4UcOROOTcLcLMathcLcLMatRepStdlEdoublecO3cO4gRsPgRcLcLSMatrixRow(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO3UcO4UcOROOTcLcLMathcLcLMatRepStdlEdoublecO3cO4gRsPgRcLcLSMatrixRow(void *p);
   static void destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO3UcO4UcOROOTcLcLMathcLcLMatRepStdlEdoublecO3cO4gRsPgRcLcLSMatrixRow(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SMatrix<double,3U,4U,ROOT::Math::MatRepStd<double,3,4> >::SMatrixRow*)
   {
      ::ROOT::Math::SMatrix<double,3U,4U,ROOT::Math::MatRepStd<double,3,4> >::SMatrixRow *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SMatrix<double,3U,4U,ROOT::Math::MatRepStd<double,3,4> >::SMatrixRow));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SMatrix<double,3U,4U,ROOT::Math::MatRepStd<double,3,4> >::SMatrixRow", "Math/SMatrix.h", 371,
                  typeid(::ROOT::Math::SMatrix<double,3U,4U,ROOT::Math::MatRepStd<double,3,4> >::SMatrixRow), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSMatrixlEdoublecO3UcO4UcOROOTcLcLMathcLcLMatRepStdlEdoublecO3cO4gRsPgRcLcLSMatrixRow_Dictionary, isa_proxy, 0,
                  sizeof(::ROOT::Math::SMatrix<double,3U,4U,ROOT::Math::MatRepStd<double,3,4> >::SMatrixRow) );
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSMatrixlEdoublecO3UcO4UcOROOTcLcLMathcLcLMatRepStdlEdoublecO3cO4gRsPgRcLcLSMatrixRow);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO3UcO4UcOROOTcLcLMathcLcLMatRepStdlEdoublecO3cO4gRsPgRcLcLSMatrixRow);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO3UcO4UcOROOTcLcLMathcLcLMatRepStdlEdoublecO3cO4gRsPgRcLcLSMatrixRow);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<double,3U,4U,ROOT::Math::MatRepStd<double,3,4> >::SMatrixRow","ROOT::Math::SMatrix<double,3,4>::SMatrixRow"));

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<double,3U,4U,ROOT::Math::MatRepStd<double,3,4> >::SMatrixRow","ROOT::Math::SMatrix<double, 3u, 4u, ROOT::Math::MatRepStd<double, 3u, 4u> >::SMatrixRow"));
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::SMatrix<double,3U,4U,ROOT::Math::MatRepStd<double,3,4> >::SMatrixRow*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::SMatrix<double,3U,4U,ROOT::Math::MatRepStd<double,3,4> >::SMatrixRow*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<double,3U,4U,ROOT::Math::MatRepStd<double,3,4> >::SMatrixRow*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLSMatrixlEdoublecO3UcO4UcOROOTcLcLMathcLcLMatRepStdlEdoublecO3cO4gRsPgRcLcLSMatrixRow_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<double,3U,4U,ROOT::Math::MatRepStd<double,3,4> >::SMatrixRow*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLSMatrixlEdoublecO3UcO4UcOROOTcLcLMathcLcLMatRepStdlEdoublecO3cO4gRsPgRcLcLSMatrixRow_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLSMatrixlEdoublecO3UcO4UcOROOTcLcLMathcLcLMatRepStdlEdoublecO3cO4gRsPgRcLcLSMatrixRow_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSMatrixlEdoublecO3UcO4UcOROOTcLcLMathcLcLMatRepStdlEdoublecO3cO4gRsPgRcLcLSMatrixRow_const_Dictionary();
   static void ROOTcLcLMathcLcLSMatrixlEdoublecO3UcO4UcOROOTcLcLMathcLcLMatRepStdlEdoublecO3cO4gRsPgRcLcLSMatrixRow_const_TClassManip(TClass*);
   static void delete_ROOTcLcLMathcLcLSMatrixlEdoublecO3UcO4UcOROOTcLcLMathcLcLMatRepStdlEdoublecO3cO4gRsPgRcLcLSMatrixRow_const(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO3UcO4UcOROOTcLcLMathcLcLMatRepStdlEdoublecO3cO4gRsPgRcLcLSMatrixRow_const(void *p);
   static void destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO3UcO4UcOROOTcLcLMathcLcLMatRepStdlEdoublecO3cO4gRsPgRcLcLSMatrixRow_const(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SMatrix<double,3U,4U,ROOT::Math::MatRepStd<double,3,4> >::SMatrixRow_const*)
   {
      ::ROOT::Math::SMatrix<double,3U,4U,ROOT::Math::MatRepStd<double,3,4> >::SMatrixRow_const *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SMatrix<double,3U,4U,ROOT::Math::MatRepStd<double,3,4> >::SMatrixRow_const));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SMatrix<double,3U,4U,ROOT::Math::MatRepStd<double,3,4> >::SMatrixRow_const", "Math/SMatrix.h", 382,
                  typeid(::ROOT::Math::SMatrix<double,3U,4U,ROOT::Math::MatRepStd<double,3,4> >::SMatrixRow_const), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSMatrixlEdoublecO3UcO4UcOROOTcLcLMathcLcLMatRepStdlEdoublecO3cO4gRsPgRcLcLSMatrixRow_const_Dictionary, isa_proxy, 0,
                  sizeof(::ROOT::Math::SMatrix<double,3U,4U,ROOT::Math::MatRepStd<double,3,4> >::SMatrixRow_const) );
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSMatrixlEdoublecO3UcO4UcOROOTcLcLMathcLcLMatRepStdlEdoublecO3cO4gRsPgRcLcLSMatrixRow_const);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO3UcO4UcOROOTcLcLMathcLcLMatRepStdlEdoublecO3cO4gRsPgRcLcLSMatrixRow_const);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO3UcO4UcOROOTcLcLMathcLcLMatRepStdlEdoublecO3cO4gRsPgRcLcLSMatrixRow_const);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<double,3U,4U,ROOT::Math::MatRepStd<double,3,4> >::SMatrixRow_const","ROOT::Math::SMatrix<double,3,4>::SMatrixRow_const"));

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<double,3U,4U,ROOT::Math::MatRepStd<double,3,4> >::SMatrixRow_const","ROOT::Math::SMatrix<double, 3u, 4u, ROOT::Math::MatRepStd<double, 3u, 4u> >::SMatrixRow_const"));
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::SMatrix<double,3U,4U,ROOT::Math::MatRepStd<double,3,4> >::SMatrixRow_const*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::SMatrix<double,3U,4U,ROOT::Math::MatRepStd<double,3,4> >::SMatrixRow_const*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<double,3U,4U,ROOT::Math::MatRepStd<double,3,4> >::SMatrixRow_const*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLSMatrixlEdoublecO3UcO4UcOROOTcLcLMathcLcLMatRepStdlEdoublecO3cO4gRsPgRcLcLSMatrixRow_const_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<double,3U,4U,ROOT::Math::MatRepStd<double,3,4> >::SMatrixRow_const*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLSMatrixlEdoublecO3UcO4UcOROOTcLcLMathcLcLMatRepStdlEdoublecO3cO4gRsPgRcLcLSMatrixRow_const_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLSMatrixlEdoublecO3UcO4UcOROOTcLcLMathcLcLMatRepStdlEdoublecO3cO4gRsPgRcLcLSMatrixRow_const_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSMatrixlEdoublecO9cO7cOROOTcLcLMathcLcLMatRepStdlEdoublecO9cO7gRsPgR_Dictionary();
   static void ROOTcLcLMathcLcLSMatrixlEdoublecO9cO7cOROOTcLcLMathcLcLMatRepStdlEdoublecO9cO7gRsPgR_TClassManip(TClass*);
   static void *new_ROOTcLcLMathcLcLSMatrixlEdoublecO9cO7cOROOTcLcLMathcLcLMatRepStdlEdoublecO9cO7gRsPgR(void *p = nullptr);
   static void *newArray_ROOTcLcLMathcLcLSMatrixlEdoublecO9cO7cOROOTcLcLMathcLcLMatRepStdlEdoublecO9cO7gRsPgR(Long_t size, void *p);
   static void delete_ROOTcLcLMathcLcLSMatrixlEdoublecO9cO7cOROOTcLcLMathcLcLMatRepStdlEdoublecO9cO7gRsPgR(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO9cO7cOROOTcLcLMathcLcLMatRepStdlEdoublecO9cO7gRsPgR(void *p);
   static void destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO9cO7cOROOTcLcLMathcLcLMatRepStdlEdoublecO9cO7gRsPgR(void *p);

   // Schema evolution read functions

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SMatrix<double,9,7,ROOT::Math::MatRepStd<double,9,7> >*)
   {
      ::ROOT::Math::SMatrix<double,9,7,ROOT::Math::MatRepStd<double,9,7> > *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SMatrix<double,9,7,ROOT::Math::MatRepStd<double,9,7> >));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SMatrix<double,9,7,ROOT::Math::MatRepStd<double,9,7> >", "Math/SMatrix.h", 101,
                  typeid(::ROOT::Math::SMatrix<double,9,7,ROOT::Math::MatRepStd<double,9,7> >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSMatrixlEdoublecO9cO7cOROOTcLcLMathcLcLMatRepStdlEdoublecO9cO7gRsPgR_Dictionary, isa_proxy, 4,
                  sizeof(::ROOT::Math::SMatrix<double,9,7,ROOT::Math::MatRepStd<double,9,7> >) );
      instance.SetNew(&new_ROOTcLcLMathcLcLSMatrixlEdoublecO9cO7cOROOTcLcLMathcLcLMatRepStdlEdoublecO9cO7gRsPgR);
      instance.SetNewArray(&newArray_ROOTcLcLMathcLcLSMatrixlEdoublecO9cO7cOROOTcLcLMathcLcLMatRepStdlEdoublecO9cO7gRsPgR);
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSMatrixlEdoublecO9cO7cOROOTcLcLMathcLcLMatRepStdlEdoublecO9cO7gRsPgR);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO9cO7cOROOTcLcLMathcLcLMatRepStdlEdoublecO9cO7gRsPgR);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO9cO7cOROOTcLcLMathcLcLMatRepStdlEdoublecO9cO7gRsPgR);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<double,9,7,ROOT::Math::MatRepStd<double,9,7> >","ROOT::Math::SMatrix<double,9,7>"));

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<double,9,7,ROOT::Math::MatRepStd<double,9,7> >","ROOT::Math::SMatrix<double, 9u, 7u, ROOT::Math::MatRepStd<double, 9u, 7u> >"));

      ::ROOT::Internal::TSchemaHelper* rule;

      // the io read rules
      std::vector<::ROOT::Internal::TSchemaHelper> readrules(3);
      rule = &readrules[0];
      rule->fSourceClass = "ROOT::Math::SMatrix<Double32_t,9,7>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[1];
      rule->fSourceClass = "ROOT::Math::SMatrix<float,9,7>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[2];
      rule->fSourceClass = "ROOT::Math::SMatrix<Float16_t,9,7>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      instance.SetReadRules( readrules );
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::SMatrix<double,9,7,ROOT::Math::MatRepStd<double,9,7> >*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::SMatrix<double,9,7,ROOT::Math::MatRepStd<double,9,7> >*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<double,9,7,ROOT::Math::MatRepStd<double,9,7> >*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLSMatrixlEdoublecO9cO7cOROOTcLcLMathcLcLMatRepStdlEdoublecO9cO7gRsPgR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<double,9,7,ROOT::Math::MatRepStd<double,9,7> >*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLSMatrixlEdoublecO9cO7cOROOTcLcLMathcLcLMatRepStdlEdoublecO9cO7gRsPgR_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLSMatrixlEdoublecO9cO7cOROOTcLcLMathcLcLMatRepStdlEdoublecO9cO7gRsPgR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSMatrixlEdoublecO9UcO7UcOROOTcLcLMathcLcLMatRepStdlEdoublecO9cO7gRsPgRcLcLSMatrixRow_Dictionary();
   static void ROOTcLcLMathcLcLSMatrixlEdoublecO9UcO7UcOROOTcLcLMathcLcLMatRepStdlEdoublecO9cO7gRsPgRcLcLSMatrixRow_TClassManip(TClass*);
   static void delete_ROOTcLcLMathcLcLSMatrixlEdoublecO9UcO7UcOROOTcLcLMathcLcLMatRepStdlEdoublecO9cO7gRsPgRcLcLSMatrixRow(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO9UcO7UcOROOTcLcLMathcLcLMatRepStdlEdoublecO9cO7gRsPgRcLcLSMatrixRow(void *p);
   static void destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO9UcO7UcOROOTcLcLMathcLcLMatRepStdlEdoublecO9cO7gRsPgRcLcLSMatrixRow(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SMatrix<double,9U,7U,ROOT::Math::MatRepStd<double,9,7> >::SMatrixRow*)
   {
      ::ROOT::Math::SMatrix<double,9U,7U,ROOT::Math::MatRepStd<double,9,7> >::SMatrixRow *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SMatrix<double,9U,7U,ROOT::Math::MatRepStd<double,9,7> >::SMatrixRow));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SMatrix<double,9U,7U,ROOT::Math::MatRepStd<double,9,7> >::SMatrixRow", "Math/SMatrix.h", 371,
                  typeid(::ROOT::Math::SMatrix<double,9U,7U,ROOT::Math::MatRepStd<double,9,7> >::SMatrixRow), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSMatrixlEdoublecO9UcO7UcOROOTcLcLMathcLcLMatRepStdlEdoublecO9cO7gRsPgRcLcLSMatrixRow_Dictionary, isa_proxy, 0,
                  sizeof(::ROOT::Math::SMatrix<double,9U,7U,ROOT::Math::MatRepStd<double,9,7> >::SMatrixRow) );
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSMatrixlEdoublecO9UcO7UcOROOTcLcLMathcLcLMatRepStdlEdoublecO9cO7gRsPgRcLcLSMatrixRow);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO9UcO7UcOROOTcLcLMathcLcLMatRepStdlEdoublecO9cO7gRsPgRcLcLSMatrixRow);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO9UcO7UcOROOTcLcLMathcLcLMatRepStdlEdoublecO9cO7gRsPgRcLcLSMatrixRow);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<double,9U,7U,ROOT::Math::MatRepStd<double,9,7> >::SMatrixRow","ROOT::Math::SMatrix<double,9,7>::SMatrixRow"));

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<double,9U,7U,ROOT::Math::MatRepStd<double,9,7> >::SMatrixRow","ROOT::Math::SMatrix<double, 9u, 7u, ROOT::Math::MatRepStd<double, 9u, 7u> >::SMatrixRow"));
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::SMatrix<double,9U,7U,ROOT::Math::MatRepStd<double,9,7> >::SMatrixRow*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::SMatrix<double,9U,7U,ROOT::Math::MatRepStd<double,9,7> >::SMatrixRow*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<double,9U,7U,ROOT::Math::MatRepStd<double,9,7> >::SMatrixRow*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLSMatrixlEdoublecO9UcO7UcOROOTcLcLMathcLcLMatRepStdlEdoublecO9cO7gRsPgRcLcLSMatrixRow_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<double,9U,7U,ROOT::Math::MatRepStd<double,9,7> >::SMatrixRow*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLSMatrixlEdoublecO9UcO7UcOROOTcLcLMathcLcLMatRepStdlEdoublecO9cO7gRsPgRcLcLSMatrixRow_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLSMatrixlEdoublecO9UcO7UcOROOTcLcLMathcLcLMatRepStdlEdoublecO9cO7gRsPgRcLcLSMatrixRow_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSMatrixlEdoublecO9UcO7UcOROOTcLcLMathcLcLMatRepStdlEdoublecO9cO7gRsPgRcLcLSMatrixRow_const_Dictionary();
   static void ROOTcLcLMathcLcLSMatrixlEdoublecO9UcO7UcOROOTcLcLMathcLcLMatRepStdlEdoublecO9cO7gRsPgRcLcLSMatrixRow_const_TClassManip(TClass*);
   static void delete_ROOTcLcLMathcLcLSMatrixlEdoublecO9UcO7UcOROOTcLcLMathcLcLMatRepStdlEdoublecO9cO7gRsPgRcLcLSMatrixRow_const(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO9UcO7UcOROOTcLcLMathcLcLMatRepStdlEdoublecO9cO7gRsPgRcLcLSMatrixRow_const(void *p);
   static void destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO9UcO7UcOROOTcLcLMathcLcLMatRepStdlEdoublecO9cO7gRsPgRcLcLSMatrixRow_const(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SMatrix<double,9U,7U,ROOT::Math::MatRepStd<double,9,7> >::SMatrixRow_const*)
   {
      ::ROOT::Math::SMatrix<double,9U,7U,ROOT::Math::MatRepStd<double,9,7> >::SMatrixRow_const *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SMatrix<double,9U,7U,ROOT::Math::MatRepStd<double,9,7> >::SMatrixRow_const));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SMatrix<double,9U,7U,ROOT::Math::MatRepStd<double,9,7> >::SMatrixRow_const", "Math/SMatrix.h", 382,
                  typeid(::ROOT::Math::SMatrix<double,9U,7U,ROOT::Math::MatRepStd<double,9,7> >::SMatrixRow_const), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSMatrixlEdoublecO9UcO7UcOROOTcLcLMathcLcLMatRepStdlEdoublecO9cO7gRsPgRcLcLSMatrixRow_const_Dictionary, isa_proxy, 0,
                  sizeof(::ROOT::Math::SMatrix<double,9U,7U,ROOT::Math::MatRepStd<double,9,7> >::SMatrixRow_const) );
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSMatrixlEdoublecO9UcO7UcOROOTcLcLMathcLcLMatRepStdlEdoublecO9cO7gRsPgRcLcLSMatrixRow_const);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO9UcO7UcOROOTcLcLMathcLcLMatRepStdlEdoublecO9cO7gRsPgRcLcLSMatrixRow_const);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO9UcO7UcOROOTcLcLMathcLcLMatRepStdlEdoublecO9cO7gRsPgRcLcLSMatrixRow_const);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<double,9U,7U,ROOT::Math::MatRepStd<double,9,7> >::SMatrixRow_const","ROOT::Math::SMatrix<double,9,7>::SMatrixRow_const"));

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<double,9U,7U,ROOT::Math::MatRepStd<double,9,7> >::SMatrixRow_const","ROOT::Math::SMatrix<double, 9u, 7u, ROOT::Math::MatRepStd<double, 9u, 7u> >::SMatrixRow_const"));
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::SMatrix<double,9U,7U,ROOT::Math::MatRepStd<double,9,7> >::SMatrixRow_const*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::SMatrix<double,9U,7U,ROOT::Math::MatRepStd<double,9,7> >::SMatrixRow_const*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<double,9U,7U,ROOT::Math::MatRepStd<double,9,7> >::SMatrixRow_const*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLSMatrixlEdoublecO9UcO7UcOROOTcLcLMathcLcLMatRepStdlEdoublecO9cO7gRsPgRcLcLSMatrixRow_const_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<double,9U,7U,ROOT::Math::MatRepStd<double,9,7> >::SMatrixRow_const*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLSMatrixlEdoublecO9UcO7UcOROOTcLcLMathcLcLMatRepStdlEdoublecO9cO7gRsPgRcLcLSMatrixRow_const_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLSMatrixlEdoublecO9UcO7UcOROOTcLcLMathcLcLMatRepStdlEdoublecO9cO7gRsPgRcLcLSMatrixRow_const_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSMatrixlEfloatcO4cO3cOROOTcLcLMathcLcLMatRepStdlEfloatcO4cO3gRsPgR_Dictionary();
   static void ROOTcLcLMathcLcLSMatrixlEfloatcO4cO3cOROOTcLcLMathcLcLMatRepStdlEfloatcO4cO3gRsPgR_TClassManip(TClass*);
   static void *new_ROOTcLcLMathcLcLSMatrixlEfloatcO4cO3cOROOTcLcLMathcLcLMatRepStdlEfloatcO4cO3gRsPgR(void *p = nullptr);
   static void *newArray_ROOTcLcLMathcLcLSMatrixlEfloatcO4cO3cOROOTcLcLMathcLcLMatRepStdlEfloatcO4cO3gRsPgR(Long_t size, void *p);
   static void delete_ROOTcLcLMathcLcLSMatrixlEfloatcO4cO3cOROOTcLcLMathcLcLMatRepStdlEfloatcO4cO3gRsPgR(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO4cO3cOROOTcLcLMathcLcLMatRepStdlEfloatcO4cO3gRsPgR(void *p);
   static void destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO4cO3cOROOTcLcLMathcLcLMatRepStdlEfloatcO4cO3gRsPgR(void *p);

   // Schema evolution read functions

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SMatrix<float,4,3,ROOT::Math::MatRepStd<float,4,3> >*)
   {
      ::ROOT::Math::SMatrix<float,4,3,ROOT::Math::MatRepStd<float,4,3> > *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SMatrix<float,4,3,ROOT::Math::MatRepStd<float,4,3> >));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SMatrix<float,4,3,ROOT::Math::MatRepStd<float,4,3> >", "Math/SMatrix.h", 101,
                  typeid(::ROOT::Math::SMatrix<float,4,3,ROOT::Math::MatRepStd<float,4,3> >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSMatrixlEfloatcO4cO3cOROOTcLcLMathcLcLMatRepStdlEfloatcO4cO3gRsPgR_Dictionary, isa_proxy, 4,
                  sizeof(::ROOT::Math::SMatrix<float,4,3,ROOT::Math::MatRepStd<float,4,3> >) );
      instance.SetNew(&new_ROOTcLcLMathcLcLSMatrixlEfloatcO4cO3cOROOTcLcLMathcLcLMatRepStdlEfloatcO4cO3gRsPgR);
      instance.SetNewArray(&newArray_ROOTcLcLMathcLcLSMatrixlEfloatcO4cO3cOROOTcLcLMathcLcLMatRepStdlEfloatcO4cO3gRsPgR);
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSMatrixlEfloatcO4cO3cOROOTcLcLMathcLcLMatRepStdlEfloatcO4cO3gRsPgR);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO4cO3cOROOTcLcLMathcLcLMatRepStdlEfloatcO4cO3gRsPgR);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO4cO3cOROOTcLcLMathcLcLMatRepStdlEfloatcO4cO3gRsPgR);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<float,4,3,ROOT::Math::MatRepStd<float,4,3> >","ROOT::Math::SMatrix<float,4,3>"));

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<float,4,3,ROOT::Math::MatRepStd<float,4,3> >","ROOT::Math::SMatrix<float, 4u, 3u, ROOT::Math::MatRepStd<float, 4u, 3u> >"));

      ::ROOT::Internal::TSchemaHelper* rule;

      // the io read rules
      std::vector<::ROOT::Internal::TSchemaHelper> readrules(3);
      rule = &readrules[0];
      rule->fSourceClass = "ROOT::Math::SMatrix<double,4,3>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[1];
      rule->fSourceClass = "ROOT::Math::SMatrix<Double32_t,4,3>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[2];
      rule->fSourceClass = "ROOT::Math::SMatrix<Float16_t,4,3>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      instance.SetReadRules( readrules );
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::SMatrix<float,4,3,ROOT::Math::MatRepStd<float,4,3> >*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::SMatrix<float,4,3,ROOT::Math::MatRepStd<float,4,3> >*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<float,4,3,ROOT::Math::MatRepStd<float,4,3> >*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLSMatrixlEfloatcO4cO3cOROOTcLcLMathcLcLMatRepStdlEfloatcO4cO3gRsPgR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<float,4,3,ROOT::Math::MatRepStd<float,4,3> >*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLSMatrixlEfloatcO4cO3cOROOTcLcLMathcLcLMatRepStdlEfloatcO4cO3gRsPgR_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLSMatrixlEfloatcO4cO3cOROOTcLcLMathcLcLMatRepStdlEfloatcO4cO3gRsPgR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSMatrixlEfloatcO4UcO3UcOROOTcLcLMathcLcLMatRepStdlEfloatcO4cO3gRsPgRcLcLSMatrixRow_Dictionary();
   static void ROOTcLcLMathcLcLSMatrixlEfloatcO4UcO3UcOROOTcLcLMathcLcLMatRepStdlEfloatcO4cO3gRsPgRcLcLSMatrixRow_TClassManip(TClass*);
   static void delete_ROOTcLcLMathcLcLSMatrixlEfloatcO4UcO3UcOROOTcLcLMathcLcLMatRepStdlEfloatcO4cO3gRsPgRcLcLSMatrixRow(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO4UcO3UcOROOTcLcLMathcLcLMatRepStdlEfloatcO4cO3gRsPgRcLcLSMatrixRow(void *p);
   static void destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO4UcO3UcOROOTcLcLMathcLcLMatRepStdlEfloatcO4cO3gRsPgRcLcLSMatrixRow(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SMatrix<float,4U,3U,ROOT::Math::MatRepStd<float,4,3> >::SMatrixRow*)
   {
      ::ROOT::Math::SMatrix<float,4U,3U,ROOT::Math::MatRepStd<float,4,3> >::SMatrixRow *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SMatrix<float,4U,3U,ROOT::Math::MatRepStd<float,4,3> >::SMatrixRow));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SMatrix<float,4U,3U,ROOT::Math::MatRepStd<float,4,3> >::SMatrixRow", "Math/SMatrix.h", 371,
                  typeid(::ROOT::Math::SMatrix<float,4U,3U,ROOT::Math::MatRepStd<float,4,3> >::SMatrixRow), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSMatrixlEfloatcO4UcO3UcOROOTcLcLMathcLcLMatRepStdlEfloatcO4cO3gRsPgRcLcLSMatrixRow_Dictionary, isa_proxy, 0,
                  sizeof(::ROOT::Math::SMatrix<float,4U,3U,ROOT::Math::MatRepStd<float,4,3> >::SMatrixRow) );
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSMatrixlEfloatcO4UcO3UcOROOTcLcLMathcLcLMatRepStdlEfloatcO4cO3gRsPgRcLcLSMatrixRow);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO4UcO3UcOROOTcLcLMathcLcLMatRepStdlEfloatcO4cO3gRsPgRcLcLSMatrixRow);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO4UcO3UcOROOTcLcLMathcLcLMatRepStdlEfloatcO4cO3gRsPgRcLcLSMatrixRow);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<float,4U,3U,ROOT::Math::MatRepStd<float,4,3> >::SMatrixRow","ROOT::Math::SMatrix<float,4,3>::SMatrixRow"));

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<float,4U,3U,ROOT::Math::MatRepStd<float,4,3> >::SMatrixRow","ROOT::Math::SMatrix<float, 4u, 3u, ROOT::Math::MatRepStd<float, 4u, 3u> >::SMatrixRow"));
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::SMatrix<float,4U,3U,ROOT::Math::MatRepStd<float,4,3> >::SMatrixRow*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::SMatrix<float,4U,3U,ROOT::Math::MatRepStd<float,4,3> >::SMatrixRow*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<float,4U,3U,ROOT::Math::MatRepStd<float,4,3> >::SMatrixRow*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLSMatrixlEfloatcO4UcO3UcOROOTcLcLMathcLcLMatRepStdlEfloatcO4cO3gRsPgRcLcLSMatrixRow_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<float,4U,3U,ROOT::Math::MatRepStd<float,4,3> >::SMatrixRow*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLSMatrixlEfloatcO4UcO3UcOROOTcLcLMathcLcLMatRepStdlEfloatcO4cO3gRsPgRcLcLSMatrixRow_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLSMatrixlEfloatcO4UcO3UcOROOTcLcLMathcLcLMatRepStdlEfloatcO4cO3gRsPgRcLcLSMatrixRow_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSMatrixlEfloatcO4UcO3UcOROOTcLcLMathcLcLMatRepStdlEfloatcO4cO3gRsPgRcLcLSMatrixRow_const_Dictionary();
   static void ROOTcLcLMathcLcLSMatrixlEfloatcO4UcO3UcOROOTcLcLMathcLcLMatRepStdlEfloatcO4cO3gRsPgRcLcLSMatrixRow_const_TClassManip(TClass*);
   static void delete_ROOTcLcLMathcLcLSMatrixlEfloatcO4UcO3UcOROOTcLcLMathcLcLMatRepStdlEfloatcO4cO3gRsPgRcLcLSMatrixRow_const(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO4UcO3UcOROOTcLcLMathcLcLMatRepStdlEfloatcO4cO3gRsPgRcLcLSMatrixRow_const(void *p);
   static void destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO4UcO3UcOROOTcLcLMathcLcLMatRepStdlEfloatcO4cO3gRsPgRcLcLSMatrixRow_const(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SMatrix<float,4U,3U,ROOT::Math::MatRepStd<float,4,3> >::SMatrixRow_const*)
   {
      ::ROOT::Math::SMatrix<float,4U,3U,ROOT::Math::MatRepStd<float,4,3> >::SMatrixRow_const *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SMatrix<float,4U,3U,ROOT::Math::MatRepStd<float,4,3> >::SMatrixRow_const));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SMatrix<float,4U,3U,ROOT::Math::MatRepStd<float,4,3> >::SMatrixRow_const", "Math/SMatrix.h", 382,
                  typeid(::ROOT::Math::SMatrix<float,4U,3U,ROOT::Math::MatRepStd<float,4,3> >::SMatrixRow_const), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSMatrixlEfloatcO4UcO3UcOROOTcLcLMathcLcLMatRepStdlEfloatcO4cO3gRsPgRcLcLSMatrixRow_const_Dictionary, isa_proxy, 0,
                  sizeof(::ROOT::Math::SMatrix<float,4U,3U,ROOT::Math::MatRepStd<float,4,3> >::SMatrixRow_const) );
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSMatrixlEfloatcO4UcO3UcOROOTcLcLMathcLcLMatRepStdlEfloatcO4cO3gRsPgRcLcLSMatrixRow_const);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO4UcO3UcOROOTcLcLMathcLcLMatRepStdlEfloatcO4cO3gRsPgRcLcLSMatrixRow_const);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO4UcO3UcOROOTcLcLMathcLcLMatRepStdlEfloatcO4cO3gRsPgRcLcLSMatrixRow_const);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<float,4U,3U,ROOT::Math::MatRepStd<float,4,3> >::SMatrixRow_const","ROOT::Math::SMatrix<float,4,3>::SMatrixRow_const"));

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<float,4U,3U,ROOT::Math::MatRepStd<float,4,3> >::SMatrixRow_const","ROOT::Math::SMatrix<float, 4u, 3u, ROOT::Math::MatRepStd<float, 4u, 3u> >::SMatrixRow_const"));
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::SMatrix<float,4U,3U,ROOT::Math::MatRepStd<float,4,3> >::SMatrixRow_const*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::SMatrix<float,4U,3U,ROOT::Math::MatRepStd<float,4,3> >::SMatrixRow_const*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<float,4U,3U,ROOT::Math::MatRepStd<float,4,3> >::SMatrixRow_const*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLSMatrixlEfloatcO4UcO3UcOROOTcLcLMathcLcLMatRepStdlEfloatcO4cO3gRsPgRcLcLSMatrixRow_const_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<float,4U,3U,ROOT::Math::MatRepStd<float,4,3> >::SMatrixRow_const*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLSMatrixlEfloatcO4UcO3UcOROOTcLcLMathcLcLMatRepStdlEfloatcO4cO3gRsPgRcLcLSMatrixRow_const_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLSMatrixlEfloatcO4UcO3UcOROOTcLcLMathcLcLMatRepStdlEfloatcO4cO3gRsPgRcLcLSMatrixRow_const_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSMatrixlEfloatcO3cO4cOROOTcLcLMathcLcLMatRepStdlEfloatcO3cO4gRsPgR_Dictionary();
   static void ROOTcLcLMathcLcLSMatrixlEfloatcO3cO4cOROOTcLcLMathcLcLMatRepStdlEfloatcO3cO4gRsPgR_TClassManip(TClass*);
   static void *new_ROOTcLcLMathcLcLSMatrixlEfloatcO3cO4cOROOTcLcLMathcLcLMatRepStdlEfloatcO3cO4gRsPgR(void *p = nullptr);
   static void *newArray_ROOTcLcLMathcLcLSMatrixlEfloatcO3cO4cOROOTcLcLMathcLcLMatRepStdlEfloatcO3cO4gRsPgR(Long_t size, void *p);
   static void delete_ROOTcLcLMathcLcLSMatrixlEfloatcO3cO4cOROOTcLcLMathcLcLMatRepStdlEfloatcO3cO4gRsPgR(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO3cO4cOROOTcLcLMathcLcLMatRepStdlEfloatcO3cO4gRsPgR(void *p);
   static void destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO3cO4cOROOTcLcLMathcLcLMatRepStdlEfloatcO3cO4gRsPgR(void *p);

   // Schema evolution read functions

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SMatrix<float,3,4,ROOT::Math::MatRepStd<float,3,4> >*)
   {
      ::ROOT::Math::SMatrix<float,3,4,ROOT::Math::MatRepStd<float,3,4> > *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SMatrix<float,3,4,ROOT::Math::MatRepStd<float,3,4> >));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SMatrix<float,3,4,ROOT::Math::MatRepStd<float,3,4> >", "Math/SMatrix.h", 101,
                  typeid(::ROOT::Math::SMatrix<float,3,4,ROOT::Math::MatRepStd<float,3,4> >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSMatrixlEfloatcO3cO4cOROOTcLcLMathcLcLMatRepStdlEfloatcO3cO4gRsPgR_Dictionary, isa_proxy, 4,
                  sizeof(::ROOT::Math::SMatrix<float,3,4,ROOT::Math::MatRepStd<float,3,4> >) );
      instance.SetNew(&new_ROOTcLcLMathcLcLSMatrixlEfloatcO3cO4cOROOTcLcLMathcLcLMatRepStdlEfloatcO3cO4gRsPgR);
      instance.SetNewArray(&newArray_ROOTcLcLMathcLcLSMatrixlEfloatcO3cO4cOROOTcLcLMathcLcLMatRepStdlEfloatcO3cO4gRsPgR);
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSMatrixlEfloatcO3cO4cOROOTcLcLMathcLcLMatRepStdlEfloatcO3cO4gRsPgR);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO3cO4cOROOTcLcLMathcLcLMatRepStdlEfloatcO3cO4gRsPgR);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO3cO4cOROOTcLcLMathcLcLMatRepStdlEfloatcO3cO4gRsPgR);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<float,3,4,ROOT::Math::MatRepStd<float,3,4> >","ROOT::Math::SMatrix<float,3,4>"));

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<float,3,4,ROOT::Math::MatRepStd<float,3,4> >","ROOT::Math::SMatrix<float, 3u, 4u, ROOT::Math::MatRepStd<float, 3u, 4u> >"));

      ::ROOT::Internal::TSchemaHelper* rule;

      // the io read rules
      std::vector<::ROOT::Internal::TSchemaHelper> readrules(3);
      rule = &readrules[0];
      rule->fSourceClass = "ROOT::Math::SMatrix<double,3,4>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[1];
      rule->fSourceClass = "ROOT::Math::SMatrix<Double32_t,3,4>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[2];
      rule->fSourceClass = "ROOT::Math::SMatrix<Float16_t,3,4>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      instance.SetReadRules( readrules );
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::SMatrix<float,3,4,ROOT::Math::MatRepStd<float,3,4> >*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::SMatrix<float,3,4,ROOT::Math::MatRepStd<float,3,4> >*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<float,3,4,ROOT::Math::MatRepStd<float,3,4> >*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLSMatrixlEfloatcO3cO4cOROOTcLcLMathcLcLMatRepStdlEfloatcO3cO4gRsPgR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<float,3,4,ROOT::Math::MatRepStd<float,3,4> >*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLSMatrixlEfloatcO3cO4cOROOTcLcLMathcLcLMatRepStdlEfloatcO3cO4gRsPgR_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLSMatrixlEfloatcO3cO4cOROOTcLcLMathcLcLMatRepStdlEfloatcO3cO4gRsPgR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSMatrixlEfloatcO3UcO4UcOROOTcLcLMathcLcLMatRepStdlEfloatcO3cO4gRsPgRcLcLSMatrixRow_Dictionary();
   static void ROOTcLcLMathcLcLSMatrixlEfloatcO3UcO4UcOROOTcLcLMathcLcLMatRepStdlEfloatcO3cO4gRsPgRcLcLSMatrixRow_TClassManip(TClass*);
   static void delete_ROOTcLcLMathcLcLSMatrixlEfloatcO3UcO4UcOROOTcLcLMathcLcLMatRepStdlEfloatcO3cO4gRsPgRcLcLSMatrixRow(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO3UcO4UcOROOTcLcLMathcLcLMatRepStdlEfloatcO3cO4gRsPgRcLcLSMatrixRow(void *p);
   static void destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO3UcO4UcOROOTcLcLMathcLcLMatRepStdlEfloatcO3cO4gRsPgRcLcLSMatrixRow(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SMatrix<float,3U,4U,ROOT::Math::MatRepStd<float,3,4> >::SMatrixRow*)
   {
      ::ROOT::Math::SMatrix<float,3U,4U,ROOT::Math::MatRepStd<float,3,4> >::SMatrixRow *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SMatrix<float,3U,4U,ROOT::Math::MatRepStd<float,3,4> >::SMatrixRow));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SMatrix<float,3U,4U,ROOT::Math::MatRepStd<float,3,4> >::SMatrixRow", "Math/SMatrix.h", 371,
                  typeid(::ROOT::Math::SMatrix<float,3U,4U,ROOT::Math::MatRepStd<float,3,4> >::SMatrixRow), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSMatrixlEfloatcO3UcO4UcOROOTcLcLMathcLcLMatRepStdlEfloatcO3cO4gRsPgRcLcLSMatrixRow_Dictionary, isa_proxy, 0,
                  sizeof(::ROOT::Math::SMatrix<float,3U,4U,ROOT::Math::MatRepStd<float,3,4> >::SMatrixRow) );
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSMatrixlEfloatcO3UcO4UcOROOTcLcLMathcLcLMatRepStdlEfloatcO3cO4gRsPgRcLcLSMatrixRow);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO3UcO4UcOROOTcLcLMathcLcLMatRepStdlEfloatcO3cO4gRsPgRcLcLSMatrixRow);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO3UcO4UcOROOTcLcLMathcLcLMatRepStdlEfloatcO3cO4gRsPgRcLcLSMatrixRow);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<float,3U,4U,ROOT::Math::MatRepStd<float,3,4> >::SMatrixRow","ROOT::Math::SMatrix<float,3,4>::SMatrixRow"));

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<float,3U,4U,ROOT::Math::MatRepStd<float,3,4> >::SMatrixRow","ROOT::Math::SMatrix<float, 3u, 4u, ROOT::Math::MatRepStd<float, 3u, 4u> >::SMatrixRow"));
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::SMatrix<float,3U,4U,ROOT::Math::MatRepStd<float,3,4> >::SMatrixRow*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::SMatrix<float,3U,4U,ROOT::Math::MatRepStd<float,3,4> >::SMatrixRow*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<float,3U,4U,ROOT::Math::MatRepStd<float,3,4> >::SMatrixRow*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLSMatrixlEfloatcO3UcO4UcOROOTcLcLMathcLcLMatRepStdlEfloatcO3cO4gRsPgRcLcLSMatrixRow_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<float,3U,4U,ROOT::Math::MatRepStd<float,3,4> >::SMatrixRow*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLSMatrixlEfloatcO3UcO4UcOROOTcLcLMathcLcLMatRepStdlEfloatcO3cO4gRsPgRcLcLSMatrixRow_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLSMatrixlEfloatcO3UcO4UcOROOTcLcLMathcLcLMatRepStdlEfloatcO3cO4gRsPgRcLcLSMatrixRow_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSMatrixlEfloatcO3UcO4UcOROOTcLcLMathcLcLMatRepStdlEfloatcO3cO4gRsPgRcLcLSMatrixRow_const_Dictionary();
   static void ROOTcLcLMathcLcLSMatrixlEfloatcO3UcO4UcOROOTcLcLMathcLcLMatRepStdlEfloatcO3cO4gRsPgRcLcLSMatrixRow_const_TClassManip(TClass*);
   static void delete_ROOTcLcLMathcLcLSMatrixlEfloatcO3UcO4UcOROOTcLcLMathcLcLMatRepStdlEfloatcO3cO4gRsPgRcLcLSMatrixRow_const(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO3UcO4UcOROOTcLcLMathcLcLMatRepStdlEfloatcO3cO4gRsPgRcLcLSMatrixRow_const(void *p);
   static void destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO3UcO4UcOROOTcLcLMathcLcLMatRepStdlEfloatcO3cO4gRsPgRcLcLSMatrixRow_const(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SMatrix<float,3U,4U,ROOT::Math::MatRepStd<float,3,4> >::SMatrixRow_const*)
   {
      ::ROOT::Math::SMatrix<float,3U,4U,ROOT::Math::MatRepStd<float,3,4> >::SMatrixRow_const *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SMatrix<float,3U,4U,ROOT::Math::MatRepStd<float,3,4> >::SMatrixRow_const));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SMatrix<float,3U,4U,ROOT::Math::MatRepStd<float,3,4> >::SMatrixRow_const", "Math/SMatrix.h", 382,
                  typeid(::ROOT::Math::SMatrix<float,3U,4U,ROOT::Math::MatRepStd<float,3,4> >::SMatrixRow_const), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSMatrixlEfloatcO3UcO4UcOROOTcLcLMathcLcLMatRepStdlEfloatcO3cO4gRsPgRcLcLSMatrixRow_const_Dictionary, isa_proxy, 0,
                  sizeof(::ROOT::Math::SMatrix<float,3U,4U,ROOT::Math::MatRepStd<float,3,4> >::SMatrixRow_const) );
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSMatrixlEfloatcO3UcO4UcOROOTcLcLMathcLcLMatRepStdlEfloatcO3cO4gRsPgRcLcLSMatrixRow_const);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO3UcO4UcOROOTcLcLMathcLcLMatRepStdlEfloatcO3cO4gRsPgRcLcLSMatrixRow_const);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO3UcO4UcOROOTcLcLMathcLcLMatRepStdlEfloatcO3cO4gRsPgRcLcLSMatrixRow_const);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<float,3U,4U,ROOT::Math::MatRepStd<float,3,4> >::SMatrixRow_const","ROOT::Math::SMatrix<float,3,4>::SMatrixRow_const"));

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<float,3U,4U,ROOT::Math::MatRepStd<float,3,4> >::SMatrixRow_const","ROOT::Math::SMatrix<float, 3u, 4u, ROOT::Math::MatRepStd<float, 3u, 4u> >::SMatrixRow_const"));
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::SMatrix<float,3U,4U,ROOT::Math::MatRepStd<float,3,4> >::SMatrixRow_const*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::SMatrix<float,3U,4U,ROOT::Math::MatRepStd<float,3,4> >::SMatrixRow_const*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<float,3U,4U,ROOT::Math::MatRepStd<float,3,4> >::SMatrixRow_const*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLSMatrixlEfloatcO3UcO4UcOROOTcLcLMathcLcLMatRepStdlEfloatcO3cO4gRsPgRcLcLSMatrixRow_const_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<float,3U,4U,ROOT::Math::MatRepStd<float,3,4> >::SMatrixRow_const*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLSMatrixlEfloatcO3UcO4UcOROOTcLcLMathcLcLMatRepStdlEfloatcO3cO4gRsPgRcLcLSMatrixRow_const_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLSMatrixlEfloatcO3UcO4UcOROOTcLcLMathcLcLMatRepStdlEfloatcO3cO4gRsPgRcLcLSMatrixRow_const_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSMatrixlEfloatcO9cO7cOROOTcLcLMathcLcLMatRepStdlEfloatcO9cO7gRsPgR_Dictionary();
   static void ROOTcLcLMathcLcLSMatrixlEfloatcO9cO7cOROOTcLcLMathcLcLMatRepStdlEfloatcO9cO7gRsPgR_TClassManip(TClass*);
   static void *new_ROOTcLcLMathcLcLSMatrixlEfloatcO9cO7cOROOTcLcLMathcLcLMatRepStdlEfloatcO9cO7gRsPgR(void *p = nullptr);
   static void *newArray_ROOTcLcLMathcLcLSMatrixlEfloatcO9cO7cOROOTcLcLMathcLcLMatRepStdlEfloatcO9cO7gRsPgR(Long_t size, void *p);
   static void delete_ROOTcLcLMathcLcLSMatrixlEfloatcO9cO7cOROOTcLcLMathcLcLMatRepStdlEfloatcO9cO7gRsPgR(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO9cO7cOROOTcLcLMathcLcLMatRepStdlEfloatcO9cO7gRsPgR(void *p);
   static void destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO9cO7cOROOTcLcLMathcLcLMatRepStdlEfloatcO9cO7gRsPgR(void *p);

   // Schema evolution read functions

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SMatrix<float,9,7,ROOT::Math::MatRepStd<float,9,7> >*)
   {
      ::ROOT::Math::SMatrix<float,9,7,ROOT::Math::MatRepStd<float,9,7> > *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SMatrix<float,9,7,ROOT::Math::MatRepStd<float,9,7> >));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SMatrix<float,9,7,ROOT::Math::MatRepStd<float,9,7> >", "Math/SMatrix.h", 101,
                  typeid(::ROOT::Math::SMatrix<float,9,7,ROOT::Math::MatRepStd<float,9,7> >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSMatrixlEfloatcO9cO7cOROOTcLcLMathcLcLMatRepStdlEfloatcO9cO7gRsPgR_Dictionary, isa_proxy, 4,
                  sizeof(::ROOT::Math::SMatrix<float,9,7,ROOT::Math::MatRepStd<float,9,7> >) );
      instance.SetNew(&new_ROOTcLcLMathcLcLSMatrixlEfloatcO9cO7cOROOTcLcLMathcLcLMatRepStdlEfloatcO9cO7gRsPgR);
      instance.SetNewArray(&newArray_ROOTcLcLMathcLcLSMatrixlEfloatcO9cO7cOROOTcLcLMathcLcLMatRepStdlEfloatcO9cO7gRsPgR);
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSMatrixlEfloatcO9cO7cOROOTcLcLMathcLcLMatRepStdlEfloatcO9cO7gRsPgR);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO9cO7cOROOTcLcLMathcLcLMatRepStdlEfloatcO9cO7gRsPgR);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO9cO7cOROOTcLcLMathcLcLMatRepStdlEfloatcO9cO7gRsPgR);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<float,9,7,ROOT::Math::MatRepStd<float,9,7> >","ROOT::Math::SMatrix<float,9,7>"));

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<float,9,7,ROOT::Math::MatRepStd<float,9,7> >","ROOT::Math::SMatrix<float, 9u, 7u, ROOT::Math::MatRepStd<float, 9u, 7u> >"));

      ::ROOT::Internal::TSchemaHelper* rule;

      // the io read rules
      std::vector<::ROOT::Internal::TSchemaHelper> readrules(3);
      rule = &readrules[0];
      rule->fSourceClass = "ROOT::Math::SMatrix<double,9,7>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[1];
      rule->fSourceClass = "ROOT::Math::SMatrix<Double32_t,9,7>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[2];
      rule->fSourceClass = "ROOT::Math::SMatrix<Float16_t,9,7>";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      instance.SetReadRules( readrules );
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::SMatrix<float,9,7,ROOT::Math::MatRepStd<float,9,7> >*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::SMatrix<float,9,7,ROOT::Math::MatRepStd<float,9,7> >*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<float,9,7,ROOT::Math::MatRepStd<float,9,7> >*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLSMatrixlEfloatcO9cO7cOROOTcLcLMathcLcLMatRepStdlEfloatcO9cO7gRsPgR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<float,9,7,ROOT::Math::MatRepStd<float,9,7> >*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLSMatrixlEfloatcO9cO7cOROOTcLcLMathcLcLMatRepStdlEfloatcO9cO7gRsPgR_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLSMatrixlEfloatcO9cO7cOROOTcLcLMathcLcLMatRepStdlEfloatcO9cO7gRsPgR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSMatrixlEfloatcO9UcO7UcOROOTcLcLMathcLcLMatRepStdlEfloatcO9cO7gRsPgRcLcLSMatrixRow_Dictionary();
   static void ROOTcLcLMathcLcLSMatrixlEfloatcO9UcO7UcOROOTcLcLMathcLcLMatRepStdlEfloatcO9cO7gRsPgRcLcLSMatrixRow_TClassManip(TClass*);
   static void delete_ROOTcLcLMathcLcLSMatrixlEfloatcO9UcO7UcOROOTcLcLMathcLcLMatRepStdlEfloatcO9cO7gRsPgRcLcLSMatrixRow(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO9UcO7UcOROOTcLcLMathcLcLMatRepStdlEfloatcO9cO7gRsPgRcLcLSMatrixRow(void *p);
   static void destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO9UcO7UcOROOTcLcLMathcLcLMatRepStdlEfloatcO9cO7gRsPgRcLcLSMatrixRow(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SMatrix<float,9U,7U,ROOT::Math::MatRepStd<float,9,7> >::SMatrixRow*)
   {
      ::ROOT::Math::SMatrix<float,9U,7U,ROOT::Math::MatRepStd<float,9,7> >::SMatrixRow *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SMatrix<float,9U,7U,ROOT::Math::MatRepStd<float,9,7> >::SMatrixRow));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SMatrix<float,9U,7U,ROOT::Math::MatRepStd<float,9,7> >::SMatrixRow", "Math/SMatrix.h", 371,
                  typeid(::ROOT::Math::SMatrix<float,9U,7U,ROOT::Math::MatRepStd<float,9,7> >::SMatrixRow), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSMatrixlEfloatcO9UcO7UcOROOTcLcLMathcLcLMatRepStdlEfloatcO9cO7gRsPgRcLcLSMatrixRow_Dictionary, isa_proxy, 0,
                  sizeof(::ROOT::Math::SMatrix<float,9U,7U,ROOT::Math::MatRepStd<float,9,7> >::SMatrixRow) );
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSMatrixlEfloatcO9UcO7UcOROOTcLcLMathcLcLMatRepStdlEfloatcO9cO7gRsPgRcLcLSMatrixRow);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO9UcO7UcOROOTcLcLMathcLcLMatRepStdlEfloatcO9cO7gRsPgRcLcLSMatrixRow);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO9UcO7UcOROOTcLcLMathcLcLMatRepStdlEfloatcO9cO7gRsPgRcLcLSMatrixRow);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<float,9U,7U,ROOT::Math::MatRepStd<float,9,7> >::SMatrixRow","ROOT::Math::SMatrix<float,9,7>::SMatrixRow"));

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<float,9U,7U,ROOT::Math::MatRepStd<float,9,7> >::SMatrixRow","ROOT::Math::SMatrix<float, 9u, 7u, ROOT::Math::MatRepStd<float, 9u, 7u> >::SMatrixRow"));
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::SMatrix<float,9U,7U,ROOT::Math::MatRepStd<float,9,7> >::SMatrixRow*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::SMatrix<float,9U,7U,ROOT::Math::MatRepStd<float,9,7> >::SMatrixRow*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<float,9U,7U,ROOT::Math::MatRepStd<float,9,7> >::SMatrixRow*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLSMatrixlEfloatcO9UcO7UcOROOTcLcLMathcLcLMatRepStdlEfloatcO9cO7gRsPgRcLcLSMatrixRow_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<float,9U,7U,ROOT::Math::MatRepStd<float,9,7> >::SMatrixRow*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLSMatrixlEfloatcO9UcO7UcOROOTcLcLMathcLcLMatRepStdlEfloatcO9cO7gRsPgRcLcLSMatrixRow_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLSMatrixlEfloatcO9UcO7UcOROOTcLcLMathcLcLMatRepStdlEfloatcO9cO7gRsPgRcLcLSMatrixRow_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSMatrixlEfloatcO9UcO7UcOROOTcLcLMathcLcLMatRepStdlEfloatcO9cO7gRsPgRcLcLSMatrixRow_const_Dictionary();
   static void ROOTcLcLMathcLcLSMatrixlEfloatcO9UcO7UcOROOTcLcLMathcLcLMatRepStdlEfloatcO9cO7gRsPgRcLcLSMatrixRow_const_TClassManip(TClass*);
   static void delete_ROOTcLcLMathcLcLSMatrixlEfloatcO9UcO7UcOROOTcLcLMathcLcLMatRepStdlEfloatcO9cO7gRsPgRcLcLSMatrixRow_const(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO9UcO7UcOROOTcLcLMathcLcLMatRepStdlEfloatcO9cO7gRsPgRcLcLSMatrixRow_const(void *p);
   static void destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO9UcO7UcOROOTcLcLMathcLcLMatRepStdlEfloatcO9cO7gRsPgRcLcLSMatrixRow_const(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SMatrix<float,9U,7U,ROOT::Math::MatRepStd<float,9,7> >::SMatrixRow_const*)
   {
      ::ROOT::Math::SMatrix<float,9U,7U,ROOT::Math::MatRepStd<float,9,7> >::SMatrixRow_const *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SMatrix<float,9U,7U,ROOT::Math::MatRepStd<float,9,7> >::SMatrixRow_const));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SMatrix<float,9U,7U,ROOT::Math::MatRepStd<float,9,7> >::SMatrixRow_const", "Math/SMatrix.h", 382,
                  typeid(::ROOT::Math::SMatrix<float,9U,7U,ROOT::Math::MatRepStd<float,9,7> >::SMatrixRow_const), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSMatrixlEfloatcO9UcO7UcOROOTcLcLMathcLcLMatRepStdlEfloatcO9cO7gRsPgRcLcLSMatrixRow_const_Dictionary, isa_proxy, 0,
                  sizeof(::ROOT::Math::SMatrix<float,9U,7U,ROOT::Math::MatRepStd<float,9,7> >::SMatrixRow_const) );
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSMatrixlEfloatcO9UcO7UcOROOTcLcLMathcLcLMatRepStdlEfloatcO9cO7gRsPgRcLcLSMatrixRow_const);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO9UcO7UcOROOTcLcLMathcLcLMatRepStdlEfloatcO9cO7gRsPgRcLcLSMatrixRow_const);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO9UcO7UcOROOTcLcLMathcLcLMatRepStdlEfloatcO9cO7gRsPgRcLcLSMatrixRow_const);

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<float,9U,7U,ROOT::Math::MatRepStd<float,9,7> >::SMatrixRow_const","ROOT::Math::SMatrix<float,9,7>::SMatrixRow_const"));

      instance.AdoptAlternate(::ROOT::AddClassAlternate("ROOT::Math::SMatrix<float,9U,7U,ROOT::Math::MatRepStd<float,9,7> >::SMatrixRow_const","ROOT::Math::SMatrix<float, 9u, 7u, ROOT::Math::MatRepStd<float, 9u, 7u> >::SMatrixRow_const"));
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::SMatrix<float,9U,7U,ROOT::Math::MatRepStd<float,9,7> >::SMatrixRow_const*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::SMatrix<float,9U,7U,ROOT::Math::MatRepStd<float,9,7> >::SMatrixRow_const*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<float,9U,7U,ROOT::Math::MatRepStd<float,9,7> >::SMatrixRow_const*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLSMatrixlEfloatcO9UcO7UcOROOTcLcLMathcLcLMatRepStdlEfloatcO9cO7gRsPgRcLcLSMatrixRow_const_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<float,9U,7U,ROOT::Math::MatRepStd<float,9,7> >::SMatrixRow_const*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLSMatrixlEfloatcO9UcO7UcOROOTcLcLMathcLcLMatRepStdlEfloatcO9cO7gRsPgRcLcLSMatrixRow_const_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLSMatrixlEfloatcO9UcO7UcOROOTcLcLMathcLcLMatRepStdlEfloatcO9cO7gRsPgRcLcLSMatrixRow_const_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSMatrixIdentity_Dictionary();
   static void ROOTcLcLMathcLcLSMatrixIdentity_TClassManip(TClass*);
   static void *new_ROOTcLcLMathcLcLSMatrixIdentity(void *p = nullptr);
   static void *newArray_ROOTcLcLMathcLcLSMatrixIdentity(Long_t size, void *p);
   static void delete_ROOTcLcLMathcLcLSMatrixIdentity(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSMatrixIdentity(void *p);
   static void destruct_ROOTcLcLMathcLcLSMatrixIdentity(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SMatrixIdentity*)
   {
      ::ROOT::Math::SMatrixIdentity *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SMatrixIdentity));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SMatrixIdentity", "Math/SMatrix.h", 72,
                  typeid(::ROOT::Math::SMatrixIdentity), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSMatrixIdentity_Dictionary, isa_proxy, 4,
                  sizeof(::ROOT::Math::SMatrixIdentity) );
      instance.SetNew(&new_ROOTcLcLMathcLcLSMatrixIdentity);
      instance.SetNewArray(&newArray_ROOTcLcLMathcLcLSMatrixIdentity);
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSMatrixIdentity);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSMatrixIdentity);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSMatrixIdentity);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::SMatrixIdentity*)
   {
      return GenerateInitInstanceLocal(static_cast<::ROOT::Math::SMatrixIdentity*>(nullptr));
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrixIdentity*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *ROOTcLcLMathcLcLSMatrixIdentity_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrixIdentity*>(nullptr))->GetClass();
      ROOTcLcLMathcLcLSMatrixIdentity_TClassManip(theClass);
   return theClass;
   }

   static void ROOTcLcLMathcLcLSMatrixIdentity_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMathcLcLMatRepStdlEdoublecO2cO2gR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::MatRepStd<double,2,2> : new ::ROOT::Math::MatRepStd<double,2,2>;
   }
   static void *newArray_ROOTcLcLMathcLcLMatRepStdlEdoublecO2cO2gR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::MatRepStd<double,2,2>[nElements] : new ::ROOT::Math::MatRepStd<double,2,2>[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLMatRepStdlEdoublecO2cO2gR(void *p) {
      delete (static_cast<::ROOT::Math::MatRepStd<double,2,2>*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLMatRepStdlEdoublecO2cO2gR(void *p) {
      delete [] (static_cast<::ROOT::Math::MatRepStd<double,2,2>*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLMatRepStdlEdoublecO2cO2gR(void *p) {
      typedef ::ROOT::Math::MatRepStd<double,2,2> current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::MatRepStd<double,2,2>

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMathcLcLMatRepStdlEdoublecO3cO3gR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::MatRepStd<double,3,3> : new ::ROOT::Math::MatRepStd<double,3,3>;
   }
   static void *newArray_ROOTcLcLMathcLcLMatRepStdlEdoublecO3cO3gR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::MatRepStd<double,3,3>[nElements] : new ::ROOT::Math::MatRepStd<double,3,3>[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLMatRepStdlEdoublecO3cO3gR(void *p) {
      delete (static_cast<::ROOT::Math::MatRepStd<double,3,3>*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLMatRepStdlEdoublecO3cO3gR(void *p) {
      delete [] (static_cast<::ROOT::Math::MatRepStd<double,3,3>*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLMatRepStdlEdoublecO3cO3gR(void *p) {
      typedef ::ROOT::Math::MatRepStd<double,3,3> current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::MatRepStd<double,3,3>

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMathcLcLMatRepStdlEdoublecO4cO4gR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::MatRepStd<double,4,4> : new ::ROOT::Math::MatRepStd<double,4,4>;
   }
   static void *newArray_ROOTcLcLMathcLcLMatRepStdlEdoublecO4cO4gR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::MatRepStd<double,4,4>[nElements] : new ::ROOT::Math::MatRepStd<double,4,4>[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLMatRepStdlEdoublecO4cO4gR(void *p) {
      delete (static_cast<::ROOT::Math::MatRepStd<double,4,4>*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLMatRepStdlEdoublecO4cO4gR(void *p) {
      delete [] (static_cast<::ROOT::Math::MatRepStd<double,4,4>*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLMatRepStdlEdoublecO4cO4gR(void *p) {
      typedef ::ROOT::Math::MatRepStd<double,4,4> current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::MatRepStd<double,4,4>

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMathcLcLMatRepStdlEdoublecO5cO5gR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::MatRepStd<double,5,5> : new ::ROOT::Math::MatRepStd<double,5,5>;
   }
   static void *newArray_ROOTcLcLMathcLcLMatRepStdlEdoublecO5cO5gR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::MatRepStd<double,5,5>[nElements] : new ::ROOT::Math::MatRepStd<double,5,5>[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLMatRepStdlEdoublecO5cO5gR(void *p) {
      delete (static_cast<::ROOT::Math::MatRepStd<double,5,5>*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLMatRepStdlEdoublecO5cO5gR(void *p) {
      delete [] (static_cast<::ROOT::Math::MatRepStd<double,5,5>*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLMatRepStdlEdoublecO5cO5gR(void *p) {
      typedef ::ROOT::Math::MatRepStd<double,5,5> current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::MatRepStd<double,5,5>

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMathcLcLMatRepStdlEdoublecO6cO6gR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::MatRepStd<double,6,6> : new ::ROOT::Math::MatRepStd<double,6,6>;
   }
   static void *newArray_ROOTcLcLMathcLcLMatRepStdlEdoublecO6cO6gR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::MatRepStd<double,6,6>[nElements] : new ::ROOT::Math::MatRepStd<double,6,6>[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLMatRepStdlEdoublecO6cO6gR(void *p) {
      delete (static_cast<::ROOT::Math::MatRepStd<double,6,6>*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLMatRepStdlEdoublecO6cO6gR(void *p) {
      delete [] (static_cast<::ROOT::Math::MatRepStd<double,6,6>*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLMatRepStdlEdoublecO6cO6gR(void *p) {
      typedef ::ROOT::Math::MatRepStd<double,6,6> current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::MatRepStd<double,6,6>

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMathcLcLMatRepStdlEdoublecO7cO7gR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::MatRepStd<double,7,7> : new ::ROOT::Math::MatRepStd<double,7,7>;
   }
   static void *newArray_ROOTcLcLMathcLcLMatRepStdlEdoublecO7cO7gR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::MatRepStd<double,7,7>[nElements] : new ::ROOT::Math::MatRepStd<double,7,7>[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLMatRepStdlEdoublecO7cO7gR(void *p) {
      delete (static_cast<::ROOT::Math::MatRepStd<double,7,7>*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLMatRepStdlEdoublecO7cO7gR(void *p) {
      delete [] (static_cast<::ROOT::Math::MatRepStd<double,7,7>*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLMatRepStdlEdoublecO7cO7gR(void *p) {
      typedef ::ROOT::Math::MatRepStd<double,7,7> current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::MatRepStd<double,7,7>

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMathcLcLMatRepStdlEfloatcO2cO2gR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::MatRepStd<float,2,2> : new ::ROOT::Math::MatRepStd<float,2,2>;
   }
   static void *newArray_ROOTcLcLMathcLcLMatRepStdlEfloatcO2cO2gR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::MatRepStd<float,2,2>[nElements] : new ::ROOT::Math::MatRepStd<float,2,2>[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLMatRepStdlEfloatcO2cO2gR(void *p) {
      delete (static_cast<::ROOT::Math::MatRepStd<float,2,2>*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLMatRepStdlEfloatcO2cO2gR(void *p) {
      delete [] (static_cast<::ROOT::Math::MatRepStd<float,2,2>*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLMatRepStdlEfloatcO2cO2gR(void *p) {
      typedef ::ROOT::Math::MatRepStd<float,2,2> current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::MatRepStd<float,2,2>

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMathcLcLMatRepStdlEfloatcO3cO3gR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::MatRepStd<float,3,3> : new ::ROOT::Math::MatRepStd<float,3,3>;
   }
   static void *newArray_ROOTcLcLMathcLcLMatRepStdlEfloatcO3cO3gR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::MatRepStd<float,3,3>[nElements] : new ::ROOT::Math::MatRepStd<float,3,3>[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLMatRepStdlEfloatcO3cO3gR(void *p) {
      delete (static_cast<::ROOT::Math::MatRepStd<float,3,3>*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLMatRepStdlEfloatcO3cO3gR(void *p) {
      delete [] (static_cast<::ROOT::Math::MatRepStd<float,3,3>*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLMatRepStdlEfloatcO3cO3gR(void *p) {
      typedef ::ROOT::Math::MatRepStd<float,3,3> current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::MatRepStd<float,3,3>

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMathcLcLMatRepStdlEfloatcO4cO4gR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::MatRepStd<float,4,4> : new ::ROOT::Math::MatRepStd<float,4,4>;
   }
   static void *newArray_ROOTcLcLMathcLcLMatRepStdlEfloatcO4cO4gR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::MatRepStd<float,4,4>[nElements] : new ::ROOT::Math::MatRepStd<float,4,4>[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLMatRepStdlEfloatcO4cO4gR(void *p) {
      delete (static_cast<::ROOT::Math::MatRepStd<float,4,4>*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLMatRepStdlEfloatcO4cO4gR(void *p) {
      delete [] (static_cast<::ROOT::Math::MatRepStd<float,4,4>*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLMatRepStdlEfloatcO4cO4gR(void *p) {
      typedef ::ROOT::Math::MatRepStd<float,4,4> current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::MatRepStd<float,4,4>

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMathcLcLMatRepStdlEfloatcO5cO5gR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::MatRepStd<float,5,5> : new ::ROOT::Math::MatRepStd<float,5,5>;
   }
   static void *newArray_ROOTcLcLMathcLcLMatRepStdlEfloatcO5cO5gR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::MatRepStd<float,5,5>[nElements] : new ::ROOT::Math::MatRepStd<float,5,5>[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLMatRepStdlEfloatcO5cO5gR(void *p) {
      delete (static_cast<::ROOT::Math::MatRepStd<float,5,5>*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLMatRepStdlEfloatcO5cO5gR(void *p) {
      delete [] (static_cast<::ROOT::Math::MatRepStd<float,5,5>*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLMatRepStdlEfloatcO5cO5gR(void *p) {
      typedef ::ROOT::Math::MatRepStd<float,5,5> current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::MatRepStd<float,5,5>

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMathcLcLMatRepStdlEfloatcO6cO6gR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::MatRepStd<float,6,6> : new ::ROOT::Math::MatRepStd<float,6,6>;
   }
   static void *newArray_ROOTcLcLMathcLcLMatRepStdlEfloatcO6cO6gR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::MatRepStd<float,6,6>[nElements] : new ::ROOT::Math::MatRepStd<float,6,6>[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLMatRepStdlEfloatcO6cO6gR(void *p) {
      delete (static_cast<::ROOT::Math::MatRepStd<float,6,6>*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLMatRepStdlEfloatcO6cO6gR(void *p) {
      delete [] (static_cast<::ROOT::Math::MatRepStd<float,6,6>*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLMatRepStdlEfloatcO6cO6gR(void *p) {
      typedef ::ROOT::Math::MatRepStd<float,6,6> current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::MatRepStd<float,6,6>

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMathcLcLMatRepStdlEfloatcO7cO7gR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::MatRepStd<float,7,7> : new ::ROOT::Math::MatRepStd<float,7,7>;
   }
   static void *newArray_ROOTcLcLMathcLcLMatRepStdlEfloatcO7cO7gR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::MatRepStd<float,7,7>[nElements] : new ::ROOT::Math::MatRepStd<float,7,7>[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLMatRepStdlEfloatcO7cO7gR(void *p) {
      delete (static_cast<::ROOT::Math::MatRepStd<float,7,7>*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLMatRepStdlEfloatcO7cO7gR(void *p) {
      delete [] (static_cast<::ROOT::Math::MatRepStd<float,7,7>*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLMatRepStdlEfloatcO7cO7gR(void *p) {
      typedef ::ROOT::Math::MatRepStd<float,7,7> current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::MatRepStd<float,7,7>

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMathcLcLMatRepStdlEdoublecO4cO3gR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::MatRepStd<double,4,3> : new ::ROOT::Math::MatRepStd<double,4,3>;
   }
   static void *newArray_ROOTcLcLMathcLcLMatRepStdlEdoublecO4cO3gR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::MatRepStd<double,4,3>[nElements] : new ::ROOT::Math::MatRepStd<double,4,3>[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLMatRepStdlEdoublecO4cO3gR(void *p) {
      delete (static_cast<::ROOT::Math::MatRepStd<double,4,3>*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLMatRepStdlEdoublecO4cO3gR(void *p) {
      delete [] (static_cast<::ROOT::Math::MatRepStd<double,4,3>*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLMatRepStdlEdoublecO4cO3gR(void *p) {
      typedef ::ROOT::Math::MatRepStd<double,4,3> current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::MatRepStd<double,4,3>

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMathcLcLMatRepStdlEdoublecO3cO4gR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::MatRepStd<double,3,4> : new ::ROOT::Math::MatRepStd<double,3,4>;
   }
   static void *newArray_ROOTcLcLMathcLcLMatRepStdlEdoublecO3cO4gR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::MatRepStd<double,3,4>[nElements] : new ::ROOT::Math::MatRepStd<double,3,4>[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLMatRepStdlEdoublecO3cO4gR(void *p) {
      delete (static_cast<::ROOT::Math::MatRepStd<double,3,4>*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLMatRepStdlEdoublecO3cO4gR(void *p) {
      delete [] (static_cast<::ROOT::Math::MatRepStd<double,3,4>*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLMatRepStdlEdoublecO3cO4gR(void *p) {
      typedef ::ROOT::Math::MatRepStd<double,3,4> current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::MatRepStd<double,3,4>

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMathcLcLMatRepStdlEdoublecO9cO7gR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::MatRepStd<double,9,7> : new ::ROOT::Math::MatRepStd<double,9,7>;
   }
   static void *newArray_ROOTcLcLMathcLcLMatRepStdlEdoublecO9cO7gR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::MatRepStd<double,9,7>[nElements] : new ::ROOT::Math::MatRepStd<double,9,7>[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLMatRepStdlEdoublecO9cO7gR(void *p) {
      delete (static_cast<::ROOT::Math::MatRepStd<double,9,7>*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLMatRepStdlEdoublecO9cO7gR(void *p) {
      delete [] (static_cast<::ROOT::Math::MatRepStd<double,9,7>*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLMatRepStdlEdoublecO9cO7gR(void *p) {
      typedef ::ROOT::Math::MatRepStd<double,9,7> current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::MatRepStd<double,9,7>

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMathcLcLMatRepStdlEfloatcO4cO3gR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::MatRepStd<float,4,3> : new ::ROOT::Math::MatRepStd<float,4,3>;
   }
   static void *newArray_ROOTcLcLMathcLcLMatRepStdlEfloatcO4cO3gR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::MatRepStd<float,4,3>[nElements] : new ::ROOT::Math::MatRepStd<float,4,3>[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLMatRepStdlEfloatcO4cO3gR(void *p) {
      delete (static_cast<::ROOT::Math::MatRepStd<float,4,3>*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLMatRepStdlEfloatcO4cO3gR(void *p) {
      delete [] (static_cast<::ROOT::Math::MatRepStd<float,4,3>*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLMatRepStdlEfloatcO4cO3gR(void *p) {
      typedef ::ROOT::Math::MatRepStd<float,4,3> current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::MatRepStd<float,4,3>

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMathcLcLMatRepStdlEfloatcO3cO4gR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::MatRepStd<float,3,4> : new ::ROOT::Math::MatRepStd<float,3,4>;
   }
   static void *newArray_ROOTcLcLMathcLcLMatRepStdlEfloatcO3cO4gR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::MatRepStd<float,3,4>[nElements] : new ::ROOT::Math::MatRepStd<float,3,4>[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLMatRepStdlEfloatcO3cO4gR(void *p) {
      delete (static_cast<::ROOT::Math::MatRepStd<float,3,4>*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLMatRepStdlEfloatcO3cO4gR(void *p) {
      delete [] (static_cast<::ROOT::Math::MatRepStd<float,3,4>*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLMatRepStdlEfloatcO3cO4gR(void *p) {
      typedef ::ROOT::Math::MatRepStd<float,3,4> current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::MatRepStd<float,3,4>

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMathcLcLMatRepStdlEfloatcO9cO7gR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::MatRepStd<float,9,7> : new ::ROOT::Math::MatRepStd<float,9,7>;
   }
   static void *newArray_ROOTcLcLMathcLcLMatRepStdlEfloatcO9cO7gR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::MatRepStd<float,9,7>[nElements] : new ::ROOT::Math::MatRepStd<float,9,7>[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLMatRepStdlEfloatcO9cO7gR(void *p) {
      delete (static_cast<::ROOT::Math::MatRepStd<float,9,7>*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLMatRepStdlEfloatcO9cO7gR(void *p) {
      delete [] (static_cast<::ROOT::Math::MatRepStd<float,9,7>*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLMatRepStdlEfloatcO9cO7gR(void *p) {
      typedef ::ROOT::Math::MatRepStd<float,9,7> current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::MatRepStd<float,9,7>

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMathcLcLRowOffsetslE7gR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::RowOffsets<7> : new ::ROOT::Math::RowOffsets<7>;
   }
   static void *newArray_ROOTcLcLMathcLcLRowOffsetslE7gR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::RowOffsets<7>[nElements] : new ::ROOT::Math::RowOffsets<7>[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLRowOffsetslE7gR(void *p) {
      delete (static_cast<::ROOT::Math::RowOffsets<7>*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLRowOffsetslE7gR(void *p) {
      delete [] (static_cast<::ROOT::Math::RowOffsets<7>*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLRowOffsetslE7gR(void *p) {
      typedef ::ROOT::Math::RowOffsets<7> current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::RowOffsets<7>

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMathcLcLRowOffsetslE6gR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::RowOffsets<6> : new ::ROOT::Math::RowOffsets<6>;
   }
   static void *newArray_ROOTcLcLMathcLcLRowOffsetslE6gR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::RowOffsets<6>[nElements] : new ::ROOT::Math::RowOffsets<6>[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLRowOffsetslE6gR(void *p) {
      delete (static_cast<::ROOT::Math::RowOffsets<6>*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLRowOffsetslE6gR(void *p) {
      delete [] (static_cast<::ROOT::Math::RowOffsets<6>*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLRowOffsetslE6gR(void *p) {
      typedef ::ROOT::Math::RowOffsets<6> current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::RowOffsets<6>

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMathcLcLRowOffsetslE5gR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::RowOffsets<5> : new ::ROOT::Math::RowOffsets<5>;
   }
   static void *newArray_ROOTcLcLMathcLcLRowOffsetslE5gR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::RowOffsets<5>[nElements] : new ::ROOT::Math::RowOffsets<5>[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLRowOffsetslE5gR(void *p) {
      delete (static_cast<::ROOT::Math::RowOffsets<5>*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLRowOffsetslE5gR(void *p) {
      delete [] (static_cast<::ROOT::Math::RowOffsets<5>*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLRowOffsetslE5gR(void *p) {
      typedef ::ROOT::Math::RowOffsets<5> current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::RowOffsets<5>

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMathcLcLRowOffsetslE4gR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::RowOffsets<4> : new ::ROOT::Math::RowOffsets<4>;
   }
   static void *newArray_ROOTcLcLMathcLcLRowOffsetslE4gR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::RowOffsets<4>[nElements] : new ::ROOT::Math::RowOffsets<4>[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLRowOffsetslE4gR(void *p) {
      delete (static_cast<::ROOT::Math::RowOffsets<4>*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLRowOffsetslE4gR(void *p) {
      delete [] (static_cast<::ROOT::Math::RowOffsets<4>*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLRowOffsetslE4gR(void *p) {
      typedef ::ROOT::Math::RowOffsets<4> current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::RowOffsets<4>

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMathcLcLRowOffsetslE3gR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::RowOffsets<3> : new ::ROOT::Math::RowOffsets<3>;
   }
   static void *newArray_ROOTcLcLMathcLcLRowOffsetslE3gR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::RowOffsets<3>[nElements] : new ::ROOT::Math::RowOffsets<3>[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLRowOffsetslE3gR(void *p) {
      delete (static_cast<::ROOT::Math::RowOffsets<3>*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLRowOffsetslE3gR(void *p) {
      delete [] (static_cast<::ROOT::Math::RowOffsets<3>*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLRowOffsetslE3gR(void *p) {
      typedef ::ROOT::Math::RowOffsets<3> current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::RowOffsets<3>

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMathcLcLRowOffsetslE2gR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::RowOffsets<2> : new ::ROOT::Math::RowOffsets<2>;
   }
   static void *newArray_ROOTcLcLMathcLcLRowOffsetslE2gR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::RowOffsets<2>[nElements] : new ::ROOT::Math::RowOffsets<2>[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLRowOffsetslE2gR(void *p) {
      delete (static_cast<::ROOT::Math::RowOffsets<2>*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLRowOffsetslE2gR(void *p) {
      delete [] (static_cast<::ROOT::Math::RowOffsets<2>*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLRowOffsetslE2gR(void *p) {
      typedef ::ROOT::Math::RowOffsets<2> current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::RowOffsets<2>

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMathcLcLMatRepSymlEdoublecO2gR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::MatRepSym<double,2> : new ::ROOT::Math::MatRepSym<double,2>;
   }
   static void *newArray_ROOTcLcLMathcLcLMatRepSymlEdoublecO2gR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::MatRepSym<double,2>[nElements] : new ::ROOT::Math::MatRepSym<double,2>[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLMatRepSymlEdoublecO2gR(void *p) {
      delete (static_cast<::ROOT::Math::MatRepSym<double,2>*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLMatRepSymlEdoublecO2gR(void *p) {
      delete [] (static_cast<::ROOT::Math::MatRepSym<double,2>*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLMatRepSymlEdoublecO2gR(void *p) {
      typedef ::ROOT::Math::MatRepSym<double,2> current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::MatRepSym<double,2>

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMathcLcLMatRepSymlEdoublecO3gR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::MatRepSym<double,3> : new ::ROOT::Math::MatRepSym<double,3>;
   }
   static void *newArray_ROOTcLcLMathcLcLMatRepSymlEdoublecO3gR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::MatRepSym<double,3>[nElements] : new ::ROOT::Math::MatRepSym<double,3>[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLMatRepSymlEdoublecO3gR(void *p) {
      delete (static_cast<::ROOT::Math::MatRepSym<double,3>*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLMatRepSymlEdoublecO3gR(void *p) {
      delete [] (static_cast<::ROOT::Math::MatRepSym<double,3>*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLMatRepSymlEdoublecO3gR(void *p) {
      typedef ::ROOT::Math::MatRepSym<double,3> current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::MatRepSym<double,3>

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMathcLcLMatRepSymlEdoublecO4gR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::MatRepSym<double,4> : new ::ROOT::Math::MatRepSym<double,4>;
   }
   static void *newArray_ROOTcLcLMathcLcLMatRepSymlEdoublecO4gR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::MatRepSym<double,4>[nElements] : new ::ROOT::Math::MatRepSym<double,4>[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLMatRepSymlEdoublecO4gR(void *p) {
      delete (static_cast<::ROOT::Math::MatRepSym<double,4>*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLMatRepSymlEdoublecO4gR(void *p) {
      delete [] (static_cast<::ROOT::Math::MatRepSym<double,4>*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLMatRepSymlEdoublecO4gR(void *p) {
      typedef ::ROOT::Math::MatRepSym<double,4> current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::MatRepSym<double,4>

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMathcLcLMatRepSymlEdoublecO5gR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::MatRepSym<double,5> : new ::ROOT::Math::MatRepSym<double,5>;
   }
   static void *newArray_ROOTcLcLMathcLcLMatRepSymlEdoublecO5gR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::MatRepSym<double,5>[nElements] : new ::ROOT::Math::MatRepSym<double,5>[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLMatRepSymlEdoublecO5gR(void *p) {
      delete (static_cast<::ROOT::Math::MatRepSym<double,5>*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLMatRepSymlEdoublecO5gR(void *p) {
      delete [] (static_cast<::ROOT::Math::MatRepSym<double,5>*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLMatRepSymlEdoublecO5gR(void *p) {
      typedef ::ROOT::Math::MatRepSym<double,5> current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::MatRepSym<double,5>

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMathcLcLMatRepSymlEdoublecO6gR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::MatRepSym<double,6> : new ::ROOT::Math::MatRepSym<double,6>;
   }
   static void *newArray_ROOTcLcLMathcLcLMatRepSymlEdoublecO6gR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::MatRepSym<double,6>[nElements] : new ::ROOT::Math::MatRepSym<double,6>[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLMatRepSymlEdoublecO6gR(void *p) {
      delete (static_cast<::ROOT::Math::MatRepSym<double,6>*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLMatRepSymlEdoublecO6gR(void *p) {
      delete [] (static_cast<::ROOT::Math::MatRepSym<double,6>*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLMatRepSymlEdoublecO6gR(void *p) {
      typedef ::ROOT::Math::MatRepSym<double,6> current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::MatRepSym<double,6>

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMathcLcLMatRepSymlEdoublecO7gR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::MatRepSym<double,7> : new ::ROOT::Math::MatRepSym<double,7>;
   }
   static void *newArray_ROOTcLcLMathcLcLMatRepSymlEdoublecO7gR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::MatRepSym<double,7>[nElements] : new ::ROOT::Math::MatRepSym<double,7>[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLMatRepSymlEdoublecO7gR(void *p) {
      delete (static_cast<::ROOT::Math::MatRepSym<double,7>*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLMatRepSymlEdoublecO7gR(void *p) {
      delete [] (static_cast<::ROOT::Math::MatRepSym<double,7>*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLMatRepSymlEdoublecO7gR(void *p) {
      typedef ::ROOT::Math::MatRepSym<double,7> current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::MatRepSym<double,7>

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMathcLcLMatRepSymlEfloatcO2gR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::MatRepSym<float,2> : new ::ROOT::Math::MatRepSym<float,2>;
   }
   static void *newArray_ROOTcLcLMathcLcLMatRepSymlEfloatcO2gR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::MatRepSym<float,2>[nElements] : new ::ROOT::Math::MatRepSym<float,2>[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLMatRepSymlEfloatcO2gR(void *p) {
      delete (static_cast<::ROOT::Math::MatRepSym<float,2>*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLMatRepSymlEfloatcO2gR(void *p) {
      delete [] (static_cast<::ROOT::Math::MatRepSym<float,2>*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLMatRepSymlEfloatcO2gR(void *p) {
      typedef ::ROOT::Math::MatRepSym<float,2> current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::MatRepSym<float,2>

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMathcLcLMatRepSymlEfloatcO3gR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::MatRepSym<float,3> : new ::ROOT::Math::MatRepSym<float,3>;
   }
   static void *newArray_ROOTcLcLMathcLcLMatRepSymlEfloatcO3gR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::MatRepSym<float,3>[nElements] : new ::ROOT::Math::MatRepSym<float,3>[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLMatRepSymlEfloatcO3gR(void *p) {
      delete (static_cast<::ROOT::Math::MatRepSym<float,3>*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLMatRepSymlEfloatcO3gR(void *p) {
      delete [] (static_cast<::ROOT::Math::MatRepSym<float,3>*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLMatRepSymlEfloatcO3gR(void *p) {
      typedef ::ROOT::Math::MatRepSym<float,3> current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::MatRepSym<float,3>

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMathcLcLMatRepSymlEfloatcO4gR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::MatRepSym<float,4> : new ::ROOT::Math::MatRepSym<float,4>;
   }
   static void *newArray_ROOTcLcLMathcLcLMatRepSymlEfloatcO4gR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::MatRepSym<float,4>[nElements] : new ::ROOT::Math::MatRepSym<float,4>[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLMatRepSymlEfloatcO4gR(void *p) {
      delete (static_cast<::ROOT::Math::MatRepSym<float,4>*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLMatRepSymlEfloatcO4gR(void *p) {
      delete [] (static_cast<::ROOT::Math::MatRepSym<float,4>*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLMatRepSymlEfloatcO4gR(void *p) {
      typedef ::ROOT::Math::MatRepSym<float,4> current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::MatRepSym<float,4>

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMathcLcLMatRepSymlEfloatcO5gR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::MatRepSym<float,5> : new ::ROOT::Math::MatRepSym<float,5>;
   }
   static void *newArray_ROOTcLcLMathcLcLMatRepSymlEfloatcO5gR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::MatRepSym<float,5>[nElements] : new ::ROOT::Math::MatRepSym<float,5>[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLMatRepSymlEfloatcO5gR(void *p) {
      delete (static_cast<::ROOT::Math::MatRepSym<float,5>*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLMatRepSymlEfloatcO5gR(void *p) {
      delete [] (static_cast<::ROOT::Math::MatRepSym<float,5>*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLMatRepSymlEfloatcO5gR(void *p) {
      typedef ::ROOT::Math::MatRepSym<float,5> current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::MatRepSym<float,5>

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMathcLcLMatRepSymlEfloatcO6gR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::MatRepSym<float,6> : new ::ROOT::Math::MatRepSym<float,6>;
   }
   static void *newArray_ROOTcLcLMathcLcLMatRepSymlEfloatcO6gR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::MatRepSym<float,6>[nElements] : new ::ROOT::Math::MatRepSym<float,6>[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLMatRepSymlEfloatcO6gR(void *p) {
      delete (static_cast<::ROOT::Math::MatRepSym<float,6>*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLMatRepSymlEfloatcO6gR(void *p) {
      delete [] (static_cast<::ROOT::Math::MatRepSym<float,6>*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLMatRepSymlEfloatcO6gR(void *p) {
      typedef ::ROOT::Math::MatRepSym<float,6> current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::MatRepSym<float,6>

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMathcLcLMatRepSymlEfloatcO7gR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::MatRepSym<float,7> : new ::ROOT::Math::MatRepSym<float,7>;
   }
   static void *newArray_ROOTcLcLMathcLcLMatRepSymlEfloatcO7gR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::MatRepSym<float,7>[nElements] : new ::ROOT::Math::MatRepSym<float,7>[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLMatRepSymlEfloatcO7gR(void *p) {
      delete (static_cast<::ROOT::Math::MatRepSym<float,7>*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLMatRepSymlEfloatcO7gR(void *p) {
      delete [] (static_cast<::ROOT::Math::MatRepSym<float,7>*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLMatRepSymlEfloatcO7gR(void *p) {
      typedef ::ROOT::Math::MatRepSym<float,7> current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::MatRepSym<float,7>

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMathcLcLSVectorlEdoublecO2gR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SVector<double,2> : new ::ROOT::Math::SVector<double,2>;
   }
   static void *newArray_ROOTcLcLMathcLcLSVectorlEdoublecO2gR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SVector<double,2>[nElements] : new ::ROOT::Math::SVector<double,2>[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSVectorlEdoublecO2gR(void *p) {
      delete (static_cast<::ROOT::Math::SVector<double,2>*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSVectorlEdoublecO2gR(void *p) {
      delete [] (static_cast<::ROOT::Math::SVector<double,2>*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSVectorlEdoublecO2gR(void *p) {
      typedef ::ROOT::Math::SVector<double,2> current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SVector<double,2>

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMathcLcLSVectorlEdoublecO3gR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SVector<double,3> : new ::ROOT::Math::SVector<double,3>;
   }
   static void *newArray_ROOTcLcLMathcLcLSVectorlEdoublecO3gR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SVector<double,3>[nElements] : new ::ROOT::Math::SVector<double,3>[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSVectorlEdoublecO3gR(void *p) {
      delete (static_cast<::ROOT::Math::SVector<double,3>*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSVectorlEdoublecO3gR(void *p) {
      delete [] (static_cast<::ROOT::Math::SVector<double,3>*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSVectorlEdoublecO3gR(void *p) {
      typedef ::ROOT::Math::SVector<double,3> current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SVector<double,3>

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMathcLcLSVectorlEdoublecO4gR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SVector<double,4> : new ::ROOT::Math::SVector<double,4>;
   }
   static void *newArray_ROOTcLcLMathcLcLSVectorlEdoublecO4gR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SVector<double,4>[nElements] : new ::ROOT::Math::SVector<double,4>[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSVectorlEdoublecO4gR(void *p) {
      delete (static_cast<::ROOT::Math::SVector<double,4>*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSVectorlEdoublecO4gR(void *p) {
      delete [] (static_cast<::ROOT::Math::SVector<double,4>*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSVectorlEdoublecO4gR(void *p) {
      typedef ::ROOT::Math::SVector<double,4> current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SVector<double,4>

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMathcLcLSVectorlEdoublecO5gR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SVector<double,5> : new ::ROOT::Math::SVector<double,5>;
   }
   static void *newArray_ROOTcLcLMathcLcLSVectorlEdoublecO5gR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SVector<double,5>[nElements] : new ::ROOT::Math::SVector<double,5>[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSVectorlEdoublecO5gR(void *p) {
      delete (static_cast<::ROOT::Math::SVector<double,5>*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSVectorlEdoublecO5gR(void *p) {
      delete [] (static_cast<::ROOT::Math::SVector<double,5>*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSVectorlEdoublecO5gR(void *p) {
      typedef ::ROOT::Math::SVector<double,5> current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SVector<double,5>

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMathcLcLSVectorlEdoublecO6gR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SVector<double,6> : new ::ROOT::Math::SVector<double,6>;
   }
   static void *newArray_ROOTcLcLMathcLcLSVectorlEdoublecO6gR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SVector<double,6>[nElements] : new ::ROOT::Math::SVector<double,6>[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSVectorlEdoublecO6gR(void *p) {
      delete (static_cast<::ROOT::Math::SVector<double,6>*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSVectorlEdoublecO6gR(void *p) {
      delete [] (static_cast<::ROOT::Math::SVector<double,6>*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSVectorlEdoublecO6gR(void *p) {
      typedef ::ROOT::Math::SVector<double,6> current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SVector<double,6>

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMathcLcLSVectorlEdoublecO7gR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SVector<double,7> : new ::ROOT::Math::SVector<double,7>;
   }
   static void *newArray_ROOTcLcLMathcLcLSVectorlEdoublecO7gR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SVector<double,7>[nElements] : new ::ROOT::Math::SVector<double,7>[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSVectorlEdoublecO7gR(void *p) {
      delete (static_cast<::ROOT::Math::SVector<double,7>*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSVectorlEdoublecO7gR(void *p) {
      delete [] (static_cast<::ROOT::Math::SVector<double,7>*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSVectorlEdoublecO7gR(void *p) {
      typedef ::ROOT::Math::SVector<double,7> current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SVector<double,7>

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMathcLcLSVectorlEfloatcO2gR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SVector<float,2> : new ::ROOT::Math::SVector<float,2>;
   }
   static void *newArray_ROOTcLcLMathcLcLSVectorlEfloatcO2gR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SVector<float,2>[nElements] : new ::ROOT::Math::SVector<float,2>[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSVectorlEfloatcO2gR(void *p) {
      delete (static_cast<::ROOT::Math::SVector<float,2>*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSVectorlEfloatcO2gR(void *p) {
      delete [] (static_cast<::ROOT::Math::SVector<float,2>*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSVectorlEfloatcO2gR(void *p) {
      typedef ::ROOT::Math::SVector<float,2> current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SVector<float,2>

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMathcLcLSVectorlEfloatcO3gR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SVector<float,3> : new ::ROOT::Math::SVector<float,3>;
   }
   static void *newArray_ROOTcLcLMathcLcLSVectorlEfloatcO3gR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SVector<float,3>[nElements] : new ::ROOT::Math::SVector<float,3>[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSVectorlEfloatcO3gR(void *p) {
      delete (static_cast<::ROOT::Math::SVector<float,3>*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSVectorlEfloatcO3gR(void *p) {
      delete [] (static_cast<::ROOT::Math::SVector<float,3>*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSVectorlEfloatcO3gR(void *p) {
      typedef ::ROOT::Math::SVector<float,3> current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SVector<float,3>

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMathcLcLSVectorlEfloatcO4gR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SVector<float,4> : new ::ROOT::Math::SVector<float,4>;
   }
   static void *newArray_ROOTcLcLMathcLcLSVectorlEfloatcO4gR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SVector<float,4>[nElements] : new ::ROOT::Math::SVector<float,4>[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSVectorlEfloatcO4gR(void *p) {
      delete (static_cast<::ROOT::Math::SVector<float,4>*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSVectorlEfloatcO4gR(void *p) {
      delete [] (static_cast<::ROOT::Math::SVector<float,4>*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSVectorlEfloatcO4gR(void *p) {
      typedef ::ROOT::Math::SVector<float,4> current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SVector<float,4>

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMathcLcLSVectorlEfloatcO5gR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SVector<float,5> : new ::ROOT::Math::SVector<float,5>;
   }
   static void *newArray_ROOTcLcLMathcLcLSVectorlEfloatcO5gR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SVector<float,5>[nElements] : new ::ROOT::Math::SVector<float,5>[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSVectorlEfloatcO5gR(void *p) {
      delete (static_cast<::ROOT::Math::SVector<float,5>*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSVectorlEfloatcO5gR(void *p) {
      delete [] (static_cast<::ROOT::Math::SVector<float,5>*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSVectorlEfloatcO5gR(void *p) {
      typedef ::ROOT::Math::SVector<float,5> current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SVector<float,5>

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMathcLcLSVectorlEfloatcO6gR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SVector<float,6> : new ::ROOT::Math::SVector<float,6>;
   }
   static void *newArray_ROOTcLcLMathcLcLSVectorlEfloatcO6gR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SVector<float,6>[nElements] : new ::ROOT::Math::SVector<float,6>[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSVectorlEfloatcO6gR(void *p) {
      delete (static_cast<::ROOT::Math::SVector<float,6>*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSVectorlEfloatcO6gR(void *p) {
      delete [] (static_cast<::ROOT::Math::SVector<float,6>*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSVectorlEfloatcO6gR(void *p) {
      typedef ::ROOT::Math::SVector<float,6> current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SVector<float,6>

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMathcLcLSVectorlEfloatcO7gR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SVector<float,7> : new ::ROOT::Math::SVector<float,7>;
   }
   static void *newArray_ROOTcLcLMathcLcLSVectorlEfloatcO7gR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SVector<float,7>[nElements] : new ::ROOT::Math::SVector<float,7>[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSVectorlEfloatcO7gR(void *p) {
      delete (static_cast<::ROOT::Math::SVector<float,7>*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSVectorlEfloatcO7gR(void *p) {
      delete [] (static_cast<::ROOT::Math::SVector<float,7>*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSVectorlEfloatcO7gR(void *p) {
      typedef ::ROOT::Math::SVector<float,7> current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SVector<float,7>

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMathcLcLSMatrixlEdoublecO2cO2cOROOTcLcLMathcLcLMatRepStdlEdoublecO2cO2gRsPgR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SMatrix<double,2,2,ROOT::Math::MatRepStd<double,2,2> > : new ::ROOT::Math::SMatrix<double,2,2,ROOT::Math::MatRepStd<double,2,2> >;
   }
   static void *newArray_ROOTcLcLMathcLcLSMatrixlEdoublecO2cO2cOROOTcLcLMathcLcLMatRepStdlEdoublecO2cO2gRsPgR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SMatrix<double,2,2,ROOT::Math::MatRepStd<double,2,2> >[nElements] : new ::ROOT::Math::SMatrix<double,2,2,ROOT::Math::MatRepStd<double,2,2> >[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSMatrixlEdoublecO2cO2cOROOTcLcLMathcLcLMatRepStdlEdoublecO2cO2gRsPgR(void *p) {
      delete (static_cast<::ROOT::Math::SMatrix<double,2,2,ROOT::Math::MatRepStd<double,2,2> >*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO2cO2cOROOTcLcLMathcLcLMatRepStdlEdoublecO2cO2gRsPgR(void *p) {
      delete [] (static_cast<::ROOT::Math::SMatrix<double,2,2,ROOT::Math::MatRepStd<double,2,2> >*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO2cO2cOROOTcLcLMathcLcLMatRepStdlEdoublecO2cO2gRsPgR(void *p) {
      typedef ::ROOT::Math::SMatrix<double,2,2,ROOT::Math::MatRepStd<double,2,2> > current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SMatrix<double,2,2,ROOT::Math::MatRepStd<double,2,2> >

namespace ROOT {
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSMatrixlEdoublecO2UcO2UcOROOTcLcLMathcLcLMatRepStdlEdoublecO2cO2gRsPgRcLcLSMatrixRow(void *p) {
      delete (static_cast<::ROOT::Math::SMatrix<double,2U,2U,ROOT::Math::MatRepStd<double,2,2> >::SMatrixRow*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO2UcO2UcOROOTcLcLMathcLcLMatRepStdlEdoublecO2cO2gRsPgRcLcLSMatrixRow(void *p) {
      delete [] (static_cast<::ROOT::Math::SMatrix<double,2U,2U,ROOT::Math::MatRepStd<double,2,2> >::SMatrixRow*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO2UcO2UcOROOTcLcLMathcLcLMatRepStdlEdoublecO2cO2gRsPgRcLcLSMatrixRow(void *p) {
      typedef ::ROOT::Math::SMatrix<double,2U,2U,ROOT::Math::MatRepStd<double,2,2> >::SMatrixRow current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SMatrix<double,2U,2U,ROOT::Math::MatRepStd<double,2,2> >::SMatrixRow

namespace ROOT {
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSMatrixlEdoublecO2UcO2UcOROOTcLcLMathcLcLMatRepStdlEdoublecO2cO2gRsPgRcLcLSMatrixRow_const(void *p) {
      delete (static_cast<::ROOT::Math::SMatrix<double,2U,2U,ROOT::Math::MatRepStd<double,2,2> >::SMatrixRow_const*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO2UcO2UcOROOTcLcLMathcLcLMatRepStdlEdoublecO2cO2gRsPgRcLcLSMatrixRow_const(void *p) {
      delete [] (static_cast<::ROOT::Math::SMatrix<double,2U,2U,ROOT::Math::MatRepStd<double,2,2> >::SMatrixRow_const*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO2UcO2UcOROOTcLcLMathcLcLMatRepStdlEdoublecO2cO2gRsPgRcLcLSMatrixRow_const(void *p) {
      typedef ::ROOT::Math::SMatrix<double,2U,2U,ROOT::Math::MatRepStd<double,2,2> >::SMatrixRow_const current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SMatrix<double,2U,2U,ROOT::Math::MatRepStd<double,2,2> >::SMatrixRow_const

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMathcLcLSMatrixlEdoublecO3cO3cOROOTcLcLMathcLcLMatRepStdlEdoublecO3cO3gRsPgR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SMatrix<double,3,3,ROOT::Math::MatRepStd<double,3,3> > : new ::ROOT::Math::SMatrix<double,3,3,ROOT::Math::MatRepStd<double,3,3> >;
   }
   static void *newArray_ROOTcLcLMathcLcLSMatrixlEdoublecO3cO3cOROOTcLcLMathcLcLMatRepStdlEdoublecO3cO3gRsPgR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SMatrix<double,3,3,ROOT::Math::MatRepStd<double,3,3> >[nElements] : new ::ROOT::Math::SMatrix<double,3,3,ROOT::Math::MatRepStd<double,3,3> >[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSMatrixlEdoublecO3cO3cOROOTcLcLMathcLcLMatRepStdlEdoublecO3cO3gRsPgR(void *p) {
      delete (static_cast<::ROOT::Math::SMatrix<double,3,3,ROOT::Math::MatRepStd<double,3,3> >*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO3cO3cOROOTcLcLMathcLcLMatRepStdlEdoublecO3cO3gRsPgR(void *p) {
      delete [] (static_cast<::ROOT::Math::SMatrix<double,3,3,ROOT::Math::MatRepStd<double,3,3> >*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO3cO3cOROOTcLcLMathcLcLMatRepStdlEdoublecO3cO3gRsPgR(void *p) {
      typedef ::ROOT::Math::SMatrix<double,3,3,ROOT::Math::MatRepStd<double,3,3> > current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SMatrix<double,3,3,ROOT::Math::MatRepStd<double,3,3> >

namespace ROOT {
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSMatrixlEdoublecO3UcO3UcOROOTcLcLMathcLcLMatRepStdlEdoublecO3cO3gRsPgRcLcLSMatrixRow(void *p) {
      delete (static_cast<::ROOT::Math::SMatrix<double,3U,3U,ROOT::Math::MatRepStd<double,3,3> >::SMatrixRow*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO3UcO3UcOROOTcLcLMathcLcLMatRepStdlEdoublecO3cO3gRsPgRcLcLSMatrixRow(void *p) {
      delete [] (static_cast<::ROOT::Math::SMatrix<double,3U,3U,ROOT::Math::MatRepStd<double,3,3> >::SMatrixRow*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO3UcO3UcOROOTcLcLMathcLcLMatRepStdlEdoublecO3cO3gRsPgRcLcLSMatrixRow(void *p) {
      typedef ::ROOT::Math::SMatrix<double,3U,3U,ROOT::Math::MatRepStd<double,3,3> >::SMatrixRow current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SMatrix<double,3U,3U,ROOT::Math::MatRepStd<double,3,3> >::SMatrixRow

namespace ROOT {
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSMatrixlEdoublecO3UcO3UcOROOTcLcLMathcLcLMatRepStdlEdoublecO3cO3gRsPgRcLcLSMatrixRow_const(void *p) {
      delete (static_cast<::ROOT::Math::SMatrix<double,3U,3U,ROOT::Math::MatRepStd<double,3,3> >::SMatrixRow_const*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO3UcO3UcOROOTcLcLMathcLcLMatRepStdlEdoublecO3cO3gRsPgRcLcLSMatrixRow_const(void *p) {
      delete [] (static_cast<::ROOT::Math::SMatrix<double,3U,3U,ROOT::Math::MatRepStd<double,3,3> >::SMatrixRow_const*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO3UcO3UcOROOTcLcLMathcLcLMatRepStdlEdoublecO3cO3gRsPgRcLcLSMatrixRow_const(void *p) {
      typedef ::ROOT::Math::SMatrix<double,3U,3U,ROOT::Math::MatRepStd<double,3,3> >::SMatrixRow_const current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SMatrix<double,3U,3U,ROOT::Math::MatRepStd<double,3,3> >::SMatrixRow_const

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMathcLcLSMatrixlEdoublecO4cO4cOROOTcLcLMathcLcLMatRepStdlEdoublecO4cO4gRsPgR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SMatrix<double,4,4,ROOT::Math::MatRepStd<double,4,4> > : new ::ROOT::Math::SMatrix<double,4,4,ROOT::Math::MatRepStd<double,4,4> >;
   }
   static void *newArray_ROOTcLcLMathcLcLSMatrixlEdoublecO4cO4cOROOTcLcLMathcLcLMatRepStdlEdoublecO4cO4gRsPgR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SMatrix<double,4,4,ROOT::Math::MatRepStd<double,4,4> >[nElements] : new ::ROOT::Math::SMatrix<double,4,4,ROOT::Math::MatRepStd<double,4,4> >[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSMatrixlEdoublecO4cO4cOROOTcLcLMathcLcLMatRepStdlEdoublecO4cO4gRsPgR(void *p) {
      delete (static_cast<::ROOT::Math::SMatrix<double,4,4,ROOT::Math::MatRepStd<double,4,4> >*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO4cO4cOROOTcLcLMathcLcLMatRepStdlEdoublecO4cO4gRsPgR(void *p) {
      delete [] (static_cast<::ROOT::Math::SMatrix<double,4,4,ROOT::Math::MatRepStd<double,4,4> >*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO4cO4cOROOTcLcLMathcLcLMatRepStdlEdoublecO4cO4gRsPgR(void *p) {
      typedef ::ROOT::Math::SMatrix<double,4,4,ROOT::Math::MatRepStd<double,4,4> > current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SMatrix<double,4,4,ROOT::Math::MatRepStd<double,4,4> >

namespace ROOT {
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSMatrixlEdoublecO4UcO4UcOROOTcLcLMathcLcLMatRepStdlEdoublecO4cO4gRsPgRcLcLSMatrixRow(void *p) {
      delete (static_cast<::ROOT::Math::SMatrix<double,4U,4U,ROOT::Math::MatRepStd<double,4,4> >::SMatrixRow*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO4UcO4UcOROOTcLcLMathcLcLMatRepStdlEdoublecO4cO4gRsPgRcLcLSMatrixRow(void *p) {
      delete [] (static_cast<::ROOT::Math::SMatrix<double,4U,4U,ROOT::Math::MatRepStd<double,4,4> >::SMatrixRow*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO4UcO4UcOROOTcLcLMathcLcLMatRepStdlEdoublecO4cO4gRsPgRcLcLSMatrixRow(void *p) {
      typedef ::ROOT::Math::SMatrix<double,4U,4U,ROOT::Math::MatRepStd<double,4,4> >::SMatrixRow current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SMatrix<double,4U,4U,ROOT::Math::MatRepStd<double,4,4> >::SMatrixRow

namespace ROOT {
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSMatrixlEdoublecO4UcO4UcOROOTcLcLMathcLcLMatRepStdlEdoublecO4cO4gRsPgRcLcLSMatrixRow_const(void *p) {
      delete (static_cast<::ROOT::Math::SMatrix<double,4U,4U,ROOT::Math::MatRepStd<double,4,4> >::SMatrixRow_const*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO4UcO4UcOROOTcLcLMathcLcLMatRepStdlEdoublecO4cO4gRsPgRcLcLSMatrixRow_const(void *p) {
      delete [] (static_cast<::ROOT::Math::SMatrix<double,4U,4U,ROOT::Math::MatRepStd<double,4,4> >::SMatrixRow_const*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO4UcO4UcOROOTcLcLMathcLcLMatRepStdlEdoublecO4cO4gRsPgRcLcLSMatrixRow_const(void *p) {
      typedef ::ROOT::Math::SMatrix<double,4U,4U,ROOT::Math::MatRepStd<double,4,4> >::SMatrixRow_const current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SMatrix<double,4U,4U,ROOT::Math::MatRepStd<double,4,4> >::SMatrixRow_const

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMathcLcLSMatrixlEdoublecO5cO5cOROOTcLcLMathcLcLMatRepStdlEdoublecO5cO5gRsPgR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SMatrix<double,5,5,ROOT::Math::MatRepStd<double,5,5> > : new ::ROOT::Math::SMatrix<double,5,5,ROOT::Math::MatRepStd<double,5,5> >;
   }
   static void *newArray_ROOTcLcLMathcLcLSMatrixlEdoublecO5cO5cOROOTcLcLMathcLcLMatRepStdlEdoublecO5cO5gRsPgR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SMatrix<double,5,5,ROOT::Math::MatRepStd<double,5,5> >[nElements] : new ::ROOT::Math::SMatrix<double,5,5,ROOT::Math::MatRepStd<double,5,5> >[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSMatrixlEdoublecO5cO5cOROOTcLcLMathcLcLMatRepStdlEdoublecO5cO5gRsPgR(void *p) {
      delete (static_cast<::ROOT::Math::SMatrix<double,5,5,ROOT::Math::MatRepStd<double,5,5> >*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO5cO5cOROOTcLcLMathcLcLMatRepStdlEdoublecO5cO5gRsPgR(void *p) {
      delete [] (static_cast<::ROOT::Math::SMatrix<double,5,5,ROOT::Math::MatRepStd<double,5,5> >*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO5cO5cOROOTcLcLMathcLcLMatRepStdlEdoublecO5cO5gRsPgR(void *p) {
      typedef ::ROOT::Math::SMatrix<double,5,5,ROOT::Math::MatRepStd<double,5,5> > current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SMatrix<double,5,5,ROOT::Math::MatRepStd<double,5,5> >

namespace ROOT {
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSMatrixlEdoublecO5UcO5UcOROOTcLcLMathcLcLMatRepStdlEdoublecO5cO5gRsPgRcLcLSMatrixRow(void *p) {
      delete (static_cast<::ROOT::Math::SMatrix<double,5U,5U,ROOT::Math::MatRepStd<double,5,5> >::SMatrixRow*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO5UcO5UcOROOTcLcLMathcLcLMatRepStdlEdoublecO5cO5gRsPgRcLcLSMatrixRow(void *p) {
      delete [] (static_cast<::ROOT::Math::SMatrix<double,5U,5U,ROOT::Math::MatRepStd<double,5,5> >::SMatrixRow*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO5UcO5UcOROOTcLcLMathcLcLMatRepStdlEdoublecO5cO5gRsPgRcLcLSMatrixRow(void *p) {
      typedef ::ROOT::Math::SMatrix<double,5U,5U,ROOT::Math::MatRepStd<double,5,5> >::SMatrixRow current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SMatrix<double,5U,5U,ROOT::Math::MatRepStd<double,5,5> >::SMatrixRow

namespace ROOT {
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSMatrixlEdoublecO5UcO5UcOROOTcLcLMathcLcLMatRepStdlEdoublecO5cO5gRsPgRcLcLSMatrixRow_const(void *p) {
      delete (static_cast<::ROOT::Math::SMatrix<double,5U,5U,ROOT::Math::MatRepStd<double,5,5> >::SMatrixRow_const*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO5UcO5UcOROOTcLcLMathcLcLMatRepStdlEdoublecO5cO5gRsPgRcLcLSMatrixRow_const(void *p) {
      delete [] (static_cast<::ROOT::Math::SMatrix<double,5U,5U,ROOT::Math::MatRepStd<double,5,5> >::SMatrixRow_const*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO5UcO5UcOROOTcLcLMathcLcLMatRepStdlEdoublecO5cO5gRsPgRcLcLSMatrixRow_const(void *p) {
      typedef ::ROOT::Math::SMatrix<double,5U,5U,ROOT::Math::MatRepStd<double,5,5> >::SMatrixRow_const current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SMatrix<double,5U,5U,ROOT::Math::MatRepStd<double,5,5> >::SMatrixRow_const

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMathcLcLSMatrixlEdoublecO6cO6cOROOTcLcLMathcLcLMatRepStdlEdoublecO6cO6gRsPgR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SMatrix<double,6,6,ROOT::Math::MatRepStd<double,6,6> > : new ::ROOT::Math::SMatrix<double,6,6,ROOT::Math::MatRepStd<double,6,6> >;
   }
   static void *newArray_ROOTcLcLMathcLcLSMatrixlEdoublecO6cO6cOROOTcLcLMathcLcLMatRepStdlEdoublecO6cO6gRsPgR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SMatrix<double,6,6,ROOT::Math::MatRepStd<double,6,6> >[nElements] : new ::ROOT::Math::SMatrix<double,6,6,ROOT::Math::MatRepStd<double,6,6> >[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSMatrixlEdoublecO6cO6cOROOTcLcLMathcLcLMatRepStdlEdoublecO6cO6gRsPgR(void *p) {
      delete (static_cast<::ROOT::Math::SMatrix<double,6,6,ROOT::Math::MatRepStd<double,6,6> >*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO6cO6cOROOTcLcLMathcLcLMatRepStdlEdoublecO6cO6gRsPgR(void *p) {
      delete [] (static_cast<::ROOT::Math::SMatrix<double,6,6,ROOT::Math::MatRepStd<double,6,6> >*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO6cO6cOROOTcLcLMathcLcLMatRepStdlEdoublecO6cO6gRsPgR(void *p) {
      typedef ::ROOT::Math::SMatrix<double,6,6,ROOT::Math::MatRepStd<double,6,6> > current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SMatrix<double,6,6,ROOT::Math::MatRepStd<double,6,6> >

namespace ROOT {
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSMatrixlEdoublecO6UcO6UcOROOTcLcLMathcLcLMatRepStdlEdoublecO6cO6gRsPgRcLcLSMatrixRow(void *p) {
      delete (static_cast<::ROOT::Math::SMatrix<double,6U,6U,ROOT::Math::MatRepStd<double,6,6> >::SMatrixRow*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO6UcO6UcOROOTcLcLMathcLcLMatRepStdlEdoublecO6cO6gRsPgRcLcLSMatrixRow(void *p) {
      delete [] (static_cast<::ROOT::Math::SMatrix<double,6U,6U,ROOT::Math::MatRepStd<double,6,6> >::SMatrixRow*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO6UcO6UcOROOTcLcLMathcLcLMatRepStdlEdoublecO6cO6gRsPgRcLcLSMatrixRow(void *p) {
      typedef ::ROOT::Math::SMatrix<double,6U,6U,ROOT::Math::MatRepStd<double,6,6> >::SMatrixRow current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SMatrix<double,6U,6U,ROOT::Math::MatRepStd<double,6,6> >::SMatrixRow

namespace ROOT {
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSMatrixlEdoublecO6UcO6UcOROOTcLcLMathcLcLMatRepStdlEdoublecO6cO6gRsPgRcLcLSMatrixRow_const(void *p) {
      delete (static_cast<::ROOT::Math::SMatrix<double,6U,6U,ROOT::Math::MatRepStd<double,6,6> >::SMatrixRow_const*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO6UcO6UcOROOTcLcLMathcLcLMatRepStdlEdoublecO6cO6gRsPgRcLcLSMatrixRow_const(void *p) {
      delete [] (static_cast<::ROOT::Math::SMatrix<double,6U,6U,ROOT::Math::MatRepStd<double,6,6> >::SMatrixRow_const*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO6UcO6UcOROOTcLcLMathcLcLMatRepStdlEdoublecO6cO6gRsPgRcLcLSMatrixRow_const(void *p) {
      typedef ::ROOT::Math::SMatrix<double,6U,6U,ROOT::Math::MatRepStd<double,6,6> >::SMatrixRow_const current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SMatrix<double,6U,6U,ROOT::Math::MatRepStd<double,6,6> >::SMatrixRow_const

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMathcLcLSMatrixlEdoublecO7cO7cOROOTcLcLMathcLcLMatRepStdlEdoublecO7cO7gRsPgR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SMatrix<double,7,7,ROOT::Math::MatRepStd<double,7,7> > : new ::ROOT::Math::SMatrix<double,7,7,ROOT::Math::MatRepStd<double,7,7> >;
   }
   static void *newArray_ROOTcLcLMathcLcLSMatrixlEdoublecO7cO7cOROOTcLcLMathcLcLMatRepStdlEdoublecO7cO7gRsPgR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SMatrix<double,7,7,ROOT::Math::MatRepStd<double,7,7> >[nElements] : new ::ROOT::Math::SMatrix<double,7,7,ROOT::Math::MatRepStd<double,7,7> >[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSMatrixlEdoublecO7cO7cOROOTcLcLMathcLcLMatRepStdlEdoublecO7cO7gRsPgR(void *p) {
      delete (static_cast<::ROOT::Math::SMatrix<double,7,7,ROOT::Math::MatRepStd<double,7,7> >*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO7cO7cOROOTcLcLMathcLcLMatRepStdlEdoublecO7cO7gRsPgR(void *p) {
      delete [] (static_cast<::ROOT::Math::SMatrix<double,7,7,ROOT::Math::MatRepStd<double,7,7> >*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO7cO7cOROOTcLcLMathcLcLMatRepStdlEdoublecO7cO7gRsPgR(void *p) {
      typedef ::ROOT::Math::SMatrix<double,7,7,ROOT::Math::MatRepStd<double,7,7> > current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SMatrix<double,7,7,ROOT::Math::MatRepStd<double,7,7> >

namespace ROOT {
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSMatrixlEdoublecO7UcO7UcOROOTcLcLMathcLcLMatRepStdlEdoublecO7cO7gRsPgRcLcLSMatrixRow(void *p) {
      delete (static_cast<::ROOT::Math::SMatrix<double,7U,7U,ROOT::Math::MatRepStd<double,7,7> >::SMatrixRow*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO7UcO7UcOROOTcLcLMathcLcLMatRepStdlEdoublecO7cO7gRsPgRcLcLSMatrixRow(void *p) {
      delete [] (static_cast<::ROOT::Math::SMatrix<double,7U,7U,ROOT::Math::MatRepStd<double,7,7> >::SMatrixRow*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO7UcO7UcOROOTcLcLMathcLcLMatRepStdlEdoublecO7cO7gRsPgRcLcLSMatrixRow(void *p) {
      typedef ::ROOT::Math::SMatrix<double,7U,7U,ROOT::Math::MatRepStd<double,7,7> >::SMatrixRow current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SMatrix<double,7U,7U,ROOT::Math::MatRepStd<double,7,7> >::SMatrixRow

namespace ROOT {
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSMatrixlEdoublecO7UcO7UcOROOTcLcLMathcLcLMatRepStdlEdoublecO7cO7gRsPgRcLcLSMatrixRow_const(void *p) {
      delete (static_cast<::ROOT::Math::SMatrix<double,7U,7U,ROOT::Math::MatRepStd<double,7,7> >::SMatrixRow_const*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO7UcO7UcOROOTcLcLMathcLcLMatRepStdlEdoublecO7cO7gRsPgRcLcLSMatrixRow_const(void *p) {
      delete [] (static_cast<::ROOT::Math::SMatrix<double,7U,7U,ROOT::Math::MatRepStd<double,7,7> >::SMatrixRow_const*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO7UcO7UcOROOTcLcLMathcLcLMatRepStdlEdoublecO7cO7gRsPgRcLcLSMatrixRow_const(void *p) {
      typedef ::ROOT::Math::SMatrix<double,7U,7U,ROOT::Math::MatRepStd<double,7,7> >::SMatrixRow_const current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SMatrix<double,7U,7U,ROOT::Math::MatRepStd<double,7,7> >::SMatrixRow_const

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMathcLcLSMatrixlEdoublecO2cO2cOROOTcLcLMathcLcLMatRepSymlEdoublecO2gRsPgR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SMatrix<double,2,2,ROOT::Math::MatRepSym<double,2> > : new ::ROOT::Math::SMatrix<double,2,2,ROOT::Math::MatRepSym<double,2> >;
   }
   static void *newArray_ROOTcLcLMathcLcLSMatrixlEdoublecO2cO2cOROOTcLcLMathcLcLMatRepSymlEdoublecO2gRsPgR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SMatrix<double,2,2,ROOT::Math::MatRepSym<double,2> >[nElements] : new ::ROOT::Math::SMatrix<double,2,2,ROOT::Math::MatRepSym<double,2> >[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSMatrixlEdoublecO2cO2cOROOTcLcLMathcLcLMatRepSymlEdoublecO2gRsPgR(void *p) {
      delete (static_cast<::ROOT::Math::SMatrix<double,2,2,ROOT::Math::MatRepSym<double,2> >*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO2cO2cOROOTcLcLMathcLcLMatRepSymlEdoublecO2gRsPgR(void *p) {
      delete [] (static_cast<::ROOT::Math::SMatrix<double,2,2,ROOT::Math::MatRepSym<double,2> >*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO2cO2cOROOTcLcLMathcLcLMatRepSymlEdoublecO2gRsPgR(void *p) {
      typedef ::ROOT::Math::SMatrix<double,2,2,ROOT::Math::MatRepSym<double,2> > current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SMatrix<double,2,2,ROOT::Math::MatRepSym<double,2> >

namespace ROOT {
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSMatrixlEdoublecO2UcO2UcOROOTcLcLMathcLcLMatRepSymlEdoublecO2gRsPgRcLcLSMatrixRow(void *p) {
      delete (static_cast<::ROOT::Math::SMatrix<double,2U,2U,ROOT::Math::MatRepSym<double,2> >::SMatrixRow*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO2UcO2UcOROOTcLcLMathcLcLMatRepSymlEdoublecO2gRsPgRcLcLSMatrixRow(void *p) {
      delete [] (static_cast<::ROOT::Math::SMatrix<double,2U,2U,ROOT::Math::MatRepSym<double,2> >::SMatrixRow*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO2UcO2UcOROOTcLcLMathcLcLMatRepSymlEdoublecO2gRsPgRcLcLSMatrixRow(void *p) {
      typedef ::ROOT::Math::SMatrix<double,2U,2U,ROOT::Math::MatRepSym<double,2> >::SMatrixRow current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SMatrix<double,2U,2U,ROOT::Math::MatRepSym<double,2> >::SMatrixRow

namespace ROOT {
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSMatrixlEdoublecO2UcO2UcOROOTcLcLMathcLcLMatRepSymlEdoublecO2gRsPgRcLcLSMatrixRow_const(void *p) {
      delete (static_cast<::ROOT::Math::SMatrix<double,2U,2U,ROOT::Math::MatRepSym<double,2> >::SMatrixRow_const*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO2UcO2UcOROOTcLcLMathcLcLMatRepSymlEdoublecO2gRsPgRcLcLSMatrixRow_const(void *p) {
      delete [] (static_cast<::ROOT::Math::SMatrix<double,2U,2U,ROOT::Math::MatRepSym<double,2> >::SMatrixRow_const*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO2UcO2UcOROOTcLcLMathcLcLMatRepSymlEdoublecO2gRsPgRcLcLSMatrixRow_const(void *p) {
      typedef ::ROOT::Math::SMatrix<double,2U,2U,ROOT::Math::MatRepSym<double,2> >::SMatrixRow_const current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SMatrix<double,2U,2U,ROOT::Math::MatRepSym<double,2> >::SMatrixRow_const

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMathcLcLSMatrixlEdoublecO3cO3cOROOTcLcLMathcLcLMatRepSymlEdoublecO3gRsPgR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SMatrix<double,3,3,ROOT::Math::MatRepSym<double,3> > : new ::ROOT::Math::SMatrix<double,3,3,ROOT::Math::MatRepSym<double,3> >;
   }
   static void *newArray_ROOTcLcLMathcLcLSMatrixlEdoublecO3cO3cOROOTcLcLMathcLcLMatRepSymlEdoublecO3gRsPgR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SMatrix<double,3,3,ROOT::Math::MatRepSym<double,3> >[nElements] : new ::ROOT::Math::SMatrix<double,3,3,ROOT::Math::MatRepSym<double,3> >[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSMatrixlEdoublecO3cO3cOROOTcLcLMathcLcLMatRepSymlEdoublecO3gRsPgR(void *p) {
      delete (static_cast<::ROOT::Math::SMatrix<double,3,3,ROOT::Math::MatRepSym<double,3> >*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO3cO3cOROOTcLcLMathcLcLMatRepSymlEdoublecO3gRsPgR(void *p) {
      delete [] (static_cast<::ROOT::Math::SMatrix<double,3,3,ROOT::Math::MatRepSym<double,3> >*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO3cO3cOROOTcLcLMathcLcLMatRepSymlEdoublecO3gRsPgR(void *p) {
      typedef ::ROOT::Math::SMatrix<double,3,3,ROOT::Math::MatRepSym<double,3> > current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SMatrix<double,3,3,ROOT::Math::MatRepSym<double,3> >

namespace ROOT {
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSMatrixlEdoublecO3UcO3UcOROOTcLcLMathcLcLMatRepSymlEdoublecO3gRsPgRcLcLSMatrixRow(void *p) {
      delete (static_cast<::ROOT::Math::SMatrix<double,3U,3U,ROOT::Math::MatRepSym<double,3> >::SMatrixRow*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO3UcO3UcOROOTcLcLMathcLcLMatRepSymlEdoublecO3gRsPgRcLcLSMatrixRow(void *p) {
      delete [] (static_cast<::ROOT::Math::SMatrix<double,3U,3U,ROOT::Math::MatRepSym<double,3> >::SMatrixRow*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO3UcO3UcOROOTcLcLMathcLcLMatRepSymlEdoublecO3gRsPgRcLcLSMatrixRow(void *p) {
      typedef ::ROOT::Math::SMatrix<double,3U,3U,ROOT::Math::MatRepSym<double,3> >::SMatrixRow current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SMatrix<double,3U,3U,ROOT::Math::MatRepSym<double,3> >::SMatrixRow

namespace ROOT {
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSMatrixlEdoublecO3UcO3UcOROOTcLcLMathcLcLMatRepSymlEdoublecO3gRsPgRcLcLSMatrixRow_const(void *p) {
      delete (static_cast<::ROOT::Math::SMatrix<double,3U,3U,ROOT::Math::MatRepSym<double,3> >::SMatrixRow_const*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO3UcO3UcOROOTcLcLMathcLcLMatRepSymlEdoublecO3gRsPgRcLcLSMatrixRow_const(void *p) {
      delete [] (static_cast<::ROOT::Math::SMatrix<double,3U,3U,ROOT::Math::MatRepSym<double,3> >::SMatrixRow_const*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO3UcO3UcOROOTcLcLMathcLcLMatRepSymlEdoublecO3gRsPgRcLcLSMatrixRow_const(void *p) {
      typedef ::ROOT::Math::SMatrix<double,3U,3U,ROOT::Math::MatRepSym<double,3> >::SMatrixRow_const current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SMatrix<double,3U,3U,ROOT::Math::MatRepSym<double,3> >::SMatrixRow_const

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMathcLcLSMatrixlEdoublecO4cO4cOROOTcLcLMathcLcLMatRepSymlEdoublecO4gRsPgR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SMatrix<double,4,4,ROOT::Math::MatRepSym<double,4> > : new ::ROOT::Math::SMatrix<double,4,4,ROOT::Math::MatRepSym<double,4> >;
   }
   static void *newArray_ROOTcLcLMathcLcLSMatrixlEdoublecO4cO4cOROOTcLcLMathcLcLMatRepSymlEdoublecO4gRsPgR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SMatrix<double,4,4,ROOT::Math::MatRepSym<double,4> >[nElements] : new ::ROOT::Math::SMatrix<double,4,4,ROOT::Math::MatRepSym<double,4> >[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSMatrixlEdoublecO4cO4cOROOTcLcLMathcLcLMatRepSymlEdoublecO4gRsPgR(void *p) {
      delete (static_cast<::ROOT::Math::SMatrix<double,4,4,ROOT::Math::MatRepSym<double,4> >*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO4cO4cOROOTcLcLMathcLcLMatRepSymlEdoublecO4gRsPgR(void *p) {
      delete [] (static_cast<::ROOT::Math::SMatrix<double,4,4,ROOT::Math::MatRepSym<double,4> >*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO4cO4cOROOTcLcLMathcLcLMatRepSymlEdoublecO4gRsPgR(void *p) {
      typedef ::ROOT::Math::SMatrix<double,4,4,ROOT::Math::MatRepSym<double,4> > current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SMatrix<double,4,4,ROOT::Math::MatRepSym<double,4> >

namespace ROOT {
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSMatrixlEdoublecO4UcO4UcOROOTcLcLMathcLcLMatRepSymlEdoublecO4gRsPgRcLcLSMatrixRow(void *p) {
      delete (static_cast<::ROOT::Math::SMatrix<double,4U,4U,ROOT::Math::MatRepSym<double,4> >::SMatrixRow*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO4UcO4UcOROOTcLcLMathcLcLMatRepSymlEdoublecO4gRsPgRcLcLSMatrixRow(void *p) {
      delete [] (static_cast<::ROOT::Math::SMatrix<double,4U,4U,ROOT::Math::MatRepSym<double,4> >::SMatrixRow*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO4UcO4UcOROOTcLcLMathcLcLMatRepSymlEdoublecO4gRsPgRcLcLSMatrixRow(void *p) {
      typedef ::ROOT::Math::SMatrix<double,4U,4U,ROOT::Math::MatRepSym<double,4> >::SMatrixRow current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SMatrix<double,4U,4U,ROOT::Math::MatRepSym<double,4> >::SMatrixRow

namespace ROOT {
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSMatrixlEdoublecO4UcO4UcOROOTcLcLMathcLcLMatRepSymlEdoublecO4gRsPgRcLcLSMatrixRow_const(void *p) {
      delete (static_cast<::ROOT::Math::SMatrix<double,4U,4U,ROOT::Math::MatRepSym<double,4> >::SMatrixRow_const*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO4UcO4UcOROOTcLcLMathcLcLMatRepSymlEdoublecO4gRsPgRcLcLSMatrixRow_const(void *p) {
      delete [] (static_cast<::ROOT::Math::SMatrix<double,4U,4U,ROOT::Math::MatRepSym<double,4> >::SMatrixRow_const*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO4UcO4UcOROOTcLcLMathcLcLMatRepSymlEdoublecO4gRsPgRcLcLSMatrixRow_const(void *p) {
      typedef ::ROOT::Math::SMatrix<double,4U,4U,ROOT::Math::MatRepSym<double,4> >::SMatrixRow_const current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SMatrix<double,4U,4U,ROOT::Math::MatRepSym<double,4> >::SMatrixRow_const

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMathcLcLSMatrixlEdoublecO5cO5cOROOTcLcLMathcLcLMatRepSymlEdoublecO5gRsPgR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SMatrix<double,5,5,ROOT::Math::MatRepSym<double,5> > : new ::ROOT::Math::SMatrix<double,5,5,ROOT::Math::MatRepSym<double,5> >;
   }
   static void *newArray_ROOTcLcLMathcLcLSMatrixlEdoublecO5cO5cOROOTcLcLMathcLcLMatRepSymlEdoublecO5gRsPgR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SMatrix<double,5,5,ROOT::Math::MatRepSym<double,5> >[nElements] : new ::ROOT::Math::SMatrix<double,5,5,ROOT::Math::MatRepSym<double,5> >[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSMatrixlEdoublecO5cO5cOROOTcLcLMathcLcLMatRepSymlEdoublecO5gRsPgR(void *p) {
      delete (static_cast<::ROOT::Math::SMatrix<double,5,5,ROOT::Math::MatRepSym<double,5> >*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO5cO5cOROOTcLcLMathcLcLMatRepSymlEdoublecO5gRsPgR(void *p) {
      delete [] (static_cast<::ROOT::Math::SMatrix<double,5,5,ROOT::Math::MatRepSym<double,5> >*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO5cO5cOROOTcLcLMathcLcLMatRepSymlEdoublecO5gRsPgR(void *p) {
      typedef ::ROOT::Math::SMatrix<double,5,5,ROOT::Math::MatRepSym<double,5> > current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SMatrix<double,5,5,ROOT::Math::MatRepSym<double,5> >

namespace ROOT {
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSMatrixlEdoublecO5UcO5UcOROOTcLcLMathcLcLMatRepSymlEdoublecO5gRsPgRcLcLSMatrixRow(void *p) {
      delete (static_cast<::ROOT::Math::SMatrix<double,5U,5U,ROOT::Math::MatRepSym<double,5> >::SMatrixRow*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO5UcO5UcOROOTcLcLMathcLcLMatRepSymlEdoublecO5gRsPgRcLcLSMatrixRow(void *p) {
      delete [] (static_cast<::ROOT::Math::SMatrix<double,5U,5U,ROOT::Math::MatRepSym<double,5> >::SMatrixRow*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO5UcO5UcOROOTcLcLMathcLcLMatRepSymlEdoublecO5gRsPgRcLcLSMatrixRow(void *p) {
      typedef ::ROOT::Math::SMatrix<double,5U,5U,ROOT::Math::MatRepSym<double,5> >::SMatrixRow current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SMatrix<double,5U,5U,ROOT::Math::MatRepSym<double,5> >::SMatrixRow

namespace ROOT {
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSMatrixlEdoublecO5UcO5UcOROOTcLcLMathcLcLMatRepSymlEdoublecO5gRsPgRcLcLSMatrixRow_const(void *p) {
      delete (static_cast<::ROOT::Math::SMatrix<double,5U,5U,ROOT::Math::MatRepSym<double,5> >::SMatrixRow_const*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO5UcO5UcOROOTcLcLMathcLcLMatRepSymlEdoublecO5gRsPgRcLcLSMatrixRow_const(void *p) {
      delete [] (static_cast<::ROOT::Math::SMatrix<double,5U,5U,ROOT::Math::MatRepSym<double,5> >::SMatrixRow_const*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO5UcO5UcOROOTcLcLMathcLcLMatRepSymlEdoublecO5gRsPgRcLcLSMatrixRow_const(void *p) {
      typedef ::ROOT::Math::SMatrix<double,5U,5U,ROOT::Math::MatRepSym<double,5> >::SMatrixRow_const current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SMatrix<double,5U,5U,ROOT::Math::MatRepSym<double,5> >::SMatrixRow_const

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMathcLcLSMatrixlEdoublecO6cO6cOROOTcLcLMathcLcLMatRepSymlEdoublecO6gRsPgR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SMatrix<double,6,6,ROOT::Math::MatRepSym<double,6> > : new ::ROOT::Math::SMatrix<double,6,6,ROOT::Math::MatRepSym<double,6> >;
   }
   static void *newArray_ROOTcLcLMathcLcLSMatrixlEdoublecO6cO6cOROOTcLcLMathcLcLMatRepSymlEdoublecO6gRsPgR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SMatrix<double,6,6,ROOT::Math::MatRepSym<double,6> >[nElements] : new ::ROOT::Math::SMatrix<double,6,6,ROOT::Math::MatRepSym<double,6> >[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSMatrixlEdoublecO6cO6cOROOTcLcLMathcLcLMatRepSymlEdoublecO6gRsPgR(void *p) {
      delete (static_cast<::ROOT::Math::SMatrix<double,6,6,ROOT::Math::MatRepSym<double,6> >*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO6cO6cOROOTcLcLMathcLcLMatRepSymlEdoublecO6gRsPgR(void *p) {
      delete [] (static_cast<::ROOT::Math::SMatrix<double,6,6,ROOT::Math::MatRepSym<double,6> >*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO6cO6cOROOTcLcLMathcLcLMatRepSymlEdoublecO6gRsPgR(void *p) {
      typedef ::ROOT::Math::SMatrix<double,6,6,ROOT::Math::MatRepSym<double,6> > current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SMatrix<double,6,6,ROOT::Math::MatRepSym<double,6> >

namespace ROOT {
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSMatrixlEdoublecO6UcO6UcOROOTcLcLMathcLcLMatRepSymlEdoublecO6gRsPgRcLcLSMatrixRow(void *p) {
      delete (static_cast<::ROOT::Math::SMatrix<double,6U,6U,ROOT::Math::MatRepSym<double,6> >::SMatrixRow*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO6UcO6UcOROOTcLcLMathcLcLMatRepSymlEdoublecO6gRsPgRcLcLSMatrixRow(void *p) {
      delete [] (static_cast<::ROOT::Math::SMatrix<double,6U,6U,ROOT::Math::MatRepSym<double,6> >::SMatrixRow*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO6UcO6UcOROOTcLcLMathcLcLMatRepSymlEdoublecO6gRsPgRcLcLSMatrixRow(void *p) {
      typedef ::ROOT::Math::SMatrix<double,6U,6U,ROOT::Math::MatRepSym<double,6> >::SMatrixRow current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SMatrix<double,6U,6U,ROOT::Math::MatRepSym<double,6> >::SMatrixRow

namespace ROOT {
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSMatrixlEdoublecO6UcO6UcOROOTcLcLMathcLcLMatRepSymlEdoublecO6gRsPgRcLcLSMatrixRow_const(void *p) {
      delete (static_cast<::ROOT::Math::SMatrix<double,6U,6U,ROOT::Math::MatRepSym<double,6> >::SMatrixRow_const*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO6UcO6UcOROOTcLcLMathcLcLMatRepSymlEdoublecO6gRsPgRcLcLSMatrixRow_const(void *p) {
      delete [] (static_cast<::ROOT::Math::SMatrix<double,6U,6U,ROOT::Math::MatRepSym<double,6> >::SMatrixRow_const*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO6UcO6UcOROOTcLcLMathcLcLMatRepSymlEdoublecO6gRsPgRcLcLSMatrixRow_const(void *p) {
      typedef ::ROOT::Math::SMatrix<double,6U,6U,ROOT::Math::MatRepSym<double,6> >::SMatrixRow_const current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SMatrix<double,6U,6U,ROOT::Math::MatRepSym<double,6> >::SMatrixRow_const

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMathcLcLSMatrixlEdoublecO7cO7cOROOTcLcLMathcLcLMatRepSymlEdoublecO7gRsPgR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SMatrix<double,7,7,ROOT::Math::MatRepSym<double,7> > : new ::ROOT::Math::SMatrix<double,7,7,ROOT::Math::MatRepSym<double,7> >;
   }
   static void *newArray_ROOTcLcLMathcLcLSMatrixlEdoublecO7cO7cOROOTcLcLMathcLcLMatRepSymlEdoublecO7gRsPgR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SMatrix<double,7,7,ROOT::Math::MatRepSym<double,7> >[nElements] : new ::ROOT::Math::SMatrix<double,7,7,ROOT::Math::MatRepSym<double,7> >[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSMatrixlEdoublecO7cO7cOROOTcLcLMathcLcLMatRepSymlEdoublecO7gRsPgR(void *p) {
      delete (static_cast<::ROOT::Math::SMatrix<double,7,7,ROOT::Math::MatRepSym<double,7> >*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO7cO7cOROOTcLcLMathcLcLMatRepSymlEdoublecO7gRsPgR(void *p) {
      delete [] (static_cast<::ROOT::Math::SMatrix<double,7,7,ROOT::Math::MatRepSym<double,7> >*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO7cO7cOROOTcLcLMathcLcLMatRepSymlEdoublecO7gRsPgR(void *p) {
      typedef ::ROOT::Math::SMatrix<double,7,7,ROOT::Math::MatRepSym<double,7> > current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SMatrix<double,7,7,ROOT::Math::MatRepSym<double,7> >

namespace ROOT {
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSMatrixlEdoublecO7UcO7UcOROOTcLcLMathcLcLMatRepSymlEdoublecO7gRsPgRcLcLSMatrixRow(void *p) {
      delete (static_cast<::ROOT::Math::SMatrix<double,7U,7U,ROOT::Math::MatRepSym<double,7> >::SMatrixRow*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO7UcO7UcOROOTcLcLMathcLcLMatRepSymlEdoublecO7gRsPgRcLcLSMatrixRow(void *p) {
      delete [] (static_cast<::ROOT::Math::SMatrix<double,7U,7U,ROOT::Math::MatRepSym<double,7> >::SMatrixRow*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO7UcO7UcOROOTcLcLMathcLcLMatRepSymlEdoublecO7gRsPgRcLcLSMatrixRow(void *p) {
      typedef ::ROOT::Math::SMatrix<double,7U,7U,ROOT::Math::MatRepSym<double,7> >::SMatrixRow current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SMatrix<double,7U,7U,ROOT::Math::MatRepSym<double,7> >::SMatrixRow

namespace ROOT {
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSMatrixlEdoublecO7UcO7UcOROOTcLcLMathcLcLMatRepSymlEdoublecO7gRsPgRcLcLSMatrixRow_const(void *p) {
      delete (static_cast<::ROOT::Math::SMatrix<double,7U,7U,ROOT::Math::MatRepSym<double,7> >::SMatrixRow_const*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO7UcO7UcOROOTcLcLMathcLcLMatRepSymlEdoublecO7gRsPgRcLcLSMatrixRow_const(void *p) {
      delete [] (static_cast<::ROOT::Math::SMatrix<double,7U,7U,ROOT::Math::MatRepSym<double,7> >::SMatrixRow_const*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO7UcO7UcOROOTcLcLMathcLcLMatRepSymlEdoublecO7gRsPgRcLcLSMatrixRow_const(void *p) {
      typedef ::ROOT::Math::SMatrix<double,7U,7U,ROOT::Math::MatRepSym<double,7> >::SMatrixRow_const current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SMatrix<double,7U,7U,ROOT::Math::MatRepSym<double,7> >::SMatrixRow_const

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMathcLcLSMatrixlEfloatcO2cO2cOROOTcLcLMathcLcLMatRepStdlEfloatcO2cO2gRsPgR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SMatrix<float,2,2,ROOT::Math::MatRepStd<float,2,2> > : new ::ROOT::Math::SMatrix<float,2,2,ROOT::Math::MatRepStd<float,2,2> >;
   }
   static void *newArray_ROOTcLcLMathcLcLSMatrixlEfloatcO2cO2cOROOTcLcLMathcLcLMatRepStdlEfloatcO2cO2gRsPgR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SMatrix<float,2,2,ROOT::Math::MatRepStd<float,2,2> >[nElements] : new ::ROOT::Math::SMatrix<float,2,2,ROOT::Math::MatRepStd<float,2,2> >[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSMatrixlEfloatcO2cO2cOROOTcLcLMathcLcLMatRepStdlEfloatcO2cO2gRsPgR(void *p) {
      delete (static_cast<::ROOT::Math::SMatrix<float,2,2,ROOT::Math::MatRepStd<float,2,2> >*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO2cO2cOROOTcLcLMathcLcLMatRepStdlEfloatcO2cO2gRsPgR(void *p) {
      delete [] (static_cast<::ROOT::Math::SMatrix<float,2,2,ROOT::Math::MatRepStd<float,2,2> >*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO2cO2cOROOTcLcLMathcLcLMatRepStdlEfloatcO2cO2gRsPgR(void *p) {
      typedef ::ROOT::Math::SMatrix<float,2,2,ROOT::Math::MatRepStd<float,2,2> > current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SMatrix<float,2,2,ROOT::Math::MatRepStd<float,2,2> >

namespace ROOT {
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSMatrixlEfloatcO2UcO2UcOROOTcLcLMathcLcLMatRepStdlEfloatcO2cO2gRsPgRcLcLSMatrixRow(void *p) {
      delete (static_cast<::ROOT::Math::SMatrix<float,2U,2U,ROOT::Math::MatRepStd<float,2,2> >::SMatrixRow*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO2UcO2UcOROOTcLcLMathcLcLMatRepStdlEfloatcO2cO2gRsPgRcLcLSMatrixRow(void *p) {
      delete [] (static_cast<::ROOT::Math::SMatrix<float,2U,2U,ROOT::Math::MatRepStd<float,2,2> >::SMatrixRow*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO2UcO2UcOROOTcLcLMathcLcLMatRepStdlEfloatcO2cO2gRsPgRcLcLSMatrixRow(void *p) {
      typedef ::ROOT::Math::SMatrix<float,2U,2U,ROOT::Math::MatRepStd<float,2,2> >::SMatrixRow current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SMatrix<float,2U,2U,ROOT::Math::MatRepStd<float,2,2> >::SMatrixRow

namespace ROOT {
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSMatrixlEfloatcO2UcO2UcOROOTcLcLMathcLcLMatRepStdlEfloatcO2cO2gRsPgRcLcLSMatrixRow_const(void *p) {
      delete (static_cast<::ROOT::Math::SMatrix<float,2U,2U,ROOT::Math::MatRepStd<float,2,2> >::SMatrixRow_const*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO2UcO2UcOROOTcLcLMathcLcLMatRepStdlEfloatcO2cO2gRsPgRcLcLSMatrixRow_const(void *p) {
      delete [] (static_cast<::ROOT::Math::SMatrix<float,2U,2U,ROOT::Math::MatRepStd<float,2,2> >::SMatrixRow_const*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO2UcO2UcOROOTcLcLMathcLcLMatRepStdlEfloatcO2cO2gRsPgRcLcLSMatrixRow_const(void *p) {
      typedef ::ROOT::Math::SMatrix<float,2U,2U,ROOT::Math::MatRepStd<float,2,2> >::SMatrixRow_const current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SMatrix<float,2U,2U,ROOT::Math::MatRepStd<float,2,2> >::SMatrixRow_const

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMathcLcLSMatrixlEfloatcO3cO3cOROOTcLcLMathcLcLMatRepStdlEfloatcO3cO3gRsPgR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SMatrix<float,3,3,ROOT::Math::MatRepStd<float,3,3> > : new ::ROOT::Math::SMatrix<float,3,3,ROOT::Math::MatRepStd<float,3,3> >;
   }
   static void *newArray_ROOTcLcLMathcLcLSMatrixlEfloatcO3cO3cOROOTcLcLMathcLcLMatRepStdlEfloatcO3cO3gRsPgR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SMatrix<float,3,3,ROOT::Math::MatRepStd<float,3,3> >[nElements] : new ::ROOT::Math::SMatrix<float,3,3,ROOT::Math::MatRepStd<float,3,3> >[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSMatrixlEfloatcO3cO3cOROOTcLcLMathcLcLMatRepStdlEfloatcO3cO3gRsPgR(void *p) {
      delete (static_cast<::ROOT::Math::SMatrix<float,3,3,ROOT::Math::MatRepStd<float,3,3> >*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO3cO3cOROOTcLcLMathcLcLMatRepStdlEfloatcO3cO3gRsPgR(void *p) {
      delete [] (static_cast<::ROOT::Math::SMatrix<float,3,3,ROOT::Math::MatRepStd<float,3,3> >*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO3cO3cOROOTcLcLMathcLcLMatRepStdlEfloatcO3cO3gRsPgR(void *p) {
      typedef ::ROOT::Math::SMatrix<float,3,3,ROOT::Math::MatRepStd<float,3,3> > current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SMatrix<float,3,3,ROOT::Math::MatRepStd<float,3,3> >

namespace ROOT {
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSMatrixlEfloatcO3UcO3UcOROOTcLcLMathcLcLMatRepStdlEfloatcO3cO3gRsPgRcLcLSMatrixRow(void *p) {
      delete (static_cast<::ROOT::Math::SMatrix<float,3U,3U,ROOT::Math::MatRepStd<float,3,3> >::SMatrixRow*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO3UcO3UcOROOTcLcLMathcLcLMatRepStdlEfloatcO3cO3gRsPgRcLcLSMatrixRow(void *p) {
      delete [] (static_cast<::ROOT::Math::SMatrix<float,3U,3U,ROOT::Math::MatRepStd<float,3,3> >::SMatrixRow*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO3UcO3UcOROOTcLcLMathcLcLMatRepStdlEfloatcO3cO3gRsPgRcLcLSMatrixRow(void *p) {
      typedef ::ROOT::Math::SMatrix<float,3U,3U,ROOT::Math::MatRepStd<float,3,3> >::SMatrixRow current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SMatrix<float,3U,3U,ROOT::Math::MatRepStd<float,3,3> >::SMatrixRow

namespace ROOT {
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSMatrixlEfloatcO3UcO3UcOROOTcLcLMathcLcLMatRepStdlEfloatcO3cO3gRsPgRcLcLSMatrixRow_const(void *p) {
      delete (static_cast<::ROOT::Math::SMatrix<float,3U,3U,ROOT::Math::MatRepStd<float,3,3> >::SMatrixRow_const*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO3UcO3UcOROOTcLcLMathcLcLMatRepStdlEfloatcO3cO3gRsPgRcLcLSMatrixRow_const(void *p) {
      delete [] (static_cast<::ROOT::Math::SMatrix<float,3U,3U,ROOT::Math::MatRepStd<float,3,3> >::SMatrixRow_const*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO3UcO3UcOROOTcLcLMathcLcLMatRepStdlEfloatcO3cO3gRsPgRcLcLSMatrixRow_const(void *p) {
      typedef ::ROOT::Math::SMatrix<float,3U,3U,ROOT::Math::MatRepStd<float,3,3> >::SMatrixRow_const current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SMatrix<float,3U,3U,ROOT::Math::MatRepStd<float,3,3> >::SMatrixRow_const

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMathcLcLSMatrixlEfloatcO4cO4cOROOTcLcLMathcLcLMatRepStdlEfloatcO4cO4gRsPgR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SMatrix<float,4,4,ROOT::Math::MatRepStd<float,4,4> > : new ::ROOT::Math::SMatrix<float,4,4,ROOT::Math::MatRepStd<float,4,4> >;
   }
   static void *newArray_ROOTcLcLMathcLcLSMatrixlEfloatcO4cO4cOROOTcLcLMathcLcLMatRepStdlEfloatcO4cO4gRsPgR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SMatrix<float,4,4,ROOT::Math::MatRepStd<float,4,4> >[nElements] : new ::ROOT::Math::SMatrix<float,4,4,ROOT::Math::MatRepStd<float,4,4> >[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSMatrixlEfloatcO4cO4cOROOTcLcLMathcLcLMatRepStdlEfloatcO4cO4gRsPgR(void *p) {
      delete (static_cast<::ROOT::Math::SMatrix<float,4,4,ROOT::Math::MatRepStd<float,4,4> >*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO4cO4cOROOTcLcLMathcLcLMatRepStdlEfloatcO4cO4gRsPgR(void *p) {
      delete [] (static_cast<::ROOT::Math::SMatrix<float,4,4,ROOT::Math::MatRepStd<float,4,4> >*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO4cO4cOROOTcLcLMathcLcLMatRepStdlEfloatcO4cO4gRsPgR(void *p) {
      typedef ::ROOT::Math::SMatrix<float,4,4,ROOT::Math::MatRepStd<float,4,4> > current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SMatrix<float,4,4,ROOT::Math::MatRepStd<float,4,4> >

namespace ROOT {
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSMatrixlEfloatcO4UcO4UcOROOTcLcLMathcLcLMatRepStdlEfloatcO4cO4gRsPgRcLcLSMatrixRow(void *p) {
      delete (static_cast<::ROOT::Math::SMatrix<float,4U,4U,ROOT::Math::MatRepStd<float,4,4> >::SMatrixRow*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO4UcO4UcOROOTcLcLMathcLcLMatRepStdlEfloatcO4cO4gRsPgRcLcLSMatrixRow(void *p) {
      delete [] (static_cast<::ROOT::Math::SMatrix<float,4U,4U,ROOT::Math::MatRepStd<float,4,4> >::SMatrixRow*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO4UcO4UcOROOTcLcLMathcLcLMatRepStdlEfloatcO4cO4gRsPgRcLcLSMatrixRow(void *p) {
      typedef ::ROOT::Math::SMatrix<float,4U,4U,ROOT::Math::MatRepStd<float,4,4> >::SMatrixRow current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SMatrix<float,4U,4U,ROOT::Math::MatRepStd<float,4,4> >::SMatrixRow

namespace ROOT {
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSMatrixlEfloatcO4UcO4UcOROOTcLcLMathcLcLMatRepStdlEfloatcO4cO4gRsPgRcLcLSMatrixRow_const(void *p) {
      delete (static_cast<::ROOT::Math::SMatrix<float,4U,4U,ROOT::Math::MatRepStd<float,4,4> >::SMatrixRow_const*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO4UcO4UcOROOTcLcLMathcLcLMatRepStdlEfloatcO4cO4gRsPgRcLcLSMatrixRow_const(void *p) {
      delete [] (static_cast<::ROOT::Math::SMatrix<float,4U,4U,ROOT::Math::MatRepStd<float,4,4> >::SMatrixRow_const*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO4UcO4UcOROOTcLcLMathcLcLMatRepStdlEfloatcO4cO4gRsPgRcLcLSMatrixRow_const(void *p) {
      typedef ::ROOT::Math::SMatrix<float,4U,4U,ROOT::Math::MatRepStd<float,4,4> >::SMatrixRow_const current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SMatrix<float,4U,4U,ROOT::Math::MatRepStd<float,4,4> >::SMatrixRow_const

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMathcLcLSMatrixlEfloatcO5cO5cOROOTcLcLMathcLcLMatRepStdlEfloatcO5cO5gRsPgR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SMatrix<float,5,5,ROOT::Math::MatRepStd<float,5,5> > : new ::ROOT::Math::SMatrix<float,5,5,ROOT::Math::MatRepStd<float,5,5> >;
   }
   static void *newArray_ROOTcLcLMathcLcLSMatrixlEfloatcO5cO5cOROOTcLcLMathcLcLMatRepStdlEfloatcO5cO5gRsPgR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SMatrix<float,5,5,ROOT::Math::MatRepStd<float,5,5> >[nElements] : new ::ROOT::Math::SMatrix<float,5,5,ROOT::Math::MatRepStd<float,5,5> >[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSMatrixlEfloatcO5cO5cOROOTcLcLMathcLcLMatRepStdlEfloatcO5cO5gRsPgR(void *p) {
      delete (static_cast<::ROOT::Math::SMatrix<float,5,5,ROOT::Math::MatRepStd<float,5,5> >*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO5cO5cOROOTcLcLMathcLcLMatRepStdlEfloatcO5cO5gRsPgR(void *p) {
      delete [] (static_cast<::ROOT::Math::SMatrix<float,5,5,ROOT::Math::MatRepStd<float,5,5> >*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO5cO5cOROOTcLcLMathcLcLMatRepStdlEfloatcO5cO5gRsPgR(void *p) {
      typedef ::ROOT::Math::SMatrix<float,5,5,ROOT::Math::MatRepStd<float,5,5> > current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SMatrix<float,5,5,ROOT::Math::MatRepStd<float,5,5> >

namespace ROOT {
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSMatrixlEfloatcO5UcO5UcOROOTcLcLMathcLcLMatRepStdlEfloatcO5cO5gRsPgRcLcLSMatrixRow(void *p) {
      delete (static_cast<::ROOT::Math::SMatrix<float,5U,5U,ROOT::Math::MatRepStd<float,5,5> >::SMatrixRow*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO5UcO5UcOROOTcLcLMathcLcLMatRepStdlEfloatcO5cO5gRsPgRcLcLSMatrixRow(void *p) {
      delete [] (static_cast<::ROOT::Math::SMatrix<float,5U,5U,ROOT::Math::MatRepStd<float,5,5> >::SMatrixRow*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO5UcO5UcOROOTcLcLMathcLcLMatRepStdlEfloatcO5cO5gRsPgRcLcLSMatrixRow(void *p) {
      typedef ::ROOT::Math::SMatrix<float,5U,5U,ROOT::Math::MatRepStd<float,5,5> >::SMatrixRow current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SMatrix<float,5U,5U,ROOT::Math::MatRepStd<float,5,5> >::SMatrixRow

namespace ROOT {
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSMatrixlEfloatcO5UcO5UcOROOTcLcLMathcLcLMatRepStdlEfloatcO5cO5gRsPgRcLcLSMatrixRow_const(void *p) {
      delete (static_cast<::ROOT::Math::SMatrix<float,5U,5U,ROOT::Math::MatRepStd<float,5,5> >::SMatrixRow_const*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO5UcO5UcOROOTcLcLMathcLcLMatRepStdlEfloatcO5cO5gRsPgRcLcLSMatrixRow_const(void *p) {
      delete [] (static_cast<::ROOT::Math::SMatrix<float,5U,5U,ROOT::Math::MatRepStd<float,5,5> >::SMatrixRow_const*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO5UcO5UcOROOTcLcLMathcLcLMatRepStdlEfloatcO5cO5gRsPgRcLcLSMatrixRow_const(void *p) {
      typedef ::ROOT::Math::SMatrix<float,5U,5U,ROOT::Math::MatRepStd<float,5,5> >::SMatrixRow_const current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SMatrix<float,5U,5U,ROOT::Math::MatRepStd<float,5,5> >::SMatrixRow_const

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMathcLcLSMatrixlEfloatcO6cO6cOROOTcLcLMathcLcLMatRepStdlEfloatcO6cO6gRsPgR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SMatrix<float,6,6,ROOT::Math::MatRepStd<float,6,6> > : new ::ROOT::Math::SMatrix<float,6,6,ROOT::Math::MatRepStd<float,6,6> >;
   }
   static void *newArray_ROOTcLcLMathcLcLSMatrixlEfloatcO6cO6cOROOTcLcLMathcLcLMatRepStdlEfloatcO6cO6gRsPgR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SMatrix<float,6,6,ROOT::Math::MatRepStd<float,6,6> >[nElements] : new ::ROOT::Math::SMatrix<float,6,6,ROOT::Math::MatRepStd<float,6,6> >[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSMatrixlEfloatcO6cO6cOROOTcLcLMathcLcLMatRepStdlEfloatcO6cO6gRsPgR(void *p) {
      delete (static_cast<::ROOT::Math::SMatrix<float,6,6,ROOT::Math::MatRepStd<float,6,6> >*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO6cO6cOROOTcLcLMathcLcLMatRepStdlEfloatcO6cO6gRsPgR(void *p) {
      delete [] (static_cast<::ROOT::Math::SMatrix<float,6,6,ROOT::Math::MatRepStd<float,6,6> >*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO6cO6cOROOTcLcLMathcLcLMatRepStdlEfloatcO6cO6gRsPgR(void *p) {
      typedef ::ROOT::Math::SMatrix<float,6,6,ROOT::Math::MatRepStd<float,6,6> > current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SMatrix<float,6,6,ROOT::Math::MatRepStd<float,6,6> >

namespace ROOT {
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSMatrixlEfloatcO6UcO6UcOROOTcLcLMathcLcLMatRepStdlEfloatcO6cO6gRsPgRcLcLSMatrixRow(void *p) {
      delete (static_cast<::ROOT::Math::SMatrix<float,6U,6U,ROOT::Math::MatRepStd<float,6,6> >::SMatrixRow*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO6UcO6UcOROOTcLcLMathcLcLMatRepStdlEfloatcO6cO6gRsPgRcLcLSMatrixRow(void *p) {
      delete [] (static_cast<::ROOT::Math::SMatrix<float,6U,6U,ROOT::Math::MatRepStd<float,6,6> >::SMatrixRow*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO6UcO6UcOROOTcLcLMathcLcLMatRepStdlEfloatcO6cO6gRsPgRcLcLSMatrixRow(void *p) {
      typedef ::ROOT::Math::SMatrix<float,6U,6U,ROOT::Math::MatRepStd<float,6,6> >::SMatrixRow current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SMatrix<float,6U,6U,ROOT::Math::MatRepStd<float,6,6> >::SMatrixRow

namespace ROOT {
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSMatrixlEfloatcO6UcO6UcOROOTcLcLMathcLcLMatRepStdlEfloatcO6cO6gRsPgRcLcLSMatrixRow_const(void *p) {
      delete (static_cast<::ROOT::Math::SMatrix<float,6U,6U,ROOT::Math::MatRepStd<float,6,6> >::SMatrixRow_const*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO6UcO6UcOROOTcLcLMathcLcLMatRepStdlEfloatcO6cO6gRsPgRcLcLSMatrixRow_const(void *p) {
      delete [] (static_cast<::ROOT::Math::SMatrix<float,6U,6U,ROOT::Math::MatRepStd<float,6,6> >::SMatrixRow_const*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO6UcO6UcOROOTcLcLMathcLcLMatRepStdlEfloatcO6cO6gRsPgRcLcLSMatrixRow_const(void *p) {
      typedef ::ROOT::Math::SMatrix<float,6U,6U,ROOT::Math::MatRepStd<float,6,6> >::SMatrixRow_const current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SMatrix<float,6U,6U,ROOT::Math::MatRepStd<float,6,6> >::SMatrixRow_const

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMathcLcLSMatrixlEfloatcO7cO7cOROOTcLcLMathcLcLMatRepStdlEfloatcO7cO7gRsPgR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SMatrix<float,7,7,ROOT::Math::MatRepStd<float,7,7> > : new ::ROOT::Math::SMatrix<float,7,7,ROOT::Math::MatRepStd<float,7,7> >;
   }
   static void *newArray_ROOTcLcLMathcLcLSMatrixlEfloatcO7cO7cOROOTcLcLMathcLcLMatRepStdlEfloatcO7cO7gRsPgR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SMatrix<float,7,7,ROOT::Math::MatRepStd<float,7,7> >[nElements] : new ::ROOT::Math::SMatrix<float,7,7,ROOT::Math::MatRepStd<float,7,7> >[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSMatrixlEfloatcO7cO7cOROOTcLcLMathcLcLMatRepStdlEfloatcO7cO7gRsPgR(void *p) {
      delete (static_cast<::ROOT::Math::SMatrix<float,7,7,ROOT::Math::MatRepStd<float,7,7> >*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO7cO7cOROOTcLcLMathcLcLMatRepStdlEfloatcO7cO7gRsPgR(void *p) {
      delete [] (static_cast<::ROOT::Math::SMatrix<float,7,7,ROOT::Math::MatRepStd<float,7,7> >*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO7cO7cOROOTcLcLMathcLcLMatRepStdlEfloatcO7cO7gRsPgR(void *p) {
      typedef ::ROOT::Math::SMatrix<float,7,7,ROOT::Math::MatRepStd<float,7,7> > current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SMatrix<float,7,7,ROOT::Math::MatRepStd<float,7,7> >

namespace ROOT {
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSMatrixlEfloatcO7UcO7UcOROOTcLcLMathcLcLMatRepStdlEfloatcO7cO7gRsPgRcLcLSMatrixRow(void *p) {
      delete (static_cast<::ROOT::Math::SMatrix<float,7U,7U,ROOT::Math::MatRepStd<float,7,7> >::SMatrixRow*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO7UcO7UcOROOTcLcLMathcLcLMatRepStdlEfloatcO7cO7gRsPgRcLcLSMatrixRow(void *p) {
      delete [] (static_cast<::ROOT::Math::SMatrix<float,7U,7U,ROOT::Math::MatRepStd<float,7,7> >::SMatrixRow*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO7UcO7UcOROOTcLcLMathcLcLMatRepStdlEfloatcO7cO7gRsPgRcLcLSMatrixRow(void *p) {
      typedef ::ROOT::Math::SMatrix<float,7U,7U,ROOT::Math::MatRepStd<float,7,7> >::SMatrixRow current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SMatrix<float,7U,7U,ROOT::Math::MatRepStd<float,7,7> >::SMatrixRow

namespace ROOT {
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSMatrixlEfloatcO7UcO7UcOROOTcLcLMathcLcLMatRepStdlEfloatcO7cO7gRsPgRcLcLSMatrixRow_const(void *p) {
      delete (static_cast<::ROOT::Math::SMatrix<float,7U,7U,ROOT::Math::MatRepStd<float,7,7> >::SMatrixRow_const*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO7UcO7UcOROOTcLcLMathcLcLMatRepStdlEfloatcO7cO7gRsPgRcLcLSMatrixRow_const(void *p) {
      delete [] (static_cast<::ROOT::Math::SMatrix<float,7U,7U,ROOT::Math::MatRepStd<float,7,7> >::SMatrixRow_const*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO7UcO7UcOROOTcLcLMathcLcLMatRepStdlEfloatcO7cO7gRsPgRcLcLSMatrixRow_const(void *p) {
      typedef ::ROOT::Math::SMatrix<float,7U,7U,ROOT::Math::MatRepStd<float,7,7> >::SMatrixRow_const current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SMatrix<float,7U,7U,ROOT::Math::MatRepStd<float,7,7> >::SMatrixRow_const

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMathcLcLSMatrixlEfloatcO2cO2cOROOTcLcLMathcLcLMatRepSymlEfloatcO2gRsPgR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SMatrix<float,2,2,ROOT::Math::MatRepSym<float,2> > : new ::ROOT::Math::SMatrix<float,2,2,ROOT::Math::MatRepSym<float,2> >;
   }
   static void *newArray_ROOTcLcLMathcLcLSMatrixlEfloatcO2cO2cOROOTcLcLMathcLcLMatRepSymlEfloatcO2gRsPgR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SMatrix<float,2,2,ROOT::Math::MatRepSym<float,2> >[nElements] : new ::ROOT::Math::SMatrix<float,2,2,ROOT::Math::MatRepSym<float,2> >[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSMatrixlEfloatcO2cO2cOROOTcLcLMathcLcLMatRepSymlEfloatcO2gRsPgR(void *p) {
      delete (static_cast<::ROOT::Math::SMatrix<float,2,2,ROOT::Math::MatRepSym<float,2> >*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO2cO2cOROOTcLcLMathcLcLMatRepSymlEfloatcO2gRsPgR(void *p) {
      delete [] (static_cast<::ROOT::Math::SMatrix<float,2,2,ROOT::Math::MatRepSym<float,2> >*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO2cO2cOROOTcLcLMathcLcLMatRepSymlEfloatcO2gRsPgR(void *p) {
      typedef ::ROOT::Math::SMatrix<float,2,2,ROOT::Math::MatRepSym<float,2> > current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SMatrix<float,2,2,ROOT::Math::MatRepSym<float,2> >

namespace ROOT {
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSMatrixlEfloatcO2UcO2UcOROOTcLcLMathcLcLMatRepSymlEfloatcO2gRsPgRcLcLSMatrixRow(void *p) {
      delete (static_cast<::ROOT::Math::SMatrix<float,2U,2U,ROOT::Math::MatRepSym<float,2> >::SMatrixRow*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO2UcO2UcOROOTcLcLMathcLcLMatRepSymlEfloatcO2gRsPgRcLcLSMatrixRow(void *p) {
      delete [] (static_cast<::ROOT::Math::SMatrix<float,2U,2U,ROOT::Math::MatRepSym<float,2> >::SMatrixRow*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO2UcO2UcOROOTcLcLMathcLcLMatRepSymlEfloatcO2gRsPgRcLcLSMatrixRow(void *p) {
      typedef ::ROOT::Math::SMatrix<float,2U,2U,ROOT::Math::MatRepSym<float,2> >::SMatrixRow current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SMatrix<float,2U,2U,ROOT::Math::MatRepSym<float,2> >::SMatrixRow

namespace ROOT {
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSMatrixlEfloatcO2UcO2UcOROOTcLcLMathcLcLMatRepSymlEfloatcO2gRsPgRcLcLSMatrixRow_const(void *p) {
      delete (static_cast<::ROOT::Math::SMatrix<float,2U,2U,ROOT::Math::MatRepSym<float,2> >::SMatrixRow_const*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO2UcO2UcOROOTcLcLMathcLcLMatRepSymlEfloatcO2gRsPgRcLcLSMatrixRow_const(void *p) {
      delete [] (static_cast<::ROOT::Math::SMatrix<float,2U,2U,ROOT::Math::MatRepSym<float,2> >::SMatrixRow_const*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO2UcO2UcOROOTcLcLMathcLcLMatRepSymlEfloatcO2gRsPgRcLcLSMatrixRow_const(void *p) {
      typedef ::ROOT::Math::SMatrix<float,2U,2U,ROOT::Math::MatRepSym<float,2> >::SMatrixRow_const current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SMatrix<float,2U,2U,ROOT::Math::MatRepSym<float,2> >::SMatrixRow_const

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMathcLcLSMatrixlEfloatcO3cO3cOROOTcLcLMathcLcLMatRepSymlEfloatcO3gRsPgR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SMatrix<float,3,3,ROOT::Math::MatRepSym<float,3> > : new ::ROOT::Math::SMatrix<float,3,3,ROOT::Math::MatRepSym<float,3> >;
   }
   static void *newArray_ROOTcLcLMathcLcLSMatrixlEfloatcO3cO3cOROOTcLcLMathcLcLMatRepSymlEfloatcO3gRsPgR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SMatrix<float,3,3,ROOT::Math::MatRepSym<float,3> >[nElements] : new ::ROOT::Math::SMatrix<float,3,3,ROOT::Math::MatRepSym<float,3> >[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSMatrixlEfloatcO3cO3cOROOTcLcLMathcLcLMatRepSymlEfloatcO3gRsPgR(void *p) {
      delete (static_cast<::ROOT::Math::SMatrix<float,3,3,ROOT::Math::MatRepSym<float,3> >*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO3cO3cOROOTcLcLMathcLcLMatRepSymlEfloatcO3gRsPgR(void *p) {
      delete [] (static_cast<::ROOT::Math::SMatrix<float,3,3,ROOT::Math::MatRepSym<float,3> >*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO3cO3cOROOTcLcLMathcLcLMatRepSymlEfloatcO3gRsPgR(void *p) {
      typedef ::ROOT::Math::SMatrix<float,3,3,ROOT::Math::MatRepSym<float,3> > current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SMatrix<float,3,3,ROOT::Math::MatRepSym<float,3> >

namespace ROOT {
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSMatrixlEfloatcO3UcO3UcOROOTcLcLMathcLcLMatRepSymlEfloatcO3gRsPgRcLcLSMatrixRow(void *p) {
      delete (static_cast<::ROOT::Math::SMatrix<float,3U,3U,ROOT::Math::MatRepSym<float,3> >::SMatrixRow*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO3UcO3UcOROOTcLcLMathcLcLMatRepSymlEfloatcO3gRsPgRcLcLSMatrixRow(void *p) {
      delete [] (static_cast<::ROOT::Math::SMatrix<float,3U,3U,ROOT::Math::MatRepSym<float,3> >::SMatrixRow*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO3UcO3UcOROOTcLcLMathcLcLMatRepSymlEfloatcO3gRsPgRcLcLSMatrixRow(void *p) {
      typedef ::ROOT::Math::SMatrix<float,3U,3U,ROOT::Math::MatRepSym<float,3> >::SMatrixRow current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SMatrix<float,3U,3U,ROOT::Math::MatRepSym<float,3> >::SMatrixRow

namespace ROOT {
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSMatrixlEfloatcO3UcO3UcOROOTcLcLMathcLcLMatRepSymlEfloatcO3gRsPgRcLcLSMatrixRow_const(void *p) {
      delete (static_cast<::ROOT::Math::SMatrix<float,3U,3U,ROOT::Math::MatRepSym<float,3> >::SMatrixRow_const*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO3UcO3UcOROOTcLcLMathcLcLMatRepSymlEfloatcO3gRsPgRcLcLSMatrixRow_const(void *p) {
      delete [] (static_cast<::ROOT::Math::SMatrix<float,3U,3U,ROOT::Math::MatRepSym<float,3> >::SMatrixRow_const*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO3UcO3UcOROOTcLcLMathcLcLMatRepSymlEfloatcO3gRsPgRcLcLSMatrixRow_const(void *p) {
      typedef ::ROOT::Math::SMatrix<float,3U,3U,ROOT::Math::MatRepSym<float,3> >::SMatrixRow_const current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SMatrix<float,3U,3U,ROOT::Math::MatRepSym<float,3> >::SMatrixRow_const

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMathcLcLSMatrixlEfloatcO4cO4cOROOTcLcLMathcLcLMatRepSymlEfloatcO4gRsPgR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SMatrix<float,4,4,ROOT::Math::MatRepSym<float,4> > : new ::ROOT::Math::SMatrix<float,4,4,ROOT::Math::MatRepSym<float,4> >;
   }
   static void *newArray_ROOTcLcLMathcLcLSMatrixlEfloatcO4cO4cOROOTcLcLMathcLcLMatRepSymlEfloatcO4gRsPgR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SMatrix<float,4,4,ROOT::Math::MatRepSym<float,4> >[nElements] : new ::ROOT::Math::SMatrix<float,4,4,ROOT::Math::MatRepSym<float,4> >[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSMatrixlEfloatcO4cO4cOROOTcLcLMathcLcLMatRepSymlEfloatcO4gRsPgR(void *p) {
      delete (static_cast<::ROOT::Math::SMatrix<float,4,4,ROOT::Math::MatRepSym<float,4> >*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO4cO4cOROOTcLcLMathcLcLMatRepSymlEfloatcO4gRsPgR(void *p) {
      delete [] (static_cast<::ROOT::Math::SMatrix<float,4,4,ROOT::Math::MatRepSym<float,4> >*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO4cO4cOROOTcLcLMathcLcLMatRepSymlEfloatcO4gRsPgR(void *p) {
      typedef ::ROOT::Math::SMatrix<float,4,4,ROOT::Math::MatRepSym<float,4> > current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SMatrix<float,4,4,ROOT::Math::MatRepSym<float,4> >

namespace ROOT {
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSMatrixlEfloatcO4UcO4UcOROOTcLcLMathcLcLMatRepSymlEfloatcO4gRsPgRcLcLSMatrixRow(void *p) {
      delete (static_cast<::ROOT::Math::SMatrix<float,4U,4U,ROOT::Math::MatRepSym<float,4> >::SMatrixRow*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO4UcO4UcOROOTcLcLMathcLcLMatRepSymlEfloatcO4gRsPgRcLcLSMatrixRow(void *p) {
      delete [] (static_cast<::ROOT::Math::SMatrix<float,4U,4U,ROOT::Math::MatRepSym<float,4> >::SMatrixRow*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO4UcO4UcOROOTcLcLMathcLcLMatRepSymlEfloatcO4gRsPgRcLcLSMatrixRow(void *p) {
      typedef ::ROOT::Math::SMatrix<float,4U,4U,ROOT::Math::MatRepSym<float,4> >::SMatrixRow current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SMatrix<float,4U,4U,ROOT::Math::MatRepSym<float,4> >::SMatrixRow

namespace ROOT {
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSMatrixlEfloatcO4UcO4UcOROOTcLcLMathcLcLMatRepSymlEfloatcO4gRsPgRcLcLSMatrixRow_const(void *p) {
      delete (static_cast<::ROOT::Math::SMatrix<float,4U,4U,ROOT::Math::MatRepSym<float,4> >::SMatrixRow_const*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO4UcO4UcOROOTcLcLMathcLcLMatRepSymlEfloatcO4gRsPgRcLcLSMatrixRow_const(void *p) {
      delete [] (static_cast<::ROOT::Math::SMatrix<float,4U,4U,ROOT::Math::MatRepSym<float,4> >::SMatrixRow_const*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO4UcO4UcOROOTcLcLMathcLcLMatRepSymlEfloatcO4gRsPgRcLcLSMatrixRow_const(void *p) {
      typedef ::ROOT::Math::SMatrix<float,4U,4U,ROOT::Math::MatRepSym<float,4> >::SMatrixRow_const current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SMatrix<float,4U,4U,ROOT::Math::MatRepSym<float,4> >::SMatrixRow_const

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMathcLcLSMatrixlEfloatcO5cO5cOROOTcLcLMathcLcLMatRepSymlEfloatcO5gRsPgR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SMatrix<float,5,5,ROOT::Math::MatRepSym<float,5> > : new ::ROOT::Math::SMatrix<float,5,5,ROOT::Math::MatRepSym<float,5> >;
   }
   static void *newArray_ROOTcLcLMathcLcLSMatrixlEfloatcO5cO5cOROOTcLcLMathcLcLMatRepSymlEfloatcO5gRsPgR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SMatrix<float,5,5,ROOT::Math::MatRepSym<float,5> >[nElements] : new ::ROOT::Math::SMatrix<float,5,5,ROOT::Math::MatRepSym<float,5> >[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSMatrixlEfloatcO5cO5cOROOTcLcLMathcLcLMatRepSymlEfloatcO5gRsPgR(void *p) {
      delete (static_cast<::ROOT::Math::SMatrix<float,5,5,ROOT::Math::MatRepSym<float,5> >*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO5cO5cOROOTcLcLMathcLcLMatRepSymlEfloatcO5gRsPgR(void *p) {
      delete [] (static_cast<::ROOT::Math::SMatrix<float,5,5,ROOT::Math::MatRepSym<float,5> >*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO5cO5cOROOTcLcLMathcLcLMatRepSymlEfloatcO5gRsPgR(void *p) {
      typedef ::ROOT::Math::SMatrix<float,5,5,ROOT::Math::MatRepSym<float,5> > current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SMatrix<float,5,5,ROOT::Math::MatRepSym<float,5> >

namespace ROOT {
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSMatrixlEfloatcO5UcO5UcOROOTcLcLMathcLcLMatRepSymlEfloatcO5gRsPgRcLcLSMatrixRow(void *p) {
      delete (static_cast<::ROOT::Math::SMatrix<float,5U,5U,ROOT::Math::MatRepSym<float,5> >::SMatrixRow*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO5UcO5UcOROOTcLcLMathcLcLMatRepSymlEfloatcO5gRsPgRcLcLSMatrixRow(void *p) {
      delete [] (static_cast<::ROOT::Math::SMatrix<float,5U,5U,ROOT::Math::MatRepSym<float,5> >::SMatrixRow*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO5UcO5UcOROOTcLcLMathcLcLMatRepSymlEfloatcO5gRsPgRcLcLSMatrixRow(void *p) {
      typedef ::ROOT::Math::SMatrix<float,5U,5U,ROOT::Math::MatRepSym<float,5> >::SMatrixRow current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SMatrix<float,5U,5U,ROOT::Math::MatRepSym<float,5> >::SMatrixRow

namespace ROOT {
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSMatrixlEfloatcO5UcO5UcOROOTcLcLMathcLcLMatRepSymlEfloatcO5gRsPgRcLcLSMatrixRow_const(void *p) {
      delete (static_cast<::ROOT::Math::SMatrix<float,5U,5U,ROOT::Math::MatRepSym<float,5> >::SMatrixRow_const*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO5UcO5UcOROOTcLcLMathcLcLMatRepSymlEfloatcO5gRsPgRcLcLSMatrixRow_const(void *p) {
      delete [] (static_cast<::ROOT::Math::SMatrix<float,5U,5U,ROOT::Math::MatRepSym<float,5> >::SMatrixRow_const*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO5UcO5UcOROOTcLcLMathcLcLMatRepSymlEfloatcO5gRsPgRcLcLSMatrixRow_const(void *p) {
      typedef ::ROOT::Math::SMatrix<float,5U,5U,ROOT::Math::MatRepSym<float,5> >::SMatrixRow_const current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SMatrix<float,5U,5U,ROOT::Math::MatRepSym<float,5> >::SMatrixRow_const

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMathcLcLSMatrixlEfloatcO6cO6cOROOTcLcLMathcLcLMatRepSymlEfloatcO6gRsPgR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SMatrix<float,6,6,ROOT::Math::MatRepSym<float,6> > : new ::ROOT::Math::SMatrix<float,6,6,ROOT::Math::MatRepSym<float,6> >;
   }
   static void *newArray_ROOTcLcLMathcLcLSMatrixlEfloatcO6cO6cOROOTcLcLMathcLcLMatRepSymlEfloatcO6gRsPgR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SMatrix<float,6,6,ROOT::Math::MatRepSym<float,6> >[nElements] : new ::ROOT::Math::SMatrix<float,6,6,ROOT::Math::MatRepSym<float,6> >[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSMatrixlEfloatcO6cO6cOROOTcLcLMathcLcLMatRepSymlEfloatcO6gRsPgR(void *p) {
      delete (static_cast<::ROOT::Math::SMatrix<float,6,6,ROOT::Math::MatRepSym<float,6> >*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO6cO6cOROOTcLcLMathcLcLMatRepSymlEfloatcO6gRsPgR(void *p) {
      delete [] (static_cast<::ROOT::Math::SMatrix<float,6,6,ROOT::Math::MatRepSym<float,6> >*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO6cO6cOROOTcLcLMathcLcLMatRepSymlEfloatcO6gRsPgR(void *p) {
      typedef ::ROOT::Math::SMatrix<float,6,6,ROOT::Math::MatRepSym<float,6> > current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SMatrix<float,6,6,ROOT::Math::MatRepSym<float,6> >

namespace ROOT {
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSMatrixlEfloatcO6UcO6UcOROOTcLcLMathcLcLMatRepSymlEfloatcO6gRsPgRcLcLSMatrixRow(void *p) {
      delete (static_cast<::ROOT::Math::SMatrix<float,6U,6U,ROOT::Math::MatRepSym<float,6> >::SMatrixRow*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO6UcO6UcOROOTcLcLMathcLcLMatRepSymlEfloatcO6gRsPgRcLcLSMatrixRow(void *p) {
      delete [] (static_cast<::ROOT::Math::SMatrix<float,6U,6U,ROOT::Math::MatRepSym<float,6> >::SMatrixRow*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO6UcO6UcOROOTcLcLMathcLcLMatRepSymlEfloatcO6gRsPgRcLcLSMatrixRow(void *p) {
      typedef ::ROOT::Math::SMatrix<float,6U,6U,ROOT::Math::MatRepSym<float,6> >::SMatrixRow current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SMatrix<float,6U,6U,ROOT::Math::MatRepSym<float,6> >::SMatrixRow

namespace ROOT {
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSMatrixlEfloatcO6UcO6UcOROOTcLcLMathcLcLMatRepSymlEfloatcO6gRsPgRcLcLSMatrixRow_const(void *p) {
      delete (static_cast<::ROOT::Math::SMatrix<float,6U,6U,ROOT::Math::MatRepSym<float,6> >::SMatrixRow_const*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO6UcO6UcOROOTcLcLMathcLcLMatRepSymlEfloatcO6gRsPgRcLcLSMatrixRow_const(void *p) {
      delete [] (static_cast<::ROOT::Math::SMatrix<float,6U,6U,ROOT::Math::MatRepSym<float,6> >::SMatrixRow_const*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO6UcO6UcOROOTcLcLMathcLcLMatRepSymlEfloatcO6gRsPgRcLcLSMatrixRow_const(void *p) {
      typedef ::ROOT::Math::SMatrix<float,6U,6U,ROOT::Math::MatRepSym<float,6> >::SMatrixRow_const current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SMatrix<float,6U,6U,ROOT::Math::MatRepSym<float,6> >::SMatrixRow_const

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMathcLcLSMatrixlEfloatcO7cO7cOROOTcLcLMathcLcLMatRepSymlEfloatcO7gRsPgR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SMatrix<float,7,7,ROOT::Math::MatRepSym<float,7> > : new ::ROOT::Math::SMatrix<float,7,7,ROOT::Math::MatRepSym<float,7> >;
   }
   static void *newArray_ROOTcLcLMathcLcLSMatrixlEfloatcO7cO7cOROOTcLcLMathcLcLMatRepSymlEfloatcO7gRsPgR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SMatrix<float,7,7,ROOT::Math::MatRepSym<float,7> >[nElements] : new ::ROOT::Math::SMatrix<float,7,7,ROOT::Math::MatRepSym<float,7> >[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSMatrixlEfloatcO7cO7cOROOTcLcLMathcLcLMatRepSymlEfloatcO7gRsPgR(void *p) {
      delete (static_cast<::ROOT::Math::SMatrix<float,7,7,ROOT::Math::MatRepSym<float,7> >*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO7cO7cOROOTcLcLMathcLcLMatRepSymlEfloatcO7gRsPgR(void *p) {
      delete [] (static_cast<::ROOT::Math::SMatrix<float,7,7,ROOT::Math::MatRepSym<float,7> >*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO7cO7cOROOTcLcLMathcLcLMatRepSymlEfloatcO7gRsPgR(void *p) {
      typedef ::ROOT::Math::SMatrix<float,7,7,ROOT::Math::MatRepSym<float,7> > current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SMatrix<float,7,7,ROOT::Math::MatRepSym<float,7> >

namespace ROOT {
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSMatrixlEfloatcO7UcO7UcOROOTcLcLMathcLcLMatRepSymlEfloatcO7gRsPgRcLcLSMatrixRow(void *p) {
      delete (static_cast<::ROOT::Math::SMatrix<float,7U,7U,ROOT::Math::MatRepSym<float,7> >::SMatrixRow*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO7UcO7UcOROOTcLcLMathcLcLMatRepSymlEfloatcO7gRsPgRcLcLSMatrixRow(void *p) {
      delete [] (static_cast<::ROOT::Math::SMatrix<float,7U,7U,ROOT::Math::MatRepSym<float,7> >::SMatrixRow*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO7UcO7UcOROOTcLcLMathcLcLMatRepSymlEfloatcO7gRsPgRcLcLSMatrixRow(void *p) {
      typedef ::ROOT::Math::SMatrix<float,7U,7U,ROOT::Math::MatRepSym<float,7> >::SMatrixRow current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SMatrix<float,7U,7U,ROOT::Math::MatRepSym<float,7> >::SMatrixRow

namespace ROOT {
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSMatrixlEfloatcO7UcO7UcOROOTcLcLMathcLcLMatRepSymlEfloatcO7gRsPgRcLcLSMatrixRow_const(void *p) {
      delete (static_cast<::ROOT::Math::SMatrix<float,7U,7U,ROOT::Math::MatRepSym<float,7> >::SMatrixRow_const*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO7UcO7UcOROOTcLcLMathcLcLMatRepSymlEfloatcO7gRsPgRcLcLSMatrixRow_const(void *p) {
      delete [] (static_cast<::ROOT::Math::SMatrix<float,7U,7U,ROOT::Math::MatRepSym<float,7> >::SMatrixRow_const*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO7UcO7UcOROOTcLcLMathcLcLMatRepSymlEfloatcO7gRsPgRcLcLSMatrixRow_const(void *p) {
      typedef ::ROOT::Math::SMatrix<float,7U,7U,ROOT::Math::MatRepSym<float,7> >::SMatrixRow_const current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SMatrix<float,7U,7U,ROOT::Math::MatRepSym<float,7> >::SMatrixRow_const

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMathcLcLSMatrixlEdoublecO4cO3cOROOTcLcLMathcLcLMatRepStdlEdoublecO4cO3gRsPgR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SMatrix<double,4,3,ROOT::Math::MatRepStd<double,4,3> > : new ::ROOT::Math::SMatrix<double,4,3,ROOT::Math::MatRepStd<double,4,3> >;
   }
   static void *newArray_ROOTcLcLMathcLcLSMatrixlEdoublecO4cO3cOROOTcLcLMathcLcLMatRepStdlEdoublecO4cO3gRsPgR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SMatrix<double,4,3,ROOT::Math::MatRepStd<double,4,3> >[nElements] : new ::ROOT::Math::SMatrix<double,4,3,ROOT::Math::MatRepStd<double,4,3> >[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSMatrixlEdoublecO4cO3cOROOTcLcLMathcLcLMatRepStdlEdoublecO4cO3gRsPgR(void *p) {
      delete (static_cast<::ROOT::Math::SMatrix<double,4,3,ROOT::Math::MatRepStd<double,4,3> >*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO4cO3cOROOTcLcLMathcLcLMatRepStdlEdoublecO4cO3gRsPgR(void *p) {
      delete [] (static_cast<::ROOT::Math::SMatrix<double,4,3,ROOT::Math::MatRepStd<double,4,3> >*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO4cO3cOROOTcLcLMathcLcLMatRepStdlEdoublecO4cO3gRsPgR(void *p) {
      typedef ::ROOT::Math::SMatrix<double,4,3,ROOT::Math::MatRepStd<double,4,3> > current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SMatrix<double,4,3,ROOT::Math::MatRepStd<double,4,3> >

namespace ROOT {
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSMatrixlEdoublecO4UcO3UcOROOTcLcLMathcLcLMatRepStdlEdoublecO4cO3gRsPgRcLcLSMatrixRow(void *p) {
      delete (static_cast<::ROOT::Math::SMatrix<double,4U,3U,ROOT::Math::MatRepStd<double,4,3> >::SMatrixRow*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO4UcO3UcOROOTcLcLMathcLcLMatRepStdlEdoublecO4cO3gRsPgRcLcLSMatrixRow(void *p) {
      delete [] (static_cast<::ROOT::Math::SMatrix<double,4U,3U,ROOT::Math::MatRepStd<double,4,3> >::SMatrixRow*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO4UcO3UcOROOTcLcLMathcLcLMatRepStdlEdoublecO4cO3gRsPgRcLcLSMatrixRow(void *p) {
      typedef ::ROOT::Math::SMatrix<double,4U,3U,ROOT::Math::MatRepStd<double,4,3> >::SMatrixRow current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SMatrix<double,4U,3U,ROOT::Math::MatRepStd<double,4,3> >::SMatrixRow

namespace ROOT {
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSMatrixlEdoublecO4UcO3UcOROOTcLcLMathcLcLMatRepStdlEdoublecO4cO3gRsPgRcLcLSMatrixRow_const(void *p) {
      delete (static_cast<::ROOT::Math::SMatrix<double,4U,3U,ROOT::Math::MatRepStd<double,4,3> >::SMatrixRow_const*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO4UcO3UcOROOTcLcLMathcLcLMatRepStdlEdoublecO4cO3gRsPgRcLcLSMatrixRow_const(void *p) {
      delete [] (static_cast<::ROOT::Math::SMatrix<double,4U,3U,ROOT::Math::MatRepStd<double,4,3> >::SMatrixRow_const*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO4UcO3UcOROOTcLcLMathcLcLMatRepStdlEdoublecO4cO3gRsPgRcLcLSMatrixRow_const(void *p) {
      typedef ::ROOT::Math::SMatrix<double,4U,3U,ROOT::Math::MatRepStd<double,4,3> >::SMatrixRow_const current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SMatrix<double,4U,3U,ROOT::Math::MatRepStd<double,4,3> >::SMatrixRow_const

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMathcLcLSMatrixlEdoublecO3cO4cOROOTcLcLMathcLcLMatRepStdlEdoublecO3cO4gRsPgR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SMatrix<double,3,4,ROOT::Math::MatRepStd<double,3,4> > : new ::ROOT::Math::SMatrix<double,3,4,ROOT::Math::MatRepStd<double,3,4> >;
   }
   static void *newArray_ROOTcLcLMathcLcLSMatrixlEdoublecO3cO4cOROOTcLcLMathcLcLMatRepStdlEdoublecO3cO4gRsPgR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SMatrix<double,3,4,ROOT::Math::MatRepStd<double,3,4> >[nElements] : new ::ROOT::Math::SMatrix<double,3,4,ROOT::Math::MatRepStd<double,3,4> >[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSMatrixlEdoublecO3cO4cOROOTcLcLMathcLcLMatRepStdlEdoublecO3cO4gRsPgR(void *p) {
      delete (static_cast<::ROOT::Math::SMatrix<double,3,4,ROOT::Math::MatRepStd<double,3,4> >*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO3cO4cOROOTcLcLMathcLcLMatRepStdlEdoublecO3cO4gRsPgR(void *p) {
      delete [] (static_cast<::ROOT::Math::SMatrix<double,3,4,ROOT::Math::MatRepStd<double,3,4> >*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO3cO4cOROOTcLcLMathcLcLMatRepStdlEdoublecO3cO4gRsPgR(void *p) {
      typedef ::ROOT::Math::SMatrix<double,3,4,ROOT::Math::MatRepStd<double,3,4> > current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SMatrix<double,3,4,ROOT::Math::MatRepStd<double,3,4> >

namespace ROOT {
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSMatrixlEdoublecO3UcO4UcOROOTcLcLMathcLcLMatRepStdlEdoublecO3cO4gRsPgRcLcLSMatrixRow(void *p) {
      delete (static_cast<::ROOT::Math::SMatrix<double,3U,4U,ROOT::Math::MatRepStd<double,3,4> >::SMatrixRow*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO3UcO4UcOROOTcLcLMathcLcLMatRepStdlEdoublecO3cO4gRsPgRcLcLSMatrixRow(void *p) {
      delete [] (static_cast<::ROOT::Math::SMatrix<double,3U,4U,ROOT::Math::MatRepStd<double,3,4> >::SMatrixRow*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO3UcO4UcOROOTcLcLMathcLcLMatRepStdlEdoublecO3cO4gRsPgRcLcLSMatrixRow(void *p) {
      typedef ::ROOT::Math::SMatrix<double,3U,4U,ROOT::Math::MatRepStd<double,3,4> >::SMatrixRow current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SMatrix<double,3U,4U,ROOT::Math::MatRepStd<double,3,4> >::SMatrixRow

namespace ROOT {
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSMatrixlEdoublecO3UcO4UcOROOTcLcLMathcLcLMatRepStdlEdoublecO3cO4gRsPgRcLcLSMatrixRow_const(void *p) {
      delete (static_cast<::ROOT::Math::SMatrix<double,3U,4U,ROOT::Math::MatRepStd<double,3,4> >::SMatrixRow_const*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO3UcO4UcOROOTcLcLMathcLcLMatRepStdlEdoublecO3cO4gRsPgRcLcLSMatrixRow_const(void *p) {
      delete [] (static_cast<::ROOT::Math::SMatrix<double,3U,4U,ROOT::Math::MatRepStd<double,3,4> >::SMatrixRow_const*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO3UcO4UcOROOTcLcLMathcLcLMatRepStdlEdoublecO3cO4gRsPgRcLcLSMatrixRow_const(void *p) {
      typedef ::ROOT::Math::SMatrix<double,3U,4U,ROOT::Math::MatRepStd<double,3,4> >::SMatrixRow_const current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SMatrix<double,3U,4U,ROOT::Math::MatRepStd<double,3,4> >::SMatrixRow_const

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMathcLcLSMatrixlEdoublecO9cO7cOROOTcLcLMathcLcLMatRepStdlEdoublecO9cO7gRsPgR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SMatrix<double,9,7,ROOT::Math::MatRepStd<double,9,7> > : new ::ROOT::Math::SMatrix<double,9,7,ROOT::Math::MatRepStd<double,9,7> >;
   }
   static void *newArray_ROOTcLcLMathcLcLSMatrixlEdoublecO9cO7cOROOTcLcLMathcLcLMatRepStdlEdoublecO9cO7gRsPgR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SMatrix<double,9,7,ROOT::Math::MatRepStd<double,9,7> >[nElements] : new ::ROOT::Math::SMatrix<double,9,7,ROOT::Math::MatRepStd<double,9,7> >[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSMatrixlEdoublecO9cO7cOROOTcLcLMathcLcLMatRepStdlEdoublecO9cO7gRsPgR(void *p) {
      delete (static_cast<::ROOT::Math::SMatrix<double,9,7,ROOT::Math::MatRepStd<double,9,7> >*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO9cO7cOROOTcLcLMathcLcLMatRepStdlEdoublecO9cO7gRsPgR(void *p) {
      delete [] (static_cast<::ROOT::Math::SMatrix<double,9,7,ROOT::Math::MatRepStd<double,9,7> >*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO9cO7cOROOTcLcLMathcLcLMatRepStdlEdoublecO9cO7gRsPgR(void *p) {
      typedef ::ROOT::Math::SMatrix<double,9,7,ROOT::Math::MatRepStd<double,9,7> > current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SMatrix<double,9,7,ROOT::Math::MatRepStd<double,9,7> >

namespace ROOT {
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSMatrixlEdoublecO9UcO7UcOROOTcLcLMathcLcLMatRepStdlEdoublecO9cO7gRsPgRcLcLSMatrixRow(void *p) {
      delete (static_cast<::ROOT::Math::SMatrix<double,9U,7U,ROOT::Math::MatRepStd<double,9,7> >::SMatrixRow*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO9UcO7UcOROOTcLcLMathcLcLMatRepStdlEdoublecO9cO7gRsPgRcLcLSMatrixRow(void *p) {
      delete [] (static_cast<::ROOT::Math::SMatrix<double,9U,7U,ROOT::Math::MatRepStd<double,9,7> >::SMatrixRow*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO9UcO7UcOROOTcLcLMathcLcLMatRepStdlEdoublecO9cO7gRsPgRcLcLSMatrixRow(void *p) {
      typedef ::ROOT::Math::SMatrix<double,9U,7U,ROOT::Math::MatRepStd<double,9,7> >::SMatrixRow current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SMatrix<double,9U,7U,ROOT::Math::MatRepStd<double,9,7> >::SMatrixRow

namespace ROOT {
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSMatrixlEdoublecO9UcO7UcOROOTcLcLMathcLcLMatRepStdlEdoublecO9cO7gRsPgRcLcLSMatrixRow_const(void *p) {
      delete (static_cast<::ROOT::Math::SMatrix<double,9U,7U,ROOT::Math::MatRepStd<double,9,7> >::SMatrixRow_const*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEdoublecO9UcO7UcOROOTcLcLMathcLcLMatRepStdlEdoublecO9cO7gRsPgRcLcLSMatrixRow_const(void *p) {
      delete [] (static_cast<::ROOT::Math::SMatrix<double,9U,7U,ROOT::Math::MatRepStd<double,9,7> >::SMatrixRow_const*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSMatrixlEdoublecO9UcO7UcOROOTcLcLMathcLcLMatRepStdlEdoublecO9cO7gRsPgRcLcLSMatrixRow_const(void *p) {
      typedef ::ROOT::Math::SMatrix<double,9U,7U,ROOT::Math::MatRepStd<double,9,7> >::SMatrixRow_const current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SMatrix<double,9U,7U,ROOT::Math::MatRepStd<double,9,7> >::SMatrixRow_const

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMathcLcLSMatrixlEfloatcO4cO3cOROOTcLcLMathcLcLMatRepStdlEfloatcO4cO3gRsPgR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SMatrix<float,4,3,ROOT::Math::MatRepStd<float,4,3> > : new ::ROOT::Math::SMatrix<float,4,3,ROOT::Math::MatRepStd<float,4,3> >;
   }
   static void *newArray_ROOTcLcLMathcLcLSMatrixlEfloatcO4cO3cOROOTcLcLMathcLcLMatRepStdlEfloatcO4cO3gRsPgR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SMatrix<float,4,3,ROOT::Math::MatRepStd<float,4,3> >[nElements] : new ::ROOT::Math::SMatrix<float,4,3,ROOT::Math::MatRepStd<float,4,3> >[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSMatrixlEfloatcO4cO3cOROOTcLcLMathcLcLMatRepStdlEfloatcO4cO3gRsPgR(void *p) {
      delete (static_cast<::ROOT::Math::SMatrix<float,4,3,ROOT::Math::MatRepStd<float,4,3> >*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO4cO3cOROOTcLcLMathcLcLMatRepStdlEfloatcO4cO3gRsPgR(void *p) {
      delete [] (static_cast<::ROOT::Math::SMatrix<float,4,3,ROOT::Math::MatRepStd<float,4,3> >*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO4cO3cOROOTcLcLMathcLcLMatRepStdlEfloatcO4cO3gRsPgR(void *p) {
      typedef ::ROOT::Math::SMatrix<float,4,3,ROOT::Math::MatRepStd<float,4,3> > current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SMatrix<float,4,3,ROOT::Math::MatRepStd<float,4,3> >

namespace ROOT {
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSMatrixlEfloatcO4UcO3UcOROOTcLcLMathcLcLMatRepStdlEfloatcO4cO3gRsPgRcLcLSMatrixRow(void *p) {
      delete (static_cast<::ROOT::Math::SMatrix<float,4U,3U,ROOT::Math::MatRepStd<float,4,3> >::SMatrixRow*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO4UcO3UcOROOTcLcLMathcLcLMatRepStdlEfloatcO4cO3gRsPgRcLcLSMatrixRow(void *p) {
      delete [] (static_cast<::ROOT::Math::SMatrix<float,4U,3U,ROOT::Math::MatRepStd<float,4,3> >::SMatrixRow*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO4UcO3UcOROOTcLcLMathcLcLMatRepStdlEfloatcO4cO3gRsPgRcLcLSMatrixRow(void *p) {
      typedef ::ROOT::Math::SMatrix<float,4U,3U,ROOT::Math::MatRepStd<float,4,3> >::SMatrixRow current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SMatrix<float,4U,3U,ROOT::Math::MatRepStd<float,4,3> >::SMatrixRow

namespace ROOT {
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSMatrixlEfloatcO4UcO3UcOROOTcLcLMathcLcLMatRepStdlEfloatcO4cO3gRsPgRcLcLSMatrixRow_const(void *p) {
      delete (static_cast<::ROOT::Math::SMatrix<float,4U,3U,ROOT::Math::MatRepStd<float,4,3> >::SMatrixRow_const*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO4UcO3UcOROOTcLcLMathcLcLMatRepStdlEfloatcO4cO3gRsPgRcLcLSMatrixRow_const(void *p) {
      delete [] (static_cast<::ROOT::Math::SMatrix<float,4U,3U,ROOT::Math::MatRepStd<float,4,3> >::SMatrixRow_const*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO4UcO3UcOROOTcLcLMathcLcLMatRepStdlEfloatcO4cO3gRsPgRcLcLSMatrixRow_const(void *p) {
      typedef ::ROOT::Math::SMatrix<float,4U,3U,ROOT::Math::MatRepStd<float,4,3> >::SMatrixRow_const current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SMatrix<float,4U,3U,ROOT::Math::MatRepStd<float,4,3> >::SMatrixRow_const

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMathcLcLSMatrixlEfloatcO3cO4cOROOTcLcLMathcLcLMatRepStdlEfloatcO3cO4gRsPgR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SMatrix<float,3,4,ROOT::Math::MatRepStd<float,3,4> > : new ::ROOT::Math::SMatrix<float,3,4,ROOT::Math::MatRepStd<float,3,4> >;
   }
   static void *newArray_ROOTcLcLMathcLcLSMatrixlEfloatcO3cO4cOROOTcLcLMathcLcLMatRepStdlEfloatcO3cO4gRsPgR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SMatrix<float,3,4,ROOT::Math::MatRepStd<float,3,4> >[nElements] : new ::ROOT::Math::SMatrix<float,3,4,ROOT::Math::MatRepStd<float,3,4> >[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSMatrixlEfloatcO3cO4cOROOTcLcLMathcLcLMatRepStdlEfloatcO3cO4gRsPgR(void *p) {
      delete (static_cast<::ROOT::Math::SMatrix<float,3,4,ROOT::Math::MatRepStd<float,3,4> >*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO3cO4cOROOTcLcLMathcLcLMatRepStdlEfloatcO3cO4gRsPgR(void *p) {
      delete [] (static_cast<::ROOT::Math::SMatrix<float,3,4,ROOT::Math::MatRepStd<float,3,4> >*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO3cO4cOROOTcLcLMathcLcLMatRepStdlEfloatcO3cO4gRsPgR(void *p) {
      typedef ::ROOT::Math::SMatrix<float,3,4,ROOT::Math::MatRepStd<float,3,4> > current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SMatrix<float,3,4,ROOT::Math::MatRepStd<float,3,4> >

namespace ROOT {
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSMatrixlEfloatcO3UcO4UcOROOTcLcLMathcLcLMatRepStdlEfloatcO3cO4gRsPgRcLcLSMatrixRow(void *p) {
      delete (static_cast<::ROOT::Math::SMatrix<float,3U,4U,ROOT::Math::MatRepStd<float,3,4> >::SMatrixRow*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO3UcO4UcOROOTcLcLMathcLcLMatRepStdlEfloatcO3cO4gRsPgRcLcLSMatrixRow(void *p) {
      delete [] (static_cast<::ROOT::Math::SMatrix<float,3U,4U,ROOT::Math::MatRepStd<float,3,4> >::SMatrixRow*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO3UcO4UcOROOTcLcLMathcLcLMatRepStdlEfloatcO3cO4gRsPgRcLcLSMatrixRow(void *p) {
      typedef ::ROOT::Math::SMatrix<float,3U,4U,ROOT::Math::MatRepStd<float,3,4> >::SMatrixRow current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SMatrix<float,3U,4U,ROOT::Math::MatRepStd<float,3,4> >::SMatrixRow

namespace ROOT {
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSMatrixlEfloatcO3UcO4UcOROOTcLcLMathcLcLMatRepStdlEfloatcO3cO4gRsPgRcLcLSMatrixRow_const(void *p) {
      delete (static_cast<::ROOT::Math::SMatrix<float,3U,4U,ROOT::Math::MatRepStd<float,3,4> >::SMatrixRow_const*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO3UcO4UcOROOTcLcLMathcLcLMatRepStdlEfloatcO3cO4gRsPgRcLcLSMatrixRow_const(void *p) {
      delete [] (static_cast<::ROOT::Math::SMatrix<float,3U,4U,ROOT::Math::MatRepStd<float,3,4> >::SMatrixRow_const*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO3UcO4UcOROOTcLcLMathcLcLMatRepStdlEfloatcO3cO4gRsPgRcLcLSMatrixRow_const(void *p) {
      typedef ::ROOT::Math::SMatrix<float,3U,4U,ROOT::Math::MatRepStd<float,3,4> >::SMatrixRow_const current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SMatrix<float,3U,4U,ROOT::Math::MatRepStd<float,3,4> >::SMatrixRow_const

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMathcLcLSMatrixlEfloatcO9cO7cOROOTcLcLMathcLcLMatRepStdlEfloatcO9cO7gRsPgR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SMatrix<float,9,7,ROOT::Math::MatRepStd<float,9,7> > : new ::ROOT::Math::SMatrix<float,9,7,ROOT::Math::MatRepStd<float,9,7> >;
   }
   static void *newArray_ROOTcLcLMathcLcLSMatrixlEfloatcO9cO7cOROOTcLcLMathcLcLMatRepStdlEfloatcO9cO7gRsPgR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SMatrix<float,9,7,ROOT::Math::MatRepStd<float,9,7> >[nElements] : new ::ROOT::Math::SMatrix<float,9,7,ROOT::Math::MatRepStd<float,9,7> >[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSMatrixlEfloatcO9cO7cOROOTcLcLMathcLcLMatRepStdlEfloatcO9cO7gRsPgR(void *p) {
      delete (static_cast<::ROOT::Math::SMatrix<float,9,7,ROOT::Math::MatRepStd<float,9,7> >*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO9cO7cOROOTcLcLMathcLcLMatRepStdlEfloatcO9cO7gRsPgR(void *p) {
      delete [] (static_cast<::ROOT::Math::SMatrix<float,9,7,ROOT::Math::MatRepStd<float,9,7> >*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO9cO7cOROOTcLcLMathcLcLMatRepStdlEfloatcO9cO7gRsPgR(void *p) {
      typedef ::ROOT::Math::SMatrix<float,9,7,ROOT::Math::MatRepStd<float,9,7> > current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SMatrix<float,9,7,ROOT::Math::MatRepStd<float,9,7> >

namespace ROOT {
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSMatrixlEfloatcO9UcO7UcOROOTcLcLMathcLcLMatRepStdlEfloatcO9cO7gRsPgRcLcLSMatrixRow(void *p) {
      delete (static_cast<::ROOT::Math::SMatrix<float,9U,7U,ROOT::Math::MatRepStd<float,9,7> >::SMatrixRow*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO9UcO7UcOROOTcLcLMathcLcLMatRepStdlEfloatcO9cO7gRsPgRcLcLSMatrixRow(void *p) {
      delete [] (static_cast<::ROOT::Math::SMatrix<float,9U,7U,ROOT::Math::MatRepStd<float,9,7> >::SMatrixRow*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO9UcO7UcOROOTcLcLMathcLcLMatRepStdlEfloatcO9cO7gRsPgRcLcLSMatrixRow(void *p) {
      typedef ::ROOT::Math::SMatrix<float,9U,7U,ROOT::Math::MatRepStd<float,9,7> >::SMatrixRow current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SMatrix<float,9U,7U,ROOT::Math::MatRepStd<float,9,7> >::SMatrixRow

namespace ROOT {
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSMatrixlEfloatcO9UcO7UcOROOTcLcLMathcLcLMatRepStdlEfloatcO9cO7gRsPgRcLcLSMatrixRow_const(void *p) {
      delete (static_cast<::ROOT::Math::SMatrix<float,9U,7U,ROOT::Math::MatRepStd<float,9,7> >::SMatrixRow_const*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEfloatcO9UcO7UcOROOTcLcLMathcLcLMatRepStdlEfloatcO9cO7gRsPgRcLcLSMatrixRow_const(void *p) {
      delete [] (static_cast<::ROOT::Math::SMatrix<float,9U,7U,ROOT::Math::MatRepStd<float,9,7> >::SMatrixRow_const*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSMatrixlEfloatcO9UcO7UcOROOTcLcLMathcLcLMatRepStdlEfloatcO9cO7gRsPgRcLcLSMatrixRow_const(void *p) {
      typedef ::ROOT::Math::SMatrix<float,9U,7U,ROOT::Math::MatRepStd<float,9,7> >::SMatrixRow_const current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SMatrix<float,9U,7U,ROOT::Math::MatRepStd<float,9,7> >::SMatrixRow_const

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMathcLcLSMatrixIdentity(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SMatrixIdentity : new ::ROOT::Math::SMatrixIdentity;
   }
   static void *newArray_ROOTcLcLMathcLcLSMatrixIdentity(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SMatrixIdentity[nElements] : new ::ROOT::Math::SMatrixIdentity[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSMatrixIdentity(void *p) {
      delete (static_cast<::ROOT::Math::SMatrixIdentity*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSMatrixIdentity(void *p) {
      delete [] (static_cast<::ROOT::Math::SMatrixIdentity*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSMatrixIdentity(void *p) {
      typedef ::ROOT::Math::SMatrixIdentity current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SMatrixIdentity

namespace {
  void TriggerDictionaryInitialization_libSmatrix_Impl() {
    static const char* headers[] = {
nullptr
    };
    static const char* includePaths[] = {
nullptr
    };
    static const char* fwdDeclCode = "";
    static const char* payloadCode = "";
    static const char* classesHeaders[] = {
""
};
    static bool isInitialized = false;
    if (!isInitialized) {
      TROOT::RegisterModule("libSmatrix",
        headers, includePaths, payloadCode, fwdDeclCode,
        TriggerDictionaryInitialization_libSmatrix_Impl, {}, classesHeaders, /*hasCxxModule*/true);
      isInitialized = true;
    }
  }
  static struct DictInit {
    DictInit() {
      TriggerDictionaryInitialization_libSmatrix_Impl();
    }
  } __TheDictionaryInitializer;
}
void TriggerDictionaryInitialization_libSmatrix() {
  TriggerDictionaryInitialization_libSmatrix_Impl();
}