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

#define R__DICTIONARY_FILENAME G__Smatrix32
#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/SMatrix.h"
#include "Math/SMatrixDfwd.h"
#include "Math/SMatrixFfwd.h"
#include "Math/SVector.h"

// Header files passed via #pragma extra_include

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

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLMatRepStdlEDouble32_tcO3cO3gR_Dictionary();
   static void ROOTcLcLMathcLcLMatRepStdlEDouble32_tcO3cO3gR_TClassManip(TClass*);
   static void *new_ROOTcLcLMathcLcLMatRepStdlEDouble32_tcO3cO3gR(void *p = nullptr);
   static void *newArray_ROOTcLcLMathcLcLMatRepStdlEDouble32_tcO3cO3gR(Long_t size, void *p);
   static void delete_ROOTcLcLMathcLcLMatRepStdlEDouble32_tcO3cO3gR(void *p);
   static void deleteArray_ROOTcLcLMathcLcLMatRepStdlEDouble32_tcO3cO3gR(void *p);
   static void destruct_ROOTcLcLMathcLcLMatRepStdlEDouble32_tcO3cO3gR(void *p);

   // Schema evolution read functions

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::MatRepStd<Double32_t,3,3>*)
   {
      ::ROOT::Math::MatRepStd<Double32_t,3,3> *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::MatRepStd<Double32_t,3,3>));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::MatRepStd<Double32_t,3,3>", "Math/MatrixRepresentationsStatic.h", 54,
                  typeid(::ROOT::Math::MatRepStd<Double32_t,3,3>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLMatRepStdlEDouble32_tcO3cO3gR_Dictionary, isa_proxy, 4,
                  sizeof(::ROOT::Math::MatRepStd<Double32_t,3,3>) );
      instance.SetNew(&new_ROOTcLcLMathcLcLMatRepStdlEDouble32_tcO3cO3gR);
      instance.SetNewArray(&newArray_ROOTcLcLMathcLcLMatRepStdlEDouble32_tcO3cO3gR);
      instance.SetDelete(&delete_ROOTcLcLMathcLcLMatRepStdlEDouble32_tcO3cO3gR);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLMatRepStdlEDouble32_tcO3cO3gR);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLMatRepStdlEDouble32_tcO3cO3gR);

      ::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<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;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::MatRepStd<Double32_t,3,3>*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

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

   static void ROOTcLcLMathcLcLMatRepStdlEDouble32_tcO3cO3gR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLMatRepStdlEDouble32_tcO4cO4gR_Dictionary();
   static void ROOTcLcLMathcLcLMatRepStdlEDouble32_tcO4cO4gR_TClassManip(TClass*);
   static void *new_ROOTcLcLMathcLcLMatRepStdlEDouble32_tcO4cO4gR(void *p = nullptr);
   static void *newArray_ROOTcLcLMathcLcLMatRepStdlEDouble32_tcO4cO4gR(Long_t size, void *p);
   static void delete_ROOTcLcLMathcLcLMatRepStdlEDouble32_tcO4cO4gR(void *p);
   static void deleteArray_ROOTcLcLMathcLcLMatRepStdlEDouble32_tcO4cO4gR(void *p);
   static void destruct_ROOTcLcLMathcLcLMatRepStdlEDouble32_tcO4cO4gR(void *p);

   // Schema evolution read functions

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::MatRepStd<Double32_t,4,4>*)
   {
      ::ROOT::Math::MatRepStd<Double32_t,4,4> *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::MatRepStd<Double32_t,4,4>));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::MatRepStd<Double32_t,4,4>", "Math/MatrixRepresentationsStatic.h", 54,
                  typeid(::ROOT::Math::MatRepStd<Double32_t,4,4>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLMatRepStdlEDouble32_tcO4cO4gR_Dictionary, isa_proxy, 4,
                  sizeof(::ROOT::Math::MatRepStd<Double32_t,4,4>) );
      instance.SetNew(&new_ROOTcLcLMathcLcLMatRepStdlEDouble32_tcO4cO4gR);
      instance.SetNewArray(&newArray_ROOTcLcLMathcLcLMatRepStdlEDouble32_tcO4cO4gR);
      instance.SetDelete(&delete_ROOTcLcLMathcLcLMatRepStdlEDouble32_tcO4cO4gR);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLMatRepStdlEDouble32_tcO4cO4gR);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLMatRepStdlEDouble32_tcO4cO4gR);

      ::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<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;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::MatRepStd<Double32_t,4,4>*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

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

   static void ROOTcLcLMathcLcLMatRepStdlEDouble32_tcO4cO4gR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLMatRepStdlEDouble32_tcO5cO5gR_Dictionary();
   static void ROOTcLcLMathcLcLMatRepStdlEDouble32_tcO5cO5gR_TClassManip(TClass*);
   static void *new_ROOTcLcLMathcLcLMatRepStdlEDouble32_tcO5cO5gR(void *p = nullptr);
   static void *newArray_ROOTcLcLMathcLcLMatRepStdlEDouble32_tcO5cO5gR(Long_t size, void *p);
   static void delete_ROOTcLcLMathcLcLMatRepStdlEDouble32_tcO5cO5gR(void *p);
   static void deleteArray_ROOTcLcLMathcLcLMatRepStdlEDouble32_tcO5cO5gR(void *p);
   static void destruct_ROOTcLcLMathcLcLMatRepStdlEDouble32_tcO5cO5gR(void *p);

   // Schema evolution read functions

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::MatRepStd<Double32_t,5,5>*)
   {
      ::ROOT::Math::MatRepStd<Double32_t,5,5> *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::MatRepStd<Double32_t,5,5>));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::MatRepStd<Double32_t,5,5>", "Math/MatrixRepresentationsStatic.h", 54,
                  typeid(::ROOT::Math::MatRepStd<Double32_t,5,5>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLMatRepStdlEDouble32_tcO5cO5gR_Dictionary, isa_proxy, 4,
                  sizeof(::ROOT::Math::MatRepStd<Double32_t,5,5>) );
      instance.SetNew(&new_ROOTcLcLMathcLcLMatRepStdlEDouble32_tcO5cO5gR);
      instance.SetNewArray(&newArray_ROOTcLcLMathcLcLMatRepStdlEDouble32_tcO5cO5gR);
      instance.SetDelete(&delete_ROOTcLcLMathcLcLMatRepStdlEDouble32_tcO5cO5gR);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLMatRepStdlEDouble32_tcO5cO5gR);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLMatRepStdlEDouble32_tcO5cO5gR);

      ::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<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;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::MatRepStd<Double32_t,5,5>*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

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

   static void ROOTcLcLMathcLcLMatRepStdlEDouble32_tcO5cO5gR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLMatRepStdlEDouble32_tcO6cO6gR_Dictionary();
   static void ROOTcLcLMathcLcLMatRepStdlEDouble32_tcO6cO6gR_TClassManip(TClass*);
   static void *new_ROOTcLcLMathcLcLMatRepStdlEDouble32_tcO6cO6gR(void *p = nullptr);
   static void *newArray_ROOTcLcLMathcLcLMatRepStdlEDouble32_tcO6cO6gR(Long_t size, void *p);
   static void delete_ROOTcLcLMathcLcLMatRepStdlEDouble32_tcO6cO6gR(void *p);
   static void deleteArray_ROOTcLcLMathcLcLMatRepStdlEDouble32_tcO6cO6gR(void *p);
   static void destruct_ROOTcLcLMathcLcLMatRepStdlEDouble32_tcO6cO6gR(void *p);

   // Schema evolution read functions

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::MatRepStd<Double32_t,6,6>*)
   {
      ::ROOT::Math::MatRepStd<Double32_t,6,6> *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::MatRepStd<Double32_t,6,6>));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::MatRepStd<Double32_t,6,6>", "Math/MatrixRepresentationsStatic.h", 54,
                  typeid(::ROOT::Math::MatRepStd<Double32_t,6,6>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLMatRepStdlEDouble32_tcO6cO6gR_Dictionary, isa_proxy, 4,
                  sizeof(::ROOT::Math::MatRepStd<Double32_t,6,6>) );
      instance.SetNew(&new_ROOTcLcLMathcLcLMatRepStdlEDouble32_tcO6cO6gR);
      instance.SetNewArray(&newArray_ROOTcLcLMathcLcLMatRepStdlEDouble32_tcO6cO6gR);
      instance.SetDelete(&delete_ROOTcLcLMathcLcLMatRepStdlEDouble32_tcO6cO6gR);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLMatRepStdlEDouble32_tcO6cO6gR);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLMatRepStdlEDouble32_tcO6cO6gR);

      ::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<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;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::MatRepStd<Double32_t,6,6>*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

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

   static void ROOTcLcLMathcLcLMatRepStdlEDouble32_tcO6cO6gR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLMatRepSymlEDouble32_tcO3gR_Dictionary();
   static void ROOTcLcLMathcLcLMatRepSymlEDouble32_tcO3gR_TClassManip(TClass*);
   static void *new_ROOTcLcLMathcLcLMatRepSymlEDouble32_tcO3gR(void *p = nullptr);
   static void *newArray_ROOTcLcLMathcLcLMatRepSymlEDouble32_tcO3gR(Long_t size, void *p);
   static void delete_ROOTcLcLMathcLcLMatRepSymlEDouble32_tcO3gR(void *p);
   static void deleteArray_ROOTcLcLMathcLcLMatRepSymlEDouble32_tcO3gR(void *p);
   static void destruct_ROOTcLcLMathcLcLMatRepSymlEDouble32_tcO3gR(void *p);

   // Schema evolution read functions

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::MatRepSym<Double32_t,3>*)
   {
      ::ROOT::Math::MatRepSym<Double32_t,3> *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::MatRepSym<Double32_t,3>));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::MatRepSym<Double32_t,3>", "Math/MatrixRepresentationsStatic.h", 213,
                  typeid(::ROOT::Math::MatRepSym<Double32_t,3>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLMatRepSymlEDouble32_tcO3gR_Dictionary, isa_proxy, 4,
                  sizeof(::ROOT::Math::MatRepSym<Double32_t,3>) );
      instance.SetNew(&new_ROOTcLcLMathcLcLMatRepSymlEDouble32_tcO3gR);
      instance.SetNewArray(&newArray_ROOTcLcLMathcLcLMatRepSymlEDouble32_tcO3gR);
      instance.SetDelete(&delete_ROOTcLcLMathcLcLMatRepSymlEDouble32_tcO3gR);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLMatRepSymlEDouble32_tcO3gR);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLMatRepSymlEDouble32_tcO3gR);

      ::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<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;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::MatRepSym<Double32_t,3>*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

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

   static void ROOTcLcLMathcLcLMatRepSymlEDouble32_tcO3gR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLMatRepSymlEDouble32_tcO4gR_Dictionary();
   static void ROOTcLcLMathcLcLMatRepSymlEDouble32_tcO4gR_TClassManip(TClass*);
   static void *new_ROOTcLcLMathcLcLMatRepSymlEDouble32_tcO4gR(void *p = nullptr);
   static void *newArray_ROOTcLcLMathcLcLMatRepSymlEDouble32_tcO4gR(Long_t size, void *p);
   static void delete_ROOTcLcLMathcLcLMatRepSymlEDouble32_tcO4gR(void *p);
   static void deleteArray_ROOTcLcLMathcLcLMatRepSymlEDouble32_tcO4gR(void *p);
   static void destruct_ROOTcLcLMathcLcLMatRepSymlEDouble32_tcO4gR(void *p);

   // Schema evolution read functions

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::MatRepSym<Double32_t,4>*)
   {
      ::ROOT::Math::MatRepSym<Double32_t,4> *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::MatRepSym<Double32_t,4>));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::MatRepSym<Double32_t,4>", "Math/MatrixRepresentationsStatic.h", 213,
                  typeid(::ROOT::Math::MatRepSym<Double32_t,4>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLMatRepSymlEDouble32_tcO4gR_Dictionary, isa_proxy, 4,
                  sizeof(::ROOT::Math::MatRepSym<Double32_t,4>) );
      instance.SetNew(&new_ROOTcLcLMathcLcLMatRepSymlEDouble32_tcO4gR);
      instance.SetNewArray(&newArray_ROOTcLcLMathcLcLMatRepSymlEDouble32_tcO4gR);
      instance.SetDelete(&delete_ROOTcLcLMathcLcLMatRepSymlEDouble32_tcO4gR);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLMatRepSymlEDouble32_tcO4gR);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLMatRepSymlEDouble32_tcO4gR);

      ::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<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;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::MatRepSym<Double32_t,4>*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

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

   static void ROOTcLcLMathcLcLMatRepSymlEDouble32_tcO4gR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLMatRepSymlEDouble32_tcO5gR_Dictionary();
   static void ROOTcLcLMathcLcLMatRepSymlEDouble32_tcO5gR_TClassManip(TClass*);
   static void *new_ROOTcLcLMathcLcLMatRepSymlEDouble32_tcO5gR(void *p = nullptr);
   static void *newArray_ROOTcLcLMathcLcLMatRepSymlEDouble32_tcO5gR(Long_t size, void *p);
   static void delete_ROOTcLcLMathcLcLMatRepSymlEDouble32_tcO5gR(void *p);
   static void deleteArray_ROOTcLcLMathcLcLMatRepSymlEDouble32_tcO5gR(void *p);
   static void destruct_ROOTcLcLMathcLcLMatRepSymlEDouble32_tcO5gR(void *p);

   // Schema evolution read functions

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::MatRepSym<Double32_t,5>*)
   {
      ::ROOT::Math::MatRepSym<Double32_t,5> *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::MatRepSym<Double32_t,5>));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::MatRepSym<Double32_t,5>", "Math/MatrixRepresentationsStatic.h", 213,
                  typeid(::ROOT::Math::MatRepSym<Double32_t,5>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLMatRepSymlEDouble32_tcO5gR_Dictionary, isa_proxy, 4,
                  sizeof(::ROOT::Math::MatRepSym<Double32_t,5>) );
      instance.SetNew(&new_ROOTcLcLMathcLcLMatRepSymlEDouble32_tcO5gR);
      instance.SetNewArray(&newArray_ROOTcLcLMathcLcLMatRepSymlEDouble32_tcO5gR);
      instance.SetDelete(&delete_ROOTcLcLMathcLcLMatRepSymlEDouble32_tcO5gR);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLMatRepSymlEDouble32_tcO5gR);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLMatRepSymlEDouble32_tcO5gR);

      ::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<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;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::MatRepSym<Double32_t,5>*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

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

   static void ROOTcLcLMathcLcLMatRepSymlEDouble32_tcO5gR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLMatRepSymlEDouble32_tcO6gR_Dictionary();
   static void ROOTcLcLMathcLcLMatRepSymlEDouble32_tcO6gR_TClassManip(TClass*);
   static void *new_ROOTcLcLMathcLcLMatRepSymlEDouble32_tcO6gR(void *p = nullptr);
   static void *newArray_ROOTcLcLMathcLcLMatRepSymlEDouble32_tcO6gR(Long_t size, void *p);
   static void delete_ROOTcLcLMathcLcLMatRepSymlEDouble32_tcO6gR(void *p);
   static void deleteArray_ROOTcLcLMathcLcLMatRepSymlEDouble32_tcO6gR(void *p);
   static void destruct_ROOTcLcLMathcLcLMatRepSymlEDouble32_tcO6gR(void *p);

   // Schema evolution read functions

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::MatRepSym<Double32_t,6>*)
   {
      ::ROOT::Math::MatRepSym<Double32_t,6> *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::MatRepSym<Double32_t,6>));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::MatRepSym<Double32_t,6>", "Math/MatrixRepresentationsStatic.h", 213,
                  typeid(::ROOT::Math::MatRepSym<Double32_t,6>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLMatRepSymlEDouble32_tcO6gR_Dictionary, isa_proxy, 4,
                  sizeof(::ROOT::Math::MatRepSym<Double32_t,6>) );
      instance.SetNew(&new_ROOTcLcLMathcLcLMatRepSymlEDouble32_tcO6gR);
      instance.SetNewArray(&newArray_ROOTcLcLMathcLcLMatRepSymlEDouble32_tcO6gR);
      instance.SetDelete(&delete_ROOTcLcLMathcLcLMatRepSymlEDouble32_tcO6gR);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLMatRepSymlEDouble32_tcO6gR);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLMatRepSymlEDouble32_tcO6gR);

      ::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<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;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::MatRepSym<Double32_t,6>*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

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

   static void ROOTcLcLMathcLcLMatRepSymlEDouble32_tcO6gR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSVectorlEDouble32_tcO3gR_Dictionary();
   static void ROOTcLcLMathcLcLSVectorlEDouble32_tcO3gR_TClassManip(TClass*);
   static void *new_ROOTcLcLMathcLcLSVectorlEDouble32_tcO3gR(void *p = nullptr);
   static void *newArray_ROOTcLcLMathcLcLSVectorlEDouble32_tcO3gR(Long_t size, void *p);
   static void delete_ROOTcLcLMathcLcLSVectorlEDouble32_tcO3gR(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSVectorlEDouble32_tcO3gR(void *p);
   static void destruct_ROOTcLcLMathcLcLSVectorlEDouble32_tcO3gR(void *p);

   // Schema evolution read functions

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SVector<Double32_t,3>*)
   {
      ::ROOT::Math::SVector<Double32_t,3> *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SVector<Double32_t,3>));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SVector<Double32_t,3>", "Math/SVector.h", 75,
                  typeid(::ROOT::Math::SVector<Double32_t,3>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSVectorlEDouble32_tcO3gR_Dictionary, isa_proxy, 4,
                  sizeof(::ROOT::Math::SVector<Double32_t,3>) );
      instance.SetNew(&new_ROOTcLcLMathcLcLSVectorlEDouble32_tcO3gR);
      instance.SetNewArray(&newArray_ROOTcLcLMathcLcLSVectorlEDouble32_tcO3gR);
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSVectorlEDouble32_tcO3gR);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSVectorlEDouble32_tcO3gR);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSVectorlEDouble32_tcO3gR);

      ::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<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;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SVector<Double32_t,3>*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

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

   static void ROOTcLcLMathcLcLSVectorlEDouble32_tcO3gR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSVectorlEDouble32_tcO4gR_Dictionary();
   static void ROOTcLcLMathcLcLSVectorlEDouble32_tcO4gR_TClassManip(TClass*);
   static void *new_ROOTcLcLMathcLcLSVectorlEDouble32_tcO4gR(void *p = nullptr);
   static void *newArray_ROOTcLcLMathcLcLSVectorlEDouble32_tcO4gR(Long_t size, void *p);
   static void delete_ROOTcLcLMathcLcLSVectorlEDouble32_tcO4gR(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSVectorlEDouble32_tcO4gR(void *p);
   static void destruct_ROOTcLcLMathcLcLSVectorlEDouble32_tcO4gR(void *p);

   // Schema evolution read functions

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SVector<Double32_t,4>*)
   {
      ::ROOT::Math::SVector<Double32_t,4> *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SVector<Double32_t,4>));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SVector<Double32_t,4>", "Math/SVector.h", 75,
                  typeid(::ROOT::Math::SVector<Double32_t,4>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSVectorlEDouble32_tcO4gR_Dictionary, isa_proxy, 4,
                  sizeof(::ROOT::Math::SVector<Double32_t,4>) );
      instance.SetNew(&new_ROOTcLcLMathcLcLSVectorlEDouble32_tcO4gR);
      instance.SetNewArray(&newArray_ROOTcLcLMathcLcLSVectorlEDouble32_tcO4gR);
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSVectorlEDouble32_tcO4gR);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSVectorlEDouble32_tcO4gR);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSVectorlEDouble32_tcO4gR);

      ::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<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;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SVector<Double32_t,4>*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

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

   static void ROOTcLcLMathcLcLSVectorlEDouble32_tcO4gR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSVectorlEDouble32_tcO5gR_Dictionary();
   static void ROOTcLcLMathcLcLSVectorlEDouble32_tcO5gR_TClassManip(TClass*);
   static void *new_ROOTcLcLMathcLcLSVectorlEDouble32_tcO5gR(void *p = nullptr);
   static void *newArray_ROOTcLcLMathcLcLSVectorlEDouble32_tcO5gR(Long_t size, void *p);
   static void delete_ROOTcLcLMathcLcLSVectorlEDouble32_tcO5gR(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSVectorlEDouble32_tcO5gR(void *p);
   static void destruct_ROOTcLcLMathcLcLSVectorlEDouble32_tcO5gR(void *p);

   // Schema evolution read functions

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SVector<Double32_t,5>*)
   {
      ::ROOT::Math::SVector<Double32_t,5> *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SVector<Double32_t,5>));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SVector<Double32_t,5>", "Math/SVector.h", 75,
                  typeid(::ROOT::Math::SVector<Double32_t,5>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSVectorlEDouble32_tcO5gR_Dictionary, isa_proxy, 4,
                  sizeof(::ROOT::Math::SVector<Double32_t,5>) );
      instance.SetNew(&new_ROOTcLcLMathcLcLSVectorlEDouble32_tcO5gR);
      instance.SetNewArray(&newArray_ROOTcLcLMathcLcLSVectorlEDouble32_tcO5gR);
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSVectorlEDouble32_tcO5gR);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSVectorlEDouble32_tcO5gR);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSVectorlEDouble32_tcO5gR);

      ::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<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;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SVector<Double32_t,5>*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

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

   static void ROOTcLcLMathcLcLSVectorlEDouble32_tcO5gR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSVectorlEDouble32_tcO6gR_Dictionary();
   static void ROOTcLcLMathcLcLSVectorlEDouble32_tcO6gR_TClassManip(TClass*);
   static void *new_ROOTcLcLMathcLcLSVectorlEDouble32_tcO6gR(void *p = nullptr);
   static void *newArray_ROOTcLcLMathcLcLSVectorlEDouble32_tcO6gR(Long_t size, void *p);
   static void delete_ROOTcLcLMathcLcLSVectorlEDouble32_tcO6gR(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSVectorlEDouble32_tcO6gR(void *p);
   static void destruct_ROOTcLcLMathcLcLSVectorlEDouble32_tcO6gR(void *p);

   // Schema evolution read functions

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SVector<Double32_t,6>*)
   {
      ::ROOT::Math::SVector<Double32_t,6> *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SVector<Double32_t,6>));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SVector<Double32_t,6>", "Math/SVector.h", 75,
                  typeid(::ROOT::Math::SVector<Double32_t,6>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSVectorlEDouble32_tcO6gR_Dictionary, isa_proxy, 4,
                  sizeof(::ROOT::Math::SVector<Double32_t,6>) );
      instance.SetNew(&new_ROOTcLcLMathcLcLSVectorlEDouble32_tcO6gR);
      instance.SetNewArray(&newArray_ROOTcLcLMathcLcLSVectorlEDouble32_tcO6gR);
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSVectorlEDouble32_tcO6gR);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSVectorlEDouble32_tcO6gR);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSVectorlEDouble32_tcO6gR);

      ::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<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;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SVector<Double32_t,6>*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

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

   static void ROOTcLcLMathcLcLSVectorlEDouble32_tcO6gR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSMatrixlEDouble32_tcO3cO3cOROOTcLcLMathcLcLMatRepStdlEDouble32_tcO3cO3gRsPgR_Dictionary();
   static void ROOTcLcLMathcLcLSMatrixlEDouble32_tcO3cO3cOROOTcLcLMathcLcLMatRepStdlEDouble32_tcO3cO3gRsPgR_TClassManip(TClass*);
   static void *new_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO3cO3cOROOTcLcLMathcLcLMatRepStdlEDouble32_tcO3cO3gRsPgR(void *p = nullptr);
   static void *newArray_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO3cO3cOROOTcLcLMathcLcLMatRepStdlEDouble32_tcO3cO3gRsPgR(Long_t size, void *p);
   static void delete_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO3cO3cOROOTcLcLMathcLcLMatRepStdlEDouble32_tcO3cO3gRsPgR(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO3cO3cOROOTcLcLMathcLcLMatRepStdlEDouble32_tcO3cO3gRsPgR(void *p);
   static void destruct_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO3cO3cOROOTcLcLMathcLcLMatRepStdlEDouble32_tcO3cO3gRsPgR(void *p);

   // Schema evolution read functions

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SMatrix<Double32_t,3,3,ROOT::Math::MatRepStd<Double32_t,3,3> >*)
   {
      ::ROOT::Math::SMatrix<Double32_t,3,3,ROOT::Math::MatRepStd<Double32_t,3,3> > *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SMatrix<Double32_t,3,3,ROOT::Math::MatRepStd<Double32_t,3,3> >));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SMatrix<Double32_t,3,3,ROOT::Math::MatRepStd<Double32_t,3,3> >", "Math/SMatrix.h", 101,
                  typeid(::ROOT::Math::SMatrix<Double32_t,3,3,ROOT::Math::MatRepStd<Double32_t,3,3> >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSMatrixlEDouble32_tcO3cO3cOROOTcLcLMathcLcLMatRepStdlEDouble32_tcO3cO3gRsPgR_Dictionary, isa_proxy, 4,
                  sizeof(::ROOT::Math::SMatrix<Double32_t,3,3,ROOT::Math::MatRepStd<Double32_t,3,3> >) );
      instance.SetNew(&new_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO3cO3cOROOTcLcLMathcLcLMatRepStdlEDouble32_tcO3cO3gRsPgR);
      instance.SetNewArray(&newArray_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO3cO3cOROOTcLcLMathcLcLMatRepStdlEDouble32_tcO3cO3gRsPgR);
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO3cO3cOROOTcLcLMathcLcLMatRepStdlEDouble32_tcO3cO3gRsPgR);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO3cO3cOROOTcLcLMathcLcLMatRepStdlEDouble32_tcO3cO3gRsPgR);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO3cO3cOROOTcLcLMathcLcLMatRepStdlEDouble32_tcO3cO3gRsPgR);

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

      ::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<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;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<Double32_t,3,3,ROOT::Math::MatRepStd<Double32_t,3,3> >*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

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

   static void ROOTcLcLMathcLcLSMatrixlEDouble32_tcO3cO3cOROOTcLcLMathcLcLMatRepStdlEDouble32_tcO3cO3gRsPgR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSMatrixlEDouble32_tcO4cO4cOROOTcLcLMathcLcLMatRepStdlEDouble32_tcO4cO4gRsPgR_Dictionary();
   static void ROOTcLcLMathcLcLSMatrixlEDouble32_tcO4cO4cOROOTcLcLMathcLcLMatRepStdlEDouble32_tcO4cO4gRsPgR_TClassManip(TClass*);
   static void *new_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO4cO4cOROOTcLcLMathcLcLMatRepStdlEDouble32_tcO4cO4gRsPgR(void *p = nullptr);
   static void *newArray_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO4cO4cOROOTcLcLMathcLcLMatRepStdlEDouble32_tcO4cO4gRsPgR(Long_t size, void *p);
   static void delete_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO4cO4cOROOTcLcLMathcLcLMatRepStdlEDouble32_tcO4cO4gRsPgR(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO4cO4cOROOTcLcLMathcLcLMatRepStdlEDouble32_tcO4cO4gRsPgR(void *p);
   static void destruct_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO4cO4cOROOTcLcLMathcLcLMatRepStdlEDouble32_tcO4cO4gRsPgR(void *p);

   // Schema evolution read functions

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SMatrix<Double32_t,4,4,ROOT::Math::MatRepStd<Double32_t,4,4> >*)
   {
      ::ROOT::Math::SMatrix<Double32_t,4,4,ROOT::Math::MatRepStd<Double32_t,4,4> > *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SMatrix<Double32_t,4,4,ROOT::Math::MatRepStd<Double32_t,4,4> >));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SMatrix<Double32_t,4,4,ROOT::Math::MatRepStd<Double32_t,4,4> >", "Math/SMatrix.h", 101,
                  typeid(::ROOT::Math::SMatrix<Double32_t,4,4,ROOT::Math::MatRepStd<Double32_t,4,4> >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSMatrixlEDouble32_tcO4cO4cOROOTcLcLMathcLcLMatRepStdlEDouble32_tcO4cO4gRsPgR_Dictionary, isa_proxy, 4,
                  sizeof(::ROOT::Math::SMatrix<Double32_t,4,4,ROOT::Math::MatRepStd<Double32_t,4,4> >) );
      instance.SetNew(&new_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO4cO4cOROOTcLcLMathcLcLMatRepStdlEDouble32_tcO4cO4gRsPgR);
      instance.SetNewArray(&newArray_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO4cO4cOROOTcLcLMathcLcLMatRepStdlEDouble32_tcO4cO4gRsPgR);
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO4cO4cOROOTcLcLMathcLcLMatRepStdlEDouble32_tcO4cO4gRsPgR);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO4cO4cOROOTcLcLMathcLcLMatRepStdlEDouble32_tcO4cO4gRsPgR);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO4cO4cOROOTcLcLMathcLcLMatRepStdlEDouble32_tcO4cO4gRsPgR);

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

      ::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<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;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<Double32_t,4,4,ROOT::Math::MatRepStd<Double32_t,4,4> >*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

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

   static void ROOTcLcLMathcLcLSMatrixlEDouble32_tcO4cO4cOROOTcLcLMathcLcLMatRepStdlEDouble32_tcO4cO4gRsPgR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSMatrixlEDouble32_tcO5cO5cOROOTcLcLMathcLcLMatRepStdlEDouble32_tcO5cO5gRsPgR_Dictionary();
   static void ROOTcLcLMathcLcLSMatrixlEDouble32_tcO5cO5cOROOTcLcLMathcLcLMatRepStdlEDouble32_tcO5cO5gRsPgR_TClassManip(TClass*);
   static void *new_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO5cO5cOROOTcLcLMathcLcLMatRepStdlEDouble32_tcO5cO5gRsPgR(void *p = nullptr);
   static void *newArray_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO5cO5cOROOTcLcLMathcLcLMatRepStdlEDouble32_tcO5cO5gRsPgR(Long_t size, void *p);
   static void delete_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO5cO5cOROOTcLcLMathcLcLMatRepStdlEDouble32_tcO5cO5gRsPgR(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO5cO5cOROOTcLcLMathcLcLMatRepStdlEDouble32_tcO5cO5gRsPgR(void *p);
   static void destruct_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO5cO5cOROOTcLcLMathcLcLMatRepStdlEDouble32_tcO5cO5gRsPgR(void *p);

   // Schema evolution read functions

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SMatrix<Double32_t,5,5,ROOT::Math::MatRepStd<Double32_t,5,5> >*)
   {
      ::ROOT::Math::SMatrix<Double32_t,5,5,ROOT::Math::MatRepStd<Double32_t,5,5> > *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SMatrix<Double32_t,5,5,ROOT::Math::MatRepStd<Double32_t,5,5> >));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SMatrix<Double32_t,5,5,ROOT::Math::MatRepStd<Double32_t,5,5> >", "Math/SMatrix.h", 101,
                  typeid(::ROOT::Math::SMatrix<Double32_t,5,5,ROOT::Math::MatRepStd<Double32_t,5,5> >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSMatrixlEDouble32_tcO5cO5cOROOTcLcLMathcLcLMatRepStdlEDouble32_tcO5cO5gRsPgR_Dictionary, isa_proxy, 4,
                  sizeof(::ROOT::Math::SMatrix<Double32_t,5,5,ROOT::Math::MatRepStd<Double32_t,5,5> >) );
      instance.SetNew(&new_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO5cO5cOROOTcLcLMathcLcLMatRepStdlEDouble32_tcO5cO5gRsPgR);
      instance.SetNewArray(&newArray_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO5cO5cOROOTcLcLMathcLcLMatRepStdlEDouble32_tcO5cO5gRsPgR);
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO5cO5cOROOTcLcLMathcLcLMatRepStdlEDouble32_tcO5cO5gRsPgR);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO5cO5cOROOTcLcLMathcLcLMatRepStdlEDouble32_tcO5cO5gRsPgR);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO5cO5cOROOTcLcLMathcLcLMatRepStdlEDouble32_tcO5cO5gRsPgR);

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

      ::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<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;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<Double32_t,5,5,ROOT::Math::MatRepStd<Double32_t,5,5> >*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

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

   static void ROOTcLcLMathcLcLSMatrixlEDouble32_tcO5cO5cOROOTcLcLMathcLcLMatRepStdlEDouble32_tcO5cO5gRsPgR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSMatrixlEDouble32_tcO6cO6cOROOTcLcLMathcLcLMatRepStdlEDouble32_tcO6cO6gRsPgR_Dictionary();
   static void ROOTcLcLMathcLcLSMatrixlEDouble32_tcO6cO6cOROOTcLcLMathcLcLMatRepStdlEDouble32_tcO6cO6gRsPgR_TClassManip(TClass*);
   static void *new_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO6cO6cOROOTcLcLMathcLcLMatRepStdlEDouble32_tcO6cO6gRsPgR(void *p = nullptr);
   static void *newArray_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO6cO6cOROOTcLcLMathcLcLMatRepStdlEDouble32_tcO6cO6gRsPgR(Long_t size, void *p);
   static void delete_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO6cO6cOROOTcLcLMathcLcLMatRepStdlEDouble32_tcO6cO6gRsPgR(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO6cO6cOROOTcLcLMathcLcLMatRepStdlEDouble32_tcO6cO6gRsPgR(void *p);
   static void destruct_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO6cO6cOROOTcLcLMathcLcLMatRepStdlEDouble32_tcO6cO6gRsPgR(void *p);

   // Schema evolution read functions

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SMatrix<Double32_t,6,6,ROOT::Math::MatRepStd<Double32_t,6,6> >*)
   {
      ::ROOT::Math::SMatrix<Double32_t,6,6,ROOT::Math::MatRepStd<Double32_t,6,6> > *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SMatrix<Double32_t,6,6,ROOT::Math::MatRepStd<Double32_t,6,6> >));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SMatrix<Double32_t,6,6,ROOT::Math::MatRepStd<Double32_t,6,6> >", "Math/SMatrix.h", 101,
                  typeid(::ROOT::Math::SMatrix<Double32_t,6,6,ROOT::Math::MatRepStd<Double32_t,6,6> >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSMatrixlEDouble32_tcO6cO6cOROOTcLcLMathcLcLMatRepStdlEDouble32_tcO6cO6gRsPgR_Dictionary, isa_proxy, 4,
                  sizeof(::ROOT::Math::SMatrix<Double32_t,6,6,ROOT::Math::MatRepStd<Double32_t,6,6> >) );
      instance.SetNew(&new_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO6cO6cOROOTcLcLMathcLcLMatRepStdlEDouble32_tcO6cO6gRsPgR);
      instance.SetNewArray(&newArray_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO6cO6cOROOTcLcLMathcLcLMatRepStdlEDouble32_tcO6cO6gRsPgR);
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO6cO6cOROOTcLcLMathcLcLMatRepStdlEDouble32_tcO6cO6gRsPgR);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO6cO6cOROOTcLcLMathcLcLMatRepStdlEDouble32_tcO6cO6gRsPgR);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO6cO6cOROOTcLcLMathcLcLMatRepStdlEDouble32_tcO6cO6gRsPgR);

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

      ::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<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;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<Double32_t,6,6,ROOT::Math::MatRepStd<Double32_t,6,6> >*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

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

   static void ROOTcLcLMathcLcLSMatrixlEDouble32_tcO6cO6cOROOTcLcLMathcLcLMatRepStdlEDouble32_tcO6cO6gRsPgR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSMatrixlEDouble32_tcO3cO3cOROOTcLcLMathcLcLMatRepSymlEDouble32_tcO3gRsPgR_Dictionary();
   static void ROOTcLcLMathcLcLSMatrixlEDouble32_tcO3cO3cOROOTcLcLMathcLcLMatRepSymlEDouble32_tcO3gRsPgR_TClassManip(TClass*);
   static void *new_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO3cO3cOROOTcLcLMathcLcLMatRepSymlEDouble32_tcO3gRsPgR(void *p = nullptr);
   static void *newArray_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO3cO3cOROOTcLcLMathcLcLMatRepSymlEDouble32_tcO3gRsPgR(Long_t size, void *p);
   static void delete_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO3cO3cOROOTcLcLMathcLcLMatRepSymlEDouble32_tcO3gRsPgR(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO3cO3cOROOTcLcLMathcLcLMatRepSymlEDouble32_tcO3gRsPgR(void *p);
   static void destruct_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO3cO3cOROOTcLcLMathcLcLMatRepSymlEDouble32_tcO3gRsPgR(void *p);

   // Schema evolution read functions

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SMatrix<Double32_t,3,3,ROOT::Math::MatRepSym<Double32_t,3> >*)
   {
      ::ROOT::Math::SMatrix<Double32_t,3,3,ROOT::Math::MatRepSym<Double32_t,3> > *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SMatrix<Double32_t,3,3,ROOT::Math::MatRepSym<Double32_t,3> >));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SMatrix<Double32_t,3,3,ROOT::Math::MatRepSym<Double32_t,3> >", "Math/SMatrix.h", 101,
                  typeid(::ROOT::Math::SMatrix<Double32_t,3,3,ROOT::Math::MatRepSym<Double32_t,3> >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSMatrixlEDouble32_tcO3cO3cOROOTcLcLMathcLcLMatRepSymlEDouble32_tcO3gRsPgR_Dictionary, isa_proxy, 4,
                  sizeof(::ROOT::Math::SMatrix<Double32_t,3,3,ROOT::Math::MatRepSym<Double32_t,3> >) );
      instance.SetNew(&new_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO3cO3cOROOTcLcLMathcLcLMatRepSymlEDouble32_tcO3gRsPgR);
      instance.SetNewArray(&newArray_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO3cO3cOROOTcLcLMathcLcLMatRepSymlEDouble32_tcO3gRsPgR);
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO3cO3cOROOTcLcLMathcLcLMatRepSymlEDouble32_tcO3gRsPgR);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO3cO3cOROOTcLcLMathcLcLMatRepSymlEDouble32_tcO3gRsPgR);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO3cO3cOROOTcLcLMathcLcLMatRepSymlEDouble32_tcO3gRsPgR);

      ::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<double,3> >";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[1];
      rule->fSourceClass = "ROOT::Math::SMatrix<float,3,3,ROOT::Math::MatRepSym<float,3> >";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[2];
      rule->fSourceClass = "ROOT::Math::SMatrix<Float16_t,3,3,ROOT::Math::MatRepSym<Float16_t,3> >";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      instance.SetReadRules( readrules );
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<Double32_t,3,3,ROOT::Math::MatRepSym<Double32_t,3> >*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

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

   static void ROOTcLcLMathcLcLSMatrixlEDouble32_tcO3cO3cOROOTcLcLMathcLcLMatRepSymlEDouble32_tcO3gRsPgR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSMatrixlEDouble32_tcO4cO4cOROOTcLcLMathcLcLMatRepSymlEDouble32_tcO4gRsPgR_Dictionary();
   static void ROOTcLcLMathcLcLSMatrixlEDouble32_tcO4cO4cOROOTcLcLMathcLcLMatRepSymlEDouble32_tcO4gRsPgR_TClassManip(TClass*);
   static void *new_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO4cO4cOROOTcLcLMathcLcLMatRepSymlEDouble32_tcO4gRsPgR(void *p = nullptr);
   static void *newArray_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO4cO4cOROOTcLcLMathcLcLMatRepSymlEDouble32_tcO4gRsPgR(Long_t size, void *p);
   static void delete_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO4cO4cOROOTcLcLMathcLcLMatRepSymlEDouble32_tcO4gRsPgR(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO4cO4cOROOTcLcLMathcLcLMatRepSymlEDouble32_tcO4gRsPgR(void *p);
   static void destruct_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO4cO4cOROOTcLcLMathcLcLMatRepSymlEDouble32_tcO4gRsPgR(void *p);

   // Schema evolution read functions

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SMatrix<Double32_t,4,4,ROOT::Math::MatRepSym<Double32_t,4> >*)
   {
      ::ROOT::Math::SMatrix<Double32_t,4,4,ROOT::Math::MatRepSym<Double32_t,4> > *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SMatrix<Double32_t,4,4,ROOT::Math::MatRepSym<Double32_t,4> >));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SMatrix<Double32_t,4,4,ROOT::Math::MatRepSym<Double32_t,4> >", "Math/SMatrix.h", 101,
                  typeid(::ROOT::Math::SMatrix<Double32_t,4,4,ROOT::Math::MatRepSym<Double32_t,4> >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSMatrixlEDouble32_tcO4cO4cOROOTcLcLMathcLcLMatRepSymlEDouble32_tcO4gRsPgR_Dictionary, isa_proxy, 4,
                  sizeof(::ROOT::Math::SMatrix<Double32_t,4,4,ROOT::Math::MatRepSym<Double32_t,4> >) );
      instance.SetNew(&new_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO4cO4cOROOTcLcLMathcLcLMatRepSymlEDouble32_tcO4gRsPgR);
      instance.SetNewArray(&newArray_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO4cO4cOROOTcLcLMathcLcLMatRepSymlEDouble32_tcO4gRsPgR);
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO4cO4cOROOTcLcLMathcLcLMatRepSymlEDouble32_tcO4gRsPgR);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO4cO4cOROOTcLcLMathcLcLMatRepSymlEDouble32_tcO4gRsPgR);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO4cO4cOROOTcLcLMathcLcLMatRepSymlEDouble32_tcO4gRsPgR);

      ::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<double,4> >";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[1];
      rule->fSourceClass = "ROOT::Math::SMatrix<float,4,4,ROOT::Math::MatRepSym<float,4> >";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[2];
      rule->fSourceClass = "ROOT::Math::SMatrix<Float16_t,4,4,ROOT::Math::MatRepSym<Float16_t,4> >";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      instance.SetReadRules( readrules );
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<Double32_t,4,4,ROOT::Math::MatRepSym<Double32_t,4> >*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

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

   static void ROOTcLcLMathcLcLSMatrixlEDouble32_tcO4cO4cOROOTcLcLMathcLcLMatRepSymlEDouble32_tcO4gRsPgR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSMatrixlEDouble32_tcO5cO5cOROOTcLcLMathcLcLMatRepSymlEDouble32_tcO5gRsPgR_Dictionary();
   static void ROOTcLcLMathcLcLSMatrixlEDouble32_tcO5cO5cOROOTcLcLMathcLcLMatRepSymlEDouble32_tcO5gRsPgR_TClassManip(TClass*);
   static void *new_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO5cO5cOROOTcLcLMathcLcLMatRepSymlEDouble32_tcO5gRsPgR(void *p = nullptr);
   static void *newArray_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO5cO5cOROOTcLcLMathcLcLMatRepSymlEDouble32_tcO5gRsPgR(Long_t size, void *p);
   static void delete_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO5cO5cOROOTcLcLMathcLcLMatRepSymlEDouble32_tcO5gRsPgR(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO5cO5cOROOTcLcLMathcLcLMatRepSymlEDouble32_tcO5gRsPgR(void *p);
   static void destruct_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO5cO5cOROOTcLcLMathcLcLMatRepSymlEDouble32_tcO5gRsPgR(void *p);

   // Schema evolution read functions

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SMatrix<Double32_t,5,5,ROOT::Math::MatRepSym<Double32_t,5> >*)
   {
      ::ROOT::Math::SMatrix<Double32_t,5,5,ROOT::Math::MatRepSym<Double32_t,5> > *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SMatrix<Double32_t,5,5,ROOT::Math::MatRepSym<Double32_t,5> >));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SMatrix<Double32_t,5,5,ROOT::Math::MatRepSym<Double32_t,5> >", "Math/SMatrix.h", 101,
                  typeid(::ROOT::Math::SMatrix<Double32_t,5,5,ROOT::Math::MatRepSym<Double32_t,5> >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSMatrixlEDouble32_tcO5cO5cOROOTcLcLMathcLcLMatRepSymlEDouble32_tcO5gRsPgR_Dictionary, isa_proxy, 4,
                  sizeof(::ROOT::Math::SMatrix<Double32_t,5,5,ROOT::Math::MatRepSym<Double32_t,5> >) );
      instance.SetNew(&new_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO5cO5cOROOTcLcLMathcLcLMatRepSymlEDouble32_tcO5gRsPgR);
      instance.SetNewArray(&newArray_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO5cO5cOROOTcLcLMathcLcLMatRepSymlEDouble32_tcO5gRsPgR);
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO5cO5cOROOTcLcLMathcLcLMatRepSymlEDouble32_tcO5gRsPgR);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO5cO5cOROOTcLcLMathcLcLMatRepSymlEDouble32_tcO5gRsPgR);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO5cO5cOROOTcLcLMathcLcLMatRepSymlEDouble32_tcO5gRsPgR);

      ::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<double,5> >";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[1];
      rule->fSourceClass = "ROOT::Math::SMatrix<float,5,5,ROOT::Math::MatRepSym<float,5> >";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[2];
      rule->fSourceClass = "ROOT::Math::SMatrix<Float16_t,5,5,ROOT::Math::MatRepSym<Float16_t,5> >";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      instance.SetReadRules( readrules );
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<Double32_t,5,5,ROOT::Math::MatRepSym<Double32_t,5> >*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

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

   static void ROOTcLcLMathcLcLSMatrixlEDouble32_tcO5cO5cOROOTcLcLMathcLcLMatRepSymlEDouble32_tcO5gRsPgR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *ROOTcLcLMathcLcLSMatrixlEDouble32_tcO6cO6cOROOTcLcLMathcLcLMatRepSymlEDouble32_tcO6gRsPgR_Dictionary();
   static void ROOTcLcLMathcLcLSMatrixlEDouble32_tcO6cO6cOROOTcLcLMathcLcLMatRepSymlEDouble32_tcO6gRsPgR_TClassManip(TClass*);
   static void *new_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO6cO6cOROOTcLcLMathcLcLMatRepSymlEDouble32_tcO6gRsPgR(void *p = nullptr);
   static void *newArray_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO6cO6cOROOTcLcLMathcLcLMatRepSymlEDouble32_tcO6gRsPgR(Long_t size, void *p);
   static void delete_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO6cO6cOROOTcLcLMathcLcLMatRepSymlEDouble32_tcO6gRsPgR(void *p);
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO6cO6cOROOTcLcLMathcLcLMatRepSymlEDouble32_tcO6gRsPgR(void *p);
   static void destruct_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO6cO6cOROOTcLcLMathcLcLMatRepSymlEDouble32_tcO6gRsPgR(void *p);

   // Schema evolution read functions

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::SMatrix<Double32_t,6,6,ROOT::Math::MatRepSym<Double32_t,6> >*)
   {
      ::ROOT::Math::SMatrix<Double32_t,6,6,ROOT::Math::MatRepSym<Double32_t,6> > *ptr = nullptr;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::SMatrix<Double32_t,6,6,ROOT::Math::MatRepSym<Double32_t,6> >));
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Math::SMatrix<Double32_t,6,6,ROOT::Math::MatRepSym<Double32_t,6> >", "Math/SMatrix.h", 101,
                  typeid(::ROOT::Math::SMatrix<Double32_t,6,6,ROOT::Math::MatRepSym<Double32_t,6> >), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &ROOTcLcLMathcLcLSMatrixlEDouble32_tcO6cO6cOROOTcLcLMathcLcLMatRepSymlEDouble32_tcO6gRsPgR_Dictionary, isa_proxy, 4,
                  sizeof(::ROOT::Math::SMatrix<Double32_t,6,6,ROOT::Math::MatRepSym<Double32_t,6> >) );
      instance.SetNew(&new_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO6cO6cOROOTcLcLMathcLcLMatRepSymlEDouble32_tcO6gRsPgR);
      instance.SetNewArray(&newArray_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO6cO6cOROOTcLcLMathcLcLMatRepSymlEDouble32_tcO6gRsPgR);
      instance.SetDelete(&delete_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO6cO6cOROOTcLcLMathcLcLMatRepSymlEDouble32_tcO6gRsPgR);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO6cO6cOROOTcLcLMathcLcLMatRepSymlEDouble32_tcO6gRsPgR);
      instance.SetDestructor(&destruct_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO6cO6cOROOTcLcLMathcLcLMatRepSymlEDouble32_tcO6gRsPgR);

      ::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<double,6> >";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[1];
      rule->fSourceClass = "ROOT::Math::SMatrix<float,6,6,ROOT::Math::MatRepSym<float,6> >";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      rule = &readrules[2];
      rule->fSourceClass = "ROOT::Math::SMatrix<Float16_t,6,6,ROOT::Math::MatRepSym<Float16_t,6> >";
      rule->fTarget      = "";
      rule->fVersion     = "[1-]";
      instance.SetReadRules( readrules );
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal(static_cast<const ::ROOT::Math::SMatrix<Double32_t,6,6,ROOT::Math::MatRepSym<Double32_t,6> >*>(nullptr)); R__UseDummy(_R__UNIQUE_DICT_(Init));

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

   static void ROOTcLcLMathcLcLSMatrixlEDouble32_tcO6cO6cOROOTcLcLMathcLcLMatRepSymlEDouble32_tcO6gRsPgR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMathcLcLMatRepStdlEDouble32_tcO3cO3gR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::MatRepStd<Double32_t,3,3> : new ::ROOT::Math::MatRepStd<Double32_t,3,3>;
   }
   static void *newArray_ROOTcLcLMathcLcLMatRepStdlEDouble32_tcO3cO3gR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::MatRepStd<Double32_t,3,3>[nElements] : new ::ROOT::Math::MatRepStd<Double32_t,3,3>[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLMatRepStdlEDouble32_tcO3cO3gR(void *p) {
      delete (static_cast<::ROOT::Math::MatRepStd<Double32_t,3,3>*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLMatRepStdlEDouble32_tcO3cO3gR(void *p) {
      delete [] (static_cast<::ROOT::Math::MatRepStd<Double32_t,3,3>*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLMatRepStdlEDouble32_tcO3cO3gR(void *p) {
      typedef ::ROOT::Math::MatRepStd<Double32_t,3,3> current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::MatRepStd<Double32_t,3,3>

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMathcLcLMatRepStdlEDouble32_tcO4cO4gR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::MatRepStd<Double32_t,4,4> : new ::ROOT::Math::MatRepStd<Double32_t,4,4>;
   }
   static void *newArray_ROOTcLcLMathcLcLMatRepStdlEDouble32_tcO4cO4gR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::MatRepStd<Double32_t,4,4>[nElements] : new ::ROOT::Math::MatRepStd<Double32_t,4,4>[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLMatRepStdlEDouble32_tcO4cO4gR(void *p) {
      delete (static_cast<::ROOT::Math::MatRepStd<Double32_t,4,4>*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLMatRepStdlEDouble32_tcO4cO4gR(void *p) {
      delete [] (static_cast<::ROOT::Math::MatRepStd<Double32_t,4,4>*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLMatRepStdlEDouble32_tcO4cO4gR(void *p) {
      typedef ::ROOT::Math::MatRepStd<Double32_t,4,4> current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::MatRepStd<Double32_t,4,4>

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMathcLcLMatRepStdlEDouble32_tcO5cO5gR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::MatRepStd<Double32_t,5,5> : new ::ROOT::Math::MatRepStd<Double32_t,5,5>;
   }
   static void *newArray_ROOTcLcLMathcLcLMatRepStdlEDouble32_tcO5cO5gR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::MatRepStd<Double32_t,5,5>[nElements] : new ::ROOT::Math::MatRepStd<Double32_t,5,5>[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLMatRepStdlEDouble32_tcO5cO5gR(void *p) {
      delete (static_cast<::ROOT::Math::MatRepStd<Double32_t,5,5>*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLMatRepStdlEDouble32_tcO5cO5gR(void *p) {
      delete [] (static_cast<::ROOT::Math::MatRepStd<Double32_t,5,5>*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLMatRepStdlEDouble32_tcO5cO5gR(void *p) {
      typedef ::ROOT::Math::MatRepStd<Double32_t,5,5> current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::MatRepStd<Double32_t,5,5>

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMathcLcLMatRepStdlEDouble32_tcO6cO6gR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::MatRepStd<Double32_t,6,6> : new ::ROOT::Math::MatRepStd<Double32_t,6,6>;
   }
   static void *newArray_ROOTcLcLMathcLcLMatRepStdlEDouble32_tcO6cO6gR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::MatRepStd<Double32_t,6,6>[nElements] : new ::ROOT::Math::MatRepStd<Double32_t,6,6>[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLMatRepStdlEDouble32_tcO6cO6gR(void *p) {
      delete (static_cast<::ROOT::Math::MatRepStd<Double32_t,6,6>*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLMatRepStdlEDouble32_tcO6cO6gR(void *p) {
      delete [] (static_cast<::ROOT::Math::MatRepStd<Double32_t,6,6>*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLMatRepStdlEDouble32_tcO6cO6gR(void *p) {
      typedef ::ROOT::Math::MatRepStd<Double32_t,6,6> current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::MatRepStd<Double32_t,6,6>

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMathcLcLMatRepSymlEDouble32_tcO3gR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::MatRepSym<Double32_t,3> : new ::ROOT::Math::MatRepSym<Double32_t,3>;
   }
   static void *newArray_ROOTcLcLMathcLcLMatRepSymlEDouble32_tcO3gR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::MatRepSym<Double32_t,3>[nElements] : new ::ROOT::Math::MatRepSym<Double32_t,3>[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLMatRepSymlEDouble32_tcO3gR(void *p) {
      delete (static_cast<::ROOT::Math::MatRepSym<Double32_t,3>*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLMatRepSymlEDouble32_tcO3gR(void *p) {
      delete [] (static_cast<::ROOT::Math::MatRepSym<Double32_t,3>*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLMatRepSymlEDouble32_tcO3gR(void *p) {
      typedef ::ROOT::Math::MatRepSym<Double32_t,3> current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::MatRepSym<Double32_t,3>

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMathcLcLMatRepSymlEDouble32_tcO4gR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::MatRepSym<Double32_t,4> : new ::ROOT::Math::MatRepSym<Double32_t,4>;
   }
   static void *newArray_ROOTcLcLMathcLcLMatRepSymlEDouble32_tcO4gR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::MatRepSym<Double32_t,4>[nElements] : new ::ROOT::Math::MatRepSym<Double32_t,4>[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLMatRepSymlEDouble32_tcO4gR(void *p) {
      delete (static_cast<::ROOT::Math::MatRepSym<Double32_t,4>*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLMatRepSymlEDouble32_tcO4gR(void *p) {
      delete [] (static_cast<::ROOT::Math::MatRepSym<Double32_t,4>*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLMatRepSymlEDouble32_tcO4gR(void *p) {
      typedef ::ROOT::Math::MatRepSym<Double32_t,4> current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::MatRepSym<Double32_t,4>

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMathcLcLMatRepSymlEDouble32_tcO5gR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::MatRepSym<Double32_t,5> : new ::ROOT::Math::MatRepSym<Double32_t,5>;
   }
   static void *newArray_ROOTcLcLMathcLcLMatRepSymlEDouble32_tcO5gR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::MatRepSym<Double32_t,5>[nElements] : new ::ROOT::Math::MatRepSym<Double32_t,5>[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLMatRepSymlEDouble32_tcO5gR(void *p) {
      delete (static_cast<::ROOT::Math::MatRepSym<Double32_t,5>*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLMatRepSymlEDouble32_tcO5gR(void *p) {
      delete [] (static_cast<::ROOT::Math::MatRepSym<Double32_t,5>*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLMatRepSymlEDouble32_tcO5gR(void *p) {
      typedef ::ROOT::Math::MatRepSym<Double32_t,5> current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::MatRepSym<Double32_t,5>

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMathcLcLMatRepSymlEDouble32_tcO6gR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::MatRepSym<Double32_t,6> : new ::ROOT::Math::MatRepSym<Double32_t,6>;
   }
   static void *newArray_ROOTcLcLMathcLcLMatRepSymlEDouble32_tcO6gR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::MatRepSym<Double32_t,6>[nElements] : new ::ROOT::Math::MatRepSym<Double32_t,6>[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLMatRepSymlEDouble32_tcO6gR(void *p) {
      delete (static_cast<::ROOT::Math::MatRepSym<Double32_t,6>*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLMatRepSymlEDouble32_tcO6gR(void *p) {
      delete [] (static_cast<::ROOT::Math::MatRepSym<Double32_t,6>*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLMatRepSymlEDouble32_tcO6gR(void *p) {
      typedef ::ROOT::Math::MatRepSym<Double32_t,6> current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::MatRepSym<Double32_t,6>

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMathcLcLSVectorlEDouble32_tcO3gR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SVector<Double32_t,3> : new ::ROOT::Math::SVector<Double32_t,3>;
   }
   static void *newArray_ROOTcLcLMathcLcLSVectorlEDouble32_tcO3gR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SVector<Double32_t,3>[nElements] : new ::ROOT::Math::SVector<Double32_t,3>[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSVectorlEDouble32_tcO3gR(void *p) {
      delete (static_cast<::ROOT::Math::SVector<Double32_t,3>*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSVectorlEDouble32_tcO3gR(void *p) {
      delete [] (static_cast<::ROOT::Math::SVector<Double32_t,3>*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSVectorlEDouble32_tcO3gR(void *p) {
      typedef ::ROOT::Math::SVector<Double32_t,3> current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SVector<Double32_t,3>

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMathcLcLSVectorlEDouble32_tcO4gR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SVector<Double32_t,4> : new ::ROOT::Math::SVector<Double32_t,4>;
   }
   static void *newArray_ROOTcLcLMathcLcLSVectorlEDouble32_tcO4gR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SVector<Double32_t,4>[nElements] : new ::ROOT::Math::SVector<Double32_t,4>[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSVectorlEDouble32_tcO4gR(void *p) {
      delete (static_cast<::ROOT::Math::SVector<Double32_t,4>*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSVectorlEDouble32_tcO4gR(void *p) {
      delete [] (static_cast<::ROOT::Math::SVector<Double32_t,4>*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSVectorlEDouble32_tcO4gR(void *p) {
      typedef ::ROOT::Math::SVector<Double32_t,4> current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SVector<Double32_t,4>

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMathcLcLSVectorlEDouble32_tcO5gR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SVector<Double32_t,5> : new ::ROOT::Math::SVector<Double32_t,5>;
   }
   static void *newArray_ROOTcLcLMathcLcLSVectorlEDouble32_tcO5gR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SVector<Double32_t,5>[nElements] : new ::ROOT::Math::SVector<Double32_t,5>[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSVectorlEDouble32_tcO5gR(void *p) {
      delete (static_cast<::ROOT::Math::SVector<Double32_t,5>*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSVectorlEDouble32_tcO5gR(void *p) {
      delete [] (static_cast<::ROOT::Math::SVector<Double32_t,5>*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSVectorlEDouble32_tcO5gR(void *p) {
      typedef ::ROOT::Math::SVector<Double32_t,5> current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SVector<Double32_t,5>

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMathcLcLSVectorlEDouble32_tcO6gR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SVector<Double32_t,6> : new ::ROOT::Math::SVector<Double32_t,6>;
   }
   static void *newArray_ROOTcLcLMathcLcLSVectorlEDouble32_tcO6gR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SVector<Double32_t,6>[nElements] : new ::ROOT::Math::SVector<Double32_t,6>[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSVectorlEDouble32_tcO6gR(void *p) {
      delete (static_cast<::ROOT::Math::SVector<Double32_t,6>*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSVectorlEDouble32_tcO6gR(void *p) {
      delete [] (static_cast<::ROOT::Math::SVector<Double32_t,6>*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSVectorlEDouble32_tcO6gR(void *p) {
      typedef ::ROOT::Math::SVector<Double32_t,6> current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SVector<Double32_t,6>

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO3cO3cOROOTcLcLMathcLcLMatRepStdlEDouble32_tcO3cO3gRsPgR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SMatrix<Double32_t,3,3,ROOT::Math::MatRepStd<Double32_t,3,3> > : new ::ROOT::Math::SMatrix<Double32_t,3,3,ROOT::Math::MatRepStd<Double32_t,3,3> >;
   }
   static void *newArray_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO3cO3cOROOTcLcLMathcLcLMatRepStdlEDouble32_tcO3cO3gRsPgR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SMatrix<Double32_t,3,3,ROOT::Math::MatRepStd<Double32_t,3,3> >[nElements] : new ::ROOT::Math::SMatrix<Double32_t,3,3,ROOT::Math::MatRepStd<Double32_t,3,3> >[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO3cO3cOROOTcLcLMathcLcLMatRepStdlEDouble32_tcO3cO3gRsPgR(void *p) {
      delete (static_cast<::ROOT::Math::SMatrix<Double32_t,3,3,ROOT::Math::MatRepStd<Double32_t,3,3> >*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO3cO3cOROOTcLcLMathcLcLMatRepStdlEDouble32_tcO3cO3gRsPgR(void *p) {
      delete [] (static_cast<::ROOT::Math::SMatrix<Double32_t,3,3,ROOT::Math::MatRepStd<Double32_t,3,3> >*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO3cO3cOROOTcLcLMathcLcLMatRepStdlEDouble32_tcO3cO3gRsPgR(void *p) {
      typedef ::ROOT::Math::SMatrix<Double32_t,3,3,ROOT::Math::MatRepStd<Double32_t,3,3> > current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SMatrix<Double32_t,3,3,ROOT::Math::MatRepStd<Double32_t,3,3> >

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO4cO4cOROOTcLcLMathcLcLMatRepStdlEDouble32_tcO4cO4gRsPgR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SMatrix<Double32_t,4,4,ROOT::Math::MatRepStd<Double32_t,4,4> > : new ::ROOT::Math::SMatrix<Double32_t,4,4,ROOT::Math::MatRepStd<Double32_t,4,4> >;
   }
   static void *newArray_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO4cO4cOROOTcLcLMathcLcLMatRepStdlEDouble32_tcO4cO4gRsPgR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SMatrix<Double32_t,4,4,ROOT::Math::MatRepStd<Double32_t,4,4> >[nElements] : new ::ROOT::Math::SMatrix<Double32_t,4,4,ROOT::Math::MatRepStd<Double32_t,4,4> >[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO4cO4cOROOTcLcLMathcLcLMatRepStdlEDouble32_tcO4cO4gRsPgR(void *p) {
      delete (static_cast<::ROOT::Math::SMatrix<Double32_t,4,4,ROOT::Math::MatRepStd<Double32_t,4,4> >*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO4cO4cOROOTcLcLMathcLcLMatRepStdlEDouble32_tcO4cO4gRsPgR(void *p) {
      delete [] (static_cast<::ROOT::Math::SMatrix<Double32_t,4,4,ROOT::Math::MatRepStd<Double32_t,4,4> >*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO4cO4cOROOTcLcLMathcLcLMatRepStdlEDouble32_tcO4cO4gRsPgR(void *p) {
      typedef ::ROOT::Math::SMatrix<Double32_t,4,4,ROOT::Math::MatRepStd<Double32_t,4,4> > current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SMatrix<Double32_t,4,4,ROOT::Math::MatRepStd<Double32_t,4,4> >

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO5cO5cOROOTcLcLMathcLcLMatRepStdlEDouble32_tcO5cO5gRsPgR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SMatrix<Double32_t,5,5,ROOT::Math::MatRepStd<Double32_t,5,5> > : new ::ROOT::Math::SMatrix<Double32_t,5,5,ROOT::Math::MatRepStd<Double32_t,5,5> >;
   }
   static void *newArray_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO5cO5cOROOTcLcLMathcLcLMatRepStdlEDouble32_tcO5cO5gRsPgR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SMatrix<Double32_t,5,5,ROOT::Math::MatRepStd<Double32_t,5,5> >[nElements] : new ::ROOT::Math::SMatrix<Double32_t,5,5,ROOT::Math::MatRepStd<Double32_t,5,5> >[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO5cO5cOROOTcLcLMathcLcLMatRepStdlEDouble32_tcO5cO5gRsPgR(void *p) {
      delete (static_cast<::ROOT::Math::SMatrix<Double32_t,5,5,ROOT::Math::MatRepStd<Double32_t,5,5> >*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO5cO5cOROOTcLcLMathcLcLMatRepStdlEDouble32_tcO5cO5gRsPgR(void *p) {
      delete [] (static_cast<::ROOT::Math::SMatrix<Double32_t,5,5,ROOT::Math::MatRepStd<Double32_t,5,5> >*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO5cO5cOROOTcLcLMathcLcLMatRepStdlEDouble32_tcO5cO5gRsPgR(void *p) {
      typedef ::ROOT::Math::SMatrix<Double32_t,5,5,ROOT::Math::MatRepStd<Double32_t,5,5> > current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SMatrix<Double32_t,5,5,ROOT::Math::MatRepStd<Double32_t,5,5> >

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO6cO6cOROOTcLcLMathcLcLMatRepStdlEDouble32_tcO6cO6gRsPgR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SMatrix<Double32_t,6,6,ROOT::Math::MatRepStd<Double32_t,6,6> > : new ::ROOT::Math::SMatrix<Double32_t,6,6,ROOT::Math::MatRepStd<Double32_t,6,6> >;
   }
   static void *newArray_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO6cO6cOROOTcLcLMathcLcLMatRepStdlEDouble32_tcO6cO6gRsPgR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SMatrix<Double32_t,6,6,ROOT::Math::MatRepStd<Double32_t,6,6> >[nElements] : new ::ROOT::Math::SMatrix<Double32_t,6,6,ROOT::Math::MatRepStd<Double32_t,6,6> >[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO6cO6cOROOTcLcLMathcLcLMatRepStdlEDouble32_tcO6cO6gRsPgR(void *p) {
      delete (static_cast<::ROOT::Math::SMatrix<Double32_t,6,6,ROOT::Math::MatRepStd<Double32_t,6,6> >*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO6cO6cOROOTcLcLMathcLcLMatRepStdlEDouble32_tcO6cO6gRsPgR(void *p) {
      delete [] (static_cast<::ROOT::Math::SMatrix<Double32_t,6,6,ROOT::Math::MatRepStd<Double32_t,6,6> >*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO6cO6cOROOTcLcLMathcLcLMatRepStdlEDouble32_tcO6cO6gRsPgR(void *p) {
      typedef ::ROOT::Math::SMatrix<Double32_t,6,6,ROOT::Math::MatRepStd<Double32_t,6,6> > current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SMatrix<Double32_t,6,6,ROOT::Math::MatRepStd<Double32_t,6,6> >

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO3cO3cOROOTcLcLMathcLcLMatRepSymlEDouble32_tcO3gRsPgR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SMatrix<Double32_t,3,3,ROOT::Math::MatRepSym<Double32_t,3> > : new ::ROOT::Math::SMatrix<Double32_t,3,3,ROOT::Math::MatRepSym<Double32_t,3> >;
   }
   static void *newArray_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO3cO3cOROOTcLcLMathcLcLMatRepSymlEDouble32_tcO3gRsPgR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SMatrix<Double32_t,3,3,ROOT::Math::MatRepSym<Double32_t,3> >[nElements] : new ::ROOT::Math::SMatrix<Double32_t,3,3,ROOT::Math::MatRepSym<Double32_t,3> >[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO3cO3cOROOTcLcLMathcLcLMatRepSymlEDouble32_tcO3gRsPgR(void *p) {
      delete (static_cast<::ROOT::Math::SMatrix<Double32_t,3,3,ROOT::Math::MatRepSym<Double32_t,3> >*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO3cO3cOROOTcLcLMathcLcLMatRepSymlEDouble32_tcO3gRsPgR(void *p) {
      delete [] (static_cast<::ROOT::Math::SMatrix<Double32_t,3,3,ROOT::Math::MatRepSym<Double32_t,3> >*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO3cO3cOROOTcLcLMathcLcLMatRepSymlEDouble32_tcO3gRsPgR(void *p) {
      typedef ::ROOT::Math::SMatrix<Double32_t,3,3,ROOT::Math::MatRepSym<Double32_t,3> > current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SMatrix<Double32_t,3,3,ROOT::Math::MatRepSym<Double32_t,3> >

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO4cO4cOROOTcLcLMathcLcLMatRepSymlEDouble32_tcO4gRsPgR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SMatrix<Double32_t,4,4,ROOT::Math::MatRepSym<Double32_t,4> > : new ::ROOT::Math::SMatrix<Double32_t,4,4,ROOT::Math::MatRepSym<Double32_t,4> >;
   }
   static void *newArray_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO4cO4cOROOTcLcLMathcLcLMatRepSymlEDouble32_tcO4gRsPgR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SMatrix<Double32_t,4,4,ROOT::Math::MatRepSym<Double32_t,4> >[nElements] : new ::ROOT::Math::SMatrix<Double32_t,4,4,ROOT::Math::MatRepSym<Double32_t,4> >[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO4cO4cOROOTcLcLMathcLcLMatRepSymlEDouble32_tcO4gRsPgR(void *p) {
      delete (static_cast<::ROOT::Math::SMatrix<Double32_t,4,4,ROOT::Math::MatRepSym<Double32_t,4> >*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO4cO4cOROOTcLcLMathcLcLMatRepSymlEDouble32_tcO4gRsPgR(void *p) {
      delete [] (static_cast<::ROOT::Math::SMatrix<Double32_t,4,4,ROOT::Math::MatRepSym<Double32_t,4> >*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO4cO4cOROOTcLcLMathcLcLMatRepSymlEDouble32_tcO4gRsPgR(void *p) {
      typedef ::ROOT::Math::SMatrix<Double32_t,4,4,ROOT::Math::MatRepSym<Double32_t,4> > current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SMatrix<Double32_t,4,4,ROOT::Math::MatRepSym<Double32_t,4> >

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO5cO5cOROOTcLcLMathcLcLMatRepSymlEDouble32_tcO5gRsPgR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SMatrix<Double32_t,5,5,ROOT::Math::MatRepSym<Double32_t,5> > : new ::ROOT::Math::SMatrix<Double32_t,5,5,ROOT::Math::MatRepSym<Double32_t,5> >;
   }
   static void *newArray_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO5cO5cOROOTcLcLMathcLcLMatRepSymlEDouble32_tcO5gRsPgR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SMatrix<Double32_t,5,5,ROOT::Math::MatRepSym<Double32_t,5> >[nElements] : new ::ROOT::Math::SMatrix<Double32_t,5,5,ROOT::Math::MatRepSym<Double32_t,5> >[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO5cO5cOROOTcLcLMathcLcLMatRepSymlEDouble32_tcO5gRsPgR(void *p) {
      delete (static_cast<::ROOT::Math::SMatrix<Double32_t,5,5,ROOT::Math::MatRepSym<Double32_t,5> >*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO5cO5cOROOTcLcLMathcLcLMatRepSymlEDouble32_tcO5gRsPgR(void *p) {
      delete [] (static_cast<::ROOT::Math::SMatrix<Double32_t,5,5,ROOT::Math::MatRepSym<Double32_t,5> >*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO5cO5cOROOTcLcLMathcLcLMatRepSymlEDouble32_tcO5gRsPgR(void *p) {
      typedef ::ROOT::Math::SMatrix<Double32_t,5,5,ROOT::Math::MatRepSym<Double32_t,5> > current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SMatrix<Double32_t,5,5,ROOT::Math::MatRepSym<Double32_t,5> >

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO6cO6cOROOTcLcLMathcLcLMatRepSymlEDouble32_tcO6gRsPgR(void *p) {
      return  p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SMatrix<Double32_t,6,6,ROOT::Math::MatRepSym<Double32_t,6> > : new ::ROOT::Math::SMatrix<Double32_t,6,6,ROOT::Math::MatRepSym<Double32_t,6> >;
   }
   static void *newArray_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO6cO6cOROOTcLcLMathcLcLMatRepSymlEDouble32_tcO6gRsPgR(Long_t nElements, void *p) {
      return p ? ::new(static_cast<::ROOT::Internal::TOperatorNewHelper*>(p)) ::ROOT::Math::SMatrix<Double32_t,6,6,ROOT::Math::MatRepSym<Double32_t,6> >[nElements] : new ::ROOT::Math::SMatrix<Double32_t,6,6,ROOT::Math::MatRepSym<Double32_t,6> >[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO6cO6cOROOTcLcLMathcLcLMatRepSymlEDouble32_tcO6gRsPgR(void *p) {
      delete (static_cast<::ROOT::Math::SMatrix<Double32_t,6,6,ROOT::Math::MatRepSym<Double32_t,6> >*>(p));
   }
   static void deleteArray_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO6cO6cOROOTcLcLMathcLcLMatRepSymlEDouble32_tcO6gRsPgR(void *p) {
      delete [] (static_cast<::ROOT::Math::SMatrix<Double32_t,6,6,ROOT::Math::MatRepSym<Double32_t,6> >*>(p));
   }
   static void destruct_ROOTcLcLMathcLcLSMatrixlEDouble32_tcO6cO6cOROOTcLcLMathcLcLMatRepSymlEDouble32_tcO6gRsPgR(void *p) {
      typedef ::ROOT::Math::SMatrix<Double32_t,6,6,ROOT::Math::MatRepSym<Double32_t,6> > current_t;
      (static_cast<current_t*>(p))->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Math::SMatrix<Double32_t,6,6,ROOT::Math::MatRepSym<Double32_t,6> >

namespace {
  void TriggerDictionaryInitialization_libSmatrix_G__Smatrix32_Impl() {
    static const char* headers[] = {
"Math/SMatrix.h",
"Math/SMatrixDfwd.h",
"Math/SMatrixFfwd.h",
"Math/SVector.h",
nullptr
    };
    static const char* includePaths[] = {
"/cvmfs/soft.computecanada.ca/gentoo/2023/x86-64-v3/usr/include",
"/cvmfs/soft.computecanada.ca/gentoo/2023/x86-64-v3/usr/include",
nullptr
    };
    static const char* fwdDeclCode = nullptr;
    static const char* payloadCode = nullptr;
    static const char* classesHeaders[] = {
nullptr
};
    static bool isInitialized = false;
    if (!isInitialized) {
      TROOT::RegisterModule("libSmatrix_G__Smatrix32",
        headers, includePaths, payloadCode, fwdDeclCode,
        TriggerDictionaryInitialization_libSmatrix_G__Smatrix32_Impl, {}, classesHeaders, /*hasCxxModule*/false);
      isInitialized = true;
    }
  }
  static struct DictInit {
    DictInit() {
      TriggerDictionaryInitialization_libSmatrix_G__Smatrix32_Impl();
    }
  } __TheDictionaryInitializer;
}
void TriggerDictionaryInitialization_libSmatrix_G__Smatrix32() {
  TriggerDictionaryInitialization_libSmatrix_G__Smatrix32_Impl();
}