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

#define R__DICTIONARY_FILENAME dIkm3netdIaanetdIbuilddIdIJsonDumperdOdict
#define R__NO_DEPRECATION

/*******************************************************************/
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#define G__DICTIONARY
#include "RConfig.h"
#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"

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

// Header files passed as explicit arguments
#include "JsonDumper.hh"

// Header files passed via #pragma extra_include

namespace ROOT {
   static TClass *JsonDumper_Dictionary();
   static void JsonDumper_TClassManip(TClass*);
   static void *new_JsonDumper(void *p = 0);
   static void *newArray_JsonDumper(Long_t size, void *p);
   static void delete_JsonDumper(void *p);
   static void deleteArray_JsonDumper(void *p);
   static void destruct_JsonDumper(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::JsonDumper*)
   {
      ::JsonDumper *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::JsonDumper));
      static ::ROOT::TGenericClassInfo 
         instance("JsonDumper", "JsonDumper.hh", 30,
                  typeid(::JsonDumper), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &JsonDumper_Dictionary, isa_proxy, 4,
                  sizeof(::JsonDumper) );
      instance.SetNew(&new_JsonDumper);
      instance.SetNewArray(&newArray_JsonDumper);
      instance.SetDelete(&delete_JsonDumper);
      instance.SetDeleteArray(&deleteArray_JsonDumper);
      instance.SetDestructor(&destruct_JsonDumper);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::JsonDumper*)
   {
      return GenerateInitInstanceLocal((::JsonDumper*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::JsonDumper*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *JsonDumper_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::JsonDumper*)0x0)->GetClass();
      JsonDumper_TClassManip(theClass);
   return theClass;
   }

   static void JsonDumper_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","JsonDumper.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *JsonDumpercLcL_TDump_Dictionary();
   static void JsonDumpercLcL_TDump_TClassManip(TClass*);
   static void delete_JsonDumpercLcL_TDump(void *p);
   static void deleteArray_JsonDumpercLcL_TDump(void *p);
   static void destruct_JsonDumpercLcL_TDump(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::JsonDumper::_TDump*)
   {
      ::JsonDumper::_TDump *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::JsonDumper::_TDump));
      static ::ROOT::TGenericClassInfo 
         instance("JsonDumper::_TDump", "JsonDumper.hh", 129,
                  typeid(::JsonDumper::_TDump), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &JsonDumpercLcL_TDump_Dictionary, isa_proxy, 4,
                  sizeof(::JsonDumper::_TDump) );
      instance.SetDelete(&delete_JsonDumpercLcL_TDump);
      instance.SetDeleteArray(&deleteArray_JsonDumpercLcL_TDump);
      instance.SetDestructor(&destruct_JsonDumpercLcL_TDump);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::JsonDumper::_TDump*)
   {
      return GenerateInitInstanceLocal((::JsonDumper::_TDump*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::JsonDumper::_TDump*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *JsonDumpercLcL_TDump_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::JsonDumper::_TDump*)0x0)->GetClass();
      JsonDumpercLcL_TDump_TClassManip(theClass);
   return theClass;
   }

   static void JsonDumpercLcL_TDump_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","JsonDumper.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *CompactJsonDumper_Dictionary();
   static void CompactJsonDumper_TClassManip(TClass*);
   static void *new_CompactJsonDumper(void *p = 0);
   static void *newArray_CompactJsonDumper(Long_t size, void *p);
   static void delete_CompactJsonDumper(void *p);
   static void deleteArray_CompactJsonDumper(void *p);
   static void destruct_CompactJsonDumper(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::CompactJsonDumper*)
   {
      ::CompactJsonDumper *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::CompactJsonDumper));
      static ::ROOT::TGenericClassInfo 
         instance("CompactJsonDumper", "JsonDumper.hh", 237,
                  typeid(::CompactJsonDumper), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &CompactJsonDumper_Dictionary, isa_proxy, 4,
                  sizeof(::CompactJsonDumper) );
      instance.SetNew(&new_CompactJsonDumper);
      instance.SetNewArray(&newArray_CompactJsonDumper);
      instance.SetDelete(&delete_CompactJsonDumper);
      instance.SetDeleteArray(&deleteArray_CompactJsonDumper);
      instance.SetDestructor(&destruct_CompactJsonDumper);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::CompactJsonDumper*)
   {
      return GenerateInitInstanceLocal((::CompactJsonDumper*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::CompactJsonDumper*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *CompactJsonDumper_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::CompactJsonDumper*)0x0)->GetClass();
      CompactJsonDumper_TClassManip(theClass);
   return theClass;
   }

   static void CompactJsonDumper_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","JsonDumper.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *Dumper_Dictionary();
   static void Dumper_TClassManip(TClass*);
   static void *new_Dumper(void *p = 0);
   static void *newArray_Dumper(Long_t size, void *p);
   static void delete_Dumper(void *p);
   static void deleteArray_Dumper(void *p);
   static void destruct_Dumper(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::Dumper*)
   {
      ::Dumper *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Dumper));
      static ::ROOT::TGenericClassInfo 
         instance("Dumper", "JsonDumper.hh", 245,
                  typeid(::Dumper), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &Dumper_Dictionary, isa_proxy, 4,
                  sizeof(::Dumper) );
      instance.SetNew(&new_Dumper);
      instance.SetNewArray(&newArray_Dumper);
      instance.SetDelete(&delete_Dumper);
      instance.SetDeleteArray(&deleteArray_Dumper);
      instance.SetDestructor(&destruct_Dumper);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::Dumper*)
   {
      return GenerateInitInstanceLocal((::Dumper*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Dumper*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *Dumper_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Dumper*)0x0)->GetClass();
      Dumper_TClassManip(theClass);
   return theClass;
   }

   static void Dumper_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","JsonDumper.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *DumpercLcL_TDump_Dictionary();
   static void DumpercLcL_TDump_TClassManip(TClass*);
   static void delete_DumpercLcL_TDump(void *p);
   static void deleteArray_DumpercLcL_TDump(void *p);
   static void destruct_DumpercLcL_TDump(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::Dumper::_TDump*)
   {
      ::Dumper::_TDump *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::Dumper::_TDump));
      static ::ROOT::TGenericClassInfo 
         instance("Dumper::_TDump", "JsonDumper.hh", 277,
                  typeid(::Dumper::_TDump), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &DumpercLcL_TDump_Dictionary, isa_proxy, 4,
                  sizeof(::Dumper::_TDump) );
      instance.SetDelete(&delete_DumpercLcL_TDump);
      instance.SetDeleteArray(&deleteArray_DumpercLcL_TDump);
      instance.SetDestructor(&destruct_DumpercLcL_TDump);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::Dumper::_TDump*)
   {
      return GenerateInitInstanceLocal((::Dumper::_TDump*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::Dumper::_TDump*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *DumpercLcL_TDump_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::Dumper::_TDump*)0x0)->GetClass();
      DumpercLcL_TDump_TClassManip(theClass);
   return theClass;
   }

   static void DumpercLcL_TDump_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","JsonDumper.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   static TClass *StdoutDumper_Dictionary();
   static void StdoutDumper_TClassManip(TClass*);
   static void *new_StdoutDumper(void *p = 0);
   static void *newArray_StdoutDumper(Long_t size, void *p);
   static void delete_StdoutDumper(void *p);
   static void deleteArray_StdoutDumper(void *p);
   static void destruct_StdoutDumper(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::StdoutDumper*)
   {
      ::StdoutDumper *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::StdoutDumper));
      static ::ROOT::TGenericClassInfo 
         instance("StdoutDumper", "JsonDumper.hh", 343,
                  typeid(::StdoutDumper), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &StdoutDumper_Dictionary, isa_proxy, 4,
                  sizeof(::StdoutDumper) );
      instance.SetNew(&new_StdoutDumper);
      instance.SetNewArray(&newArray_StdoutDumper);
      instance.SetDelete(&delete_StdoutDumper);
      instance.SetDeleteArray(&deleteArray_StdoutDumper);
      instance.SetDestructor(&destruct_StdoutDumper);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::StdoutDumper*)
   {
      return GenerateInitInstanceLocal((::StdoutDumper*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::StdoutDumper*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *StdoutDumper_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::StdoutDumper*)0x0)->GetClass();
      StdoutDumper_TClassManip(theClass);
   return theClass;
   }

   static void StdoutDumper_TClassManip(TClass* theClass){
      theClass->CreateAttributeMap();
      TDictAttributeMap* attrMap( theClass->GetAttributeMap() );
      attrMap->AddProperty("file_name","JsonDumper.hh");
   }

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_JsonDumper(void *p) {
      return  p ? new(p) ::JsonDumper : new ::JsonDumper;
   }
   static void *newArray_JsonDumper(Long_t nElements, void *p) {
      return p ? new(p) ::JsonDumper[nElements] : new ::JsonDumper[nElements];
   }
   // Wrapper around operator delete
   static void delete_JsonDumper(void *p) {
      delete ((::JsonDumper*)p);
   }
   static void deleteArray_JsonDumper(void *p) {
      delete [] ((::JsonDumper*)p);
   }
   static void destruct_JsonDumper(void *p) {
      typedef ::JsonDumper current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::JsonDumper

namespace ROOT {
   // Wrapper around operator delete
   static void delete_JsonDumpercLcL_TDump(void *p) {
      delete ((::JsonDumper::_TDump*)p);
   }
   static void deleteArray_JsonDumpercLcL_TDump(void *p) {
      delete [] ((::JsonDumper::_TDump*)p);
   }
   static void destruct_JsonDumpercLcL_TDump(void *p) {
      typedef ::JsonDumper::_TDump current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::JsonDumper::_TDump

namespace ROOT {
   // Wrappers around operator new
   static void *new_CompactJsonDumper(void *p) {
      return  p ? new(p) ::CompactJsonDumper : new ::CompactJsonDumper;
   }
   static void *newArray_CompactJsonDumper(Long_t nElements, void *p) {
      return p ? new(p) ::CompactJsonDumper[nElements] : new ::CompactJsonDumper[nElements];
   }
   // Wrapper around operator delete
   static void delete_CompactJsonDumper(void *p) {
      delete ((::CompactJsonDumper*)p);
   }
   static void deleteArray_CompactJsonDumper(void *p) {
      delete [] ((::CompactJsonDumper*)p);
   }
   static void destruct_CompactJsonDumper(void *p) {
      typedef ::CompactJsonDumper current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::CompactJsonDumper

namespace ROOT {
   // Wrappers around operator new
   static void *new_Dumper(void *p) {
      return  p ? new(p) ::Dumper : new ::Dumper;
   }
   static void *newArray_Dumper(Long_t nElements, void *p) {
      return p ? new(p) ::Dumper[nElements] : new ::Dumper[nElements];
   }
   // Wrapper around operator delete
   static void delete_Dumper(void *p) {
      delete ((::Dumper*)p);
   }
   static void deleteArray_Dumper(void *p) {
      delete [] ((::Dumper*)p);
   }
   static void destruct_Dumper(void *p) {
      typedef ::Dumper current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::Dumper

namespace ROOT {
   // Wrapper around operator delete
   static void delete_DumpercLcL_TDump(void *p) {
      delete ((::Dumper::_TDump*)p);
   }
   static void deleteArray_DumpercLcL_TDump(void *p) {
      delete [] ((::Dumper::_TDump*)p);
   }
   static void destruct_DumpercLcL_TDump(void *p) {
      typedef ::Dumper::_TDump current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::Dumper::_TDump

namespace ROOT {
   // Wrappers around operator new
   static void *new_StdoutDumper(void *p) {
      return  p ? new(p) ::StdoutDumper : new ::StdoutDumper;
   }
   static void *newArray_StdoutDumper(Long_t nElements, void *p) {
      return p ? new(p) ::StdoutDumper[nElements] : new ::StdoutDumper[nElements];
   }
   // Wrapper around operator delete
   static void delete_StdoutDumper(void *p) {
      delete ((::StdoutDumper*)p);
   }
   static void deleteArray_StdoutDumper(void *p) {
      delete [] ((::StdoutDumper*)p);
   }
   static void destruct_StdoutDumper(void *p) {
      typedef ::StdoutDumper current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::StdoutDumper

namespace ROOT {
   static TClass *vectorlEstringgR_Dictionary();
   static void vectorlEstringgR_TClassManip(TClass*);
   static void *new_vectorlEstringgR(void *p = 0);
   static void *newArray_vectorlEstringgR(Long_t size, void *p);
   static void delete_vectorlEstringgR(void *p);
   static void deleteArray_vectorlEstringgR(void *p);
   static void destruct_vectorlEstringgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const vector<string>*)
   {
      vector<string> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<string>));
      static ::ROOT::TGenericClassInfo 
         instance("vector<string>", -2, "vector", 210,
                  typeid(vector<string>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
                  &vectorlEstringgR_Dictionary, isa_proxy, 0,
                  sizeof(vector<string>) );
      instance.SetNew(&new_vectorlEstringgR);
      instance.SetNewArray(&newArray_vectorlEstringgR);
      instance.SetDelete(&delete_vectorlEstringgR);
      instance.SetDeleteArray(&deleteArray_vectorlEstringgR);
      instance.SetDestructor(&destruct_vectorlEstringgR);
      instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<string> >()));

      ::ROOT::AddClassAlternate("vector<string>","std::vector<std::string, std::allocator<std::string> >");
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const vector<string>*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));

   // Dictionary for non-ClassDef classes
   static TClass *vectorlEstringgR_Dictionary() {
      TClass* theClass =::ROOT::GenerateInitInstanceLocal((const vector<string>*)0x0)->GetClass();
      vectorlEstringgR_TClassManip(theClass);
   return theClass;
   }

   static void vectorlEstringgR_TClassManip(TClass* ){
   }

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_vectorlEstringgR(void *p) {
      return  p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<string> : new vector<string>;
   }
   static void *newArray_vectorlEstringgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) vector<string>[nElements] : new vector<string>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlEstringgR(void *p) {
      delete ((vector<string>*)p);
   }
   static void deleteArray_vectorlEstringgR(void *p) {
      delete [] ((vector<string>*)p);
   }
   static void destruct_vectorlEstringgR(void *p) {
      typedef vector<string> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class vector<string>

namespace {
  void TriggerDictionaryInitialization_JsonDumperdOdict_Impl() {
    static const char* headers[] = {
"JsonDumper.hh",
0
    };
    static const char* includePaths[] = {
"/usr/local/include",
"/km3net/aanet/evt",
"/km3net/aanet/astro",
"/km3net/aanet",
"/km3net/aanet/externals",
"/km3net/aanet/externals/km3net-dataformat/offline",
"/km3net/aanet/externals/km3net-dataformat/online",
"/km3net/aanet/externals/flux",
"/usr/local/include/",
"/km3net/aanet/evt/",
0
    };
    static const char* fwdDeclCode = R"DICTFWDDCLS(
#line 1 "JsonDumperdOdict dictionary forward declarations' payload"
#pragma clang diagnostic ignored "-Wkeyword-compat"
#pragma clang diagnostic ignored "-Wignored-attributes"
#pragma clang diagnostic ignored "-Wreturn-type-c-linkage"
extern int __Cling_AutoLoading_Map;
struct __attribute__((annotate(R"ATTRDUMP(file_name@@@JsonDumper.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$JsonDumper.hh")))  JsonDumper;
struct __attribute__((annotate(R"ATTRDUMP(file_name@@@JsonDumper.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$JsonDumper.hh")))  CompactJsonDumper;
struct __attribute__((annotate(R"ATTRDUMP(file_name@@@JsonDumper.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$JsonDumper.hh")))  Dumper;
struct __attribute__((annotate(R"ATTRDUMP(file_name@@@JsonDumper.hh)ATTRDUMP"))) __attribute__((annotate(R"ATTRDUMP(pattern@@@*)ATTRDUMP"))) __attribute__((annotate("$clingAutoload$JsonDumper.hh")))  StdoutDumper;
)DICTFWDDCLS";
    static const char* payloadCode = R"DICTPAYLOAD(
#line 1 "JsonDumperdOdict dictionary payload"


#define _BACKWARD_BACKWARD_WARNING_H
// Inline headers
#include "JsonDumper.hh"

#undef  _BACKWARD_BACKWARD_WARNING_H
)DICTPAYLOAD";
    static const char* classesHeaders[] = {
"", payloadCode, "@",
"CompactJsonDumper", payloadCode, "@",
"Dumper", payloadCode, "@",
"JsonDumper", payloadCode, "@",
"StdoutDumper", payloadCode, "@",
"jsons", payloadCode, "@",
"write_aa3d", payloadCode, "@",
nullptr
};
    static bool isInitialized = false;
    if (!isInitialized) {
      TROOT::RegisterModule("JsonDumper.dict",
        headers, includePaths, payloadCode, fwdDeclCode,
        TriggerDictionaryInitialization_JsonDumperdOdict_Impl, {}, classesHeaders, /*hasCxxModule*/false);
      isInitialized = true;
    }
  }
  static struct DictInit {
    DictInit() {
      TriggerDictionaryInitialization_JsonDumperdOdict_Impl();
    }
  } __TheDictionaryInitializer;
}
void TriggerDictionaryInitialization_JsonDumperdOdict() {
  TriggerDictionaryInitialization_JsonDumperdOdict_Impl();
}