/*
 * hddm_s.c - DO NOT EDIT THIS FILE
 *
 * This file was generated automatically by hddm-c from the file
 * event.xml

 * This c file contains the i/o interface to the c structures
 * described in the data model (from event.xml). 
 *
 * The hddm data model tool set was written by
 * Richard Jones, University of Connecticut.
 *
 * For more information see the following web site
 *
 * http://zeus.phys.uconn.edu/halld/datamodel/doc
 */

int hddm_s_nullTarget=0;
#define HDDM_NULL (void*)&hddm_s_nullTarget

#include "hddm_s.h"


s_HDDM_t* make_s_HDDM()
{
   int size = sizeof(s_HDDM_t);
   s_HDDM_t* p = (s_HDDM_t*)MALLOC(size,"s_HDDM_t");
   p->physicsEvents = (s_PhysicsEvents_t*)&hddm_s_nullTarget;
   return p;
}

s_PhysicsEvents_t* make_s_PhysicsEvents(int n)
{
   int i;
   int rep = (n > 1) ? n-1 : 0;
   int size = sizeof(s_PhysicsEvents_t) + rep * sizeof(s_PhysicsEvent_t);
   s_PhysicsEvents_t* p = (s_PhysicsEvents_t*)MALLOC(size,"s_PhysicsEvents_t");
   p->mult = 0;
   for (i=0; i<n; i++) {
      s_PhysicsEvent_t* pp = &p->in[i];
      pp->eventNo = 0;
      pp->runNo = 0;
      pp->reactions = (s_Reactions_t*)&hddm_s_nullTarget;
      pp->hitView = (s_HitView_t*)&hddm_s_nullTarget;
      pp->reconView = (s_ReconView_t*)&hddm_s_nullTarget;
   }
   return p;
}

s_Reactions_t* make_s_Reactions(int n)
{
   int i;
   int rep = (n > 1) ? n-1 : 0;
   int size = sizeof(s_Reactions_t) + rep * sizeof(s_Reaction_t);
   s_Reactions_t* p = (s_Reactions_t*)MALLOC(size,"s_Reactions_t");
   p->mult = 0;
   for (i=0; i<n; i++) {
      s_Reaction_t* pp = &p->in[i];
      pp->type = 0;
      pp->weight = 0;
      pp->beam = (s_Beam_t*)&hddm_s_nullTarget;
      pp->target = (s_Target_t*)&hddm_s_nullTarget;
      pp->vertices = (s_Vertices_t*)&hddm_s_nullTarget;
      pp->random = (s_Random_t*)&hddm_s_nullTarget;
   }
   return p;
}

s_Beam_t* make_s_Beam()
{
   int size = sizeof(s_Beam_t);
   s_Beam_t* p = (s_Beam_t*)MALLOC(size,"s_Beam_t");
   p->type = (Particle_t)0;
   p->momentum = (s_Momentum_t*)&hddm_s_nullTarget;
   p->properties = (s_Properties_t*)&hddm_s_nullTarget;
   return p;
}

s_Momentum_t* make_s_Momentum()
{
   int size = sizeof(s_Momentum_t);
   s_Momentum_t* p = (s_Momentum_t*)MALLOC(size,"s_Momentum_t");
   p->E = 0;
   p->px = 0;
   p->py = 0;
   p->pz = 0;
   return p;
}

s_Properties_t* make_s_Properties()
{
   int size = sizeof(s_Properties_t);
   s_Properties_t* p = (s_Properties_t*)MALLOC(size,"s_Properties_t");
   p->charge = 0;
   p->mass = 0;
   return p;
}

s_Target_t* make_s_Target()
{
   int size = sizeof(s_Target_t);
   s_Target_t* p = (s_Target_t*)MALLOC(size,"s_Target_t");
   p->type = (Particle_t)0;
   p->momentum = (s_Momentum_t*)&hddm_s_nullTarget;
   p->properties = (s_Properties_t*)&hddm_s_nullTarget;
   return p;
}

s_Vertices_t* make_s_Vertices(int n)
{
   int i;
   int rep = (n > 1) ? n-1 : 0;
   int size = sizeof(s_Vertices_t) + rep * sizeof(s_Vertex_t);
   s_Vertices_t* p = (s_Vertices_t*)MALLOC(size,"s_Vertices_t");
   p->mult = 0;
   for (i=0; i<n; i++) {
      s_Vertex_t* pp = &p->in[i];
      pp->products = (s_Products_t*)&hddm_s_nullTarget;
      pp->origin = (s_Origin_t*)&hddm_s_nullTarget;
   }
   return p;
}

s_Products_t* make_s_Products(int n)
{
   int i;
   int rep = (n > 1) ? n-1 : 0;
   int size = sizeof(s_Products_t) + rep * sizeof(s_Product_t);
   s_Products_t* p = (s_Products_t*)MALLOC(size,"s_Products_t");
   p->mult = 0;
   for (i=0; i<n; i++) {
      s_Product_t* pp = &p->in[i];
      pp->decayVertex = 0;
      pp->id = 0;
      pp->mech = 0;
      pp->parentid = 0;
      pp->pdgtype = 0;
      pp->type = (Particle_t)0;
      pp->momentum = (s_Momentum_t*)&hddm_s_nullTarget;
      pp->properties = (s_Properties_t*)&hddm_s_nullTarget;
   }
   return p;
}

s_Origin_t* make_s_Origin()
{
   int size = sizeof(s_Origin_t);
   s_Origin_t* p = (s_Origin_t*)MALLOC(size,"s_Origin_t");
   p->t = 0;
   p->vx = 0;
   p->vy = 0;
   p->vz = 0;
   return p;
}

s_Random_t* make_s_Random()
{
   int size = sizeof(s_Random_t);
   s_Random_t* p = (s_Random_t*)MALLOC(size,"s_Random_t");
   p->seed1 = 0;
   p->seed2 = 0;
   p->seed_mcsmear1 = 0;
   p->seed_mcsmear2 = 0;
   p->seed_mcsmear3 = 0;
   return p;
}

s_HitView_t* make_s_HitView()
{
   int size = sizeof(s_HitView_t);
   s_HitView_t* p = (s_HitView_t*)MALLOC(size,"s_HitView_t");
   p->centralDC = (s_CentralDC_t*)&hddm_s_nullTarget;
   p->forwardDC = (s_ForwardDC_t*)&hddm_s_nullTarget;
   p->startCntr = (s_StartCntr_t*)&hddm_s_nullTarget;
   p->barrelEMcal = (s_BarrelEMcal_t*)&hddm_s_nullTarget;
   p->gapEMcal = (s_GapEMcal_t*)&hddm_s_nullTarget;
   p->Cerenkov = (s_Cerenkov_t*)&hddm_s_nullTarget;
   p->forwardTOF = (s_ForwardTOF_t*)&hddm_s_nullTarget;
   p->forwardEMcal = (s_ForwardEMcal_t*)&hddm_s_nullTarget;
   p->ComptonEMcal = (s_ComptonEMcal_t*)&hddm_s_nullTarget;
   p->upstreamEMveto = (s_UpstreamEMveto_t*)&hddm_s_nullTarget;
   p->tagger = (s_Tagger_t*)&hddm_s_nullTarget;
   p->mcTrajectory = (s_McTrajectory_t*)&hddm_s_nullTarget;
   return p;
}

s_CentralDC_t* make_s_CentralDC()
{
   int size = sizeof(s_CentralDC_t);
   s_CentralDC_t* p = (s_CentralDC_t*)MALLOC(size,"s_CentralDC_t");
   p->cdcStraws = (s_CdcStraws_t*)&hddm_s_nullTarget;
   p->cdcTruthPoints = (s_CdcTruthPoints_t*)&hddm_s_nullTarget;
   return p;
}

s_CdcStraws_t* make_s_CdcStraws(int n)
{
   int i;
   int rep = (n > 1) ? n-1 : 0;
   int size = sizeof(s_CdcStraws_t) + rep * sizeof(s_CdcStraw_t);
   s_CdcStraws_t* p = (s_CdcStraws_t*)MALLOC(size,"s_CdcStraws_t");
   p->mult = 0;
   for (i=0; i<n; i++) {
      s_CdcStraw_t* pp = &p->in[i];
      pp->ring = 0;
      pp->straw = 0;
      pp->cdcStrawHits = (s_CdcStrawHits_t*)&hddm_s_nullTarget;
      pp->cdcStrawTruthHits = (s_CdcStrawTruthHits_t*)&hddm_s_nullTarget;
   }
   return p;
}

s_CdcStrawHits_t* make_s_CdcStrawHits(int n)
{
   int i;
   int rep = (n > 1) ? n-1 : 0;
   int size = sizeof(s_CdcStrawHits_t) + rep * sizeof(s_CdcStrawHit_t);
   s_CdcStrawHits_t* p = (s_CdcStrawHits_t*)MALLOC(size,"s_CdcStrawHits_t");
   p->mult = 0;
   for (i=0; i<n; i++) {
      s_CdcStrawHit_t* pp = &p->in[i];
      pp->d = 0;
      pp->dE = 0;
      pp->itrack = 0;
      pp->ptype = 0;
      pp->t = 0;
   }
   return p;
}

s_CdcStrawTruthHits_t* make_s_CdcStrawTruthHits(int n)
{
   int i;
   int rep = (n > 1) ? n-1 : 0;
   int size = sizeof(s_CdcStrawTruthHits_t) + rep * sizeof(s_CdcStrawTruthHit_t);
   s_CdcStrawTruthHits_t* p = (s_CdcStrawTruthHits_t*)MALLOC(size,"s_CdcStrawTruthHits_t");
   p->mult = 0;
   for (i=0; i<n; i++) {
      s_CdcStrawTruthHit_t* pp = &p->in[i];
      pp->d = 0;
      pp->dE = 0;
      pp->itrack = 0;
      pp->ptype = 0;
      pp->t = 0;
   }
   return p;
}

s_CdcTruthPoints_t* make_s_CdcTruthPoints(int n)
{
   int i;
   int rep = (n > 1) ? n-1 : 0;
   int size = sizeof(s_CdcTruthPoints_t) + rep * sizeof(s_CdcTruthPoint_t);
   s_CdcTruthPoints_t* p = (s_CdcTruthPoints_t*)MALLOC(size,"s_CdcTruthPoints_t");
   p->mult = 0;
   for (i=0; i<n; i++) {
      s_CdcTruthPoint_t* pp = &p->in[i];
      pp->dEdx = 0;
      pp->dradius = 0;
      pp->phi = 0;
      pp->primary = 0;
      pp->ptype = 0;
      pp->px = 0;
      pp->py = 0;
      pp->pz = 0;
      pp->r = 0;
      pp->t = 0;
      pp->track = 0;
      pp->z = 0;
   }
   return p;
}

s_ForwardDC_t* make_s_ForwardDC()
{
   int size = sizeof(s_ForwardDC_t);
   s_ForwardDC_t* p = (s_ForwardDC_t*)MALLOC(size,"s_ForwardDC_t");
   p->fdcChambers = (s_FdcChambers_t*)&hddm_s_nullTarget;
   return p;
}

s_FdcChambers_t* make_s_FdcChambers(int n)
{
   int i;
   int rep = (n > 1) ? n-1 : 0;
   int size = sizeof(s_FdcChambers_t) + rep * sizeof(s_FdcChamber_t);
   s_FdcChambers_t* p = (s_FdcChambers_t*)MALLOC(size,"s_FdcChambers_t");
   p->mult = 0;
   for (i=0; i<n; i++) {
      s_FdcChamber_t* pp = &p->in[i];
      pp->layer = 0;
      pp->module = 0;
      pp->fdcAnodeWires = (s_FdcAnodeWires_t*)&hddm_s_nullTarget;
      pp->fdcCathodeStrips = (s_FdcCathodeStrips_t*)&hddm_s_nullTarget;
      pp->fdcTruthPoints = (s_FdcTruthPoints_t*)&hddm_s_nullTarget;
   }
   return p;
}

s_FdcAnodeWires_t* make_s_FdcAnodeWires(int n)
{
   int i;
   int rep = (n > 1) ? n-1 : 0;
   int size = sizeof(s_FdcAnodeWires_t) + rep * sizeof(s_FdcAnodeWire_t);
   s_FdcAnodeWires_t* p = (s_FdcAnodeWires_t*)MALLOC(size,"s_FdcAnodeWires_t");
   p->mult = 0;
   for (i=0; i<n; i++) {
      s_FdcAnodeWire_t* pp = &p->in[i];
      pp->wire = 0;
      pp->fdcAnodeHits = (s_FdcAnodeHits_t*)&hddm_s_nullTarget;
      pp->fdcAnodeTruthHits = (s_FdcAnodeTruthHits_t*)&hddm_s_nullTarget;
   }
   return p;
}

s_FdcAnodeHits_t* make_s_FdcAnodeHits(int n)
{
   int i;
   int rep = (n > 1) ? n-1 : 0;
   int size = sizeof(s_FdcAnodeHits_t) + rep * sizeof(s_FdcAnodeHit_t);
   s_FdcAnodeHits_t* p = (s_FdcAnodeHits_t*)MALLOC(size,"s_FdcAnodeHits_t");
   p->mult = 0;
   for (i=0; i<n; i++) {
      s_FdcAnodeHit_t* pp = &p->in[i];
      pp->d = 0;
      pp->dE = 0;
      pp->itrack = 0;
      pp->ptype = 0;
      pp->t = 0;
   }
   return p;
}

s_FdcAnodeTruthHits_t* make_s_FdcAnodeTruthHits(int n)
{
   int i;
   int rep = (n > 1) ? n-1 : 0;
   int size = sizeof(s_FdcAnodeTruthHits_t) + rep * sizeof(s_FdcAnodeTruthHit_t);
   s_FdcAnodeTruthHits_t* p = (s_FdcAnodeTruthHits_t*)MALLOC(size,"s_FdcAnodeTruthHits_t");
   p->mult = 0;
   for (i=0; i<n; i++) {
      s_FdcAnodeTruthHit_t* pp = &p->in[i];
      pp->d = 0;
      pp->dE = 0;
      pp->itrack = 0;
      pp->ptype = 0;
      pp->t = 0;
      pp->t_unsmeared = 0;
   }
   return p;
}

s_FdcCathodeStrips_t* make_s_FdcCathodeStrips(int n)
{
   int i;
   int rep = (n > 1) ? n-1 : 0;
   int size = sizeof(s_FdcCathodeStrips_t) + rep * sizeof(s_FdcCathodeStrip_t);
   s_FdcCathodeStrips_t* p = (s_FdcCathodeStrips_t*)MALLOC(size,"s_FdcCathodeStrips_t");
   p->mult = 0;
   for (i=0; i<n; i++) {
      s_FdcCathodeStrip_t* pp = &p->in[i];
      pp->plane = 0;
      pp->strip = 0;
      pp->fdcCathodeHits = (s_FdcCathodeHits_t*)&hddm_s_nullTarget;
      pp->fdcCathodeTruthHits = (s_FdcCathodeTruthHits_t*)&hddm_s_nullTarget;
   }
   return p;
}

s_FdcCathodeHits_t* make_s_FdcCathodeHits(int n)
{
   int i;
   int rep = (n > 1) ? n-1 : 0;
   int size = sizeof(s_FdcCathodeHits_t) + rep * sizeof(s_FdcCathodeHit_t);
   s_FdcCathodeHits_t* p = (s_FdcCathodeHits_t*)MALLOC(size,"s_FdcCathodeHits_t");
   p->mult = 0;
   for (i=0; i<n; i++) {
      s_FdcCathodeHit_t* pp = &p->in[i];
      pp->itrack = 0;
      pp->ptype = 0;
      pp->q = 0;
      pp->t = 0;
   }
   return p;
}

s_FdcCathodeTruthHits_t* make_s_FdcCathodeTruthHits(int n)
{
   int i;
   int rep = (n > 1) ? n-1 : 0;
   int size = sizeof(s_FdcCathodeTruthHits_t) + rep * sizeof(s_FdcCathodeTruthHit_t);
   s_FdcCathodeTruthHits_t* p = (s_FdcCathodeTruthHits_t*)MALLOC(size,"s_FdcCathodeTruthHits_t");
   p->mult = 0;
   for (i=0; i<n; i++) {
      s_FdcCathodeTruthHit_t* pp = &p->in[i];
      pp->itrack = 0;
      pp->ptype = 0;
      pp->q = 0;
      pp->t = 0;
   }
   return p;
}

s_FdcTruthPoints_t* make_s_FdcTruthPoints(int n)
{
   int i;
   int rep = (n > 1) ? n-1 : 0;
   int size = sizeof(s_FdcTruthPoints_t) + rep * sizeof(s_FdcTruthPoint_t);
   s_FdcTruthPoints_t* p = (s_FdcTruthPoints_t*)MALLOC(size,"s_FdcTruthPoints_t");
   p->mult = 0;
   for (i=0; i<n; i++) {
      s_FdcTruthPoint_t* pp = &p->in[i];
      pp->E = 0;
      pp->dEdx = 0;
      pp->dradius = 0;
      pp->primary = 0;
      pp->ptype = 0;
      pp->px = 0;
      pp->py = 0;
      pp->pz = 0;
      pp->t = 0;
      pp->track = 0;
      pp->x = 0;
      pp->y = 0;
      pp->z = 0;
   }
   return p;
}

s_StartCntr_t* make_s_StartCntr()
{
   int size = sizeof(s_StartCntr_t);
   s_StartCntr_t* p = (s_StartCntr_t*)MALLOC(size,"s_StartCntr_t");
   p->stcPaddles = (s_StcPaddles_t*)&hddm_s_nullTarget;
   p->stcTruthPoints = (s_StcTruthPoints_t*)&hddm_s_nullTarget;
   return p;
}

s_StcPaddles_t* make_s_StcPaddles(int n)
{
   int i;
   int rep = (n > 1) ? n-1 : 0;
   int size = sizeof(s_StcPaddles_t) + rep * sizeof(s_StcPaddle_t);
   s_StcPaddles_t* p = (s_StcPaddles_t*)MALLOC(size,"s_StcPaddles_t");
   p->mult = 0;
   for (i=0; i<n; i++) {
      s_StcPaddle_t* pp = &p->in[i];
      pp->sector = 0;
      pp->stcHits = (s_StcHits_t*)&hddm_s_nullTarget;
      pp->stcTruthHits = (s_StcTruthHits_t*)&hddm_s_nullTarget;
   }
   return p;
}

s_StcHits_t* make_s_StcHits(int n)
{
   int i;
   int rep = (n > 1) ? n-1 : 0;
   int size = sizeof(s_StcHits_t) + rep * sizeof(s_StcHit_t);
   s_StcHits_t* p = (s_StcHits_t*)MALLOC(size,"s_StcHits_t");
   p->mult = 0;
   for (i=0; i<n; i++) {
      s_StcHit_t* pp = &p->in[i];
      pp->dE = 0;
      pp->t = 0;
   }
   return p;
}

s_StcTruthHits_t* make_s_StcTruthHits(int n)
{
   int i;
   int rep = (n > 1) ? n-1 : 0;
   int size = sizeof(s_StcTruthHits_t) + rep * sizeof(s_StcTruthHit_t);
   s_StcTruthHits_t* p = (s_StcTruthHits_t*)MALLOC(size,"s_StcTruthHits_t");
   p->mult = 0;
   for (i=0; i<n; i++) {
      s_StcTruthHit_t* pp = &p->in[i];
      pp->dE = 0;
      pp->t = 0;
   }
   return p;
}

s_StcTruthPoints_t* make_s_StcTruthPoints(int n)
{
   int i;
   int rep = (n > 1) ? n-1 : 0;
   int size = sizeof(s_StcTruthPoints_t) + rep * sizeof(s_StcTruthPoint_t);
   s_StcTruthPoints_t* p = (s_StcTruthPoints_t*)MALLOC(size,"s_StcTruthPoints_t");
   p->mult = 0;
   for (i=0; i<n; i++) {
      s_StcTruthPoint_t* pp = &p->in[i];
      pp->E = 0;
      pp->dEdx = 0;
      pp->phi = 0;
      pp->primary = 0;
      pp->ptype = 0;
      pp->px = 0;
      pp->py = 0;
      pp->pz = 0;
      pp->r = 0;
      pp->sector = 0;
      pp->t = 0;
      pp->track = 0;
      pp->z = 0;
   }
   return p;
}

s_BarrelEMcal_t* make_s_BarrelEMcal()
{
   int size = sizeof(s_BarrelEMcal_t);
   s_BarrelEMcal_t* p = (s_BarrelEMcal_t*)MALLOC(size,"s_BarrelEMcal_t");
   p->bcalCells = (s_BcalCells_t*)&hddm_s_nullTarget;
   p->bcalIncidentParticles = (s_BcalIncidentParticles_t*)&hddm_s_nullTarget;
   p->bcalSiPMSpectrums = (s_BcalSiPMSpectrums_t*)&hddm_s_nullTarget;
   p->bcalfADCCells = (s_BcalfADCCells_t*)&hddm_s_nullTarget;
   p->bcalTDCHits = (s_BcalTDCHits_t*)&hddm_s_nullTarget;
   p->bcalTruthShowers = (s_BcalTruthShowers_t*)&hddm_s_nullTarget;
   return p;
}

s_BcalCells_t* make_s_BcalCells(int n)
{
   int i;
   int rep = (n > 1) ? n-1 : 0;
   int size = sizeof(s_BcalCells_t) + rep * sizeof(s_BcalCell_t);
   s_BcalCells_t* p = (s_BcalCells_t*)MALLOC(size,"s_BcalCells_t");
   p->mult = 0;
   for (i=0; i<n; i++) {
      s_BcalCell_t* pp = &p->in[i];
      pp->layer = 0;
      pp->module = 0;
      pp->sector = 0;
      pp->bcalSiPMUpHits = (s_BcalSiPMUpHits_t*)&hddm_s_nullTarget;
      pp->bcalSiPMDownHits = (s_BcalSiPMDownHits_t*)&hddm_s_nullTarget;
      pp->bcalHits = (s_BcalHits_t*)&hddm_s_nullTarget;
   }
   return p;
}

s_BcalSiPMUpHits_t* make_s_BcalSiPMUpHits(int n)
{
   int i;
   int rep = (n > 1) ? n-1 : 0;
   int size = sizeof(s_BcalSiPMUpHits_t) + rep * sizeof(s_BcalSiPMUpHit_t);
   s_BcalSiPMUpHits_t* p = (s_BcalSiPMUpHits_t*)MALLOC(size,"s_BcalSiPMUpHits_t");
   p->mult = 0;
   for (i=0; i<n; i++) {
      s_BcalSiPMUpHit_t* pp = &p->in[i];
      pp->E = 0;
      pp->t = 0;
   }
   return p;
}

s_BcalSiPMDownHits_t* make_s_BcalSiPMDownHits(int n)
{
   int i;
   int rep = (n > 1) ? n-1 : 0;
   int size = sizeof(s_BcalSiPMDownHits_t) + rep * sizeof(s_BcalSiPMDownHit_t);
   s_BcalSiPMDownHits_t* p = (s_BcalSiPMDownHits_t*)MALLOC(size,"s_BcalSiPMDownHits_t");
   p->mult = 0;
   for (i=0; i<n; i++) {
      s_BcalSiPMDownHit_t* pp = &p->in[i];
      pp->E = 0;
      pp->t = 0;
   }
   return p;
}

s_BcalHits_t* make_s_BcalHits(int n)
{
   int i;
   int rep = (n > 1) ? n-1 : 0;
   int size = sizeof(s_BcalHits_t) + rep * sizeof(s_BcalHit_t);
   s_BcalHits_t* p = (s_BcalHits_t*)MALLOC(size,"s_BcalHits_t");
   p->mult = 0;
   for (i=0; i<n; i++) {
      s_BcalHit_t* pp = &p->in[i];
      pp->E = 0;
      pp->t = 0;
      pp->zLocal = 0;
   }
   return p;
}

s_BcalIncidentParticles_t* make_s_BcalIncidentParticles(int n)
{
   int i;
   int rep = (n > 1) ? n-1 : 0;
   int size = sizeof(s_BcalIncidentParticles_t) + rep * sizeof(s_BcalIncidentParticle_t);
   s_BcalIncidentParticles_t* p = (s_BcalIncidentParticles_t*)MALLOC(size,"s_BcalIncidentParticles_t");
   p->mult = 0;
   for (i=0; i<n; i++) {
      s_BcalIncidentParticle_t* pp = &p->in[i];
      pp->id = 0;
      pp->ptype = 0;
      pp->px = 0;
      pp->py = 0;
      pp->pz = 0;
      pp->x = 0;
      pp->y = 0;
      pp->z = 0;
   }
   return p;
}

s_BcalSiPMSpectrums_t* make_s_BcalSiPMSpectrums(int n)
{
   int i;
   int rep = (n > 1) ? n-1 : 0;
   int size = sizeof(s_BcalSiPMSpectrums_t) + rep * sizeof(s_BcalSiPMSpectrum_t);
   s_BcalSiPMSpectrums_t* p = (s_BcalSiPMSpectrums_t*)MALLOC(size,"s_BcalSiPMSpectrums_t");
   p->mult = 0;
   for (i=0; i<n; i++) {
      s_BcalSiPMSpectrum_t* pp = &p->in[i];
      pp->Etruth = 0;
      pp->bin_width = 0;
      pp->end = 0;
      pp->incident_id = 0;
      pp->layer = 0;
      pp->module = 0;
      pp->sector = 0;
      pp->tstart = 0;
      pp->vals = (string_t)&hddm_s_nullTarget;
   }
   return p;
}

s_BcalfADCCells_t* make_s_BcalfADCCells(int n)
{
   int i;
   int rep = (n > 1) ? n-1 : 0;
   int size = sizeof(s_BcalfADCCells_t) + rep * sizeof(s_BcalfADCCell_t);
   s_BcalfADCCells_t* p = (s_BcalfADCCells_t*)MALLOC(size,"s_BcalfADCCells_t");
   p->mult = 0;
   for (i=0; i<n; i++) {
      s_BcalfADCCell_t* pp = &p->in[i];
      pp->layer = 0;
      pp->module = 0;
      pp->sector = 0;
      pp->bcalfADCUpHits = (s_BcalfADCUpHits_t*)&hddm_s_nullTarget;
      pp->bcalfADCDownHits = (s_BcalfADCDownHits_t*)&hddm_s_nullTarget;
   }
   return p;
}

s_BcalfADCUpHits_t* make_s_BcalfADCUpHits(int n)
{
   int i;
   int rep = (n > 1) ? n-1 : 0;
   int size = sizeof(s_BcalfADCUpHits_t) + rep * sizeof(s_BcalfADCUpHit_t);
   s_BcalfADCUpHits_t* p = (s_BcalfADCUpHits_t*)MALLOC(size,"s_BcalfADCUpHits_t");
   p->mult = 0;
   for (i=0; i<n; i++) {
      s_BcalfADCUpHit_t* pp = &p->in[i];
      pp->E = 0;
      pp->t = 0;
   }
   return p;
}

s_BcalfADCDownHits_t* make_s_BcalfADCDownHits(int n)
{
   int i;
   int rep = (n > 1) ? n-1 : 0;
   int size = sizeof(s_BcalfADCDownHits_t) + rep * sizeof(s_BcalfADCDownHit_t);
   s_BcalfADCDownHits_t* p = (s_BcalfADCDownHits_t*)MALLOC(size,"s_BcalfADCDownHits_t");
   p->mult = 0;
   for (i=0; i<n; i++) {
      s_BcalfADCDownHit_t* pp = &p->in[i];
      pp->E = 0;
      pp->t = 0;
   }
   return p;
}

s_BcalTDCHits_t* make_s_BcalTDCHits(int n)
{
   int i;
   int rep = (n > 1) ? n-1 : 0;
   int size = sizeof(s_BcalTDCHits_t) + rep * sizeof(s_BcalTDCHit_t);
   s_BcalTDCHits_t* p = (s_BcalTDCHits_t*)MALLOC(size,"s_BcalTDCHits_t");
   p->mult = 0;
   for (i=0; i<n; i++) {
      s_BcalTDCHit_t* pp = &p->in[i];
      pp->end = 0;
      pp->layer = 0;
      pp->module = 0;
      pp->sector = 0;
      pp->t = 0;
   }
   return p;
}

s_BcalTruthShowers_t* make_s_BcalTruthShowers(int n)
{
   int i;
   int rep = (n > 1) ? n-1 : 0;
   int size = sizeof(s_BcalTruthShowers_t) + rep * sizeof(s_BcalTruthShower_t);
   s_BcalTruthShowers_t* p = (s_BcalTruthShowers_t*)MALLOC(size,"s_BcalTruthShowers_t");
   p->mult = 0;
   for (i=0; i<n; i++) {
      s_BcalTruthShower_t* pp = &p->in[i];
      pp->E = 0;
      pp->phi = 0;
      pp->primary = 0;
      pp->ptype = 0;
      pp->px = 0;
      pp->py = 0;
      pp->pz = 0;
      pp->r = 0;
      pp->t = 0;
      pp->track = 0;
      pp->z = 0;
   }
   return p;
}

s_GapEMcal_t* make_s_GapEMcal()
{
   int size = sizeof(s_GapEMcal_t);
   s_GapEMcal_t* p = (s_GapEMcal_t*)MALLOC(size,"s_GapEMcal_t");
   p->gcalCells = (s_GcalCells_t*)&hddm_s_nullTarget;
   p->gcalTruthShowers = (s_GcalTruthShowers_t*)&hddm_s_nullTarget;
   return p;
}

s_GcalCells_t* make_s_GcalCells(int n)
{
   int i;
   int rep = (n > 1) ? n-1 : 0;
   int size = sizeof(s_GcalCells_t) + rep * sizeof(s_GcalCell_t);
   s_GcalCells_t* p = (s_GcalCells_t*)MALLOC(size,"s_GcalCells_t");
   p->mult = 0;
   for (i=0; i<n; i++) {
      s_GcalCell_t* pp = &p->in[i];
      pp->module = 0;
      pp->gcalHits = (s_GcalHits_t*)&hddm_s_nullTarget;
   }
   return p;
}

s_GcalHits_t* make_s_GcalHits(int n)
{
   int i;
   int rep = (n > 1) ? n-1 : 0;
   int size = sizeof(s_GcalHits_t) + rep * sizeof(s_GcalHit_t);
   s_GcalHits_t* p = (s_GcalHits_t*)MALLOC(size,"s_GcalHits_t");
   p->mult = 0;
   for (i=0; i<n; i++) {
      s_GcalHit_t* pp = &p->in[i];
      pp->E = 0;
      pp->t = 0;
      pp->zLocal = 0;
   }
   return p;
}

s_GcalTruthShowers_t* make_s_GcalTruthShowers(int n)
{
   int i;
   int rep = (n > 1) ? n-1 : 0;
   int size = sizeof(s_GcalTruthShowers_t) + rep * sizeof(s_GcalTruthShower_t);
   s_GcalTruthShowers_t* p = (s_GcalTruthShowers_t*)MALLOC(size,"s_GcalTruthShowers_t");
   p->mult = 0;
   for (i=0; i<n; i++) {
      s_GcalTruthShower_t* pp = &p->in[i];
      pp->E = 0;
      pp->phi = 0;
      pp->primary = 0;
      pp->ptype = 0;
      pp->px = 0;
      pp->py = 0;
      pp->pz = 0;
      pp->r = 0;
      pp->t = 0;
      pp->track = 0;
      pp->z = 0;
   }
   return p;
}

s_Cerenkov_t* make_s_Cerenkov()
{
   int size = sizeof(s_Cerenkov_t);
   s_Cerenkov_t* p = (s_Cerenkov_t*)MALLOC(size,"s_Cerenkov_t");
   p->cereSections = (s_CereSections_t*)&hddm_s_nullTarget;
   p->cereRichHits = (s_CereRichHits_t*)&hddm_s_nullTarget;
   p->cereTruthPoints = (s_CereTruthPoints_t*)&hddm_s_nullTarget;
   return p;
}

s_CereSections_t* make_s_CereSections(int n)
{
   int i;
   int rep = (n > 1) ? n-1 : 0;
   int size = sizeof(s_CereSections_t) + rep * sizeof(s_CereSection_t);
   s_CereSections_t* p = (s_CereSections_t*)MALLOC(size,"s_CereSections_t");
   p->mult = 0;
   for (i=0; i<n; i++) {
      s_CereSection_t* pp = &p->in[i];
      pp->sector = 0;
      pp->cereHits = (s_CereHits_t*)&hddm_s_nullTarget;
   }
   return p;
}

s_CereHits_t* make_s_CereHits(int n)
{
   int i;
   int rep = (n > 1) ? n-1 : 0;
   int size = sizeof(s_CereHits_t) + rep * sizeof(s_CereHit_t);
   s_CereHits_t* p = (s_CereHits_t*)MALLOC(size,"s_CereHits_t");
   p->mult = 0;
   for (i=0; i<n; i++) {
      s_CereHit_t* pp = &p->in[i];
      pp->pe = 0;
      pp->t = 0;
   }
   return p;
}

s_CereRichHits_t* make_s_CereRichHits(int n)
{
   int i;
   int rep = (n > 1) ? n-1 : 0;
   int size = sizeof(s_CereRichHits_t) + rep * sizeof(s_CereRichHit_t);
   s_CereRichHits_t* p = (s_CereRichHits_t*)MALLOC(size,"s_CereRichHits_t");
   p->mult = 0;
   for (i=0; i<n; i++) {
      s_CereRichHit_t* pp = &p->in[i];
      pp->t = 0;
      pp->x = 0;
      pp->y = 0;
      pp->z = 0;
   }
   return p;
}

s_CereTruthPoints_t* make_s_CereTruthPoints(int n)
{
   int i;
   int rep = (n > 1) ? n-1 : 0;
   int size = sizeof(s_CereTruthPoints_t) + rep * sizeof(s_CereTruthPoint_t);
   s_CereTruthPoints_t* p = (s_CereTruthPoints_t*)MALLOC(size,"s_CereTruthPoints_t");
   p->mult = 0;
   for (i=0; i<n; i++) {
      s_CereTruthPoint_t* pp = &p->in[i];
      pp->E = 0;
      pp->primary = 0;
      pp->ptype = 0;
      pp->px = 0;
      pp->py = 0;
      pp->pz = 0;
      pp->t = 0;
      pp->track = 0;
      pp->x = 0;
      pp->y = 0;
      pp->z = 0;
   }
   return p;
}

s_ForwardTOF_t* make_s_ForwardTOF()
{
   int size = sizeof(s_ForwardTOF_t);
   s_ForwardTOF_t* p = (s_ForwardTOF_t*)MALLOC(size,"s_ForwardTOF_t");
   p->ftofCounters = (s_FtofCounters_t*)&hddm_s_nullTarget;
   p->ftofTruthPoints = (s_FtofTruthPoints_t*)&hddm_s_nullTarget;
   return p;
}

s_FtofCounters_t* make_s_FtofCounters(int n)
{
   int i;
   int rep = (n > 1) ? n-1 : 0;
   int size = sizeof(s_FtofCounters_t) + rep * sizeof(s_FtofCounter_t);
   s_FtofCounters_t* p = (s_FtofCounters_t*)MALLOC(size,"s_FtofCounters_t");
   p->mult = 0;
   for (i=0; i<n; i++) {
      s_FtofCounter_t* pp = &p->in[i];
      pp->bar = 0;
      pp->plane = 0;
      pp->ftofNorthTruthHits = (s_FtofNorthTruthHits_t*)&hddm_s_nullTarget;
      pp->ftofSouthTruthHits = (s_FtofSouthTruthHits_t*)&hddm_s_nullTarget;
      pp->ftofNorthHits = (s_FtofNorthHits_t*)&hddm_s_nullTarget;
      pp->ftofSouthHits = (s_FtofSouthHits_t*)&hddm_s_nullTarget;
   }
   return p;
}

s_FtofNorthTruthHits_t* make_s_FtofNorthTruthHits(int n)
{
   int i;
   int rep = (n > 1) ? n-1 : 0;
   int size = sizeof(s_FtofNorthTruthHits_t) + rep * sizeof(s_FtofNorthTruthHit_t);
   s_FtofNorthTruthHits_t* p = (s_FtofNorthTruthHits_t*)MALLOC(size,"s_FtofNorthTruthHits_t");
   p->mult = 0;
   for (i=0; i<n; i++) {
      s_FtofNorthTruthHit_t* pp = &p->in[i];
      pp->dE = 0;
      pp->t = 0;
      pp->ftofMCHits = (s_FtofMCHits_t*)&hddm_s_nullTarget;
   }
   return p;
}

s_FtofMCHits_t* make_s_FtofMCHits(int n)
{
   int i;
   int rep = (n > 1) ? n-1 : 0;
   int size = sizeof(s_FtofMCHits_t) + rep * sizeof(s_FtofMCHit_t);
   s_FtofMCHits_t* p = (s_FtofMCHits_t*)MALLOC(size,"s_FtofMCHits_t");
   p->mult = 0;
   for (i=0; i<n; i++) {
      s_FtofMCHit_t* pp = &p->in[i];
      pp->E = 0;
      pp->dist = 0;
      pp->itrack = 0;
      pp->ptype = 0;
      pp->px = 0;
      pp->py = 0;
      pp->pz = 0;
      pp->x = 0;
      pp->y = 0;
      pp->z = 0;
   }
   return p;
}

s_FtofSouthTruthHits_t* make_s_FtofSouthTruthHits(int n)
{
   int i;
   int rep = (n > 1) ? n-1 : 0;
   int size = sizeof(s_FtofSouthTruthHits_t) + rep * sizeof(s_FtofSouthTruthHit_t);
   s_FtofSouthTruthHits_t* p = (s_FtofSouthTruthHits_t*)MALLOC(size,"s_FtofSouthTruthHits_t");
   p->mult = 0;
   for (i=0; i<n; i++) {
      s_FtofSouthTruthHit_t* pp = &p->in[i];
      pp->dE = 0;
      pp->t = 0;
      pp->ftofMCHits = (s_FtofMCHits_t*)&hddm_s_nullTarget;
   }
   return p;
}

s_FtofNorthHits_t* make_s_FtofNorthHits(int n)
{
   int i;
   int rep = (n > 1) ? n-1 : 0;
   int size = sizeof(s_FtofNorthHits_t) + rep * sizeof(s_FtofNorthHit_t);
   s_FtofNorthHits_t* p = (s_FtofNorthHits_t*)MALLOC(size,"s_FtofNorthHits_t");
   p->mult = 0;
   for (i=0; i<n; i++) {
      s_FtofNorthHit_t* pp = &p->in[i];
      pp->dE = 0;
      pp->t = 0;
   }
   return p;
}

s_FtofSouthHits_t* make_s_FtofSouthHits(int n)
{
   int i;
   int rep = (n > 1) ? n-1 : 0;
   int size = sizeof(s_FtofSouthHits_t) + rep * sizeof(s_FtofSouthHit_t);
   s_FtofSouthHits_t* p = (s_FtofSouthHits_t*)MALLOC(size,"s_FtofSouthHits_t");
   p->mult = 0;
   for (i=0; i<n; i++) {
      s_FtofSouthHit_t* pp = &p->in[i];
      pp->dE = 0;
      pp->t = 0;
   }
   return p;
}

s_FtofTruthPoints_t* make_s_FtofTruthPoints(int n)
{
   int i;
   int rep = (n > 1) ? n-1 : 0;
   int size = sizeof(s_FtofTruthPoints_t) + rep * sizeof(s_FtofTruthPoint_t);
   s_FtofTruthPoints_t* p = (s_FtofTruthPoints_t*)MALLOC(size,"s_FtofTruthPoints_t");
   p->mult = 0;
   for (i=0; i<n; i++) {
      s_FtofTruthPoint_t* pp = &p->in[i];
      pp->E = 0;
      pp->primary = 0;
      pp->ptype = 0;
      pp->px = 0;
      pp->py = 0;
      pp->pz = 0;
      pp->t = 0;
      pp->track = 0;
      pp->x = 0;
      pp->y = 0;
      pp->z = 0;
   }
   return p;
}

s_ForwardEMcal_t* make_s_ForwardEMcal()
{
   int size = sizeof(s_ForwardEMcal_t);
   s_ForwardEMcal_t* p = (s_ForwardEMcal_t*)MALLOC(size,"s_ForwardEMcal_t");
   p->fcalBlocks = (s_FcalBlocks_t*)&hddm_s_nullTarget;
   p->fcalTruthShowers = (s_FcalTruthShowers_t*)&hddm_s_nullTarget;
   return p;
}

s_FcalBlocks_t* make_s_FcalBlocks(int n)
{
   int i;
   int rep = (n > 1) ? n-1 : 0;
   int size = sizeof(s_FcalBlocks_t) + rep * sizeof(s_FcalBlock_t);
   s_FcalBlocks_t* p = (s_FcalBlocks_t*)MALLOC(size,"s_FcalBlocks_t");
   p->mult = 0;
   for (i=0; i<n; i++) {
      s_FcalBlock_t* pp = &p->in[i];
      pp->column = 0;
      pp->row = 0;
      pp->fcalHits = (s_FcalHits_t*)&hddm_s_nullTarget;
      pp->fcalTruthHits = (s_FcalTruthHits_t*)&hddm_s_nullTarget;
   }
   return p;
}

s_FcalHits_t* make_s_FcalHits(int n)
{
   int i;
   int rep = (n > 1) ? n-1 : 0;
   int size = sizeof(s_FcalHits_t) + rep * sizeof(s_FcalHit_t);
   s_FcalHits_t* p = (s_FcalHits_t*)MALLOC(size,"s_FcalHits_t");
   p->mult = 0;
   for (i=0; i<n; i++) {
      s_FcalHit_t* pp = &p->in[i];
      pp->E = 0;
      pp->t = 0;
   }
   return p;
}

s_FcalTruthHits_t* make_s_FcalTruthHits(int n)
{
   int i;
   int rep = (n > 1) ? n-1 : 0;
   int size = sizeof(s_FcalTruthHits_t) + rep * sizeof(s_FcalTruthHit_t);
   s_FcalTruthHits_t* p = (s_FcalTruthHits_t*)MALLOC(size,"s_FcalTruthHits_t");
   p->mult = 0;
   for (i=0; i<n; i++) {
      s_FcalTruthHit_t* pp = &p->in[i];
      pp->E = 0;
      pp->t = 0;
   }
   return p;
}

s_FcalTruthShowers_t* make_s_FcalTruthShowers(int n)
{
   int i;
   int rep = (n > 1) ? n-1 : 0;
   int size = sizeof(s_FcalTruthShowers_t) + rep * sizeof(s_FcalTruthShower_t);
   s_FcalTruthShowers_t* p = (s_FcalTruthShowers_t*)MALLOC(size,"s_FcalTruthShowers_t");
   p->mult = 0;
   for (i=0; i<n; i++) {
      s_FcalTruthShower_t* pp = &p->in[i];
      pp->E = 0;
      pp->primary = 0;
      pp->ptype = 0;
      pp->px = 0;
      pp->py = 0;
      pp->pz = 0;
      pp->t = 0;
      pp->track = 0;
      pp->x = 0;
      pp->y = 0;
      pp->z = 0;
   }
   return p;
}

s_ComptonEMcal_t* make_s_ComptonEMcal()
{
   int size = sizeof(s_ComptonEMcal_t);
   s_ComptonEMcal_t* p = (s_ComptonEMcal_t*)MALLOC(size,"s_ComptonEMcal_t");
   p->ccalBlocks = (s_CcalBlocks_t*)&hddm_s_nullTarget;
   p->ccalTruthShowers = (s_CcalTruthShowers_t*)&hddm_s_nullTarget;
   return p;
}

s_CcalBlocks_t* make_s_CcalBlocks(int n)
{
   int i;
   int rep = (n > 1) ? n-1 : 0;
   int size = sizeof(s_CcalBlocks_t) + rep * sizeof(s_CcalBlock_t);
   s_CcalBlocks_t* p = (s_CcalBlocks_t*)MALLOC(size,"s_CcalBlocks_t");
   p->mult = 0;
   for (i=0; i<n; i++) {
      s_CcalBlock_t* pp = &p->in[i];
      pp->column = 0;
      pp->row = 0;
      pp->ccalHits = (s_CcalHits_t*)&hddm_s_nullTarget;
      pp->ccalTruthHits = (s_CcalTruthHits_t*)&hddm_s_nullTarget;
   }
   return p;
}

s_CcalHits_t* make_s_CcalHits(int n)
{
   int i;
   int rep = (n > 1) ? n-1 : 0;
   int size = sizeof(s_CcalHits_t) + rep * sizeof(s_CcalHit_t);
   s_CcalHits_t* p = (s_CcalHits_t*)MALLOC(size,"s_CcalHits_t");
   p->mult = 0;
   for (i=0; i<n; i++) {
      s_CcalHit_t* pp = &p->in[i];
      pp->E = 0;
      pp->t = 0;
   }
   return p;
}

s_CcalTruthHits_t* make_s_CcalTruthHits(int n)
{
   int i;
   int rep = (n > 1) ? n-1 : 0;
   int size = sizeof(s_CcalTruthHits_t) + rep * sizeof(s_CcalTruthHit_t);
   s_CcalTruthHits_t* p = (s_CcalTruthHits_t*)MALLOC(size,"s_CcalTruthHits_t");
   p->mult = 0;
   for (i=0; i<n; i++) {
      s_CcalTruthHit_t* pp = &p->in[i];
      pp->E = 0;
      pp->t = 0;
   }
   return p;
}

s_CcalTruthShowers_t* make_s_CcalTruthShowers(int n)
{
   int i;
   int rep = (n > 1) ? n-1 : 0;
   int size = sizeof(s_CcalTruthShowers_t) + rep * sizeof(s_CcalTruthShower_t);
   s_CcalTruthShowers_t* p = (s_CcalTruthShowers_t*)MALLOC(size,"s_CcalTruthShowers_t");
   p->mult = 0;
   for (i=0; i<n; i++) {
      s_CcalTruthShower_t* pp = &p->in[i];
      pp->E = 0;
      pp->primary = 0;
      pp->ptype = 0;
      pp->px = 0;
      pp->py = 0;
      pp->pz = 0;
      pp->t = 0;
      pp->track = 0;
      pp->x = 0;
      pp->y = 0;
      pp->z = 0;
   }
   return p;
}

s_UpstreamEMveto_t* make_s_UpstreamEMveto()
{
   int size = sizeof(s_UpstreamEMveto_t);
   s_UpstreamEMveto_t* p = (s_UpstreamEMveto_t*)MALLOC(size,"s_UpstreamEMveto_t");
   p->upvPaddles = (s_UpvPaddles_t*)&hddm_s_nullTarget;
   p->upvTruthShowers = (s_UpvTruthShowers_t*)&hddm_s_nullTarget;
   return p;
}

s_UpvPaddles_t* make_s_UpvPaddles(int n)
{
   int i;
   int rep = (n > 1) ? n-1 : 0;
   int size = sizeof(s_UpvPaddles_t) + rep * sizeof(s_UpvPaddle_t);
   s_UpvPaddles_t* p = (s_UpvPaddles_t*)MALLOC(size,"s_UpvPaddles_t");
   p->mult = 0;
   for (i=0; i<n; i++) {
      s_UpvPaddle_t* pp = &p->in[i];
      pp->layer = 0;
      pp->row = 0;
      pp->upvLeftHits = (s_UpvLeftHits_t*)&hddm_s_nullTarget;
      pp->upvRightHits = (s_UpvRightHits_t*)&hddm_s_nullTarget;
   }
   return p;
}

s_UpvLeftHits_t* make_s_UpvLeftHits(int n)
{
   int i;
   int rep = (n > 1) ? n-1 : 0;
   int size = sizeof(s_UpvLeftHits_t) + rep * sizeof(s_UpvLeftHit_t);
   s_UpvLeftHits_t* p = (s_UpvLeftHits_t*)MALLOC(size,"s_UpvLeftHits_t");
   p->mult = 0;
   for (i=0; i<n; i++) {
      s_UpvLeftHit_t* pp = &p->in[i];
      pp->E = 0;
      pp->t = 0;
   }
   return p;
}

s_UpvRightHits_t* make_s_UpvRightHits(int n)
{
   int i;
   int rep = (n > 1) ? n-1 : 0;
   int size = sizeof(s_UpvRightHits_t) + rep * sizeof(s_UpvRightHit_t);
   s_UpvRightHits_t* p = (s_UpvRightHits_t*)MALLOC(size,"s_UpvRightHits_t");
   p->mult = 0;
   for (i=0; i<n; i++) {
      s_UpvRightHit_t* pp = &p->in[i];
      pp->E = 0;
      pp->t = 0;
   }
   return p;
}

s_UpvTruthShowers_t* make_s_UpvTruthShowers(int n)
{
   int i;
   int rep = (n > 1) ? n-1 : 0;
   int size = sizeof(s_UpvTruthShowers_t) + rep * sizeof(s_UpvTruthShower_t);
   s_UpvTruthShowers_t* p = (s_UpvTruthShowers_t*)MALLOC(size,"s_UpvTruthShowers_t");
   p->mult = 0;
   for (i=0; i<n; i++) {
      s_UpvTruthShower_t* pp = &p->in[i];
      pp->E = 0;
      pp->primary = 0;
      pp->ptype = 0;
      pp->px = 0;
      pp->py = 0;
      pp->pz = 0;
      pp->t = 0;
      pp->track = 0;
      pp->x = 0;
      pp->y = 0;
      pp->z = 0;
   }
   return p;
}

s_Tagger_t* make_s_Tagger()
{
   int size = sizeof(s_Tagger_t);
   s_Tagger_t* p = (s_Tagger_t*)MALLOC(size,"s_Tagger_t");
   p->microChannels = (s_MicroChannels_t*)&hddm_s_nullTarget;
   return p;
}

s_MicroChannels_t* make_s_MicroChannels(int n)
{
   int i;
   int rep = (n > 1) ? n-1 : 0;
   int size = sizeof(s_MicroChannels_t) + rep * sizeof(s_MicroChannel_t);
   s_MicroChannels_t* p = (s_MicroChannels_t*)MALLOC(size,"s_MicroChannels_t");
   p->mult = 0;
   for (i=0; i<n; i++) {
      s_MicroChannel_t* pp = &p->in[i];
      pp->E = 0;
      pp->column = 0;
      pp->row = 0;
      pp->taggerHits = (s_TaggerHits_t*)&hddm_s_nullTarget;
   }
   return p;
}

s_TaggerHits_t* make_s_TaggerHits(int n)
{
   int i;
   int rep = (n > 1) ? n-1 : 0;
   int size = sizeof(s_TaggerHits_t) + rep * sizeof(s_TaggerHit_t);
   s_TaggerHits_t* p = (s_TaggerHits_t*)MALLOC(size,"s_TaggerHits_t");
   p->mult = 0;
   for (i=0; i<n; i++) {
      s_TaggerHit_t* pp = &p->in[i];
      pp->t = 0;
   }
   return p;
}

s_McTrajectory_t* make_s_McTrajectory()
{
   int size = sizeof(s_McTrajectory_t);
   s_McTrajectory_t* p = (s_McTrajectory_t*)MALLOC(size,"s_McTrajectory_t");
   p->mcTrajectoryPoints = (s_McTrajectoryPoints_t*)&hddm_s_nullTarget;
   return p;
}

s_McTrajectoryPoints_t* make_s_McTrajectoryPoints(int n)
{
   int i;
   int rep = (n > 1) ? n-1 : 0;
   int size = sizeof(s_McTrajectoryPoints_t) + rep * sizeof(s_McTrajectoryPoint_t);
   s_McTrajectoryPoints_t* p = (s_McTrajectoryPoints_t*)MALLOC(size,"s_McTrajectoryPoints_t");
   p->mult = 0;
   for (i=0; i<n; i++) {
      s_McTrajectoryPoint_t* pp = &p->in[i];
      pp->E = 0;
      pp->dE = 0;
      pp->mech = 0;
      pp->part = 0;
      pp->primary_track = 0;
      pp->px = 0;
      pp->py = 0;
      pp->pz = 0;
      pp->radlen = 0;
      pp->step = 0;
      pp->t = 0;
      pp->track = 0;
      pp->x = 0;
      pp->y = 0;
      pp->z = 0;
   }
   return p;
}

s_ReconView_t* make_s_ReconView()
{
   int size = sizeof(s_ReconView_t);
   s_ReconView_t* p = (s_ReconView_t*)MALLOC(size,"s_ReconView_t");
   p->tracktimebaseds = (s_Tracktimebaseds_t*)&hddm_s_nullTarget;
   return p;
}

s_Tracktimebaseds_t* make_s_Tracktimebaseds(int n)
{
   int i;
   int rep = (n > 1) ? n-1 : 0;
   int size = sizeof(s_Tracktimebaseds_t) + rep * sizeof(s_Tracktimebased_t);
   s_Tracktimebaseds_t* p = (s_Tracktimebaseds_t*)MALLOC(size,"s_Tracktimebaseds_t");
   p->mult = 0;
   for (i=0; i<n; i++) {
      s_Tracktimebased_t* pp = &p->in[i];
      pp->FOM = 0;
      pp->Ndof = 0;
      pp->candidateid = 0;
      pp->chisq = 0;
      pp->id = 0;
      pp->trackid = 0;
      pp->momentum = (s_Momentum_t*)&hddm_s_nullTarget;
      pp->properties = (s_Properties_t*)&hddm_s_nullTarget;
      pp->origin = (s_Origin_t*)&hddm_s_nullTarget;
      pp->errorMatrix = (s_ErrorMatrix_t*)&hddm_s_nullTarget;
      pp->TrackingErrorMatrix = (s_TrackingErrorMatrix_t*)&hddm_s_nullTarget;
   }
   return p;
}

s_ErrorMatrix_t* make_s_ErrorMatrix()
{
   int size = sizeof(s_ErrorMatrix_t);
   s_ErrorMatrix_t* p = (s_ErrorMatrix_t*)MALLOC(size,"s_ErrorMatrix_t");
   p->Ncols = 0;
   p->Nrows = 0;
   p->type = (string_t)&hddm_s_nullTarget;
   p->vals = (string_t)&hddm_s_nullTarget;
   return p;
}

s_TrackingErrorMatrix_t* make_s_TrackingErrorMatrix()
{
   int size = sizeof(s_TrackingErrorMatrix_t);
   s_TrackingErrorMatrix_t* p = (s_TrackingErrorMatrix_t*)MALLOC(size,"s_TrackingErrorMatrix_t");
   p->Ncols = 0;
   p->Nrows = 0;
   p->type = (string_t)&hddm_s_nullTarget;
   p->vals = (string_t)&hddm_s_nullTarget;
   return p;
}

char HDDM_s_DocumentString[] = 
"<HDDM class=\"s\" version=\"1.0\" xmlns=\"http://www.gluex.org/hddm\">\n"
"  <physicsEvent eventNo=\"int\" maxOccurs=\"unbounded\" runNo=\"int\">\n"
"    <reaction maxOccurs=\"unbounded\" minOccurs=\"0\" type=\"int\" weight=\"float\">\n"
"      <beam minOccurs=\"0\" type=\"Particle_t\">\n"
"        <momentum E=\"float\" px=\"float\" py=\"float\" pz=\"float\" />\n"
"        <properties charge=\"int\" mass=\"float\" />\n"
"      </beam>\n"
"      <target minOccurs=\"0\" type=\"Particle_t\">\n"
"        <momentum E=\"float\" px=\"float\" py=\"float\" pz=\"float\" />\n"
"        <properties charge=\"int\" mass=\"float\" />\n"
"      </target>\n"
"      <vertex maxOccurs=\"unbounded\">\n"
"        <product decayVertex=\"int\" id=\"int\" maxOccurs=\"unbounded\" mech=\"int\" parentid=\"int\" pdgtype=\"int\" type=\"Particle_t\">\n"
"          <momentum E=\"float\" px=\"float\" py=\"float\" pz=\"float\" />\n"
"          <properties charge=\"int\" mass=\"float\" minOccurs=\"0\" />\n"
"        </product>\n"
"        <origin t=\"float\" vx=\"float\" vy=\"float\" vz=\"float\" />\n"
"      </vertex>\n"
"      <random maxOccurs=\"1\" minOccurs=\"0\" seed1=\"int\" seed2=\"int\" seed_mcsmear1=\"int\" seed_mcsmear2=\"int\" seed_mcsmear3=\"int\" />\n"
"    </reaction>\n"
"    <hitView minOccurs=\"0\" version=\"2.0\">\n"
"      <centralDC minOccurs=\"0\">\n"
"        <cdcStraw maxOccurs=\"unbounded\" minOccurs=\"0\" ring=\"int\" straw=\"int\">\n"
"          <cdcStrawHit d=\"float\" dE=\"float\" itrack=\"int\" maxOccurs=\"unbounded\" ptype=\"int\" t=\"float\" />\n"
"          <cdcStrawTruthHit d=\"float\" dE=\"float\" itrack=\"int\" maxOccurs=\"unbounded\" ptype=\"int\" t=\"float\" />\n"
"        </cdcStraw>\n"
"        <cdcTruthPoint dEdx=\"float\" dradius=\"float\" maxOccurs=\"unbounded\" minOccurs=\"0\" phi=\"float\" primary=\"boolean\" ptype=\"int\" px=\"float\" py=\"float\" pz=\"float\" r=\"float\" t=\"float\" track=\"int\" z=\"float\" />\n"
"      </centralDC>\n"
"      <forwardDC minOccurs=\"0\">\n"
"        <fdcChamber layer=\"int\" maxOccurs=\"unbounded\" module=\"int\">\n"
"          <fdcAnodeWire maxOccurs=\"unbounded\" minOccurs=\"0\" wire=\"int\">\n"
"            <fdcAnodeHit d=\"float\" dE=\"float\" itrack=\"int\" maxOccurs=\"unbounded\" ptype=\"int\" t=\"float\" />\n"
"            <fdcAnodeTruthHit d=\"float\" dE=\"float\" itrack=\"int\" maxOccurs=\"unbounded\" ptype=\"int\" t=\"float\" t_unsmeared=\"float\" />\n"
"          </fdcAnodeWire>\n"
"          <fdcCathodeStrip maxOccurs=\"unbounded\" minOccurs=\"0\" plane=\"int\" strip=\"int\">\n"
"            <fdcCathodeHit itrack=\"int\" maxOccurs=\"unbounded\" ptype=\"int\" q=\"float\" t=\"float\" />\n"
"            <fdcCathodeTruthHit itrack=\"int\" maxOccurs=\"unbounded\" ptype=\"int\" q=\"float\" t=\"float\" />\n"
"          </fdcCathodeStrip>\n"
"          <fdcTruthPoint E=\"float\" dEdx=\"float\" dradius=\"float\" maxOccurs=\"unbounded\" minOccurs=\"0\" primary=\"boolean\" ptype=\"int\" px=\"float\" py=\"float\" pz=\"float\" t=\"float\" track=\"int\" x=\"float\" y=\"float\" z=\"float\" />\n"
"        </fdcChamber>\n"
"      </forwardDC>\n"
"      <startCntr minOccurs=\"0\">\n"
"        <stcPaddle maxOccurs=\"unbounded\" minOccurs=\"0\" sector=\"int\">\n"
"          <stcHit dE=\"float\" maxOccurs=\"unbounded\" t=\"float\" />\n"
"          <stcTruthHit dE=\"float\" maxOccurs=\"unbounded\" t=\"float\" />\n"
"        </stcPaddle>\n"
"        <stcTruthPoint E=\"float\" dEdx=\"float\" maxOccurs=\"unbounded\" minOccurs=\"0\" phi=\"float\" primary=\"boolean\" ptype=\"int\" px=\"float\" py=\"float\" pz=\"float\" r=\"float\" sector=\"int\" t=\"float\" track=\"int\" z=\"float\" />\n"
"      </startCntr>\n"
"      <barrelEMcal minOccurs=\"0\">\n"
"        <bcalCell layer=\"int\" maxOccurs=\"unbounded\" minOccurs=\"0\" module=\"int\" sector=\"int\">\n"
"          <bcalSiPMUpHit E=\"float\" maxOccurs=\"unbounded\" minOccurs=\"0\" t=\"float\" />\n"
"          <bcalSiPMDownHit E=\"float\" maxOccurs=\"unbounded\" minOccurs=\"0\" t=\"float\" />\n"
"          <bcalHit E=\"float\" maxOccurs=\"unbounded\" minOccurs=\"0\" t=\"float\" zLocal=\"float\" />\n"
"        </bcalCell>\n"
"        <bcalIncidentParticle id=\"int\" maxOccurs=\"unbounded\" minOccurs=\"0\" ptype=\"int\" px=\"float\" py=\"float\" pz=\"float\" x=\"float\" y=\"float\" z=\"float\" />\n"
"        <bcalSiPMSpectrum Etruth=\"float\" bin_width=\"float\" end=\"int\" incident_id=\"int\" layer=\"int\" maxOccurs=\"unbounded\" minOccurs=\"0\" module=\"int\" sector=\"int\" tstart=\"float\" vals=\"string\" />\n"
"        <bcalfADCCell layer=\"int\" maxOccurs=\"unbounded\" minOccurs=\"0\" module=\"int\" sector=\"int\">\n"
"          <bcalfADCUpHit E=\"float\" maxOccurs=\"unbounded\" minOccurs=\"0\" t=\"float\" />\n"
"          <bcalfADCDownHit E=\"float\" maxOccurs=\"unbounded\" minOccurs=\"0\" t=\"float\" />\n"
"        </bcalfADCCell>\n"
"        <bcalTDCHit end=\"int\" layer=\"int\" maxOccurs=\"unbounded\" minOccurs=\"0\" module=\"int\" sector=\"int\" t=\"float\" />\n"
"        <bcalTruthShower E=\"float\" maxOccurs=\"unbounded\" minOccurs=\"0\" phi=\"float\" primary=\"boolean\" ptype=\"int\" px=\"float\" py=\"float\" pz=\"float\" r=\"float\" t=\"float\" track=\"int\" z=\"float\" />\n"
"      </barrelEMcal>\n"
"      <gapEMcal minOccurs=\"0\">\n"
"        <gcalCell maxOccurs=\"48\" minOccurs=\"0\" module=\"int\">\n"
"          <gcalHit E=\"float\" maxOccurs=\"unbounded\" minOccurs=\"0\" t=\"float\" zLocal=\"float\" />\n"
"        </gcalCell>\n"
"        <gcalTruthShower E=\"float\" maxOccurs=\"unbounded\" minOccurs=\"0\" phi=\"float\" primary=\"boolean\" ptype=\"int\" px=\"float\" py=\"float\" pz=\"float\" r=\"float\" t=\"float\" track=\"int\" z=\"float\" />\n"
"      </gapEMcal>\n"
"      <Cerenkov minOccurs=\"0\">\n"
"        <cereSection maxOccurs=\"unbounded\" minOccurs=\"0\" sector=\"int\">\n"
"          <cereHit maxOccurs=\"unbounded\" pe=\"float\" t=\"float\" />\n"
"        </cereSection>\n"
"        <cereRichHit maxOccurs=\"unbounded\" minOccurs=\"0\" t=\"float\" x=\"float\" y=\"float\" z=\"float\" />\n"
"        <cereTruthPoint E=\"float\" maxOccurs=\"unbounded\" minOccurs=\"0\" primary=\"boolean\" ptype=\"int\" px=\"float\" py=\"float\" pz=\"float\" t=\"float\" track=\"int\" x=\"float\" y=\"float\" z=\"float\" />\n"
"      </Cerenkov>\n"
"      <forwardTOF minOccurs=\"0\">\n"
"        <ftofCounter bar=\"int\" maxOccurs=\"unbounded\" minOccurs=\"0\" plane=\"int\">\n"
"          <ftofNorthTruthHit dE=\"float\" maxOccurs=\"unbounded\" minOccurs=\"0\" t=\"float\">\n"
"            <ftofMCHit E=\"float\" dist=\"float\" itrack=\"int\" maxOccurs=\"unbounded\" minOccurs=\"0\" ptype=\"int\" px=\"float\" py=\"float\" pz=\"float\" x=\"float\" y=\"float\" z=\"float\" />\n"
"          </ftofNorthTruthHit>\n"
"          <ftofSouthTruthHit dE=\"float\" maxOccurs=\"unbounded\" minOccurs=\"0\" t=\"float\">\n"
"            <ftofMCHit E=\"float\" dist=\"float\" itrack=\"int\" maxOccurs=\"unbounded\" minOccurs=\"0\" ptype=\"int\" px=\"float\" py=\"float\" pz=\"float\" x=\"float\" y=\"float\" z=\"float\" />\n"
"          </ftofSouthTruthHit>\n"
"          <ftofNorthHit dE=\"float\" maxOccurs=\"unbounded\" minOccurs=\"0\" t=\"float\" />\n"
"          <ftofSouthHit dE=\"float\" maxOccurs=\"unbounded\" minOccurs=\"0\" t=\"float\" />\n"
"        </ftofCounter>\n"
"        <ftofTruthPoint E=\"float\" maxOccurs=\"unbounded\" minOccurs=\"0\" primary=\"boolean\" ptype=\"int\" px=\"float\" py=\"float\" pz=\"float\" t=\"float\" track=\"int\" x=\"float\" y=\"float\" z=\"float\" />\n"
"      </forwardTOF>\n"
"      <forwardEMcal minOccurs=\"0\">\n"
"        <fcalBlock column=\"int\" maxOccurs=\"unbounded\" minOccurs=\"0\" row=\"int\">\n"
"          <fcalHit E=\"float\" maxOccurs=\"unbounded\" t=\"float\" />\n"
"          <fcalTruthHit E=\"float\" maxOccurs=\"unbounded\" t=\"float\" />\n"
"        </fcalBlock>\n"
"        <fcalTruthShower E=\"float\" maxOccurs=\"unbounded\" minOccurs=\"0\" primary=\"boolean\" ptype=\"int\" px=\"float\" py=\"float\" pz=\"float\" t=\"float\" track=\"int\" x=\"float\" y=\"float\" z=\"float\" />\n"
"      </forwardEMcal>\n"
"      <ComptonEMcal minOccurs=\"0\">\n"
"        <ccalBlock column=\"int\" maxOccurs=\"unbounded\" minOccurs=\"0\" row=\"int\">\n"
"          <ccalHit E=\"float\" maxOccurs=\"unbounded\" t=\"float\" />\n"
"          <ccalTruthHit E=\"float\" maxOccurs=\"unbounded\" t=\"float\" />\n"
"        </ccalBlock>\n"
"        <ccalTruthShower E=\"float\" maxOccurs=\"unbounded\" minOccurs=\"0\" primary=\"boolean\" ptype=\"int\" px=\"float\" py=\"float\" pz=\"float\" t=\"float\" track=\"int\" x=\"float\" y=\"float\" z=\"float\" />\n"
"      </ComptonEMcal>\n"
"      <upstreamEMveto minOccurs=\"0\">\n"
"        <upvPaddle layer=\"int\" maxOccurs=\"unbounded\" minOccurs=\"0\" row=\"int\">\n"
"          <upvLeftHit E=\"float\" maxOccurs=\"unbounded\" minOccurs=\"0\" t=\"float\" />\n"
"          <upvRightHit E=\"float\" maxOccurs=\"unbounded\" minOccurs=\"0\" t=\"float\" />\n"
"        </upvPaddle>\n"
"        <upvTruthShower E=\"float\" maxOccurs=\"unbounded\" minOccurs=\"0\" primary=\"boolean\" ptype=\"int\" px=\"float\" py=\"float\" pz=\"float\" t=\"float\" track=\"int\" x=\"float\" y=\"float\" z=\"float\" />\n"
"      </upstreamEMveto>\n"
"      <tagger minOccurs=\"0\">\n"
"        <microChannel E=\"float\" column=\"int\" maxOccurs=\"unbounded\" minOccurs=\"0\" row=\"int\">\n"
"          <taggerHit maxOccurs=\"unbounded\" minOccurs=\"0\" t=\"float\" />\n"
"        </microChannel>\n"
"      </tagger>\n"
"      <mcTrajectory minOccurs=\"0\">\n"
"        <mcTrajectoryPoint E=\"float\" dE=\"float\" maxOccurs=\"unbounded\" mech=\"int\" minOccurs=\"0\" part=\"int\" primary_track=\"int\" px=\"float\" py=\"float\" pz=\"float\" radlen=\"float\" step=\"float\" t=\"float\" track=\"int\" x=\"float\" y=\"float\" z=\"float\" />\n"
"      </mcTrajectory>\n"
"    </hitView>\n"
"    <reconView minOccurs=\"0\" version=\"1.0\">\n"
"      <tracktimebased FOM=\"float\" Ndof=\"int\" candidateid=\"int\" chisq=\"float\" id=\"int\" maxOccurs=\"unbounded\" minOccurs=\"0\" trackid=\"int\">\n"
"        <momentum E=\"float\" px=\"float\" py=\"float\" pz=\"float\" />\n"
"        <properties charge=\"int\" mass=\"float\" />\n"
"        <origin t=\"float\" vx=\"float\" vy=\"float\" vz=\"float\" />\n"
"        <errorMatrix Ncols=\"int\" Nrows=\"int\" type=\"string\" vals=\"string\" />\n"
"        <TrackingErrorMatrix Ncols=\"int\" Nrows=\"int\" type=\"string\" vals=\"string\" />\n"
"      </tracktimebased>\n"
"    </reconView>\n"
"  </physicsEvent>\n"
"</HDDM>\n"
;

#ifndef _FILE_OFFSET_BITS
# define _FILE_OFFSET_BITS 64
#endif

static off_t xdr_getpos64(XDR *xdrs)
{
   if (xdrs->x_base == 0) {
      return ftello((FILE *)xdrs->x_private);
   }
   off_t pos = xdr_getpos(xdrs);
   return pos;
}

static bool_t xdr_setpos64(XDR *xdrs, off_t pos) 
{ 
   if (xdrs->x_base == 0) {
      return ((fseeko((FILE *)xdrs->x_private, pos, 0) < 0)? FALSE : TRUE);
   }
   return xdr_setpos(xdrs,pos);
}


static s_HDDM_t* unpack_s_HDDM(XDR* xdrs, popNode* pop)
{
   s_HDDM_t* this1 = (s_HDDM_t*)HDDM_NULL;
   unsigned int size;
   if (! xdr_u_int(xdrs,&size))
   {
       return this1;
   }
   else if (size == 1)
   {
      fprintf(stderr,"hddm error - "
      "compressed data found in input stream.\n"
      "Compression/decompression is not supported "
      "by the hddm c i/o interface.\n");
      fprintf(stderr,"You must use the c++ "
      "interface to read this file.\n");
      exit(9);
   }
   else if (size > 0)
   {
      off_t start = xdr_getpos64(xdrs);
      this1 = make_s_HDDM();
      {
         int p;
         void* (*ptr) = (void**) &this1->physicsEvents;
         for (p = 0; p < pop->popListLength; p++)
         {
            popNode* pnode = pop->popList[p];
            if (pnode)
            {
               int kid = pnode->inParent;
               ptr[kid] = pnode->unpacker(xdrs,pnode);
            }
            else
            {
               unsigned int skip;
               xdr_u_int(xdrs,&skip);
               xdr_setpos64(xdrs,xdr_getpos64(xdrs)+skip);
            }
         }
      }
      xdr_setpos64(xdrs,start+size);
   }
   return this1;
}

static s_PhysicsEvents_t* unpack_s_PhysicsEvents(XDR* xdrs, popNode* pop)
{
   s_PhysicsEvents_t* this1 = (s_PhysicsEvents_t*)HDDM_NULL;
   unsigned int size;
   if (! xdr_u_int(xdrs,&size))
   {
       return this1;
   }
   else if (size == 1)
   {
      fprintf(stderr,"hddm error - "
      "compressed data found in input stream.\n"
      "Compression/decompression is not supported "
      "by the hddm c i/o interface.\n");
      fprintf(stderr,"You must use the c++ "
      "interface to read this file.\n");
      exit(9);
   }
   else if (size > 0)
   {
      off_t start = xdr_getpos64(xdrs);
      int m;
      unsigned int mult;
      xdr_u_int(xdrs,&mult);
      this1 = make_s_PhysicsEvents(mult);
      this1->mult = mult;
      for (m = 0; m < mult; m++ )
      {
         int p;
         void* (*ptr) = (void**) &this1->in[m].reactions;
         xdr_int(xdrs,&this1->in[m].eventNo);
         xdr_int(xdrs,&this1->in[m].runNo);
         for (p = 0; p < pop->popListLength; p++)
         {
            popNode* pnode = pop->popList[p];
            if (pnode)
            {
               int kid = pnode->inParent;
               ptr[kid] = pnode->unpacker(xdrs,pnode);
            }
            else
            {
               unsigned int skip;
               xdr_u_int(xdrs,&skip);
               xdr_setpos64(xdrs,xdr_getpos64(xdrs)+skip);
            }
         }
      }
      xdr_setpos64(xdrs,start+size);
   }
   return this1;
}

static s_Reactions_t* unpack_s_Reactions(XDR* xdrs, popNode* pop)
{
   s_Reactions_t* this1 = (s_Reactions_t*)HDDM_NULL;
   unsigned int size;
   if (! xdr_u_int(xdrs,&size))
   {
       return this1;
   }
   else if (size == 1)
   {
      fprintf(stderr,"hddm error - "
      "compressed data found in input stream.\n"
      "Compression/decompression is not supported "
      "by the hddm c i/o interface.\n");
      fprintf(stderr,"You must use the c++ "
      "interface to read this file.\n");
      exit(9);
   }
   else if (size > 0)
   {
      off_t start = xdr_getpos64(xdrs);
      int m;
      unsigned int mult;
      xdr_u_int(xdrs,&mult);
      this1 = make_s_Reactions(mult);
      this1->mult = mult;
      for (m = 0; m < mult; m++ )
      {
         int p;
         void* (*ptr) = (void**) &this1->in[m].beam;
         xdr_int(xdrs,&this1->in[m].type);
         xdr_float(xdrs,&this1->in[m].weight);
         for (p = 0; p < pop->popListLength; p++)
         {
            popNode* pnode = pop->popList[p];
            if (pnode)
            {
               int kid = pnode->inParent;
               ptr[kid] = pnode->unpacker(xdrs,pnode);
            }
            else
            {
               unsigned int skip;
               xdr_u_int(xdrs,&skip);
               xdr_setpos64(xdrs,xdr_getpos64(xdrs)+skip);
            }
         }
      }
      xdr_setpos64(xdrs,start+size);
   }
   return this1;
}

static s_Beam_t* unpack_s_Beam(XDR* xdrs, popNode* pop)
{
   s_Beam_t* this1 = (s_Beam_t*)HDDM_NULL;
   unsigned int size;
   if (! xdr_u_int(xdrs,&size))
   {
       return this1;
   }
   else if (size == 1)
   {
      fprintf(stderr,"hddm error - "
      "compressed data found in input stream.\n"
      "Compression/decompression is not supported "
      "by the hddm c i/o interface.\n");
      fprintf(stderr,"You must use the c++ "
      "interface to read this file.\n");
      exit(9);
   }
   else if (size > 0)
   {
      off_t start = xdr_getpos64(xdrs);
      this1 = make_s_Beam();
      {
         int p;
         void* (*ptr) = (void**) &this1->momentum;
         xdr_int(xdrs,(int*)&this1->type);
         for (p = 0; p < pop->popListLength; p++)
         {
            popNode* pnode = pop->popList[p];
            if (pnode)
            {
               int kid = pnode->inParent;
               ptr[kid] = pnode->unpacker(xdrs,pnode);
            }
            else
            {
               unsigned int skip;
               xdr_u_int(xdrs,&skip);
               xdr_setpos64(xdrs,xdr_getpos64(xdrs)+skip);
            }
         }
      }
      xdr_setpos64(xdrs,start+size);
   }
   return this1;
}

static s_Momentum_t* unpack_s_Momentum(XDR* xdrs, popNode* pop)
{
   s_Momentum_t* this1 = (s_Momentum_t*)HDDM_NULL;
   unsigned int size;
   if (! xdr_u_int(xdrs,&size))
   {
       return this1;
   }
   else if (size == 1)
   {
      fprintf(stderr,"hddm error - "
      "compressed data found in input stream.\n"
      "Compression/decompression is not supported "
      "by the hddm c i/o interface.\n");
      fprintf(stderr,"You must use the c++ "
      "interface to read this file.\n");
      exit(9);
   }
   else if (size > 0)
   {
      off_t start = xdr_getpos64(xdrs);
      this1 = make_s_Momentum();
      {
         xdr_float(xdrs,&this1->E);
         xdr_float(xdrs,&this1->px);
         xdr_float(xdrs,&this1->py);
         xdr_float(xdrs,&this1->pz);
      }
      xdr_setpos64(xdrs,start+size);
   }
   return this1;
}

static s_Properties_t* unpack_s_Properties(XDR* xdrs, popNode* pop)
{
   s_Properties_t* this1 = (s_Properties_t*)HDDM_NULL;
   unsigned int size;
   if (! xdr_u_int(xdrs,&size))
   {
       return this1;
   }
   else if (size == 1)
   {
      fprintf(stderr,"hddm error - "
      "compressed data found in input stream.\n"
      "Compression/decompression is not supported "
      "by the hddm c i/o interface.\n");
      fprintf(stderr,"You must use the c++ "
      "interface to read this file.\n");
      exit(9);
   }
   else if (size > 0)
   {
      off_t start = xdr_getpos64(xdrs);
      this1 = make_s_Properties();
      {
         xdr_int(xdrs,&this1->charge);
         xdr_float(xdrs,&this1->mass);
      }
      xdr_setpos64(xdrs,start+size);
   }
   return this1;
}

static s_Target_t* unpack_s_Target(XDR* xdrs, popNode* pop)
{
   s_Target_t* this1 = (s_Target_t*)HDDM_NULL;
   unsigned int size;
   if (! xdr_u_int(xdrs,&size))
   {
       return this1;
   }
   else if (size == 1)
   {
      fprintf(stderr,"hddm error - "
      "compressed data found in input stream.\n"
      "Compression/decompression is not supported "
      "by the hddm c i/o interface.\n");
      fprintf(stderr,"You must use the c++ "
      "interface to read this file.\n");
      exit(9);
   }
   else if (size > 0)
   {
      off_t start = xdr_getpos64(xdrs);
      this1 = make_s_Target();
      {
         int p;
         void* (*ptr) = (void**) &this1->momentum;
         xdr_int(xdrs,(int*)&this1->type);
         for (p = 0; p < pop->popListLength; p++)
         {
            popNode* pnode = pop->popList[p];
            if (pnode)
            {
               int kid = pnode->inParent;
               ptr[kid] = pnode->unpacker(xdrs,pnode);
            }
            else
            {
               unsigned int skip;
               xdr_u_int(xdrs,&skip);
               xdr_setpos64(xdrs,xdr_getpos64(xdrs)+skip);
            }
         }
      }
      xdr_setpos64(xdrs,start+size);
   }
   return this1;
}

static s_Vertices_t* unpack_s_Vertices(XDR* xdrs, popNode* pop)
{
   s_Vertices_t* this1 = (s_Vertices_t*)HDDM_NULL;
   unsigned int size;
   if (! xdr_u_int(xdrs,&size))
   {
       return this1;
   }
   else if (size == 1)
   {
      fprintf(stderr,"hddm error - "
      "compressed data found in input stream.\n"
      "Compression/decompression is not supported "
      "by the hddm c i/o interface.\n");
      fprintf(stderr,"You must use the c++ "
      "interface to read this file.\n");
      exit(9);
   }
   else if (size > 0)
   {
      off_t start = xdr_getpos64(xdrs);
      int m;
      unsigned int mult;
      xdr_u_int(xdrs,&mult);
      this1 = make_s_Vertices(mult);
      this1->mult = mult;
      for (m = 0; m < mult; m++ )
      {
         int p;
         void* (*ptr) = (void**) &this1->in[m].products;
         for (p = 0; p < pop->popListLength; p++)
         {
            popNode* pnode = pop->popList[p];
            if (pnode)
            {
               int kid = pnode->inParent;
               ptr[kid] = pnode->unpacker(xdrs,pnode);
            }
            else
            {
               unsigned int skip;
               xdr_u_int(xdrs,&skip);
               xdr_setpos64(xdrs,xdr_getpos64(xdrs)+skip);
            }
         }
      }
      xdr_setpos64(xdrs,start+size);
   }
   return this1;
}

static s_Products_t* unpack_s_Products(XDR* xdrs, popNode* pop)
{
   s_Products_t* this1 = (s_Products_t*)HDDM_NULL;
   unsigned int size;
   if (! xdr_u_int(xdrs,&size))
   {
       return this1;
   }
   else if (size == 1)
   {
      fprintf(stderr,"hddm error - "
      "compressed data found in input stream.\n"
      "Compression/decompression is not supported "
      "by the hddm c i/o interface.\n");
      fprintf(stderr,"You must use the c++ "
      "interface to read this file.\n");
      exit(9);
   }
   else if (size > 0)
   {
      off_t start = xdr_getpos64(xdrs);
      int m;
      unsigned int mult;
      xdr_u_int(xdrs,&mult);
      this1 = make_s_Products(mult);
      this1->mult = mult;
      for (m = 0; m < mult; m++ )
      {
         int p;
         void* (*ptr) = (void**) &this1->in[m].momentum;
         xdr_int(xdrs,&this1->in[m].decayVertex);
         xdr_int(xdrs,&this1->in[m].id);
         xdr_int(xdrs,&this1->in[m].mech);
         xdr_int(xdrs,&this1->in[m].parentid);
         xdr_int(xdrs,&this1->in[m].pdgtype);
         xdr_int(xdrs,(int*)&this1->in[m].type);
         for (p = 0; p < pop->popListLength; p++)
         {
            popNode* pnode = pop->popList[p];
            if (pnode)
            {
               int kid = pnode->inParent;
               ptr[kid] = pnode->unpacker(xdrs,pnode);
            }
            else
            {
               unsigned int skip;
               xdr_u_int(xdrs,&skip);
               xdr_setpos64(xdrs,xdr_getpos64(xdrs)+skip);
            }
         }
      }
      xdr_setpos64(xdrs,start+size);
   }
   return this1;
}

static s_Origin_t* unpack_s_Origin(XDR* xdrs, popNode* pop)
{
   s_Origin_t* this1 = (s_Origin_t*)HDDM_NULL;
   unsigned int size;
   if (! xdr_u_int(xdrs,&size))
   {
       return this1;
   }
   else if (size == 1)
   {
      fprintf(stderr,"hddm error - "
      "compressed data found in input stream.\n"
      "Compression/decompression is not supported "
      "by the hddm c i/o interface.\n");
      fprintf(stderr,"You must use the c++ "
      "interface to read this file.\n");
      exit(9);
   }
   else if (size > 0)
   {
      off_t start = xdr_getpos64(xdrs);
      this1 = make_s_Origin();
      {
         xdr_float(xdrs,&this1->t);
         xdr_float(xdrs,&this1->vx);
         xdr_float(xdrs,&this1->vy);
         xdr_float(xdrs,&this1->vz);
      }
      xdr_setpos64(xdrs,start+size);
   }
   return this1;
}

static s_Random_t* unpack_s_Random(XDR* xdrs, popNode* pop)
{
   s_Random_t* this1 = (s_Random_t*)HDDM_NULL;
   unsigned int size;
   if (! xdr_u_int(xdrs,&size))
   {
       return this1;
   }
   else if (size == 1)
   {
      fprintf(stderr,"hddm error - "
      "compressed data found in input stream.\n"
      "Compression/decompression is not supported "
      "by the hddm c i/o interface.\n");
      fprintf(stderr,"You must use the c++ "
      "interface to read this file.\n");
      exit(9);
   }
   else if (size > 0)
   {
      off_t start = xdr_getpos64(xdrs);
      this1 = make_s_Random();
      {
         xdr_int(xdrs,&this1->seed1);
         xdr_int(xdrs,&this1->seed2);
         xdr_int(xdrs,&this1->seed_mcsmear1);
         xdr_int(xdrs,&this1->seed_mcsmear2);
         xdr_int(xdrs,&this1->seed_mcsmear3);
      }
      xdr_setpos64(xdrs,start+size);
   }
   return this1;
}

static s_HitView_t* unpack_s_HitView(XDR* xdrs, popNode* pop)
{
   s_HitView_t* this1 = (s_HitView_t*)HDDM_NULL;
   unsigned int size;
   if (! xdr_u_int(xdrs,&size))
   {
       return this1;
   }
   else if (size == 1)
   {
      fprintf(stderr,"hddm error - "
      "compressed data found in input stream.\n"
      "Compression/decompression is not supported "
      "by the hddm c i/o interface.\n");
      fprintf(stderr,"You must use the c++ "
      "interface to read this file.\n");
      exit(9);
   }
   else if (size > 0)
   {
      off_t start = xdr_getpos64(xdrs);
      this1 = make_s_HitView();
      {
         int p;
         void* (*ptr) = (void**) &this1->centralDC;
         for (p = 0; p < pop->popListLength; p++)
         {
            popNode* pnode = pop->popList[p];
            if (pnode)
            {
               int kid = pnode->inParent;
               ptr[kid] = pnode->unpacker(xdrs,pnode);
            }
            else
            {
               unsigned int skip;
               xdr_u_int(xdrs,&skip);
               xdr_setpos64(xdrs,xdr_getpos64(xdrs)+skip);
            }
         }
      }
      xdr_setpos64(xdrs,start+size);
   }
   return this1;
}

static s_CentralDC_t* unpack_s_CentralDC(XDR* xdrs, popNode* pop)
{
   s_CentralDC_t* this1 = (s_CentralDC_t*)HDDM_NULL;
   unsigned int size;
   if (! xdr_u_int(xdrs,&size))
   {
       return this1;
   }
   else if (size == 1)
   {
      fprintf(stderr,"hddm error - "
      "compressed data found in input stream.\n"
      "Compression/decompression is not supported "
      "by the hddm c i/o interface.\n");
      fprintf(stderr,"You must use the c++ "
      "interface to read this file.\n");
      exit(9);
   }
   else if (size > 0)
   {
      off_t start = xdr_getpos64(xdrs);
      this1 = make_s_CentralDC();
      {
         int p;
         void* (*ptr) = (void**) &this1->cdcStraws;
         for (p = 0; p < pop->popListLength; p++)
         {
            popNode* pnode = pop->popList[p];
            if (pnode)
            {
               int kid = pnode->inParent;
               ptr[kid] = pnode->unpacker(xdrs,pnode);
            }
            else
            {
               unsigned int skip;
               xdr_u_int(xdrs,&skip);
               xdr_setpos64(xdrs,xdr_getpos64(xdrs)+skip);
            }
         }
      }
      xdr_setpos64(xdrs,start+size);
   }
   return this1;
}

static s_CdcStraws_t* unpack_s_CdcStraws(XDR* xdrs, popNode* pop)
{
   s_CdcStraws_t* this1 = (s_CdcStraws_t*)HDDM_NULL;
   unsigned int size;
   if (! xdr_u_int(xdrs,&size))
   {
       return this1;
   }
   else if (size == 1)
   {
      fprintf(stderr,"hddm error - "
      "compressed data found in input stream.\n"
      "Compression/decompression is not supported "
      "by the hddm c i/o interface.\n");
      fprintf(stderr,"You must use the c++ "
      "interface to read this file.\n");
      exit(9);
   }
   else if (size > 0)
   {
      off_t start = xdr_getpos64(xdrs);
      int m;
      unsigned int mult;
      xdr_u_int(xdrs,&mult);
      this1 = make_s_CdcStraws(mult);
      this1->mult = mult;
      for (m = 0; m < mult; m++ )
      {
         int p;
         void* (*ptr) = (void**) &this1->in[m].cdcStrawHits;
         xdr_int(xdrs,&this1->in[m].ring);
         xdr_int(xdrs,&this1->in[m].straw);
         for (p = 0; p < pop->popListLength; p++)
         {
            popNode* pnode = pop->popList[p];
            if (pnode)
            {
               int kid = pnode->inParent;
               ptr[kid] = pnode->unpacker(xdrs,pnode);
            }
            else
            {
               unsigned int skip;
               xdr_u_int(xdrs,&skip);
               xdr_setpos64(xdrs,xdr_getpos64(xdrs)+skip);
            }
         }
      }
      xdr_setpos64(xdrs,start+size);
   }
   return this1;
}

static s_CdcStrawHits_t* unpack_s_CdcStrawHits(XDR* xdrs, popNode* pop)
{
   s_CdcStrawHits_t* this1 = (s_CdcStrawHits_t*)HDDM_NULL;
   unsigned int size;
   if (! xdr_u_int(xdrs,&size))
   {
       return this1;
   }
   else if (size == 1)
   {
      fprintf(stderr,"hddm error - "
      "compressed data found in input stream.\n"
      "Compression/decompression is not supported "
      "by the hddm c i/o interface.\n");
      fprintf(stderr,"You must use the c++ "
      "interface to read this file.\n");
      exit(9);
   }
   else if (size > 0)
   {
      off_t start = xdr_getpos64(xdrs);
      int m;
      unsigned int mult;
      xdr_u_int(xdrs,&mult);
      this1 = make_s_CdcStrawHits(mult);
      this1->mult = mult;
      for (m = 0; m < mult; m++ )
      {
         xdr_float(xdrs,&this1->in[m].d);
         xdr_float(xdrs,&this1->in[m].dE);
         xdr_int(xdrs,&this1->in[m].itrack);
         xdr_int(xdrs,&this1->in[m].ptype);
         xdr_float(xdrs,&this1->in[m].t);
      }
      xdr_setpos64(xdrs,start+size);
   }
   return this1;
}

static s_CdcStrawTruthHits_t* unpack_s_CdcStrawTruthHits(XDR* xdrs, popNode* pop)
{
   s_CdcStrawTruthHits_t* this1 = (s_CdcStrawTruthHits_t*)HDDM_NULL;
   unsigned int size;
   if (! xdr_u_int(xdrs,&size))
   {
       return this1;
   }
   else if (size == 1)
   {
      fprintf(stderr,"hddm error - "
      "compressed data found in input stream.\n"
      "Compression/decompression is not supported "
      "by the hddm c i/o interface.\n");
      fprintf(stderr,"You must use the c++ "
      "interface to read this file.\n");
      exit(9);
   }
   else if (size > 0)
   {
      off_t start = xdr_getpos64(xdrs);
      int m;
      unsigned int mult;
      xdr_u_int(xdrs,&mult);
      this1 = make_s_CdcStrawTruthHits(mult);
      this1->mult = mult;
      for (m = 0; m < mult; m++ )
      {
         xdr_float(xdrs,&this1->in[m].d);
         xdr_float(xdrs,&this1->in[m].dE);
         xdr_int(xdrs,&this1->in[m].itrack);
         xdr_int(xdrs,&this1->in[m].ptype);
         xdr_float(xdrs,&this1->in[m].t);
      }
      xdr_setpos64(xdrs,start+size);
   }
   return this1;
}

static s_CdcTruthPoints_t* unpack_s_CdcTruthPoints(XDR* xdrs, popNode* pop)
{
   s_CdcTruthPoints_t* this1 = (s_CdcTruthPoints_t*)HDDM_NULL;
   unsigned int size;
   if (! xdr_u_int(xdrs,&size))
   {
       return this1;
   }
   else if (size == 1)
   {
      fprintf(stderr,"hddm error - "
      "compressed data found in input stream.\n"
      "Compression/decompression is not supported "
      "by the hddm c i/o interface.\n");
      fprintf(stderr,"You must use the c++ "
      "interface to read this file.\n");
      exit(9);
   }
   else if (size > 0)
   {
      off_t start = xdr_getpos64(xdrs);
      int m;
      unsigned int mult;
      xdr_u_int(xdrs,&mult);
      this1 = make_s_CdcTruthPoints(mult);
      this1->mult = mult;
      for (m = 0; m < mult; m++ )
      {
         xdr_float(xdrs,&this1->in[m].dEdx);
         xdr_float(xdrs,&this1->in[m].dradius);
         xdr_float(xdrs,&this1->in[m].phi);
         xdr_bool(xdrs,&this1->in[m].primary);
         xdr_int(xdrs,&this1->in[m].ptype);
         xdr_float(xdrs,&this1->in[m].px);
         xdr_float(xdrs,&this1->in[m].py);
         xdr_float(xdrs,&this1->in[m].pz);
         xdr_float(xdrs,&this1->in[m].r);
         xdr_float(xdrs,&this1->in[m].t);
         xdr_int(xdrs,&this1->in[m].track);
         xdr_float(xdrs,&this1->in[m].z);
      }
      xdr_setpos64(xdrs,start+size);
   }
   return this1;
}

static s_ForwardDC_t* unpack_s_ForwardDC(XDR* xdrs, popNode* pop)
{
   s_ForwardDC_t* this1 = (s_ForwardDC_t*)HDDM_NULL;
   unsigned int size;
   if (! xdr_u_int(xdrs,&size))
   {
       return this1;
   }
   else if (size == 1)
   {
      fprintf(stderr,"hddm error - "
      "compressed data found in input stream.\n"
      "Compression/decompression is not supported "
      "by the hddm c i/o interface.\n");
      fprintf(stderr,"You must use the c++ "
      "interface to read this file.\n");
      exit(9);
   }
   else if (size > 0)
   {
      off_t start = xdr_getpos64(xdrs);
      this1 = make_s_ForwardDC();
      {
         int p;
         void* (*ptr) = (void**) &this1->fdcChambers;
         for (p = 0; p < pop->popListLength; p++)
         {
            popNode* pnode = pop->popList[p];
            if (pnode)
            {
               int kid = pnode->inParent;
               ptr[kid] = pnode->unpacker(xdrs,pnode);
            }
            else
            {
               unsigned int skip;
               xdr_u_int(xdrs,&skip);
               xdr_setpos64(xdrs,xdr_getpos64(xdrs)+skip);
            }
         }
      }
      xdr_setpos64(xdrs,start+size);
   }
   return this1;
}

static s_FdcChambers_t* unpack_s_FdcChambers(XDR* xdrs, popNode* pop)
{
   s_FdcChambers_t* this1 = (s_FdcChambers_t*)HDDM_NULL;
   unsigned int size;
   if (! xdr_u_int(xdrs,&size))
   {
       return this1;
   }
   else if (size == 1)
   {
      fprintf(stderr,"hddm error - "
      "compressed data found in input stream.\n"
      "Compression/decompression is not supported "
      "by the hddm c i/o interface.\n");
      fprintf(stderr,"You must use the c++ "
      "interface to read this file.\n");
      exit(9);
   }
   else if (size > 0)
   {
      off_t start = xdr_getpos64(xdrs);
      int m;
      unsigned int mult;
      xdr_u_int(xdrs,&mult);
      this1 = make_s_FdcChambers(mult);
      this1->mult = mult;
      for (m = 0; m < mult; m++ )
      {
         int p;
         void* (*ptr) = (void**) &this1->in[m].fdcAnodeWires;
         xdr_int(xdrs,&this1->in[m].layer);
         xdr_int(xdrs,&this1->in[m].module);
         for (p = 0; p < pop->popListLength; p++)
         {
            popNode* pnode = pop->popList[p];
            if (pnode)
            {
               int kid = pnode->inParent;
               ptr[kid] = pnode->unpacker(xdrs,pnode);
            }
            else
            {
               unsigned int skip;
               xdr_u_int(xdrs,&skip);
               xdr_setpos64(xdrs,xdr_getpos64(xdrs)+skip);
            }
         }
      }
      xdr_setpos64(xdrs,start+size);
   }
   return this1;
}

static s_FdcAnodeWires_t* unpack_s_FdcAnodeWires(XDR* xdrs, popNode* pop)
{
   s_FdcAnodeWires_t* this1 = (s_FdcAnodeWires_t*)HDDM_NULL;
   unsigned int size;
   if (! xdr_u_int(xdrs,&size))
   {
       return this1;
   }
   else if (size == 1)
   {
      fprintf(stderr,"hddm error - "
      "compressed data found in input stream.\n"
      "Compression/decompression is not supported "
      "by the hddm c i/o interface.\n");
      fprintf(stderr,"You must use the c++ "
      "interface to read this file.\n");
      exit(9);
   }
   else if (size > 0)
   {
      off_t start = xdr_getpos64(xdrs);
      int m;
      unsigned int mult;
      xdr_u_int(xdrs,&mult);
      this1 = make_s_FdcAnodeWires(mult);
      this1->mult = mult;
      for (m = 0; m < mult; m++ )
      {
         int p;
         void* (*ptr) = (void**) &this1->in[m].fdcAnodeHits;
         xdr_int(xdrs,&this1->in[m].wire);
         for (p = 0; p < pop->popListLength; p++)
         {
            popNode* pnode = pop->popList[p];
            if (pnode)
            {
               int kid = pnode->inParent;
               ptr[kid] = pnode->unpacker(xdrs,pnode);
            }
            else
            {
               unsigned int skip;
               xdr_u_int(xdrs,&skip);
               xdr_setpos64(xdrs,xdr_getpos64(xdrs)+skip);
            }
         }
      }
      xdr_setpos64(xdrs,start+size);
   }
   return this1;
}

static s_FdcAnodeHits_t* unpack_s_FdcAnodeHits(XDR* xdrs, popNode* pop)
{
   s_FdcAnodeHits_t* this1 = (s_FdcAnodeHits_t*)HDDM_NULL;
   unsigned int size;
   if (! xdr_u_int(xdrs,&size))
   {
       return this1;
   }
   else if (size == 1)
   {
      fprintf(stderr,"hddm error - "
      "compressed data found in input stream.\n"
      "Compression/decompression is not supported "
      "by the hddm c i/o interface.\n");
      fprintf(stderr,"You must use the c++ "
      "interface to read this file.\n");
      exit(9);
   }
   else if (size > 0)
   {
      off_t start = xdr_getpos64(xdrs);
      int m;
      unsigned int mult;
      xdr_u_int(xdrs,&mult);
      this1 = make_s_FdcAnodeHits(mult);
      this1->mult = mult;
      for (m = 0; m < mult; m++ )
      {
         xdr_float(xdrs,&this1->in[m].d);
         xdr_float(xdrs,&this1->in[m].dE);
         xdr_int(xdrs,&this1->in[m].itrack);
         xdr_int(xdrs,&this1->in[m].ptype);
         xdr_float(xdrs,&this1->in[m].t);
      }
      xdr_setpos64(xdrs,start+size);
   }
   return this1;
}

static s_FdcAnodeTruthHits_t* unpack_s_FdcAnodeTruthHits(XDR* xdrs, popNode* pop)
{
   s_FdcAnodeTruthHits_t* this1 = (s_FdcAnodeTruthHits_t*)HDDM_NULL;
   unsigned int size;
   if (! xdr_u_int(xdrs,&size))
   {
       return this1;
   }
   else if (size == 1)
   {
      fprintf(stderr,"hddm error - "
      "compressed data found in input stream.\n"
      "Compression/decompression is not supported "
      "by the hddm c i/o interface.\n");
      fprintf(stderr,"You must use the c++ "
      "interface to read this file.\n");
      exit(9);
   }
   else if (size > 0)
   {
      off_t start = xdr_getpos64(xdrs);
      int m;
      unsigned int mult;
      xdr_u_int(xdrs,&mult);
      this1 = make_s_FdcAnodeTruthHits(mult);
      this1->mult = mult;
      for (m = 0; m < mult; m++ )
      {
         xdr_float(xdrs,&this1->in[m].d);
         xdr_float(xdrs,&this1->in[m].dE);
         xdr_int(xdrs,&this1->in[m].itrack);
         xdr_int(xdrs,&this1->in[m].ptype);
         xdr_float(xdrs,&this1->in[m].t);
         xdr_float(xdrs,&this1->in[m].t_unsmeared);
      }
      xdr_setpos64(xdrs,start+size);
   }
   return this1;
}

static s_FdcCathodeStrips_t* unpack_s_FdcCathodeStrips(XDR* xdrs, popNode* pop)
{
   s_FdcCathodeStrips_t* this1 = (s_FdcCathodeStrips_t*)HDDM_NULL;
   unsigned int size;
   if (! xdr_u_int(xdrs,&size))
   {
       return this1;
   }
   else if (size == 1)
   {
      fprintf(stderr,"hddm error - "
      "compressed data found in input stream.\n"
      "Compression/decompression is not supported "
      "by the hddm c i/o interface.\n");
      fprintf(stderr,"You must use the c++ "
      "interface to read this file.\n");
      exit(9);
   }
   else if (size > 0)
   {
      off_t start = xdr_getpos64(xdrs);
      int m;
      unsigned int mult;
      xdr_u_int(xdrs,&mult);
      this1 = make_s_FdcCathodeStrips(mult);
      this1->mult = mult;
      for (m = 0; m < mult; m++ )
      {
         int p;
         void* (*ptr) = (void**) &this1->in[m].fdcCathodeHits;
         xdr_int(xdrs,&this1->in[m].plane);
         xdr_int(xdrs,&this1->in[m].strip);
         for (p = 0; p < pop->popListLength; p++)
         {
            popNode* pnode = pop->popList[p];
            if (pnode)
            {
               int kid = pnode->inParent;
               ptr[kid] = pnode->unpacker(xdrs,pnode);
            }
            else
            {
               unsigned int skip;
               xdr_u_int(xdrs,&skip);
               xdr_setpos64(xdrs,xdr_getpos64(xdrs)+skip);
            }
         }
      }
      xdr_setpos64(xdrs,start+size);
   }
   return this1;
}

static s_FdcCathodeHits_t* unpack_s_FdcCathodeHits(XDR* xdrs, popNode* pop)
{
   s_FdcCathodeHits_t* this1 = (s_FdcCathodeHits_t*)HDDM_NULL;
   unsigned int size;
   if (! xdr_u_int(xdrs,&size))
   {
       return this1;
   }
   else if (size == 1)
   {
      fprintf(stderr,"hddm error - "
      "compressed data found in input stream.\n"
      "Compression/decompression is not supported "
      "by the hddm c i/o interface.\n");
      fprintf(stderr,"You must use the c++ "
      "interface to read this file.\n");
      exit(9);
   }
   else if (size > 0)
   {
      off_t start = xdr_getpos64(xdrs);
      int m;
      unsigned int mult;
      xdr_u_int(xdrs,&mult);
      this1 = make_s_FdcCathodeHits(mult);
      this1->mult = mult;
      for (m = 0; m < mult; m++ )
      {
         xdr_int(xdrs,&this1->in[m].itrack);
         xdr_int(xdrs,&this1->in[m].ptype);
         xdr_float(xdrs,&this1->in[m].q);
         xdr_float(xdrs,&this1->in[m].t);
      }
      xdr_setpos64(xdrs,start+size);
   }
   return this1;
}

static s_FdcCathodeTruthHits_t* unpack_s_FdcCathodeTruthHits(XDR* xdrs, popNode* pop)
{
   s_FdcCathodeTruthHits_t* this1 = (s_FdcCathodeTruthHits_t*)HDDM_NULL;
   unsigned int size;
   if (! xdr_u_int(xdrs,&size))
   {
       return this1;
   }
   else if (size == 1)
   {
      fprintf(stderr,"hddm error - "
      "compressed data found in input stream.\n"
      "Compression/decompression is not supported "
      "by the hddm c i/o interface.\n");
      fprintf(stderr,"You must use the c++ "
      "interface to read this file.\n");
      exit(9);
   }
   else if (size > 0)
   {
      off_t start = xdr_getpos64(xdrs);
      int m;
      unsigned int mult;
      xdr_u_int(xdrs,&mult);
      this1 = make_s_FdcCathodeTruthHits(mult);
      this1->mult = mult;
      for (m = 0; m < mult; m++ )
      {
         xdr_int(xdrs,&this1->in[m].itrack);
         xdr_int(xdrs,&this1->in[m].ptype);
         xdr_float(xdrs,&this1->in[m].q);
         xdr_float(xdrs,&this1->in[m].t);
      }
      xdr_setpos64(xdrs,start+size);
   }
   return this1;
}

static s_FdcTruthPoints_t* unpack_s_FdcTruthPoints(XDR* xdrs, popNode* pop)
{
   s_FdcTruthPoints_t* this1 = (s_FdcTruthPoints_t*)HDDM_NULL;
   unsigned int size;
   if (! xdr_u_int(xdrs,&size))
   {
       return this1;
   }
   else if (size == 1)
   {
      fprintf(stderr,"hddm error - "
      "compressed data found in input stream.\n"
      "Compression/decompression is not supported "
      "by the hddm c i/o interface.\n");
      fprintf(stderr,"You must use the c++ "
      "interface to read this file.\n");
      exit(9);
   }
   else if (size > 0)
   {
      off_t start = xdr_getpos64(xdrs);
      int m;
      unsigned int mult;
      xdr_u_int(xdrs,&mult);
      this1 = make_s_FdcTruthPoints(mult);
      this1->mult = mult;
      for (m = 0; m < mult; m++ )
      {
         xdr_float(xdrs,&this1->in[m].E);
         xdr_float(xdrs,&this1->in[m].dEdx);
         xdr_float(xdrs,&this1->in[m].dradius);
         xdr_bool(xdrs,&this1->in[m].primary);
         xdr_int(xdrs,&this1->in[m].ptype);
         xdr_float(xdrs,&this1->in[m].px);
         xdr_float(xdrs,&this1->in[m].py);
         xdr_float(xdrs,&this1->in[m].pz);
         xdr_float(xdrs,&this1->in[m].t);
         xdr_int(xdrs,&this1->in[m].track);
         xdr_float(xdrs,&this1->in[m].x);
         xdr_float(xdrs,&this1->in[m].y);
         xdr_float(xdrs,&this1->in[m].z);
      }
      xdr_setpos64(xdrs,start+size);
   }
   return this1;
}

static s_StartCntr_t* unpack_s_StartCntr(XDR* xdrs, popNode* pop)
{
   s_StartCntr_t* this1 = (s_StartCntr_t*)HDDM_NULL;
   unsigned int size;
   if (! xdr_u_int(xdrs,&size))
   {
       return this1;
   }
   else if (size == 1)
   {
      fprintf(stderr,"hddm error - "
      "compressed data found in input stream.\n"
      "Compression/decompression is not supported "
      "by the hddm c i/o interface.\n");
      fprintf(stderr,"You must use the c++ "
      "interface to read this file.\n");
      exit(9);
   }
   else if (size > 0)
   {
      off_t start = xdr_getpos64(xdrs);
      this1 = make_s_StartCntr();
      {
         int p;
         void* (*ptr) = (void**) &this1->stcPaddles;
         for (p = 0; p < pop->popListLength; p++)
         {
            popNode* pnode = pop->popList[p];
            if (pnode)
            {
               int kid = pnode->inParent;
               ptr[kid] = pnode->unpacker(xdrs,pnode);
            }
            else
            {
               unsigned int skip;
               xdr_u_int(xdrs,&skip);
               xdr_setpos64(xdrs,xdr_getpos64(xdrs)+skip);
            }
         }
      }
      xdr_setpos64(xdrs,start+size);
   }
   return this1;
}

static s_StcPaddles_t* unpack_s_StcPaddles(XDR* xdrs, popNode* pop)
{
   s_StcPaddles_t* this1 = (s_StcPaddles_t*)HDDM_NULL;
   unsigned int size;
   if (! xdr_u_int(xdrs,&size))
   {
       return this1;
   }
   else if (size == 1)
   {
      fprintf(stderr,"hddm error - "
      "compressed data found in input stream.\n"
      "Compression/decompression is not supported "
      "by the hddm c i/o interface.\n");
      fprintf(stderr,"You must use the c++ "
      "interface to read this file.\n");
      exit(9);
   }
   else if (size > 0)
   {
      off_t start = xdr_getpos64(xdrs);
      int m;
      unsigned int mult;
      xdr_u_int(xdrs,&mult);
      this1 = make_s_StcPaddles(mult);
      this1->mult = mult;
      for (m = 0; m < mult; m++ )
      {
         int p;
         void* (*ptr) = (void**) &this1->in[m].stcHits;
         xdr_int(xdrs,&this1->in[m].sector);
         for (p = 0; p < pop->popListLength; p++)
         {
            popNode* pnode = pop->popList[p];
            if (pnode)
            {
               int kid = pnode->inParent;
               ptr[kid] = pnode->unpacker(xdrs,pnode);
            }
            else
            {
               unsigned int skip;
               xdr_u_int(xdrs,&skip);
               xdr_setpos64(xdrs,xdr_getpos64(xdrs)+skip);
            }
         }
      }
      xdr_setpos64(xdrs,start+size);
   }
   return this1;
}

static s_StcHits_t* unpack_s_StcHits(XDR* xdrs, popNode* pop)
{
   s_StcHits_t* this1 = (s_StcHits_t*)HDDM_NULL;
   unsigned int size;
   if (! xdr_u_int(xdrs,&size))
   {
       return this1;
   }
   else if (size == 1)
   {
      fprintf(stderr,"hddm error - "
      "compressed data found in input stream.\n"
      "Compression/decompression is not supported "
      "by the hddm c i/o interface.\n");
      fprintf(stderr,"You must use the c++ "
      "interface to read this file.\n");
      exit(9);
   }
   else if (size > 0)
   {
      off_t start = xdr_getpos64(xdrs);
      int m;
      unsigned int mult;
      xdr_u_int(xdrs,&mult);
      this1 = make_s_StcHits(mult);
      this1->mult = mult;
      for (m = 0; m < mult; m++ )
      {
         xdr_float(xdrs,&this1->in[m].dE);
         xdr_float(xdrs,&this1->in[m].t);
      }
      xdr_setpos64(xdrs,start+size);
   }
   return this1;
}

static s_StcTruthHits_t* unpack_s_StcTruthHits(XDR* xdrs, popNode* pop)
{
   s_StcTruthHits_t* this1 = (s_StcTruthHits_t*)HDDM_NULL;
   unsigned int size;
   if (! xdr_u_int(xdrs,&size))
   {
       return this1;
   }
   else if (size == 1)
   {
      fprintf(stderr,"hddm error - "
      "compressed data found in input stream.\n"
      "Compression/decompression is not supported "
      "by the hddm c i/o interface.\n");
      fprintf(stderr,"You must use the c++ "
      "interface to read this file.\n");
      exit(9);
   }
   else if (size > 0)
   {
      off_t start = xdr_getpos64(xdrs);
      int m;
      unsigned int mult;
      xdr_u_int(xdrs,&mult);
      this1 = make_s_StcTruthHits(mult);
      this1->mult = mult;
      for (m = 0; m < mult; m++ )
      {
         xdr_float(xdrs,&this1->in[m].dE);
         xdr_float(xdrs,&this1->in[m].t);
      }
      xdr_setpos64(xdrs,start+size);
   }
   return this1;
}

static s_StcTruthPoints_t* unpack_s_StcTruthPoints(XDR* xdrs, popNode* pop)
{
   s_StcTruthPoints_t* this1 = (s_StcTruthPoints_t*)HDDM_NULL;
   unsigned int size;
   if (! xdr_u_int(xdrs,&size))
   {
       return this1;
   }
   else if (size == 1)
   {
      fprintf(stderr,"hddm error - "
      "compressed data found in input stream.\n"
      "Compression/decompression is not supported "
      "by the hddm c i/o interface.\n");
      fprintf(stderr,"You must use the c++ "
      "interface to read this file.\n");
      exit(9);
   }
   else if (size > 0)
   {
      off_t start = xdr_getpos64(xdrs);
      int m;
      unsigned int mult;
      xdr_u_int(xdrs,&mult);
      this1 = make_s_StcTruthPoints(mult);
      this1->mult = mult;
      for (m = 0; m < mult; m++ )
      {
         xdr_float(xdrs,&this1->in[m].E);
         xdr_float(xdrs,&this1->in[m].dEdx);
         xdr_float(xdrs,&this1->in[m].phi);
         xdr_bool(xdrs,&this1->in[m].primary);
         xdr_int(xdrs,&this1->in[m].ptype);
         xdr_float(xdrs,&this1->in[m].px);
         xdr_float(xdrs,&this1->in[m].py);
         xdr_float(xdrs,&this1->in[m].pz);
         xdr_float(xdrs,&this1->in[m].r);
         xdr_int(xdrs,&this1->in[m].sector);
         xdr_float(xdrs,&this1->in[m].t);
         xdr_int(xdrs,&this1->in[m].track);
         xdr_float(xdrs,&this1->in[m].z);
      }
      xdr_setpos64(xdrs,start+size);
   }
   return this1;
}

static s_BarrelEMcal_t* unpack_s_BarrelEMcal(XDR* xdrs, popNode* pop)
{
   s_BarrelEMcal_t* this1 = (s_BarrelEMcal_t*)HDDM_NULL;
   unsigned int size;
   if (! xdr_u_int(xdrs,&size))
   {
       return this1;
   }
   else if (size == 1)
   {
      fprintf(stderr,"hddm error - "
      "compressed data found in input stream.\n"
      "Compression/decompression is not supported "
      "by the hddm c i/o interface.\n");
      fprintf(stderr,"You must use the c++ "
      "interface to read this file.\n");
      exit(9);
   }
   else if (size > 0)
   {
      off_t start = xdr_getpos64(xdrs);
      this1 = make_s_BarrelEMcal();
      {
         int p;
         void* (*ptr) = (void**) &this1->bcalCells;
         for (p = 0; p < pop->popListLength; p++)
         {
            popNode* pnode = pop->popList[p];
            if (pnode)
            {
               int kid = pnode->inParent;
               ptr[kid] = pnode->unpacker(xdrs,pnode);
            }
            else
            {
               unsigned int skip;
               xdr_u_int(xdrs,&skip);
               xdr_setpos64(xdrs,xdr_getpos64(xdrs)+skip);
            }
         }
      }
      xdr_setpos64(xdrs,start+size);
   }
   return this1;
}

static s_BcalCells_t* unpack_s_BcalCells(XDR* xdrs, popNode* pop)
{
   s_BcalCells_t* this1 = (s_BcalCells_t*)HDDM_NULL;
   unsigned int size;
   if (! xdr_u_int(xdrs,&size))
   {
       return this1;
   }
   else if (size == 1)
   {
      fprintf(stderr,"hddm error - "
      "compressed data found in input stream.\n"
      "Compression/decompression is not supported "
      "by the hddm c i/o interface.\n");
      fprintf(stderr,"You must use the c++ "
      "interface to read this file.\n");
      exit(9);
   }
   else if (size > 0)
   {
      off_t start = xdr_getpos64(xdrs);
      int m;
      unsigned int mult;
      xdr_u_int(xdrs,&mult);
      this1 = make_s_BcalCells(mult);
      this1->mult = mult;
      for (m = 0; m < mult; m++ )
      {
         int p;
         void* (*ptr) = (void**) &this1->in[m].bcalSiPMUpHits;
         xdr_int(xdrs,&this1->in[m].layer);
         xdr_int(xdrs,&this1->in[m].module);
         xdr_int(xdrs,&this1->in[m].sector);
         for (p = 0; p < pop->popListLength; p++)
         {
            popNode* pnode = pop->popList[p];
            if (pnode)
            {
               int kid = pnode->inParent;
               ptr[kid] = pnode->unpacker(xdrs,pnode);
            }
            else
            {
               unsigned int skip;
               xdr_u_int(xdrs,&skip);
               xdr_setpos64(xdrs,xdr_getpos64(xdrs)+skip);
            }
         }
      }
      xdr_setpos64(xdrs,start+size);
   }
   return this1;
}

static s_BcalSiPMUpHits_t* unpack_s_BcalSiPMUpHits(XDR* xdrs, popNode* pop)
{
   s_BcalSiPMUpHits_t* this1 = (s_BcalSiPMUpHits_t*)HDDM_NULL;
   unsigned int size;
   if (! xdr_u_int(xdrs,&size))
   {
       return this1;
   }
   else if (size == 1)
   {
      fprintf(stderr,"hddm error - "
      "compressed data found in input stream.\n"
      "Compression/decompression is not supported "
      "by the hddm c i/o interface.\n");
      fprintf(stderr,"You must use the c++ "
      "interface to read this file.\n");
      exit(9);
   }
   else if (size > 0)
   {
      off_t start = xdr_getpos64(xdrs);
      int m;
      unsigned int mult;
      xdr_u_int(xdrs,&mult);
      this1 = make_s_BcalSiPMUpHits(mult);
      this1->mult = mult;
      for (m = 0; m < mult; m++ )
      {
         xdr_float(xdrs,&this1->in[m].E);
         xdr_float(xdrs,&this1->in[m].t);
      }
      xdr_setpos64(xdrs,start+size);
   }
   return this1;
}

static s_BcalSiPMDownHits_t* unpack_s_BcalSiPMDownHits(XDR* xdrs, popNode* pop)
{
   s_BcalSiPMDownHits_t* this1 = (s_BcalSiPMDownHits_t*)HDDM_NULL;
   unsigned int size;
   if (! xdr_u_int(xdrs,&size))
   {
       return this1;
   }
   else if (size == 1)
   {
      fprintf(stderr,"hddm error - "
      "compressed data found in input stream.\n"
      "Compression/decompression is not supported "
      "by the hddm c i/o interface.\n");
      fprintf(stderr,"You must use the c++ "
      "interface to read this file.\n");
      exit(9);
   }
   else if (size > 0)
   {
      off_t start = xdr_getpos64(xdrs);
      int m;
      unsigned int mult;
      xdr_u_int(xdrs,&mult);
      this1 = make_s_BcalSiPMDownHits(mult);
      this1->mult = mult;
      for (m = 0; m < mult; m++ )
      {
         xdr_float(xdrs,&this1->in[m].E);
         xdr_float(xdrs,&this1->in[m].t);
      }
      xdr_setpos64(xdrs,start+size);
   }
   return this1;
}

static s_BcalHits_t* unpack_s_BcalHits(XDR* xdrs, popNode* pop)
{
   s_BcalHits_t* this1 = (s_BcalHits_t*)HDDM_NULL;
   unsigned int size;
   if (! xdr_u_int(xdrs,&size))
   {
       return this1;
   }
   else if (size == 1)
   {
      fprintf(stderr,"hddm error - "
      "compressed data found in input stream.\n"
      "Compression/decompression is not supported "
      "by the hddm c i/o interface.\n");
      fprintf(stderr,"You must use the c++ "
      "interface to read this file.\n");
      exit(9);
   }
   else if (size > 0)
   {
      off_t start = xdr_getpos64(xdrs);
      int m;
      unsigned int mult;
      xdr_u_int(xdrs,&mult);
      this1 = make_s_BcalHits(mult);
      this1->mult = mult;
      for (m = 0; m < mult; m++ )
      {
         xdr_float(xdrs,&this1->in[m].E);
         xdr_float(xdrs,&this1->in[m].t);
         xdr_float(xdrs,&this1->in[m].zLocal);
      }
      xdr_setpos64(xdrs,start+size);
   }
   return this1;
}

static s_BcalIncidentParticles_t* unpack_s_BcalIncidentParticles(XDR* xdrs, popNode* pop)
{
   s_BcalIncidentParticles_t* this1 = (s_BcalIncidentParticles_t*)HDDM_NULL;
   unsigned int size;
   if (! xdr_u_int(xdrs,&size))
   {
       return this1;
   }
   else if (size == 1)
   {
      fprintf(stderr,"hddm error - "
      "compressed data found in input stream.\n"
      "Compression/decompression is not supported "
      "by the hddm c i/o interface.\n");
      fprintf(stderr,"You must use the c++ "
      "interface to read this file.\n");
      exit(9);
   }
   else if (size > 0)
   {
      off_t start = xdr_getpos64(xdrs);
      int m;
      unsigned int mult;
      xdr_u_int(xdrs,&mult);
      this1 = make_s_BcalIncidentParticles(mult);
      this1->mult = mult;
      for (m = 0; m < mult; m++ )
      {
         xdr_int(xdrs,&this1->in[m].id);
         xdr_int(xdrs,&this1->in[m].ptype);
         xdr_float(xdrs,&this1->in[m].px);
         xdr_float(xdrs,&this1->in[m].py);
         xdr_float(xdrs,&this1->in[m].pz);
         xdr_float(xdrs,&this1->in[m].x);
         xdr_float(xdrs,&this1->in[m].y);
         xdr_float(xdrs,&this1->in[m].z);
      }
      xdr_setpos64(xdrs,start+size);
   }
   return this1;
}

static s_BcalSiPMSpectrums_t* unpack_s_BcalSiPMSpectrums(XDR* xdrs, popNode* pop)
{
   s_BcalSiPMSpectrums_t* this1 = (s_BcalSiPMSpectrums_t*)HDDM_NULL;
   unsigned int size;
   if (! xdr_u_int(xdrs,&size))
   {
       return this1;
   }
   else if (size == 1)
   {
      fprintf(stderr,"hddm error - "
      "compressed data found in input stream.\n"
      "Compression/decompression is not supported "
      "by the hddm c i/o interface.\n");
      fprintf(stderr,"You must use the c++ "
      "interface to read this file.\n");
      exit(9);
   }
   else if (size > 0)
   {
      off_t start = xdr_getpos64(xdrs);
      int m;
      unsigned int mult;
      xdr_u_int(xdrs,&mult);
      this1 = make_s_BcalSiPMSpectrums(mult);
      this1->mult = mult;
      for (m = 0; m < mult; m++ )
      {
         xdr_float(xdrs,&this1->in[m].Etruth);
         xdr_float(xdrs,&this1->in[m].bin_width);
         xdr_int(xdrs,&this1->in[m].end);
         xdr_int(xdrs,&this1->in[m].incident_id);
         xdr_int(xdrs,&this1->in[m].layer);
         xdr_int(xdrs,&this1->in[m].module);
         xdr_int(xdrs,&this1->in[m].sector);
         xdr_float(xdrs,&this1->in[m].tstart);
         this1->in[m].vals = 0;
         xdr_string(xdrs, &this1->in[m].vals, 1000000);
      }
      xdr_setpos64(xdrs,start+size);
   }
   return this1;
}

static s_BcalfADCCells_t* unpack_s_BcalfADCCells(XDR* xdrs, popNode* pop)
{
   s_BcalfADCCells_t* this1 = (s_BcalfADCCells_t*)HDDM_NULL;
   unsigned int size;
   if (! xdr_u_int(xdrs,&size))
   {
       return this1;
   }
   else if (size == 1)
   {
      fprintf(stderr,"hddm error - "
      "compressed data found in input stream.\n"
      "Compression/decompression is not supported "
      "by the hddm c i/o interface.\n");
      fprintf(stderr,"You must use the c++ "
      "interface to read this file.\n");
      exit(9);
   }
   else if (size > 0)
   {
      off_t start = xdr_getpos64(xdrs);
      int m;
      unsigned int mult;
      xdr_u_int(xdrs,&mult);
      this1 = make_s_BcalfADCCells(mult);
      this1->mult = mult;
      for (m = 0; m < mult; m++ )
      {
         int p;
         void* (*ptr) = (void**) &this1->in[m].bcalfADCUpHits;
         xdr_int(xdrs,&this1->in[m].layer);
         xdr_int(xdrs,&this1->in[m].module);
         xdr_int(xdrs,&this1->in[m].sector);
         for (p = 0; p < pop->popListLength; p++)
         {
            popNode* pnode = pop->popList[p];
            if (pnode)
            {
               int kid = pnode->inParent;
               ptr[kid] = pnode->unpacker(xdrs,pnode);
            }
            else
            {
               unsigned int skip;
               xdr_u_int(xdrs,&skip);
               xdr_setpos64(xdrs,xdr_getpos64(xdrs)+skip);
            }
         }
      }
      xdr_setpos64(xdrs,start+size);
   }
   return this1;
}

static s_BcalfADCUpHits_t* unpack_s_BcalfADCUpHits(XDR* xdrs, popNode* pop)
{
   s_BcalfADCUpHits_t* this1 = (s_BcalfADCUpHits_t*)HDDM_NULL;
   unsigned int size;
   if (! xdr_u_int(xdrs,&size))
   {
       return this1;
   }
   else if (size == 1)
   {
      fprintf(stderr,"hddm error - "
      "compressed data found in input stream.\n"
      "Compression/decompression is not supported "
      "by the hddm c i/o interface.\n");
      fprintf(stderr,"You must use the c++ "
      "interface to read this file.\n");
      exit(9);
   }
   else if (size > 0)
   {
      off_t start = xdr_getpos64(xdrs);
      int m;
      unsigned int mult;
      xdr_u_int(xdrs,&mult);
      this1 = make_s_BcalfADCUpHits(mult);
      this1->mult = mult;
      for (m = 0; m < mult; m++ )
      {
         xdr_float(xdrs,&this1->in[m].E);
         xdr_float(xdrs,&this1->in[m].t);
      }
      xdr_setpos64(xdrs,start+size);
   }
   return this1;
}

static s_BcalfADCDownHits_t* unpack_s_BcalfADCDownHits(XDR* xdrs, popNode* pop)
{
   s_BcalfADCDownHits_t* this1 = (s_BcalfADCDownHits_t*)HDDM_NULL;
   unsigned int size;
   if (! xdr_u_int(xdrs,&size))
   {
       return this1;
   }
   else if (size == 1)
   {
      fprintf(stderr,"hddm error - "
      "compressed data found in input stream.\n"
      "Compression/decompression is not supported "
      "by the hddm c i/o interface.\n");
      fprintf(stderr,"You must use the c++ "
      "interface to read this file.\n");
      exit(9);
   }
   else if (size > 0)
   {
      off_t start = xdr_getpos64(xdrs);
      int m;
      unsigned int mult;
      xdr_u_int(xdrs,&mult);
      this1 = make_s_BcalfADCDownHits(mult);
      this1->mult = mult;
      for (m = 0; m < mult; m++ )
      {
         xdr_float(xdrs,&this1->in[m].E);
         xdr_float(xdrs,&this1->in[m].t);
      }
      xdr_setpos64(xdrs,start+size);
   }
   return this1;
}

static s_BcalTDCHits_t* unpack_s_BcalTDCHits(XDR* xdrs, popNode* pop)
{
   s_BcalTDCHits_t* this1 = (s_BcalTDCHits_t*)HDDM_NULL;
   unsigned int size;
   if (! xdr_u_int(xdrs,&size))
   {
       return this1;
   }
   else if (size == 1)
   {
      fprintf(stderr,"hddm error - "
      "compressed data found in input stream.\n"
      "Compression/decompression is not supported "
      "by the hddm c i/o interface.\n");
      fprintf(stderr,"You must use the c++ "
      "interface to read this file.\n");
      exit(9);
   }
   else if (size > 0)
   {
      off_t start = xdr_getpos64(xdrs);
      int m;
      unsigned int mult;
      xdr_u_int(xdrs,&mult);
      this1 = make_s_BcalTDCHits(mult);
      this1->mult = mult;
      for (m = 0; m < mult; m++ )
      {
         xdr_int(xdrs,&this1->in[m].end);
         xdr_int(xdrs,&this1->in[m].layer);
         xdr_int(xdrs,&this1->in[m].module);
         xdr_int(xdrs,&this1->in[m].sector);
         xdr_float(xdrs,&this1->in[m].t);
      }
      xdr_setpos64(xdrs,start+size);
   }
   return this1;
}

static s_BcalTruthShowers_t* unpack_s_BcalTruthShowers(XDR* xdrs, popNode* pop)
{
   s_BcalTruthShowers_t* this1 = (s_BcalTruthShowers_t*)HDDM_NULL;
   unsigned int size;
   if (! xdr_u_int(xdrs,&size))
   {
       return this1;
   }
   else if (size == 1)
   {
      fprintf(stderr,"hddm error - "
      "compressed data found in input stream.\n"
      "Compression/decompression is not supported "
      "by the hddm c i/o interface.\n");
      fprintf(stderr,"You must use the c++ "
      "interface to read this file.\n");
      exit(9);
   }
   else if (size > 0)
   {
      off_t start = xdr_getpos64(xdrs);
      int m;
      unsigned int mult;
      xdr_u_int(xdrs,&mult);
      this1 = make_s_BcalTruthShowers(mult);
      this1->mult = mult;
      for (m = 0; m < mult; m++ )
      {
         xdr_float(xdrs,&this1->in[m].E);
         xdr_float(xdrs,&this1->in[m].phi);
         xdr_bool(xdrs,&this1->in[m].primary);
         xdr_int(xdrs,&this1->in[m].ptype);
         xdr_float(xdrs,&this1->in[m].px);
         xdr_float(xdrs,&this1->in[m].py);
         xdr_float(xdrs,&this1->in[m].pz);
         xdr_float(xdrs,&this1->in[m].r);
         xdr_float(xdrs,&this1->in[m].t);
         xdr_int(xdrs,&this1->in[m].track);
         xdr_float(xdrs,&this1->in[m].z);
      }
      xdr_setpos64(xdrs,start+size);
   }
   return this1;
}

static s_GapEMcal_t* unpack_s_GapEMcal(XDR* xdrs, popNode* pop)
{
   s_GapEMcal_t* this1 = (s_GapEMcal_t*)HDDM_NULL;
   unsigned int size;
   if (! xdr_u_int(xdrs,&size))
   {
       return this1;
   }
   else if (size == 1)
   {
      fprintf(stderr,"hddm error - "
      "compressed data found in input stream.\n"
      "Compression/decompression is not supported "
      "by the hddm c i/o interface.\n");
      fprintf(stderr,"You must use the c++ "
      "interface to read this file.\n");
      exit(9);
   }
   else if (size > 0)
   {
      off_t start = xdr_getpos64(xdrs);
      this1 = make_s_GapEMcal();
      {
         int p;
         void* (*ptr) = (void**) &this1->gcalCells;
         for (p = 0; p < pop->popListLength; p++)
         {
            popNode* pnode = pop->popList[p];
            if (pnode)
            {
               int kid = pnode->inParent;
               ptr[kid] = pnode->unpacker(xdrs,pnode);
            }
            else
            {
               unsigned int skip;
               xdr_u_int(xdrs,&skip);
               xdr_setpos64(xdrs,xdr_getpos64(xdrs)+skip);
            }
         }
      }
      xdr_setpos64(xdrs,start+size);
   }
   return this1;
}

static s_GcalCells_t* unpack_s_GcalCells(XDR* xdrs, popNode* pop)
{
   s_GcalCells_t* this1 = (s_GcalCells_t*)HDDM_NULL;
   unsigned int size;
   if (! xdr_u_int(xdrs,&size))
   {
       return this1;
   }
   else if (size == 1)
   {
      fprintf(stderr,"hddm error - "
      "compressed data found in input stream.\n"
      "Compression/decompression is not supported "
      "by the hddm c i/o interface.\n");
      fprintf(stderr,"You must use the c++ "
      "interface to read this file.\n");
      exit(9);
   }
   else if (size > 0)
   {
      off_t start = xdr_getpos64(xdrs);
      int m;
      unsigned int mult;
      xdr_u_int(xdrs,&mult);
      this1 = make_s_GcalCells(mult);
      this1->mult = mult;
      for (m = 0; m < mult; m++ )
      {
         int p;
         void* (*ptr) = (void**) &this1->in[m].gcalHits;
         xdr_int(xdrs,&this1->in[m].module);
         for (p = 0; p < pop->popListLength; p++)
         {
            popNode* pnode = pop->popList[p];
            if (pnode)
            {
               int kid = pnode->inParent;
               ptr[kid] = pnode->unpacker(xdrs,pnode);
            }
            else
            {
               unsigned int skip;
               xdr_u_int(xdrs,&skip);
               xdr_setpos64(xdrs,xdr_getpos64(xdrs)+skip);
            }
         }
      }
      xdr_setpos64(xdrs,start+size);
   }
   return this1;
}

static s_GcalHits_t* unpack_s_GcalHits(XDR* xdrs, popNode* pop)
{
   s_GcalHits_t* this1 = (s_GcalHits_t*)HDDM_NULL;
   unsigned int size;
   if (! xdr_u_int(xdrs,&size))
   {
       return this1;
   }
   else if (size == 1)
   {
      fprintf(stderr,"hddm error - "
      "compressed data found in input stream.\n"
      "Compression/decompression is not supported "
      "by the hddm c i/o interface.\n");
      fprintf(stderr,"You must use the c++ "
      "interface to read this file.\n");
      exit(9);
   }
   else if (size > 0)
   {
      off_t start = xdr_getpos64(xdrs);
      int m;
      unsigned int mult;
      xdr_u_int(xdrs,&mult);
      this1 = make_s_GcalHits(mult);
      this1->mult = mult;
      for (m = 0; m < mult; m++ )
      {
         xdr_float(xdrs,&this1->in[m].E);
         xdr_float(xdrs,&this1->in[m].t);
         xdr_float(xdrs,&this1->in[m].zLocal);
      }
      xdr_setpos64(xdrs,start+size);
   }
   return this1;
}

static s_GcalTruthShowers_t* unpack_s_GcalTruthShowers(XDR* xdrs, popNode* pop)
{
   s_GcalTruthShowers_t* this1 = (s_GcalTruthShowers_t*)HDDM_NULL;
   unsigned int size;
   if (! xdr_u_int(xdrs,&size))
   {
       return this1;
   }
   else if (size == 1)
   {
      fprintf(stderr,"hddm error - "
      "compressed data found in input stream.\n"
      "Compression/decompression is not supported "
      "by the hddm c i/o interface.\n");
      fprintf(stderr,"You must use the c++ "
      "interface to read this file.\n");
      exit(9);
   }
   else if (size > 0)
   {
      off_t start = xdr_getpos64(xdrs);
      int m;
      unsigned int mult;
      xdr_u_int(xdrs,&mult);
      this1 = make_s_GcalTruthShowers(mult);
      this1->mult = mult;
      for (m = 0; m < mult; m++ )
      {
         xdr_float(xdrs,&this1->in[m].E);
         xdr_float(xdrs,&this1->in[m].phi);
         xdr_bool(xdrs,&this1->in[m].primary);
         xdr_int(xdrs,&this1->in[m].ptype);
         xdr_float(xdrs,&this1->in[m].px);
         xdr_float(xdrs,&this1->in[m].py);
         xdr_float(xdrs,&this1->in[m].pz);
         xdr_float(xdrs,&this1->in[m].r);
         xdr_float(xdrs,&this1->in[m].t);
         xdr_int(xdrs,&this1->in[m].track);
         xdr_float(xdrs,&this1->in[m].z);
      }
      xdr_setpos64(xdrs,start+size);
   }
   return this1;
}

static s_Cerenkov_t* unpack_s_Cerenkov(XDR* xdrs, popNode* pop)
{
   s_Cerenkov_t* this1 = (s_Cerenkov_t*)HDDM_NULL;
   unsigned int size;
   if (! xdr_u_int(xdrs,&size))
   {
       return this1;
   }
   else if (size == 1)
   {
      fprintf(stderr,"hddm error - "
      "compressed data found in input stream.\n"
      "Compression/decompression is not supported "
      "by the hddm c i/o interface.\n");
      fprintf(stderr,"You must use the c++ "
      "interface to read this file.\n");
      exit(9);
   }
   else if (size > 0)
   {
      off_t start = xdr_getpos64(xdrs);
      this1 = make_s_Cerenkov();
      {
         int p;
         void* (*ptr) = (void**) &this1->cereSections;
         for (p = 0; p < pop->popListLength; p++)
         {
            popNode* pnode = pop->popList[p];
            if (pnode)
            {
               int kid = pnode->inParent;
               ptr[kid] = pnode->unpacker(xdrs,pnode);
            }
            else
            {
               unsigned int skip;
               xdr_u_int(xdrs,&skip);
               xdr_setpos64(xdrs,xdr_getpos64(xdrs)+skip);
            }
         }
      }
      xdr_setpos64(xdrs,start+size);
   }
   return this1;
}

static s_CereSections_t* unpack_s_CereSections(XDR* xdrs, popNode* pop)
{
   s_CereSections_t* this1 = (s_CereSections_t*)HDDM_NULL;
   unsigned int size;
   if (! xdr_u_int(xdrs,&size))
   {
       return this1;
   }
   else if (size == 1)
   {
      fprintf(stderr,"hddm error - "
      "compressed data found in input stream.\n"
      "Compression/decompression is not supported "
      "by the hddm c i/o interface.\n");
      fprintf(stderr,"You must use the c++ "
      "interface to read this file.\n");
      exit(9);
   }
   else if (size > 0)
   {
      off_t start = xdr_getpos64(xdrs);
      int m;
      unsigned int mult;
      xdr_u_int(xdrs,&mult);
      this1 = make_s_CereSections(mult);
      this1->mult = mult;
      for (m = 0; m < mult; m++ )
      {
         int p;
         void* (*ptr) = (void**) &this1->in[m].cereHits;
         xdr_int(xdrs,&this1->in[m].sector);
         for (p = 0; p < pop->popListLength; p++)
         {
            popNode* pnode = pop->popList[p];
            if (pnode)
            {
               int kid = pnode->inParent;
               ptr[kid] = pnode->unpacker(xdrs,pnode);
            }
            else
            {
               unsigned int skip;
               xdr_u_int(xdrs,&skip);
               xdr_setpos64(xdrs,xdr_getpos64(xdrs)+skip);
            }
         }
      }
      xdr_setpos64(xdrs,start+size);
   }
   return this1;
}

static s_CereHits_t* unpack_s_CereHits(XDR* xdrs, popNode* pop)
{
   s_CereHits_t* this1 = (s_CereHits_t*)HDDM_NULL;
   unsigned int size;
   if (! xdr_u_int(xdrs,&size))
   {
       return this1;
   }
   else if (size == 1)
   {
      fprintf(stderr,"hddm error - "
      "compressed data found in input stream.\n"
      "Compression/decompression is not supported "
      "by the hddm c i/o interface.\n");
      fprintf(stderr,"You must use the c++ "
      "interface to read this file.\n");
      exit(9);
   }
   else if (size > 0)
   {
      off_t start = xdr_getpos64(xdrs);
      int m;
      unsigned int mult;
      xdr_u_int(xdrs,&mult);
      this1 = make_s_CereHits(mult);
      this1->mult = mult;
      for (m = 0; m < mult; m++ )
      {
         xdr_float(xdrs,&this1->in[m].pe);
         xdr_float(xdrs,&this1->in[m].t);
      }
      xdr_setpos64(xdrs,start+size);
   }
   return this1;
}

static s_CereRichHits_t* unpack_s_CereRichHits(XDR* xdrs, popNode* pop)
{
   s_CereRichHits_t* this1 = (s_CereRichHits_t*)HDDM_NULL;
   unsigned int size;
   if (! xdr_u_int(xdrs,&size))
   {
       return this1;
   }
   else if (size == 1)
   {
      fprintf(stderr,"hddm error - "
      "compressed data found in input stream.\n"
      "Compression/decompression is not supported "
      "by the hddm c i/o interface.\n");
      fprintf(stderr,"You must use the c++ "
      "interface to read this file.\n");
      exit(9);
   }
   else if (size > 0)
   {
      off_t start = xdr_getpos64(xdrs);
      int m;
      unsigned int mult;
      xdr_u_int(xdrs,&mult);
      this1 = make_s_CereRichHits(mult);
      this1->mult = mult;
      for (m = 0; m < mult; m++ )
      {
         xdr_float(xdrs,&this1->in[m].t);
         xdr_float(xdrs,&this1->in[m].x);
         xdr_float(xdrs,&this1->in[m].y);
         xdr_float(xdrs,&this1->in[m].z);
      }
      xdr_setpos64(xdrs,start+size);
   }
   return this1;
}

static s_CereTruthPoints_t* unpack_s_CereTruthPoints(XDR* xdrs, popNode* pop)
{
   s_CereTruthPoints_t* this1 = (s_CereTruthPoints_t*)HDDM_NULL;
   unsigned int size;
   if (! xdr_u_int(xdrs,&size))
   {
       return this1;
   }
   else if (size == 1)
   {
      fprintf(stderr,"hddm error - "
      "compressed data found in input stream.\n"
      "Compression/decompression is not supported "
      "by the hddm c i/o interface.\n");
      fprintf(stderr,"You must use the c++ "
      "interface to read this file.\n");
      exit(9);
   }
   else if (size > 0)
   {
      off_t start = xdr_getpos64(xdrs);
      int m;
      unsigned int mult;
      xdr_u_int(xdrs,&mult);
      this1 = make_s_CereTruthPoints(mult);
      this1->mult = mult;
      for (m = 0; m < mult; m++ )
      {
         xdr_float(xdrs,&this1->in[m].E);
         xdr_bool(xdrs,&this1->in[m].primary);
         xdr_int(xdrs,&this1->in[m].ptype);
         xdr_float(xdrs,&this1->in[m].px);
         xdr_float(xdrs,&this1->in[m].py);
         xdr_float(xdrs,&this1->in[m].pz);
         xdr_float(xdrs,&this1->in[m].t);
         xdr_int(xdrs,&this1->in[m].track);
         xdr_float(xdrs,&this1->in[m].x);
         xdr_float(xdrs,&this1->in[m].y);
         xdr_float(xdrs,&this1->in[m].z);
      }
      xdr_setpos64(xdrs,start+size);
   }
   return this1;
}

static s_ForwardTOF_t* unpack_s_ForwardTOF(XDR* xdrs, popNode* pop)
{
   s_ForwardTOF_t* this1 = (s_ForwardTOF_t*)HDDM_NULL;
   unsigned int size;
   if (! xdr_u_int(xdrs,&size))
   {
       return this1;
   }
   else if (size == 1)
   {
      fprintf(stderr,"hddm error - "
      "compressed data found in input stream.\n"
      "Compression/decompression is not supported "
      "by the hddm c i/o interface.\n");
      fprintf(stderr,"You must use the c++ "
      "interface to read this file.\n");
      exit(9);
   }
   else if (size > 0)
   {
      off_t start = xdr_getpos64(xdrs);
      this1 = make_s_ForwardTOF();
      {
         int p;
         void* (*ptr) = (void**) &this1->ftofCounters;
         for (p = 0; p < pop->popListLength; p++)
         {
            popNode* pnode = pop->popList[p];
            if (pnode)
            {
               int kid = pnode->inParent;
               ptr[kid] = pnode->unpacker(xdrs,pnode);
            }
            else
            {
               unsigned int skip;
               xdr_u_int(xdrs,&skip);
               xdr_setpos64(xdrs,xdr_getpos64(xdrs)+skip);
            }
         }
      }
      xdr_setpos64(xdrs,start+size);
   }
   return this1;
}

static s_FtofCounters_t* unpack_s_FtofCounters(XDR* xdrs, popNode* pop)
{
   s_FtofCounters_t* this1 = (s_FtofCounters_t*)HDDM_NULL;
   unsigned int size;
   if (! xdr_u_int(xdrs,&size))
   {
       return this1;
   }
   else if (size == 1)
   {
      fprintf(stderr,"hddm error - "
      "compressed data found in input stream.\n"
      "Compression/decompression is not supported "
      "by the hddm c i/o interface.\n");
      fprintf(stderr,"You must use the c++ "
      "interface to read this file.\n");
      exit(9);
   }
   else if (size > 0)
   {
      off_t start = xdr_getpos64(xdrs);
      int m;
      unsigned int mult;
      xdr_u_int(xdrs,&mult);
      this1 = make_s_FtofCounters(mult);
      this1->mult = mult;
      for (m = 0; m < mult; m++ )
      {
         int p;
         void* (*ptr) = (void**) &this1->in[m].ftofNorthTruthHits;
         xdr_int(xdrs,&this1->in[m].bar);
         xdr_int(xdrs,&this1->in[m].plane);
         for (p = 0; p < pop->popListLength; p++)
         {
            popNode* pnode = pop->popList[p];
            if (pnode)
            {
               int kid = pnode->inParent;
               ptr[kid] = pnode->unpacker(xdrs,pnode);
            }
            else
            {
               unsigned int skip;
               xdr_u_int(xdrs,&skip);
               xdr_setpos64(xdrs,xdr_getpos64(xdrs)+skip);
            }
         }
      }
      xdr_setpos64(xdrs,start+size);
   }
   return this1;
}

static s_FtofNorthTruthHits_t* unpack_s_FtofNorthTruthHits(XDR* xdrs, popNode* pop)
{
   s_FtofNorthTruthHits_t* this1 = (s_FtofNorthTruthHits_t*)HDDM_NULL;
   unsigned int size;
   if (! xdr_u_int(xdrs,&size))
   {
       return this1;
   }
   else if (size == 1)
   {
      fprintf(stderr,"hddm error - "
      "compressed data found in input stream.\n"
      "Compression/decompression is not supported "
      "by the hddm c i/o interface.\n");
      fprintf(stderr,"You must use the c++ "
      "interface to read this file.\n");
      exit(9);
   }
   else if (size > 0)
   {
      off_t start = xdr_getpos64(xdrs);
      int m;
      unsigned int mult;
      xdr_u_int(xdrs,&mult);
      this1 = make_s_FtofNorthTruthHits(mult);
      this1->mult = mult;
      for (m = 0; m < mult; m++ )
      {
         int p;
         void* (*ptr) = (void**) &this1->in[m].ftofMCHits;
         xdr_float(xdrs,&this1->in[m].dE);
         xdr_float(xdrs,&this1->in[m].t);
         for (p = 0; p < pop->popListLength; p++)
         {
            popNode* pnode = pop->popList[p];
            if (pnode)
            {
               int kid = pnode->inParent;
               ptr[kid] = pnode->unpacker(xdrs,pnode);
            }
            else
            {
               unsigned int skip;
               xdr_u_int(xdrs,&skip);
               xdr_setpos64(xdrs,xdr_getpos64(xdrs)+skip);
            }
         }
      }
      xdr_setpos64(xdrs,start+size);
   }
   return this1;
}

static s_FtofMCHits_t* unpack_s_FtofMCHits(XDR* xdrs, popNode* pop)
{
   s_FtofMCHits_t* this1 = (s_FtofMCHits_t*)HDDM_NULL;
   unsigned int size;
   if (! xdr_u_int(xdrs,&size))
   {
       return this1;
   }
   else if (size == 1)
   {
      fprintf(stderr,"hddm error - "
      "compressed data found in input stream.\n"
      "Compression/decompression is not supported "
      "by the hddm c i/o interface.\n");
      fprintf(stderr,"You must use the c++ "
      "interface to read this file.\n");
      exit(9);
   }
   else if (size > 0)
   {
      off_t start = xdr_getpos64(xdrs);
      int m;
      unsigned int mult;
      xdr_u_int(xdrs,&mult);
      this1 = make_s_FtofMCHits(mult);
      this1->mult = mult;
      for (m = 0; m < mult; m++ )
      {
         xdr_float(xdrs,&this1->in[m].E);
         xdr_float(xdrs,&this1->in[m].dist);
         xdr_int(xdrs,&this1->in[m].itrack);
         xdr_int(xdrs,&this1->in[m].ptype);
         xdr_float(xdrs,&this1->in[m].px);
         xdr_float(xdrs,&this1->in[m].py);
         xdr_float(xdrs,&this1->in[m].pz);
         xdr_float(xdrs,&this1->in[m].x);
         xdr_float(xdrs,&this1->in[m].y);
         xdr_float(xdrs,&this1->in[m].z);
      }
      xdr_setpos64(xdrs,start+size);
   }
   return this1;
}

static s_FtofSouthTruthHits_t* unpack_s_FtofSouthTruthHits(XDR* xdrs, popNode* pop)
{
   s_FtofSouthTruthHits_t* this1 = (s_FtofSouthTruthHits_t*)HDDM_NULL;
   unsigned int size;
   if (! xdr_u_int(xdrs,&size))
   {
       return this1;
   }
   else if (size == 1)
   {
      fprintf(stderr,"hddm error - "
      "compressed data found in input stream.\n"
      "Compression/decompression is not supported "
      "by the hddm c i/o interface.\n");
      fprintf(stderr,"You must use the c++ "
      "interface to read this file.\n");
      exit(9);
   }
   else if (size > 0)
   {
      off_t start = xdr_getpos64(xdrs);
      int m;
      unsigned int mult;
      xdr_u_int(xdrs,&mult);
      this1 = make_s_FtofSouthTruthHits(mult);
      this1->mult = mult;
      for (m = 0; m < mult; m++ )
      {
         int p;
         void* (*ptr) = (void**) &this1->in[m].ftofMCHits;
         xdr_float(xdrs,&this1->in[m].dE);
         xdr_float(xdrs,&this1->in[m].t);
         for (p = 0; p < pop->popListLength; p++)
         {
            popNode* pnode = pop->popList[p];
            if (pnode)
            {
               int kid = pnode->inParent;
               ptr[kid] = pnode->unpacker(xdrs,pnode);
            }
            else
            {
               unsigned int skip;
               xdr_u_int(xdrs,&skip);
               xdr_setpos64(xdrs,xdr_getpos64(xdrs)+skip);
            }
         }
      }
      xdr_setpos64(xdrs,start+size);
   }
   return this1;
}

static s_FtofNorthHits_t* unpack_s_FtofNorthHits(XDR* xdrs, popNode* pop)
{
   s_FtofNorthHits_t* this1 = (s_FtofNorthHits_t*)HDDM_NULL;
   unsigned int size;
   if (! xdr_u_int(xdrs,&size))
   {
       return this1;
   }
   else if (size == 1)
   {
      fprintf(stderr,"hddm error - "
      "compressed data found in input stream.\n"
      "Compression/decompression is not supported "
      "by the hddm c i/o interface.\n");
      fprintf(stderr,"You must use the c++ "
      "interface to read this file.\n");
      exit(9);
   }
   else if (size > 0)
   {
      off_t start = xdr_getpos64(xdrs);
      int m;
      unsigned int mult;
      xdr_u_int(xdrs,&mult);
      this1 = make_s_FtofNorthHits(mult);
      this1->mult = mult;
      for (m = 0; m < mult; m++ )
      {
         xdr_float(xdrs,&this1->in[m].dE);
         xdr_float(xdrs,&this1->in[m].t);
      }
      xdr_setpos64(xdrs,start+size);
   }
   return this1;
}

static s_FtofSouthHits_t* unpack_s_FtofSouthHits(XDR* xdrs, popNode* pop)
{
   s_FtofSouthHits_t* this1 = (s_FtofSouthHits_t*)HDDM_NULL;
   unsigned int size;
   if (! xdr_u_int(xdrs,&size))
   {
       return this1;
   }
   else if (size == 1)
   {
      fprintf(stderr,"hddm error - "
      "compressed data found in input stream.\n"
      "Compression/decompression is not supported "
      "by the hddm c i/o interface.\n");
      fprintf(stderr,"You must use the c++ "
      "interface to read this file.\n");
      exit(9);
   }
   else if (size > 0)
   {
      off_t start = xdr_getpos64(xdrs);
      int m;
      unsigned int mult;
      xdr_u_int(xdrs,&mult);
      this1 = make_s_FtofSouthHits(mult);
      this1->mult = mult;
      for (m = 0; m < mult; m++ )
      {
         xdr_float(xdrs,&this1->in[m].dE);
         xdr_float(xdrs,&this1->in[m].t);
      }
      xdr_setpos64(xdrs,start+size);
   }
   return this1;
}

static s_FtofTruthPoints_t* unpack_s_FtofTruthPoints(XDR* xdrs, popNode* pop)
{
   s_FtofTruthPoints_t* this1 = (s_FtofTruthPoints_t*)HDDM_NULL;
   unsigned int size;
   if (! xdr_u_int(xdrs,&size))
   {
       return this1;
   }
   else if (size == 1)
   {
      fprintf(stderr,"hddm error - "
      "compressed data found in input stream.\n"
      "Compression/decompression is not supported "
      "by the hddm c i/o interface.\n");
      fprintf(stderr,"You must use the c++ "
      "interface to read this file.\n");
      exit(9);
   }
   else if (size > 0)
   {
      off_t start = xdr_getpos64(xdrs);
      int m;
      unsigned int mult;
      xdr_u_int(xdrs,&mult);
      this1 = make_s_FtofTruthPoints(mult);
      this1->mult = mult;
      for (m = 0; m < mult; m++ )
      {
         xdr_float(xdrs,&this1->in[m].E);
         xdr_bool(xdrs,&this1->in[m].primary);
         xdr_int(xdrs,&this1->in[m].ptype);
         xdr_float(xdrs,&this1->in[m].px);
         xdr_float(xdrs,&this1->in[m].py);
         xdr_float(xdrs,&this1->in[m].pz);
         xdr_float(xdrs,&this1->in[m].t);
         xdr_int(xdrs,&this1->in[m].track);
         xdr_float(xdrs,&this1->in[m].x);
         xdr_float(xdrs,&this1->in[m].y);
         xdr_float(xdrs,&this1->in[m].z);
      }
      xdr_setpos64(xdrs,start+size);
   }
   return this1;
}

static s_ForwardEMcal_t* unpack_s_ForwardEMcal(XDR* xdrs, popNode* pop)
{
   s_ForwardEMcal_t* this1 = (s_ForwardEMcal_t*)HDDM_NULL;
   unsigned int size;
   if (! xdr_u_int(xdrs,&size))
   {
       return this1;
   }
   else if (size == 1)
   {
      fprintf(stderr,"hddm error - "
      "compressed data found in input stream.\n"
      "Compression/decompression is not supported "
      "by the hddm c i/o interface.\n");
      fprintf(stderr,"You must use the c++ "
      "interface to read this file.\n");
      exit(9);
   }
   else if (size > 0)
   {
      off_t start = xdr_getpos64(xdrs);
      this1 = make_s_ForwardEMcal();
      {
         int p;
         void* (*ptr) = (void**) &this1->fcalBlocks;
         for (p = 0; p < pop->popListLength; p++)
         {
            popNode* pnode = pop->popList[p];
            if (pnode)
            {
               int kid = pnode->inParent;
               ptr[kid] = pnode->unpacker(xdrs,pnode);
            }
            else
            {
               unsigned int skip;
               xdr_u_int(xdrs,&skip);
               xdr_setpos64(xdrs,xdr_getpos64(xdrs)+skip);
            }
         }
      }
      xdr_setpos64(xdrs,start+size);
   }
   return this1;
}

static s_FcalBlocks_t* unpack_s_FcalBlocks(XDR* xdrs, popNode* pop)
{
   s_FcalBlocks_t* this1 = (s_FcalBlocks_t*)HDDM_NULL;
   unsigned int size;
   if (! xdr_u_int(xdrs,&size))
   {
       return this1;
   }
   else if (size == 1)
   {
      fprintf(stderr,"hddm error - "
      "compressed data found in input stream.\n"
      "Compression/decompression is not supported "
      "by the hddm c i/o interface.\n");
      fprintf(stderr,"You must use the c++ "
      "interface to read this file.\n");
      exit(9);
   }
   else if (size > 0)
   {
      off_t start = xdr_getpos64(xdrs);
      int m;
      unsigned int mult;
      xdr_u_int(xdrs,&mult);
      this1 = make_s_FcalBlocks(mult);
      this1->mult = mult;
      for (m = 0; m < mult; m++ )
      {
         int p;
         void* (*ptr) = (void**) &this1->in[m].fcalHits;
         xdr_int(xdrs,&this1->in[m].column);
         xdr_int(xdrs,&this1->in[m].row);
         for (p = 0; p < pop->popListLength; p++)
         {
            popNode* pnode = pop->popList[p];
            if (pnode)
            {
               int kid = pnode->inParent;
               ptr[kid] = pnode->unpacker(xdrs,pnode);
            }
            else
            {
               unsigned int skip;
               xdr_u_int(xdrs,&skip);
               xdr_setpos64(xdrs,xdr_getpos64(xdrs)+skip);
            }
         }
      }
      xdr_setpos64(xdrs,start+size);
   }
   return this1;
}

static s_FcalHits_t* unpack_s_FcalHits(XDR* xdrs, popNode* pop)
{
   s_FcalHits_t* this1 = (s_FcalHits_t*)HDDM_NULL;
   unsigned int size;
   if (! xdr_u_int(xdrs,&size))
   {
       return this1;
   }
   else if (size == 1)
   {
      fprintf(stderr,"hddm error - "
      "compressed data found in input stream.\n"
      "Compression/decompression is not supported "
      "by the hddm c i/o interface.\n");
      fprintf(stderr,"You must use the c++ "
      "interface to read this file.\n");
      exit(9);
   }
   else if (size > 0)
   {
      off_t start = xdr_getpos64(xdrs);
      int m;
      unsigned int mult;
      xdr_u_int(xdrs,&mult);
      this1 = make_s_FcalHits(mult);
      this1->mult = mult;
      for (m = 0; m < mult; m++ )
      {
         xdr_float(xdrs,&this1->in[m].E);
         xdr_float(xdrs,&this1->in[m].t);
      }
      xdr_setpos64(xdrs,start+size);
   }
   return this1;
}

static s_FcalTruthHits_t* unpack_s_FcalTruthHits(XDR* xdrs, popNode* pop)
{
   s_FcalTruthHits_t* this1 = (s_FcalTruthHits_t*)HDDM_NULL;
   unsigned int size;
   if (! xdr_u_int(xdrs,&size))
   {
       return this1;
   }
   else if (size == 1)
   {
      fprintf(stderr,"hddm error - "
      "compressed data found in input stream.\n"
      "Compression/decompression is not supported "
      "by the hddm c i/o interface.\n");
      fprintf(stderr,"You must use the c++ "
      "interface to read this file.\n");
      exit(9);
   }
   else if (size > 0)
   {
      off_t start = xdr_getpos64(xdrs);
      int m;
      unsigned int mult;
      xdr_u_int(xdrs,&mult);
      this1 = make_s_FcalTruthHits(mult);
      this1->mult = mult;
      for (m = 0; m < mult; m++ )
      {
         xdr_float(xdrs,&this1->in[m].E);
         xdr_float(xdrs,&this1->in[m].t);
      }
      xdr_setpos64(xdrs,start+size);
   }
   return this1;
}

static s_FcalTruthShowers_t* unpack_s_FcalTruthShowers(XDR* xdrs, popNode* pop)
{
   s_FcalTruthShowers_t* this1 = (s_FcalTruthShowers_t*)HDDM_NULL;
   unsigned int size;
   if (! xdr_u_int(xdrs,&size))
   {
       return this1;
   }
   else if (size == 1)
   {
      fprintf(stderr,"hddm error - "
      "compressed data found in input stream.\n"
      "Compression/decompression is not supported "
      "by the hddm c i/o interface.\n");
      fprintf(stderr,"You must use the c++ "
      "interface to read this file.\n");
      exit(9);
   }
   else if (size > 0)
   {
      off_t start = xdr_getpos64(xdrs);
      int m;
      unsigned int mult;
      xdr_u_int(xdrs,&mult);
      this1 = make_s_FcalTruthShowers(mult);
      this1->mult = mult;
      for (m = 0; m < mult; m++ )
      {
         xdr_float(xdrs,&this1->in[m].E);
         xdr_bool(xdrs,&this1->in[m].primary);
         xdr_int(xdrs,&this1->in[m].ptype);
         xdr_float(xdrs,&this1->in[m].px);
         xdr_float(xdrs,&this1->in[m].py);
         xdr_float(xdrs,&this1->in[m].pz);
         xdr_float(xdrs,&this1->in[m].t);
         xdr_int(xdrs,&this1->in[m].track);
         xdr_float(xdrs,&this1->in[m].x);
         xdr_float(xdrs,&this1->in[m].y);
         xdr_float(xdrs,&this1->in[m].z);
      }
      xdr_setpos64(xdrs,start+size);
   }
   return this1;
}

static s_ComptonEMcal_t* unpack_s_ComptonEMcal(XDR* xdrs, popNode* pop)
{
   s_ComptonEMcal_t* this1 = (s_ComptonEMcal_t*)HDDM_NULL;
   unsigned int size;
   if (! xdr_u_int(xdrs,&size))
   {
       return this1;
   }
   else if (size == 1)
   {
      fprintf(stderr,"hddm error - "
      "compressed data found in input stream.\n"
      "Compression/decompression is not supported "
      "by the hddm c i/o interface.\n");
      fprintf(stderr,"You must use the c++ "
      "interface to read this file.\n");
      exit(9);
   }
   else if (size > 0)
   {
      off_t start = xdr_getpos64(xdrs);
      this1 = make_s_ComptonEMcal();
      {
         int p;
         void* (*ptr) = (void**) &this1->ccalBlocks;
         for (p = 0; p < pop->popListLength; p++)
         {
            popNode* pnode = pop->popList[p];
            if (pnode)
            {
               int kid = pnode->inParent;
               ptr[kid] = pnode->unpacker(xdrs,pnode);
            }
            else
            {
               unsigned int skip;
               xdr_u_int(xdrs,&skip);
               xdr_setpos64(xdrs,xdr_getpos64(xdrs)+skip);
            }
         }
      }
      xdr_setpos64(xdrs,start+size);
   }
   return this1;
}

static s_CcalBlocks_t* unpack_s_CcalBlocks(XDR* xdrs, popNode* pop)
{
   s_CcalBlocks_t* this1 = (s_CcalBlocks_t*)HDDM_NULL;
   unsigned int size;
   if (! xdr_u_int(xdrs,&size))
   {
       return this1;
   }
   else if (size == 1)
   {
      fprintf(stderr,"hddm error - "
      "compressed data found in input stream.\n"
      "Compression/decompression is not supported "
      "by the hddm c i/o interface.\n");
      fprintf(stderr,"You must use the c++ "
      "interface to read this file.\n");
      exit(9);
   }
   else if (size > 0)
   {
      off_t start = xdr_getpos64(xdrs);
      int m;
      unsigned int mult;
      xdr_u_int(xdrs,&mult);
      this1 = make_s_CcalBlocks(mult);
      this1->mult = mult;
      for (m = 0; m < mult; m++ )
      {
         int p;
         void* (*ptr) = (void**) &this1->in[m].ccalHits;
         xdr_int(xdrs,&this1->in[m].column);
         xdr_int(xdrs,&this1->in[m].row);
         for (p = 0; p < pop->popListLength; p++)
         {
            popNode* pnode = pop->popList[p];
            if (pnode)
            {
               int kid = pnode->inParent;
               ptr[kid] = pnode->unpacker(xdrs,pnode);
            }
            else
            {
               unsigned int skip;
               xdr_u_int(xdrs,&skip);
               xdr_setpos64(xdrs,xdr_getpos64(xdrs)+skip);
            }
         }
      }
      xdr_setpos64(xdrs,start+size);
   }
   return this1;
}

static s_CcalHits_t* unpack_s_CcalHits(XDR* xdrs, popNode* pop)
{
   s_CcalHits_t* this1 = (s_CcalHits_t*)HDDM_NULL;
   unsigned int size;
   if (! xdr_u_int(xdrs,&size))
   {
       return this1;
   }
   else if (size == 1)
   {
      fprintf(stderr,"hddm error - "
      "compressed data found in input stream.\n"
      "Compression/decompression is not supported "
      "by the hddm c i/o interface.\n");
      fprintf(stderr,"You must use the c++ "
      "interface to read this file.\n");
      exit(9);
   }
   else if (size > 0)
   {
      off_t start = xdr_getpos64(xdrs);
      int m;
      unsigned int mult;
      xdr_u_int(xdrs,&mult);
      this1 = make_s_CcalHits(mult);
      this1->mult = mult;
      for (m = 0; m < mult; m++ )
      {
         xdr_float(xdrs,&this1->in[m].E);
         xdr_float(xdrs,&this1->in[m].t);
      }
      xdr_setpos64(xdrs,start+size);
   }
   return this1;
}

static s_CcalTruthHits_t* unpack_s_CcalTruthHits(XDR* xdrs, popNode* pop)
{
   s_CcalTruthHits_t* this1 = (s_CcalTruthHits_t*)HDDM_NULL;
   unsigned int size;
   if (! xdr_u_int(xdrs,&size))
   {
       return this1;
   }
   else if (size == 1)
   {
      fprintf(stderr,"hddm error - "
      "compressed data found in input stream.\n"
      "Compression/decompression is not supported "
      "by the hddm c i/o interface.\n");
      fprintf(stderr,"You must use the c++ "
      "interface to read this file.\n");
      exit(9);
   }
   else if (size > 0)
   {
      off_t start = xdr_getpos64(xdrs);
      int m;
      unsigned int mult;
      xdr_u_int(xdrs,&mult);
      this1 = make_s_CcalTruthHits(mult);
      this1->mult = mult;
      for (m = 0; m < mult; m++ )
      {
         xdr_float(xdrs,&this1->in[m].E);
         xdr_float(xdrs,&this1->in[m].t);
      }
      xdr_setpos64(xdrs,start+size);
   }
   return this1;
}

static s_CcalTruthShowers_t* unpack_s_CcalTruthShowers(XDR* xdrs, popNode* pop)
{
   s_CcalTruthShowers_t* this1 = (s_CcalTruthShowers_t*)HDDM_NULL;
   unsigned int size;
   if (! xdr_u_int(xdrs,&size))
   {
       return this1;
   }
   else if (size == 1)
   {
      fprintf(stderr,"hddm error - "
      "compressed data found in input stream.\n"
      "Compression/decompression is not supported "
      "by the hddm c i/o interface.\n");
      fprintf(stderr,"You must use the c++ "
      "interface to read this file.\n");
      exit(9);
   }
   else if (size > 0)
   {
      off_t start = xdr_getpos64(xdrs);
      int m;
      unsigned int mult;
      xdr_u_int(xdrs,&mult);
      this1 = make_s_CcalTruthShowers(mult);
      this1->mult = mult;
      for (m = 0; m < mult; m++ )
      {
         xdr_float(xdrs,&this1->in[m].E);
         xdr_bool(xdrs,&this1->in[m].primary);
         xdr_int(xdrs,&this1->in[m].ptype);
         xdr_float(xdrs,&this1->in[m].px);
         xdr_float(xdrs,&this1->in[m].py);
         xdr_float(xdrs,&this1->in[m].pz);
         xdr_float(xdrs,&this1->in[m].t);
         xdr_int(xdrs,&this1->in[m].track);
         xdr_float(xdrs,&this1->in[m].x);
         xdr_float(xdrs,&this1->in[m].y);
         xdr_float(xdrs,&this1->in[m].z);
      }
      xdr_setpos64(xdrs,start+size);
   }
   return this1;
}

static s_UpstreamEMveto_t* unpack_s_UpstreamEMveto(XDR* xdrs, popNode* pop)
{
   s_UpstreamEMveto_t* this1 = (s_UpstreamEMveto_t*)HDDM_NULL;
   unsigned int size;
   if (! xdr_u_int(xdrs,&size))
   {
       return this1;
   }
   else if (size == 1)
   {
      fprintf(stderr,"hddm error - "
      "compressed data found in input stream.\n"
      "Compression/decompression is not supported "
      "by the hddm c i/o interface.\n");
      fprintf(stderr,"You must use the c++ "
      "interface to read this file.\n");
      exit(9);
   }
   else if (size > 0)
   {
      off_t start = xdr_getpos64(xdrs);
      this1 = make_s_UpstreamEMveto();
      {
         int p;
         void* (*ptr) = (void**) &this1->upvPaddles;
         for (p = 0; p < pop->popListLength; p++)
         {
            popNode* pnode = pop->popList[p];
            if (pnode)
            {
               int kid = pnode->inParent;
               ptr[kid] = pnode->unpacker(xdrs,pnode);
            }
            else
            {
               unsigned int skip;
               xdr_u_int(xdrs,&skip);
               xdr_setpos64(xdrs,xdr_getpos64(xdrs)+skip);
            }
         }
      }
      xdr_setpos64(xdrs,start+size);
   }
   return this1;
}

static s_UpvPaddles_t* unpack_s_UpvPaddles(XDR* xdrs, popNode* pop)
{
   s_UpvPaddles_t* this1 = (s_UpvPaddles_t*)HDDM_NULL;
   unsigned int size;
   if (! xdr_u_int(xdrs,&size))
   {
       return this1;
   }
   else if (size == 1)
   {
      fprintf(stderr,"hddm error - "
      "compressed data found in input stream.\n"
      "Compression/decompression is not supported "
      "by the hddm c i/o interface.\n");
      fprintf(stderr,"You must use the c++ "
      "interface to read this file.\n");
      exit(9);
   }
   else if (size > 0)
   {
      off_t start = xdr_getpos64(xdrs);
      int m;
      unsigned int mult;
      xdr_u_int(xdrs,&mult);
      this1 = make_s_UpvPaddles(mult);
      this1->mult = mult;
      for (m = 0; m < mult; m++ )
      {
         int p;
         void* (*ptr) = (void**) &this1->in[m].upvLeftHits;
         xdr_int(xdrs,&this1->in[m].layer);
         xdr_int(xdrs,&this1->in[m].row);
         for (p = 0; p < pop->popListLength; p++)
         {
            popNode* pnode = pop->popList[p];
            if (pnode)
            {
               int kid = pnode->inParent;
               ptr[kid] = pnode->unpacker(xdrs,pnode);
            }
            else
            {
               unsigned int skip;
               xdr_u_int(xdrs,&skip);
               xdr_setpos64(xdrs,xdr_getpos64(xdrs)+skip);
            }
         }
      }
      xdr_setpos64(xdrs,start+size);
   }
   return this1;
}

static s_UpvLeftHits_t* unpack_s_UpvLeftHits(XDR* xdrs, popNode* pop)
{
   s_UpvLeftHits_t* this1 = (s_UpvLeftHits_t*)HDDM_NULL;
   unsigned int size;
   if (! xdr_u_int(xdrs,&size))
   {
       return this1;
   }
   else if (size == 1)
   {
      fprintf(stderr,"hddm error - "
      "compressed data found in input stream.\n"
      "Compression/decompression is not supported "
      "by the hddm c i/o interface.\n");
      fprintf(stderr,"You must use the c++ "
      "interface to read this file.\n");
      exit(9);
   }
   else if (size > 0)
   {
      off_t start = xdr_getpos64(xdrs);
      int m;
      unsigned int mult;
      xdr_u_int(xdrs,&mult);
      this1 = make_s_UpvLeftHits(mult);
      this1->mult = mult;
      for (m = 0; m < mult; m++ )
      {
         xdr_float(xdrs,&this1->in[m].E);
         xdr_float(xdrs,&this1->in[m].t);
      }
      xdr_setpos64(xdrs,start+size);
   }
   return this1;
}

static s_UpvRightHits_t* unpack_s_UpvRightHits(XDR* xdrs, popNode* pop)
{
   s_UpvRightHits_t* this1 = (s_UpvRightHits_t*)HDDM_NULL;
   unsigned int size;
   if (! xdr_u_int(xdrs,&size))
   {
       return this1;
   }
   else if (size == 1)
   {
      fprintf(stderr,"hddm error - "
      "compressed data found in input stream.\n"
      "Compression/decompression is not supported "
      "by the hddm c i/o interface.\n");
      fprintf(stderr,"You must use the c++ "
      "interface to read this file.\n");
      exit(9);
   }
   else if (size > 0)
   {
      off_t start = xdr_getpos64(xdrs);
      int m;
      unsigned int mult;
      xdr_u_int(xdrs,&mult);
      this1 = make_s_UpvRightHits(mult);
      this1->mult = mult;
      for (m = 0; m < mult; m++ )
      {
         xdr_float(xdrs,&this1->in[m].E);
         xdr_float(xdrs,&this1->in[m].t);
      }
      xdr_setpos64(xdrs,start+size);
   }
   return this1;
}

static s_UpvTruthShowers_t* unpack_s_UpvTruthShowers(XDR* xdrs, popNode* pop)
{
   s_UpvTruthShowers_t* this1 = (s_UpvTruthShowers_t*)HDDM_NULL;
   unsigned int size;
   if (! xdr_u_int(xdrs,&size))
   {
       return this1;
   }
   else if (size == 1)
   {
      fprintf(stderr,"hddm error - "
      "compressed data found in input stream.\n"
      "Compression/decompression is not supported "
      "by the hddm c i/o interface.\n");
      fprintf(stderr,"You must use the c++ "
      "interface to read this file.\n");
      exit(9);
   }
   else if (size > 0)
   {
      off_t start = xdr_getpos64(xdrs);
      int m;
      unsigned int mult;
      xdr_u_int(xdrs,&mult);
      this1 = make_s_UpvTruthShowers(mult);
      this1->mult = mult;
      for (m = 0; m < mult; m++ )
      {
         xdr_float(xdrs,&this1->in[m].E);
         xdr_bool(xdrs,&this1->in[m].primary);
         xdr_int(xdrs,&this1->in[m].ptype);
         xdr_float(xdrs,&this1->in[m].px);
         xdr_float(xdrs,&this1->in[m].py);
         xdr_float(xdrs,&this1->in[m].pz);
         xdr_float(xdrs,&this1->in[m].t);
         xdr_int(xdrs,&this1->in[m].track);
         xdr_float(xdrs,&this1->in[m].x);
         xdr_float(xdrs,&this1->in[m].y);
         xdr_float(xdrs,&this1->in[m].z);
      }
      xdr_setpos64(xdrs,start+size);
   }
   return this1;
}

static s_Tagger_t* unpack_s_Tagger(XDR* xdrs, popNode* pop)
{
   s_Tagger_t* this1 = (s_Tagger_t*)HDDM_NULL;
   unsigned int size;
   if (! xdr_u_int(xdrs,&size))
   {
       return this1;
   }
   else if (size == 1)
   {
      fprintf(stderr,"hddm error - "
      "compressed data found in input stream.\n"
      "Compression/decompression is not supported "
      "by the hddm c i/o interface.\n");
      fprintf(stderr,"You must use the c++ "
      "interface to read this file.\n");
      exit(9);
   }
   else if (size > 0)
   {
      off_t start = xdr_getpos64(xdrs);
      this1 = make_s_Tagger();
      {
         int p;
         void* (*ptr) = (void**) &this1->microChannels;
         for (p = 0; p < pop->popListLength; p++)
         {
            popNode* pnode = pop->popList[p];
            if (pnode)
            {
               int kid = pnode->inParent;
               ptr[kid] = pnode->unpacker(xdrs,pnode);
            }
            else
            {
               unsigned int skip;
               xdr_u_int(xdrs,&skip);
               xdr_setpos64(xdrs,xdr_getpos64(xdrs)+skip);
            }
         }
      }
      xdr_setpos64(xdrs,start+size);
   }
   return this1;
}

static s_MicroChannels_t* unpack_s_MicroChannels(XDR* xdrs, popNode* pop)
{
   s_MicroChannels_t* this1 = (s_MicroChannels_t*)HDDM_NULL;
   unsigned int size;
   if (! xdr_u_int(xdrs,&size))
   {
       return this1;
   }
   else if (size == 1)
   {
      fprintf(stderr,"hddm error - "
      "compressed data found in input stream.\n"
      "Compression/decompression is not supported "
      "by the hddm c i/o interface.\n");
      fprintf(stderr,"You must use the c++ "
      "interface to read this file.\n");
      exit(9);
   }
   else if (size > 0)
   {
      off_t start = xdr_getpos64(xdrs);
      int m;
      unsigned int mult;
      xdr_u_int(xdrs,&mult);
      this1 = make_s_MicroChannels(mult);
      this1->mult = mult;
      for (m = 0; m < mult; m++ )
      {
         int p;
         void* (*ptr) = (void**) &this1->in[m].taggerHits;
         xdr_float(xdrs,&this1->in[m].E);
         xdr_int(xdrs,&this1->in[m].column);
         xdr_int(xdrs,&this1->in[m].row);
         for (p = 0; p < pop->popListLength; p++)
         {
            popNode* pnode = pop->popList[p];
            if (pnode)
            {
               int kid = pnode->inParent;
               ptr[kid] = pnode->unpacker(xdrs,pnode);
            }
            else
            {
               unsigned int skip;
               xdr_u_int(xdrs,&skip);
               xdr_setpos64(xdrs,xdr_getpos64(xdrs)+skip);
            }
         }
      }
      xdr_setpos64(xdrs,start+size);
   }
   return this1;
}

static s_TaggerHits_t* unpack_s_TaggerHits(XDR* xdrs, popNode* pop)
{
   s_TaggerHits_t* this1 = (s_TaggerHits_t*)HDDM_NULL;
   unsigned int size;
   if (! xdr_u_int(xdrs,&size))
   {
       return this1;
   }
   else if (size == 1)
   {
      fprintf(stderr,"hddm error - "
      "compressed data found in input stream.\n"
      "Compression/decompression is not supported "
      "by the hddm c i/o interface.\n");
      fprintf(stderr,"You must use the c++ "
      "interface to read this file.\n");
      exit(9);
   }
   else if (size > 0)
   {
      off_t start = xdr_getpos64(xdrs);
      int m;
      unsigned int mult;
      xdr_u_int(xdrs,&mult);
      this1 = make_s_TaggerHits(mult);
      this1->mult = mult;
      for (m = 0; m < mult; m++ )
      {
         xdr_float(xdrs,&this1->in[m].t);
      }
      xdr_setpos64(xdrs,start+size);
   }
   return this1;
}

static s_McTrajectory_t* unpack_s_McTrajectory(XDR* xdrs, popNode* pop)
{
   s_McTrajectory_t* this1 = (s_McTrajectory_t*)HDDM_NULL;
   unsigned int size;
   if (! xdr_u_int(xdrs,&size))
   {
       return this1;
   }
   else if (size == 1)
   {
      fprintf(stderr,"hddm error - "
      "compressed data found in input stream.\n"
      "Compression/decompression is not supported "
      "by the hddm c i/o interface.\n");
      fprintf(stderr,"You must use the c++ "
      "interface to read this file.\n");
      exit(9);
   }
   else if (size > 0)
   {
      off_t start = xdr_getpos64(xdrs);
      this1 = make_s_McTrajectory();
      {
         int p;
         void* (*ptr) = (void**) &this1->mcTrajectoryPoints;
         for (p = 0; p < pop->popListLength; p++)
         {
            popNode* pnode = pop->popList[p];
            if (pnode)
            {
               int kid = pnode->inParent;
               ptr[kid] = pnode->unpacker(xdrs,pnode);
            }
            else
            {
               unsigned int skip;
               xdr_u_int(xdrs,&skip);
               xdr_setpos64(xdrs,xdr_getpos64(xdrs)+skip);
            }
         }
      }
      xdr_setpos64(xdrs,start+size);
   }
   return this1;
}

static s_McTrajectoryPoints_t* unpack_s_McTrajectoryPoints(XDR* xdrs, popNode* pop)
{
   s_McTrajectoryPoints_t* this1 = (s_McTrajectoryPoints_t*)HDDM_NULL;
   unsigned int size;
   if (! xdr_u_int(xdrs,&size))
   {
       return this1;
   }
   else if (size == 1)
   {
      fprintf(stderr,"hddm error - "
      "compressed data found in input stream.\n"
      "Compression/decompression is not supported "
      "by the hddm c i/o interface.\n");
      fprintf(stderr,"You must use the c++ "
      "interface to read this file.\n");
      exit(9);
   }
   else if (size > 0)
   {
      off_t start = xdr_getpos64(xdrs);
      int m;
      unsigned int mult;
      xdr_u_int(xdrs,&mult);
      this1 = make_s_McTrajectoryPoints(mult);
      this1->mult = mult;
      for (m = 0; m < mult; m++ )
      {
         xdr_float(xdrs,&this1->in[m].E);
         xdr_float(xdrs,&this1->in[m].dE);
         xdr_int(xdrs,&this1->in[m].mech);
         xdr_int(xdrs,&this1->in[m].part);
         xdr_int(xdrs,&this1->in[m].primary_track);
         xdr_float(xdrs,&this1->in[m].px);
         xdr_float(xdrs,&this1->in[m].py);
         xdr_float(xdrs,&this1->in[m].pz);
         xdr_float(xdrs,&this1->in[m].radlen);
         xdr_float(xdrs,&this1->in[m].step);
         xdr_float(xdrs,&this1->in[m].t);
         xdr_int(xdrs,&this1->in[m].track);
         xdr_float(xdrs,&this1->in[m].x);
         xdr_float(xdrs,&this1->in[m].y);
         xdr_float(xdrs,&this1->in[m].z);
      }
      xdr_setpos64(xdrs,start+size);
   }
   return this1;
}

static s_ReconView_t* unpack_s_ReconView(XDR* xdrs, popNode* pop)
{
   s_ReconView_t* this1 = (s_ReconView_t*)HDDM_NULL;
   unsigned int size;
   if (! xdr_u_int(xdrs,&size))
   {
       return this1;
   }
   else if (size == 1)
   {
      fprintf(stderr,"hddm error - "
      "compressed data found in input stream.\n"
      "Compression/decompression is not supported "
      "by the hddm c i/o interface.\n");
      fprintf(stderr,"You must use the c++ "
      "interface to read this file.\n");
      exit(9);
   }
   else if (size > 0)
   {
      off_t start = xdr_getpos64(xdrs);
      this1 = make_s_ReconView();
      {
         int p;
         void* (*ptr) = (void**) &this1->tracktimebaseds;
         for (p = 0; p < pop->popListLength; p++)
         {
            popNode* pnode = pop->popList[p];
            if (pnode)
            {
               int kid = pnode->inParent;
               ptr[kid] = pnode->unpacker(xdrs,pnode);
            }
            else
            {
               unsigned int skip;
               xdr_u_int(xdrs,&skip);
               xdr_setpos64(xdrs,xdr_getpos64(xdrs)+skip);
            }
         }
      }
      xdr_setpos64(xdrs,start+size);
   }
   return this1;
}

static s_Tracktimebaseds_t* unpack_s_Tracktimebaseds(XDR* xdrs, popNode* pop)
{
   s_Tracktimebaseds_t* this1 = (s_Tracktimebaseds_t*)HDDM_NULL;
   unsigned int size;
   if (! xdr_u_int(xdrs,&size))
   {
       return this1;
   }
   else if (size == 1)
   {
      fprintf(stderr,"hddm error - "
      "compressed data found in input stream.\n"
      "Compression/decompression is not supported "
      "by the hddm c i/o interface.\n");
      fprintf(stderr,"You must use the c++ "
      "interface to read this file.\n");
      exit(9);
   }
   else if (size > 0)
   {
      off_t start = xdr_getpos64(xdrs);
      int m;
      unsigned int mult;
      xdr_u_int(xdrs,&mult);
      this1 = make_s_Tracktimebaseds(mult);
      this1->mult = mult;
      for (m = 0; m < mult; m++ )
      {
         int p;
         void* (*ptr) = (void**) &this1->in[m].momentum;
         xdr_float(xdrs,&this1->in[m].FOM);
         xdr_int(xdrs,&this1->in[m].Ndof);
         xdr_int(xdrs,&this1->in[m].candidateid);
         xdr_float(xdrs,&this1->in[m].chisq);
         xdr_int(xdrs,&this1->in[m].id);
         xdr_int(xdrs,&this1->in[m].trackid);
         for (p = 0; p < pop->popListLength; p++)
         {
            popNode* pnode = pop->popList[p];
            if (pnode)
            {
               int kid = pnode->inParent;
               ptr[kid] = pnode->unpacker(xdrs,pnode);
            }
            else
            {
               unsigned int skip;
               xdr_u_int(xdrs,&skip);
               xdr_setpos64(xdrs,xdr_getpos64(xdrs)+skip);
            }
         }
      }
      xdr_setpos64(xdrs,start+size);
   }
   return this1;
}

static s_ErrorMatrix_t* unpack_s_ErrorMatrix(XDR* xdrs, popNode* pop)
{
   s_ErrorMatrix_t* this1 = (s_ErrorMatrix_t*)HDDM_NULL;
   unsigned int size;
   if (! xdr_u_int(xdrs,&size))
   {
       return this1;
   }
   else if (size == 1)
   {
      fprintf(stderr,"hddm error - "
      "compressed data found in input stream.\n"
      "Compression/decompression is not supported "
      "by the hddm c i/o interface.\n");
      fprintf(stderr,"You must use the c++ "
      "interface to read this file.\n");
      exit(9);
   }
   else if (size > 0)
   {
      off_t start = xdr_getpos64(xdrs);
      this1 = make_s_ErrorMatrix();
      {
         xdr_int(xdrs,&this1->Ncols);
         xdr_int(xdrs,&this1->Nrows);
         this1->type = 0;
         xdr_string(xdrs, &this1->type, 1000000);
         this1->vals = 0;
         xdr_string(xdrs, &this1->vals, 1000000);
      }
      xdr_setpos64(xdrs,start+size);
   }
   return this1;
}

static s_TrackingErrorMatrix_t* unpack_s_TrackingErrorMatrix(XDR* xdrs, popNode* pop)
{
   s_TrackingErrorMatrix_t* this1 = (s_TrackingErrorMatrix_t*)HDDM_NULL;
   unsigned int size;
   if (! xdr_u_int(xdrs,&size))
   {
       return this1;
   }
   else if (size == 1)
   {
      fprintf(stderr,"hddm error - "
      "compressed data found in input stream.\n"
      "Compression/decompression is not supported "
      "by the hddm c i/o interface.\n");
      fprintf(stderr,"You must use the c++ "
      "interface to read this file.\n");
      exit(9);
   }
   else if (size > 0)
   {
      off_t start = xdr_getpos64(xdrs);
      this1 = make_s_TrackingErrorMatrix();
      {
         xdr_int(xdrs,&this1->Ncols);
         xdr_int(xdrs,&this1->Nrows);
         this1->type = 0;
         xdr_string(xdrs, &this1->type, 1000000);
         this1->vals = 0;
         xdr_string(xdrs, &this1->vals, 1000000);
      }
      xdr_setpos64(xdrs,start+size);
   }
   return this1;
}

s_HDDM_t* read_s_HDDM(s_iostream_t* fp)
{
   s_HDDM_t* nextEvent = unpack_s_HDDM(fp->xdrs,fp->popTop);
   return (nextEvent == HDDM_NULL)? 0 : nextEvent;
}

int skip_s_HDDM(s_iostream_t* fp, int nskip)
{
   int skipped;
   for (skipped=0; skipped < nskip; ++skipped)
   {
      unsigned int size;
      if (! xdr_u_int(fp->xdrs,&size))
      {
         return skipped;
      }
      else if (size == 1)
      {
         fprintf(stderr,"hddm error - "
         "compressed data found in input stream.\n"
         "Compression/decompression is not supported "
         "by the hddm c i/o interface.\n");
         fprintf(stderr,"You must use the c++ "
         "interface to read this file.\n");
         exit(9);
      }
      else if (size > 0)
      {
         off_t start = xdr_getpos64(fp->xdrs);
         if (xdr_setpos64(fp->xdrs,start+size) != 0) {
            fp->lerrno = errno;
            return skipped;
         }
      }
   }
   return skipped;
}

static int pack_s_HDDM(XDR* xdrs, s_HDDM_t* this1);
static int pack_s_PhysicsEvents(XDR* xdrs, s_PhysicsEvents_t* this1);
static int pack_s_Reactions(XDR* xdrs, s_Reactions_t* this1);
static int pack_s_Beam(XDR* xdrs, s_Beam_t* this1);
static int pack_s_Momentum(XDR* xdrs, s_Momentum_t* this1);
static int pack_s_Properties(XDR* xdrs, s_Properties_t* this1);
static int pack_s_Target(XDR* xdrs, s_Target_t* this1);
static int pack_s_Vertices(XDR* xdrs, s_Vertices_t* this1);
static int pack_s_Products(XDR* xdrs, s_Products_t* this1);
static int pack_s_Origin(XDR* xdrs, s_Origin_t* this1);
static int pack_s_Random(XDR* xdrs, s_Random_t* this1);
static int pack_s_HitView(XDR* xdrs, s_HitView_t* this1);
static int pack_s_CentralDC(XDR* xdrs, s_CentralDC_t* this1);
static int pack_s_CdcStraws(XDR* xdrs, s_CdcStraws_t* this1);
static int pack_s_CdcStrawHits(XDR* xdrs, s_CdcStrawHits_t* this1);
static int pack_s_CdcStrawTruthHits(XDR* xdrs, s_CdcStrawTruthHits_t* this1);
static int pack_s_CdcTruthPoints(XDR* xdrs, s_CdcTruthPoints_t* this1);
static int pack_s_ForwardDC(XDR* xdrs, s_ForwardDC_t* this1);
static int pack_s_FdcChambers(XDR* xdrs, s_FdcChambers_t* this1);
static int pack_s_FdcAnodeWires(XDR* xdrs, s_FdcAnodeWires_t* this1);
static int pack_s_FdcAnodeHits(XDR* xdrs, s_FdcAnodeHits_t* this1);
static int pack_s_FdcAnodeTruthHits(XDR* xdrs, s_FdcAnodeTruthHits_t* this1);
static int pack_s_FdcCathodeStrips(XDR* xdrs, s_FdcCathodeStrips_t* this1);
static int pack_s_FdcCathodeHits(XDR* xdrs, s_FdcCathodeHits_t* this1);
static int pack_s_FdcCathodeTruthHits(XDR* xdrs, s_FdcCathodeTruthHits_t* this1);
static int pack_s_FdcTruthPoints(XDR* xdrs, s_FdcTruthPoints_t* this1);
static int pack_s_StartCntr(XDR* xdrs, s_StartCntr_t* this1);
static int pack_s_StcPaddles(XDR* xdrs, s_StcPaddles_t* this1);
static int pack_s_StcHits(XDR* xdrs, s_StcHits_t* this1);
static int pack_s_StcTruthHits(XDR* xdrs, s_StcTruthHits_t* this1);
static int pack_s_StcTruthPoints(XDR* xdrs, s_StcTruthPoints_t* this1);
static int pack_s_BarrelEMcal(XDR* xdrs, s_BarrelEMcal_t* this1);
static int pack_s_BcalCells(XDR* xdrs, s_BcalCells_t* this1);
static int pack_s_BcalSiPMUpHits(XDR* xdrs, s_BcalSiPMUpHits_t* this1);
static int pack_s_BcalSiPMDownHits(XDR* xdrs, s_BcalSiPMDownHits_t* this1);
static int pack_s_BcalHits(XDR* xdrs, s_BcalHits_t* this1);
static int pack_s_BcalIncidentParticles(XDR* xdrs, s_BcalIncidentParticles_t* this1);
static int pack_s_BcalSiPMSpectrums(XDR* xdrs, s_BcalSiPMSpectrums_t* this1);
static int pack_s_BcalfADCCells(XDR* xdrs, s_BcalfADCCells_t* this1);
static int pack_s_BcalfADCUpHits(XDR* xdrs, s_BcalfADCUpHits_t* this1);
static int pack_s_BcalfADCDownHits(XDR* xdrs, s_BcalfADCDownHits_t* this1);
static int pack_s_BcalTDCHits(XDR* xdrs, s_BcalTDCHits_t* this1);
static int pack_s_BcalTruthShowers(XDR* xdrs, s_BcalTruthShowers_t* this1);
static int pack_s_GapEMcal(XDR* xdrs, s_GapEMcal_t* this1);
static int pack_s_GcalCells(XDR* xdrs, s_GcalCells_t* this1);
static int pack_s_GcalHits(XDR* xdrs, s_GcalHits_t* this1);
static int pack_s_GcalTruthShowers(XDR* xdrs, s_GcalTruthShowers_t* this1);
static int pack_s_Cerenkov(XDR* xdrs, s_Cerenkov_t* this1);
static int pack_s_CereSections(XDR* xdrs, s_CereSections_t* this1);
static int pack_s_CereHits(XDR* xdrs, s_CereHits_t* this1);
static int pack_s_CereRichHits(XDR* xdrs, s_CereRichHits_t* this1);
static int pack_s_CereTruthPoints(XDR* xdrs, s_CereTruthPoints_t* this1);
static int pack_s_ForwardTOF(XDR* xdrs, s_ForwardTOF_t* this1);
static int pack_s_FtofCounters(XDR* xdrs, s_FtofCounters_t* this1);
static int pack_s_FtofNorthTruthHits(XDR* xdrs, s_FtofNorthTruthHits_t* this1);
static int pack_s_FtofMCHits(XDR* xdrs, s_FtofMCHits_t* this1);
static int pack_s_FtofSouthTruthHits(XDR* xdrs, s_FtofSouthTruthHits_t* this1);
static int pack_s_FtofNorthHits(XDR* xdrs, s_FtofNorthHits_t* this1);
static int pack_s_FtofSouthHits(XDR* xdrs, s_FtofSouthHits_t* this1);
static int pack_s_FtofTruthPoints(XDR* xdrs, s_FtofTruthPoints_t* this1);
static int pack_s_ForwardEMcal(XDR* xdrs, s_ForwardEMcal_t* this1);
static int pack_s_FcalBlocks(XDR* xdrs, s_FcalBlocks_t* this1);
static int pack_s_FcalHits(XDR* xdrs, s_FcalHits_t* this1);
static int pack_s_FcalTruthHits(XDR* xdrs, s_FcalTruthHits_t* this1);
static int pack_s_FcalTruthShowers(XDR* xdrs, s_FcalTruthShowers_t* this1);
static int pack_s_ComptonEMcal(XDR* xdrs, s_ComptonEMcal_t* this1);
static int pack_s_CcalBlocks(XDR* xdrs, s_CcalBlocks_t* this1);
static int pack_s_CcalHits(XDR* xdrs, s_CcalHits_t* this1);
static int pack_s_CcalTruthHits(XDR* xdrs, s_CcalTruthHits_t* this1);
static int pack_s_CcalTruthShowers(XDR* xdrs, s_CcalTruthShowers_t* this1);
static int pack_s_UpstreamEMveto(XDR* xdrs, s_UpstreamEMveto_t* this1);
static int pack_s_UpvPaddles(XDR* xdrs, s_UpvPaddles_t* this1);
static int pack_s_UpvLeftHits(XDR* xdrs, s_UpvLeftHits_t* this1);
static int pack_s_UpvRightHits(XDR* xdrs, s_UpvRightHits_t* this1);
static int pack_s_UpvTruthShowers(XDR* xdrs, s_UpvTruthShowers_t* this1);
static int pack_s_Tagger(XDR* xdrs, s_Tagger_t* this1);
static int pack_s_MicroChannels(XDR* xdrs, s_MicroChannels_t* this1);
static int pack_s_TaggerHits(XDR* xdrs, s_TaggerHits_t* this1);
static int pack_s_McTrajectory(XDR* xdrs, s_McTrajectory_t* this1);
static int pack_s_McTrajectoryPoints(XDR* xdrs, s_McTrajectoryPoints_t* this1);
static int pack_s_ReconView(XDR* xdrs, s_ReconView_t* this1);
static int pack_s_Tracktimebaseds(XDR* xdrs, s_Tracktimebaseds_t* this1);
static int pack_s_ErrorMatrix(XDR* xdrs, s_ErrorMatrix_t* this1);
static int pack_s_TrackingErrorMatrix(XDR* xdrs, s_TrackingErrorMatrix_t* this1);

static int pack_s_HDDM(XDR* xdrs, s_HDDM_t* this1)
{
   int m=0;
   unsigned int size=0;
   off_t base,start,end;
   base = xdr_getpos64(xdrs);
   xdr_u_int(xdrs,&size);
   start = xdr_getpos64(xdrs);

   {
      if (this1->physicsEvents != (s_PhysicsEvents_t*)&hddm_s_nullTarget)
      {
         if (pack_s_PhysicsEvents(xdrs,this1->physicsEvents) < 0) {
            return -1;
         }
      }
      else
      {
         int zero=0;
         xdr_int(xdrs,&zero);
      }
   }
   FREE(this1);
   end = xdr_getpos64(xdrs);
   xdr_setpos64(xdrs,base);
   size = end-start;
   xdr_u_int(xdrs,&size);
   xdr_setpos64(xdrs,end);
   return size;
}

static int pack_s_PhysicsEvents(XDR* xdrs, s_PhysicsEvents_t* this1)
{
   int m=0;
   unsigned int size=0;
   off_t base,start,end;
   base = xdr_getpos64(xdrs);
   xdr_u_int(xdrs,&size);
   start = xdr_getpos64(xdrs);

   xdr_u_int(xdrs,&this1->mult);
   for (m = 0; m < this1->mult; m++)
   {
      xdr_int(xdrs,&this1->in[m].eventNo);
      xdr_int(xdrs,&this1->in[m].runNo);
      if (this1->in[m].reactions != (s_Reactions_t*)&hddm_s_nullTarget)
      {
         if (pack_s_Reactions(xdrs,this1->in[m].reactions) < 0) {
            return -1;
         }
      }
      else
      {
         int zero=0;
         xdr_int(xdrs,&zero);
      }
      if (this1->in[m].hitView != (s_HitView_t*)&hddm_s_nullTarget)
      {
         if (pack_s_HitView(xdrs,this1->in[m].hitView) < 0) {
            return -1;
         }
      }
      else
      {
         int zero=0;
         xdr_int(xdrs,&zero);
      }
      if (this1->in[m].reconView != (s_ReconView_t*)&hddm_s_nullTarget)
      {
         if (pack_s_ReconView(xdrs,this1->in[m].reconView) < 0) {
            return -1;
         }
      }
      else
      {
         int zero=0;
         xdr_int(xdrs,&zero);
      }
   }
   FREE(this1);
   end = xdr_getpos64(xdrs);
   xdr_setpos64(xdrs,base);
   size = end-start;
   xdr_u_int(xdrs,&size);
   xdr_setpos64(xdrs,end);
   return size;
}

static int pack_s_Reactions(XDR* xdrs, s_Reactions_t* this1)
{
   int m=0;
   unsigned int size=0;
   off_t base,start,end;
   base = xdr_getpos64(xdrs);
   xdr_u_int(xdrs,&size);
   start = xdr_getpos64(xdrs);

   xdr_u_int(xdrs,&this1->mult);
   for (m = 0; m < this1->mult; m++)
   {
      xdr_int(xdrs,&this1->in[m].type);
      xdr_float(xdrs,&this1->in[m].weight);
      if (this1->in[m].beam != (s_Beam_t*)&hddm_s_nullTarget)
      {
         if (pack_s_Beam(xdrs,this1->in[m].beam) < 0) {
            return -1;
         }
      }
      else
      {
         int zero=0;
         xdr_int(xdrs,&zero);
      }
      if (this1->in[m].target != (s_Target_t*)&hddm_s_nullTarget)
      {
         if (pack_s_Target(xdrs,this1->in[m].target) < 0) {
            return -1;
         }
      }
      else
      {
         int zero=0;
         xdr_int(xdrs,&zero);
      }
      if (this1->in[m].vertices != (s_Vertices_t*)&hddm_s_nullTarget)
      {
         if (pack_s_Vertices(xdrs,this1->in[m].vertices) < 0) {
            return -1;
         }
      }
      else
      {
         int zero=0;
         xdr_int(xdrs,&zero);
      }
      if (this1->in[m].random != (s_Random_t*)&hddm_s_nullTarget)
      {
         if (pack_s_Random(xdrs,this1->in[m].random) < 0) {
            return -1;
         }
      }
      else
      {
         int zero=0;
         xdr_int(xdrs,&zero);
      }
   }
   FREE(this1);
   end = xdr_getpos64(xdrs);
   xdr_setpos64(xdrs,base);
   size = end-start;
   xdr_u_int(xdrs,&size);
   xdr_setpos64(xdrs,end);
   return size;
}

static int pack_s_Beam(XDR* xdrs, s_Beam_t* this1)
{
   int m=0;
   unsigned int size=0;
   off_t base,start,end;
   base = xdr_getpos64(xdrs);
   xdr_u_int(xdrs,&size);
   start = xdr_getpos64(xdrs);

   {
      xdr_int(xdrs,(int*)&this1->type);
      if (this1->momentum != (s_Momentum_t*)&hddm_s_nullTarget)
      {
         if (pack_s_Momentum(xdrs,this1->momentum) < 0) {
            return -1;
         }
      }
      else
      {
         int zero=0;
         xdr_int(xdrs,&zero);
      }
      if (this1->properties != (s_Properties_t*)&hddm_s_nullTarget)
      {
         if (pack_s_Properties(xdrs,this1->properties) < 0) {
            return -1;
         }
      }
      else
      {
         int zero=0;
         xdr_int(xdrs,&zero);
      }
   }
   FREE(this1);
   end = xdr_getpos64(xdrs);
   xdr_setpos64(xdrs,base);
   size = end-start;
   xdr_u_int(xdrs,&size);
   xdr_setpos64(xdrs,end);
   return size;
}

static int pack_s_Momentum(XDR* xdrs, s_Momentum_t* this1)
{
   int m=0;
   unsigned int size=0;
   off_t base,start,end;
   base = xdr_getpos64(xdrs);
   xdr_u_int(xdrs,&size);
   start = xdr_getpos64(xdrs);

   {
      xdr_float(xdrs,&this1->E);
      xdr_float(xdrs,&this1->px);
      xdr_float(xdrs,&this1->py);
      xdr_float(xdrs,&this1->pz);
   }
   FREE(this1);
   end = xdr_getpos64(xdrs);
   xdr_setpos64(xdrs,base);
   size = end-start;
   xdr_u_int(xdrs,&size);
   xdr_setpos64(xdrs,end);
   return size;
}

static int pack_s_Properties(XDR* xdrs, s_Properties_t* this1)
{
   int m=0;
   unsigned int size=0;
   off_t base,start,end;
   base = xdr_getpos64(xdrs);
   xdr_u_int(xdrs,&size);
   start = xdr_getpos64(xdrs);

   {
      xdr_int(xdrs,&this1->charge);
      xdr_float(xdrs,&this1->mass);
   }
   FREE(this1);
   end = xdr_getpos64(xdrs);
   xdr_setpos64(xdrs,base);
   size = end-start;
   xdr_u_int(xdrs,&size);
   xdr_setpos64(xdrs,end);
   return size;
}

static int pack_s_Target(XDR* xdrs, s_Target_t* this1)
{
   int m=0;
   unsigned int size=0;
   off_t base,start,end;
   base = xdr_getpos64(xdrs);
   xdr_u_int(xdrs,&size);
   start = xdr_getpos64(xdrs);

   {
      xdr_int(xdrs,(int*)&this1->type);
      if (this1->momentum != (s_Momentum_t*)&hddm_s_nullTarget)
      {
         if (pack_s_Momentum(xdrs,this1->momentum) < 0) {
            return -1;
         }
      }
      else
      {
         int zero=0;
         xdr_int(xdrs,&zero);
      }
      if (this1->properties != (s_Properties_t*)&hddm_s_nullTarget)
      {
         if (pack_s_Properties(xdrs,this1->properties) < 0) {
            return -1;
         }
      }
      else
      {
         int zero=0;
         xdr_int(xdrs,&zero);
      }
   }
   FREE(this1);
   end = xdr_getpos64(xdrs);
   xdr_setpos64(xdrs,base);
   size = end-start;
   xdr_u_int(xdrs,&size);
   xdr_setpos64(xdrs,end);
   return size;
}

static int pack_s_Vertices(XDR* xdrs, s_Vertices_t* this1)
{
   int m=0;
   unsigned int size=0;
   off_t base,start,end;
   base = xdr_getpos64(xdrs);
   xdr_u_int(xdrs,&size);
   start = xdr_getpos64(xdrs);

   xdr_u_int(xdrs,&this1->mult);
   for (m = 0; m < this1->mult; m++)
   {
      if (this1->in[m].products != (s_Products_t*)&hddm_s_nullTarget)
      {
         if (pack_s_Products(xdrs,this1->in[m].products) < 0) {
            return -1;
         }
      }
      else
      {
         int zero=0;
         xdr_int(xdrs,&zero);
      }
      if (this1->in[m].origin != (s_Origin_t*)&hddm_s_nullTarget)
      {
         if (pack_s_Origin(xdrs,this1->in[m].origin) < 0) {
            return -1;
         }
      }
      else
      {
         int zero=0;
         xdr_int(xdrs,&zero);
      }
   }
   FREE(this1);
   end = xdr_getpos64(xdrs);
   xdr_setpos64(xdrs,base);
   size = end-start;
   xdr_u_int(xdrs,&size);
   xdr_setpos64(xdrs,end);
   return size;
}

static int pack_s_Products(XDR* xdrs, s_Products_t* this1)
{
   int m=0;
   unsigned int size=0;
   off_t base,start,end;
   base = xdr_getpos64(xdrs);
   xdr_u_int(xdrs,&size);
   start = xdr_getpos64(xdrs);

   xdr_u_int(xdrs,&this1->mult);
   for (m = 0; m < this1->mult; m++)
   {
      xdr_int(xdrs,&this1->in[m].decayVertex);
      xdr_int(xdrs,&this1->in[m].id);
      xdr_int(xdrs,&this1->in[m].mech);
      xdr_int(xdrs,&this1->in[m].parentid);
      xdr_int(xdrs,&this1->in[m].pdgtype);
      xdr_int(xdrs,(int*)&this1->in[m].type);
      if (this1->in[m].momentum != (s_Momentum_t*)&hddm_s_nullTarget)
      {
         if (pack_s_Momentum(xdrs,this1->in[m].momentum) < 0) {
            return -1;
         }
      }
      else
      {
         int zero=0;
         xdr_int(xdrs,&zero);
      }
      if (this1->in[m].properties != (s_Properties_t*)&hddm_s_nullTarget)
      {
         if (pack_s_Properties(xdrs,this1->in[m].properties) < 0) {
            return -1;
         }
      }
      else
      {
         int zero=0;
         xdr_int(xdrs,&zero);
      }
   }
   FREE(this1);
   end = xdr_getpos64(xdrs);
   xdr_setpos64(xdrs,base);
   size = end-start;
   xdr_u_int(xdrs,&size);
   xdr_setpos64(xdrs,end);
   return size;
}

static int pack_s_Origin(XDR* xdrs, s_Origin_t* this1)
{
   int m=0;
   unsigned int size=0;
   off_t base,start,end;
   base = xdr_getpos64(xdrs);
   xdr_u_int(xdrs,&size);
   start = xdr_getpos64(xdrs);

   {
      xdr_float(xdrs,&this1->t);
      xdr_float(xdrs,&this1->vx);
      xdr_float(xdrs,&this1->vy);
      xdr_float(xdrs,&this1->vz);
   }
   FREE(this1);
   end = xdr_getpos64(xdrs);
   xdr_setpos64(xdrs,base);
   size = end-start;
   xdr_u_int(xdrs,&size);
   xdr_setpos64(xdrs,end);
   return size;
}

static int pack_s_Random(XDR* xdrs, s_Random_t* this1)
{
   int m=0;
   unsigned int size=0;
   off_t base,start,end;
   base = xdr_getpos64(xdrs);
   xdr_u_int(xdrs,&size);
   start = xdr_getpos64(xdrs);

   {
      xdr_int(xdrs,&this1->seed1);
      xdr_int(xdrs,&this1->seed2);
      xdr_int(xdrs,&this1->seed_mcsmear1);
      xdr_int(xdrs,&this1->seed_mcsmear2);
      xdr_int(xdrs,&this1->seed_mcsmear3);
   }
   FREE(this1);
   end = xdr_getpos64(xdrs);
   xdr_setpos64(xdrs,base);
   size = end-start;
   xdr_u_int(xdrs,&size);
   xdr_setpos64(xdrs,end);
   return size;
}

static int pack_s_HitView(XDR* xdrs, s_HitView_t* this1)
{
   int m=0;
   unsigned int size=0;
   off_t base,start,end;
   base = xdr_getpos64(xdrs);
   xdr_u_int(xdrs,&size);
   start = xdr_getpos64(xdrs);

   {
      if (this1->centralDC != (s_CentralDC_t*)&hddm_s_nullTarget)
      {
         if (pack_s_CentralDC(xdrs,this1->centralDC) < 0) {
            return -1;
         }
      }
      else
      {
         int zero=0;
         xdr_int(xdrs,&zero);
      }
      if (this1->forwardDC != (s_ForwardDC_t*)&hddm_s_nullTarget)
      {
         if (pack_s_ForwardDC(xdrs,this1->forwardDC) < 0) {
            return -1;
         }
      }
      else
      {
         int zero=0;
         xdr_int(xdrs,&zero);
      }
      if (this1->startCntr != (s_StartCntr_t*)&hddm_s_nullTarget)
      {
         if (pack_s_StartCntr(xdrs,this1->startCntr) < 0) {
            return -1;
         }
      }
      else
      {
         int zero=0;
         xdr_int(xdrs,&zero);
      }
      if (this1->barrelEMcal != (s_BarrelEMcal_t*)&hddm_s_nullTarget)
      {
         if (pack_s_BarrelEMcal(xdrs,this1->barrelEMcal) < 0) {
            return -1;
         }
      }
      else
      {
         int zero=0;
         xdr_int(xdrs,&zero);
      }
      if (this1->gapEMcal != (s_GapEMcal_t*)&hddm_s_nullTarget)
      {
         if (pack_s_GapEMcal(xdrs,this1->gapEMcal) < 0) {
            return -1;
         }
      }
      else
      {
         int zero=0;
         xdr_int(xdrs,&zero);
      }
      if (this1->Cerenkov != (s_Cerenkov_t*)&hddm_s_nullTarget)
      {
         if (pack_s_Cerenkov(xdrs,this1->Cerenkov) < 0) {
            return -1;
         }
      }
      else
      {
         int zero=0;
         xdr_int(xdrs,&zero);
      }
      if (this1->forwardTOF != (s_ForwardTOF_t*)&hddm_s_nullTarget)
      {
         if (pack_s_ForwardTOF(xdrs,this1->forwardTOF) < 0) {
            return -1;
         }
      }
      else
      {
         int zero=0;
         xdr_int(xdrs,&zero);
      }
      if (this1->forwardEMcal != (s_ForwardEMcal_t*)&hddm_s_nullTarget)
      {
         if (pack_s_ForwardEMcal(xdrs,this1->forwardEMcal) < 0) {
            return -1;
         }
      }
      else
      {
         int zero=0;
         xdr_int(xdrs,&zero);
      }
      if (this1->ComptonEMcal != (s_ComptonEMcal_t*)&hddm_s_nullTarget)
      {
         if (pack_s_ComptonEMcal(xdrs,this1->ComptonEMcal) < 0) {
            return -1;
         }
      }
      else
      {
         int zero=0;
         xdr_int(xdrs,&zero);
      }
      if (this1->upstreamEMveto != (s_UpstreamEMveto_t*)&hddm_s_nullTarget)
      {
         if (pack_s_UpstreamEMveto(xdrs,this1->upstreamEMveto) < 0) {
            return -1;
         }
      }
      else
      {
         int zero=0;
         xdr_int(xdrs,&zero);
      }
      if (this1->tagger != (s_Tagger_t*)&hddm_s_nullTarget)
      {
         if (pack_s_Tagger(xdrs,this1->tagger) < 0) {
            return -1;
         }
      }
      else
      {
         int zero=0;
         xdr_int(xdrs,&zero);
      }
      if (this1->mcTrajectory != (s_McTrajectory_t*)&hddm_s_nullTarget)
      {
         if (pack_s_McTrajectory(xdrs,this1->mcTrajectory) < 0) {
            return -1;
         }
      }
      else
      {
         int zero=0;
         xdr_int(xdrs,&zero);
      }
   }
   FREE(this1);
   end = xdr_getpos64(xdrs);
   xdr_setpos64(xdrs,base);
   size = end-start;
   xdr_u_int(xdrs,&size);
   xdr_setpos64(xdrs,end);
   return size;
}

static int pack_s_CentralDC(XDR* xdrs, s_CentralDC_t* this1)
{
   int m=0;
   unsigned int size=0;
   off_t base,start,end;
   base = xdr_getpos64(xdrs);
   xdr_u_int(xdrs,&size);
   start = xdr_getpos64(xdrs);

   {
      if (this1->cdcStraws != (s_CdcStraws_t*)&hddm_s_nullTarget)
      {
         if (pack_s_CdcStraws(xdrs,this1->cdcStraws) < 0) {
            return -1;
         }
      }
      else
      {
         int zero=0;
         xdr_int(xdrs,&zero);
      }
      if (this1->cdcTruthPoints != (s_CdcTruthPoints_t*)&hddm_s_nullTarget)
      {
         if (pack_s_CdcTruthPoints(xdrs,this1->cdcTruthPoints) < 0) {
            return -1;
         }
      }
      else
      {
         int zero=0;
         xdr_int(xdrs,&zero);
      }
   }
   FREE(this1);
   end = xdr_getpos64(xdrs);
   xdr_setpos64(xdrs,base);
   size = end-start;
   xdr_u_int(xdrs,&size);
   xdr_setpos64(xdrs,end);
   return size;
}

static int pack_s_CdcStraws(XDR* xdrs, s_CdcStraws_t* this1)
{
   int m=0;
   unsigned int size=0;
   off_t base,start,end;
   base = xdr_getpos64(xdrs);
   xdr_u_int(xdrs,&size);
   start = xdr_getpos64(xdrs);

   xdr_u_int(xdrs,&this1->mult);
   for (m = 0; m < this1->mult; m++)
   {
      xdr_int(xdrs,&this1->in[m].ring);
      xdr_int(xdrs,&this1->in[m].straw);
      if (this1->in[m].cdcStrawHits != (s_CdcStrawHits_t*)&hddm_s_nullTarget)
      {
         if (pack_s_CdcStrawHits(xdrs,this1->in[m].cdcStrawHits) < 0) {
            return -1;
         }
      }
      else
      {
         int zero=0;
         xdr_int(xdrs,&zero);
      }
      if (this1->in[m].cdcStrawTruthHits != (s_CdcStrawTruthHits_t*)&hddm_s_nullTarget)
      {
         if (pack_s_CdcStrawTruthHits(xdrs,this1->in[m].cdcStrawTruthHits) < 0) {
            return -1;
         }
      }
      else
      {
         int zero=0;
         xdr_int(xdrs,&zero);
      }
   }
   FREE(this1);
   end = xdr_getpos64(xdrs);
   xdr_setpos64(xdrs,base);
   size = end-start;
   xdr_u_int(xdrs,&size);
   xdr_setpos64(xdrs,end);
   return size;
}

static int pack_s_CdcStrawHits(XDR* xdrs, s_CdcStrawHits_t* this1)
{
   int m=0;
   unsigned int size=0;
   off_t base,start,end;
   base = xdr_getpos64(xdrs);
   xdr_u_int(xdrs,&size);
   start = xdr_getpos64(xdrs);

   xdr_u_int(xdrs,&this1->mult);
   for (m = 0; m < this1->mult; m++)
   {
      xdr_float(xdrs,&this1->in[m].d);
      xdr_float(xdrs,&this1->in[m].dE);
      xdr_int(xdrs,&this1->in[m].itrack);
      xdr_int(xdrs,&this1->in[m].ptype);
      xdr_float(xdrs,&this1->in[m].t);
   }
   FREE(this1);
   end = xdr_getpos64(xdrs);
   xdr_setpos64(xdrs,base);
   size = end-start;
   xdr_u_int(xdrs,&size);
   xdr_setpos64(xdrs,end);
   return size;
}

static int pack_s_CdcStrawTruthHits(XDR* xdrs, s_CdcStrawTruthHits_t* this1)
{
   int m=0;
   unsigned int size=0;
   off_t base,start,end;
   base = xdr_getpos64(xdrs);
   xdr_u_int(xdrs,&size);
   start = xdr_getpos64(xdrs);

   xdr_u_int(xdrs,&this1->mult);
   for (m = 0; m < this1->mult; m++)
   {
      xdr_float(xdrs,&this1->in[m].d);
      xdr_float(xdrs,&this1->in[m].dE);
      xdr_int(xdrs,&this1->in[m].itrack);
      xdr_int(xdrs,&this1->in[m].ptype);
      xdr_float(xdrs,&this1->in[m].t);
   }
   FREE(this1);
   end = xdr_getpos64(xdrs);
   xdr_setpos64(xdrs,base);
   size = end-start;
   xdr_u_int(xdrs,&size);
   xdr_setpos64(xdrs,end);
   return size;
}

static int pack_s_CdcTruthPoints(XDR* xdrs, s_CdcTruthPoints_t* this1)
{
   int m=0;
   unsigned int size=0;
   off_t base,start,end;
   base = xdr_getpos64(xdrs);
   xdr_u_int(xdrs,&size);
   start = xdr_getpos64(xdrs);

   xdr_u_int(xdrs,&this1->mult);
   for (m = 0; m < this1->mult; m++)
   {
      xdr_float(xdrs,&this1->in[m].dEdx);
      xdr_float(xdrs,&this1->in[m].dradius);
      xdr_float(xdrs,&this1->in[m].phi);
      xdr_bool(xdrs,&this1->in[m].primary);
      xdr_int(xdrs,&this1->in[m].ptype);
      xdr_float(xdrs,&this1->in[m].px);
      xdr_float(xdrs,&this1->in[m].py);
      xdr_float(xdrs,&this1->in[m].pz);
      xdr_float(xdrs,&this1->in[m].r);
      xdr_float(xdrs,&this1->in[m].t);
      xdr_int(xdrs,&this1->in[m].track);
      xdr_float(xdrs,&this1->in[m].z);
   }
   FREE(this1);
   end = xdr_getpos64(xdrs);
   xdr_setpos64(xdrs,base);
   size = end-start;
   xdr_u_int(xdrs,&size);
   xdr_setpos64(xdrs,end);
   return size;
}

static int pack_s_ForwardDC(XDR* xdrs, s_ForwardDC_t* this1)
{
   int m=0;
   unsigned int size=0;
   off_t base,start,end;
   base = xdr_getpos64(xdrs);
   xdr_u_int(xdrs,&size);
   start = xdr_getpos64(xdrs);

   {
      if (this1->fdcChambers != (s_FdcChambers_t*)&hddm_s_nullTarget)
      {
         if (pack_s_FdcChambers(xdrs,this1->fdcChambers) < 0) {
            return -1;
         }
      }
      else
      {
         int zero=0;
         xdr_int(xdrs,&zero);
      }
   }
   FREE(this1);
   end = xdr_getpos64(xdrs);
   xdr_setpos64(xdrs,base);
   size = end-start;
   xdr_u_int(xdrs,&size);
   xdr_setpos64(xdrs,end);
   return size;
}

static int pack_s_FdcChambers(XDR* xdrs, s_FdcChambers_t* this1)
{
   int m=0;
   unsigned int size=0;
   off_t base,start,end;
   base = xdr_getpos64(xdrs);
   xdr_u_int(xdrs,&size);
   start = xdr_getpos64(xdrs);

   xdr_u_int(xdrs,&this1->mult);
   for (m = 0; m < this1->mult; m++)
   {
      xdr_int(xdrs,&this1->in[m].layer);
      xdr_int(xdrs,&this1->in[m].module);
      if (this1->in[m].fdcAnodeWires != (s_FdcAnodeWires_t*)&hddm_s_nullTarget)
      {
         if (pack_s_FdcAnodeWires(xdrs,this1->in[m].fdcAnodeWires) < 0) {
            return -1;
         }
      }
      else
      {
         int zero=0;
         xdr_int(xdrs,&zero);
      }
      if (this1->in[m].fdcCathodeStrips != (s_FdcCathodeStrips_t*)&hddm_s_nullTarget)
      {
         if (pack_s_FdcCathodeStrips(xdrs,this1->in[m].fdcCathodeStrips) < 0) {
            return -1;
         }
      }
      else
      {
         int zero=0;
         xdr_int(xdrs,&zero);
      }
      if (this1->in[m].fdcTruthPoints != (s_FdcTruthPoints_t*)&hddm_s_nullTarget)
      {
         if (pack_s_FdcTruthPoints(xdrs,this1->in[m].fdcTruthPoints) < 0) {
            return -1;
         }
      }
      else
      {
         int zero=0;
         xdr_int(xdrs,&zero);
      }
   }
   FREE(this1);
   end = xdr_getpos64(xdrs);
   xdr_setpos64(xdrs,base);
   size = end-start;
   xdr_u_int(xdrs,&size);
   xdr_setpos64(xdrs,end);
   return size;
}

static int pack_s_FdcAnodeWires(XDR* xdrs, s_FdcAnodeWires_t* this1)
{
   int m=0;
   unsigned int size=0;
   off_t base,start,end;
   base = xdr_getpos64(xdrs);
   xdr_u_int(xdrs,&size);
   start = xdr_getpos64(xdrs);

   xdr_u_int(xdrs,&this1->mult);
   for (m = 0; m < this1->mult; m++)
   {
      xdr_int(xdrs,&this1->in[m].wire);
      if (this1->in[m].fdcAnodeHits != (s_FdcAnodeHits_t*)&hddm_s_nullTarget)
      {
         if (pack_s_FdcAnodeHits(xdrs,this1->in[m].fdcAnodeHits) < 0) {
            return -1;
         }
      }
      else
      {
         int zero=0;
         xdr_int(xdrs,&zero);
      }
      if (this1->in[m].fdcAnodeTruthHits != (s_FdcAnodeTruthHits_t*)&hddm_s_nullTarget)
      {
         if (pack_s_FdcAnodeTruthHits(xdrs,this1->in[m].fdcAnodeTruthHits) < 0) {
            return -1;
         }
      }
      else
      {
         int zero=0;
         xdr_int(xdrs,&zero);
      }
   }
   FREE(this1);
   end = xdr_getpos64(xdrs);
   xdr_setpos64(xdrs,base);
   size = end-start;
   xdr_u_int(xdrs,&size);
   xdr_setpos64(xdrs,end);
   return size;
}

static int pack_s_FdcAnodeHits(XDR* xdrs, s_FdcAnodeHits_t* this1)
{
   int m=0;
   unsigned int size=0;
   off_t base,start,end;
   base = xdr_getpos64(xdrs);
   xdr_u_int(xdrs,&size);
   start = xdr_getpos64(xdrs);

   xdr_u_int(xdrs,&this1->mult);
   for (m = 0; m < this1->mult; m++)
   {
      xdr_float(xdrs,&this1->in[m].d);
      xdr_float(xdrs,&this1->in[m].dE);
      xdr_int(xdrs,&this1->in[m].itrack);
      xdr_int(xdrs,&this1->in[m].ptype);
      xdr_float(xdrs,&this1->in[m].t);
   }
   FREE(this1);
   end = xdr_getpos64(xdrs);
   xdr_setpos64(xdrs,base);
   size = end-start;
   xdr_u_int(xdrs,&size);
   xdr_setpos64(xdrs,end);
   return size;
}

static int pack_s_FdcAnodeTruthHits(XDR* xdrs, s_FdcAnodeTruthHits_t* this1)
{
   int m=0;
   unsigned int size=0;
   off_t base,start,end;
   base = xdr_getpos64(xdrs);
   xdr_u_int(xdrs,&size);
   start = xdr_getpos64(xdrs);

   xdr_u_int(xdrs,&this1->mult);
   for (m = 0; m < this1->mult; m++)
   {
      xdr_float(xdrs,&this1->in[m].d);
      xdr_float(xdrs,&this1->in[m].dE);
      xdr_int(xdrs,&this1->in[m].itrack);
      xdr_int(xdrs,&this1->in[m].ptype);
      xdr_float(xdrs,&this1->in[m].t);
      xdr_float(xdrs,&this1->in[m].t_unsmeared);
   }
   FREE(this1);
   end = xdr_getpos64(xdrs);
   xdr_setpos64(xdrs,base);
   size = end-start;
   xdr_u_int(xdrs,&size);
   xdr_setpos64(xdrs,end);
   return size;
}

static int pack_s_FdcCathodeStrips(XDR* xdrs, s_FdcCathodeStrips_t* this1)
{
   int m=0;
   unsigned int size=0;
   off_t base,start,end;
   base = xdr_getpos64(xdrs);
   xdr_u_int(xdrs,&size);
   start = xdr_getpos64(xdrs);

   xdr_u_int(xdrs,&this1->mult);
   for (m = 0; m < this1->mult; m++)
   {
      xdr_int(xdrs,&this1->in[m].plane);
      xdr_int(xdrs,&this1->in[m].strip);
      if (this1->in[m].fdcCathodeHits != (s_FdcCathodeHits_t*)&hddm_s_nullTarget)
      {
         if (pack_s_FdcCathodeHits(xdrs,this1->in[m].fdcCathodeHits) < 0) {
            return -1;
         }
      }
      else
      {
         int zero=0;
         xdr_int(xdrs,&zero);
      }
      if (this1->in[m].fdcCathodeTruthHits != (s_FdcCathodeTruthHits_t*)&hddm_s_nullTarget)
      {
         if (pack_s_FdcCathodeTruthHits(xdrs,this1->in[m].fdcCathodeTruthHits) < 0) {
            return -1;
         }
      }
      else
      {
         int zero=0;
         xdr_int(xdrs,&zero);
      }
   }
   FREE(this1);
   end = xdr_getpos64(xdrs);
   xdr_setpos64(xdrs,base);
   size = end-start;
   xdr_u_int(xdrs,&size);
   xdr_setpos64(xdrs,end);
   return size;
}

static int pack_s_FdcCathodeHits(XDR* xdrs, s_FdcCathodeHits_t* this1)
{
   int m=0;
   unsigned int size=0;
   off_t base,start,end;
   base = xdr_getpos64(xdrs);
   xdr_u_int(xdrs,&size);
   start = xdr_getpos64(xdrs);

   xdr_u_int(xdrs,&this1->mult);
   for (m = 0; m < this1->mult; m++)
   {
      xdr_int(xdrs,&this1->in[m].itrack);
      xdr_int(xdrs,&this1->in[m].ptype);
      xdr_float(xdrs,&this1->in[m].q);
      xdr_float(xdrs,&this1->in[m].t);
   }
   FREE(this1);
   end = xdr_getpos64(xdrs);
   xdr_setpos64(xdrs,base);
   size = end-start;
   xdr_u_int(xdrs,&size);
   xdr_setpos64(xdrs,end);
   return size;
}

static int pack_s_FdcCathodeTruthHits(XDR* xdrs, s_FdcCathodeTruthHits_t* this1)
{
   int m=0;
   unsigned int size=0;
   off_t base,start,end;
   base = xdr_getpos64(xdrs);
   xdr_u_int(xdrs,&size);
   start = xdr_getpos64(xdrs);

   xdr_u_int(xdrs,&this1->mult);
   for (m = 0; m < this1->mult; m++)
   {
      xdr_int(xdrs,&this1->in[m].itrack);
      xdr_int(xdrs,&this1->in[m].ptype);
      xdr_float(xdrs,&this1->in[m].q);
      xdr_float(xdrs,&this1->in[m].t);
   }
   FREE(this1);
   end = xdr_getpos64(xdrs);
   xdr_setpos64(xdrs,base);
   size = end-start;
   xdr_u_int(xdrs,&size);
   xdr_setpos64(xdrs,end);
   return size;
}

static int pack_s_FdcTruthPoints(XDR* xdrs, s_FdcTruthPoints_t* this1)
{
   int m=0;
   unsigned int size=0;
   off_t base,start,end;
   base = xdr_getpos64(xdrs);
   xdr_u_int(xdrs,&size);
   start = xdr_getpos64(xdrs);

   xdr_u_int(xdrs,&this1->mult);
   for (m = 0; m < this1->mult; m++)
   {
      xdr_float(xdrs,&this1->in[m].E);
      xdr_float(xdrs,&this1->in[m].dEdx);
      xdr_float(xdrs,&this1->in[m].dradius);
      xdr_bool(xdrs,&this1->in[m].primary);
      xdr_int(xdrs,&this1->in[m].ptype);
      xdr_float(xdrs,&this1->in[m].px);
      xdr_float(xdrs,&this1->in[m].py);
      xdr_float(xdrs,&this1->in[m].pz);
      xdr_float(xdrs,&this1->in[m].t);
      xdr_int(xdrs,&this1->in[m].track);
      xdr_float(xdrs,&this1->in[m].x);
      xdr_float(xdrs,&this1->in[m].y);
      xdr_float(xdrs,&this1->in[m].z);
   }
   FREE(this1);
   end = xdr_getpos64(xdrs);
   xdr_setpos64(xdrs,base);
   size = end-start;
   xdr_u_int(xdrs,&size);
   xdr_setpos64(xdrs,end);
   return size;
}

static int pack_s_StartCntr(XDR* xdrs, s_StartCntr_t* this1)
{
   int m=0;
   unsigned int size=0;
   off_t base,start,end;
   base = xdr_getpos64(xdrs);
   xdr_u_int(xdrs,&size);
   start = xdr_getpos64(xdrs);

   {
      if (this1->stcPaddles != (s_StcPaddles_t*)&hddm_s_nullTarget)
      {
         if (pack_s_StcPaddles(xdrs,this1->stcPaddles) < 0) {
            return -1;
         }
      }
      else
      {
         int zero=0;
         xdr_int(xdrs,&zero);
      }
      if (this1->stcTruthPoints != (s_StcTruthPoints_t*)&hddm_s_nullTarget)
      {
         if (pack_s_StcTruthPoints(xdrs,this1->stcTruthPoints) < 0) {
            return -1;
         }
      }
      else
      {
         int zero=0;
         xdr_int(xdrs,&zero);
      }
   }
   FREE(this1);
   end = xdr_getpos64(xdrs);
   xdr_setpos64(xdrs,base);
   size = end-start;
   xdr_u_int(xdrs,&size);
   xdr_setpos64(xdrs,end);
   return size;
}

static int pack_s_StcPaddles(XDR* xdrs, s_StcPaddles_t* this1)
{
   int m=0;
   unsigned int size=0;
   off_t base,start,end;
   base = xdr_getpos64(xdrs);
   xdr_u_int(xdrs,&size);
   start = xdr_getpos64(xdrs);

   xdr_u_int(xdrs,&this1->mult);
   for (m = 0; m < this1->mult; m++)
   {
      xdr_int(xdrs,&this1->in[m].sector);
      if (this1->in[m].stcHits != (s_StcHits_t*)&hddm_s_nullTarget)
      {
         if (pack_s_StcHits(xdrs,this1->in[m].stcHits) < 0) {
            return -1;
         }
      }
      else
      {
         int zero=0;
         xdr_int(xdrs,&zero);
      }
      if (this1->in[m].stcTruthHits != (s_StcTruthHits_t*)&hddm_s_nullTarget)
      {
         if (pack_s_StcTruthHits(xdrs,this1->in[m].stcTruthHits) < 0) {
            return -1;
         }
      }
      else
      {
         int zero=0;
         xdr_int(xdrs,&zero);
      }
   }
   FREE(this1);
   end = xdr_getpos64(xdrs);
   xdr_setpos64(xdrs,base);
   size = end-start;
   xdr_u_int(xdrs,&size);
   xdr_setpos64(xdrs,end);
   return size;
}

static int pack_s_StcHits(XDR* xdrs, s_StcHits_t* this1)
{
   int m=0;
   unsigned int size=0;
   off_t base,start,end;
   base = xdr_getpos64(xdrs);
   xdr_u_int(xdrs,&size);
   start = xdr_getpos64(xdrs);

   xdr_u_int(xdrs,&this1->mult);
   for (m = 0; m < this1->mult; m++)
   {
      xdr_float(xdrs,&this1->in[m].dE);
      xdr_float(xdrs,&this1->in[m].t);
   }
   FREE(this1);
   end = xdr_getpos64(xdrs);
   xdr_setpos64(xdrs,base);
   size = end-start;
   xdr_u_int(xdrs,&size);
   xdr_setpos64(xdrs,end);
   return size;
}

static int pack_s_StcTruthHits(XDR* xdrs, s_StcTruthHits_t* this1)
{
   int m=0;
   unsigned int size=0;
   off_t base,start,end;
   base = xdr_getpos64(xdrs);
   xdr_u_int(xdrs,&size);
   start = xdr_getpos64(xdrs);

   xdr_u_int(xdrs,&this1->mult);
   for (m = 0; m < this1->mult; m++)
   {
      xdr_float(xdrs,&this1->in[m].dE);
      xdr_float(xdrs,&this1->in[m].t);
   }
   FREE(this1);
   end = xdr_getpos64(xdrs);
   xdr_setpos64(xdrs,base);
   size = end-start;
   xdr_u_int(xdrs,&size);
   xdr_setpos64(xdrs,end);
   return size;
}

static int pack_s_StcTruthPoints(XDR* xdrs, s_StcTruthPoints_t* this1)
{
   int m=0;
   unsigned int size=0;
   off_t base,start,end;
   base = xdr_getpos64(xdrs);
   xdr_u_int(xdrs,&size);
   start = xdr_getpos64(xdrs);

   xdr_u_int(xdrs,&this1->mult);
   for (m = 0; m < this1->mult; m++)
   {
      xdr_float(xdrs,&this1->in[m].E);
      xdr_float(xdrs,&this1->in[m].dEdx);
      xdr_float(xdrs,&this1->in[m].phi);
      xdr_bool(xdrs,&this1->in[m].primary);
      xdr_int(xdrs,&this1->in[m].ptype);
      xdr_float(xdrs,&this1->in[m].px);
      xdr_float(xdrs,&this1->in[m].py);
      xdr_float(xdrs,&this1->in[m].pz);
      xdr_float(xdrs,&this1->in[m].r);
      xdr_int(xdrs,&this1->in[m].sector);
      xdr_float(xdrs,&this1->in[m].t);
      xdr_int(xdrs,&this1->in[m].track);
      xdr_float(xdrs,&this1->in[m].z);
   }
   FREE(this1);
   end = xdr_getpos64(xdrs);
   xdr_setpos64(xdrs,base);
   size = end-start;
   xdr_u_int(xdrs,&size);
   xdr_setpos64(xdrs,end);
   return size;
}

static int pack_s_BarrelEMcal(XDR* xdrs, s_BarrelEMcal_t* this1)
{
   int m=0;
   unsigned int size=0;
   off_t base,start,end;
   base = xdr_getpos64(xdrs);
   xdr_u_int(xdrs,&size);
   start = xdr_getpos64(xdrs);

   {
      if (this1->bcalCells != (s_BcalCells_t*)&hddm_s_nullTarget)
      {
         if (pack_s_BcalCells(xdrs,this1->bcalCells) < 0) {
            return -1;
         }
      }
      else
      {
         int zero=0;
         xdr_int(xdrs,&zero);
      }
      if (this1->bcalIncidentParticles != (s_BcalIncidentParticles_t*)&hddm_s_nullTarget)
      {
         if (pack_s_BcalIncidentParticles(xdrs,this1->bcalIncidentParticles) < 0) {
            return -1;
         }
      }
      else
      {
         int zero=0;
         xdr_int(xdrs,&zero);
      }
      if (this1->bcalSiPMSpectrums != (s_BcalSiPMSpectrums_t*)&hddm_s_nullTarget)
      {
         if (pack_s_BcalSiPMSpectrums(xdrs,this1->bcalSiPMSpectrums) < 0) {
            return -1;
         }
      }
      else
      {
         int zero=0;
         xdr_int(xdrs,&zero);
      }
      if (this1->bcalfADCCells != (s_BcalfADCCells_t*)&hddm_s_nullTarget)
      {
         if (pack_s_BcalfADCCells(xdrs,this1->bcalfADCCells) < 0) {
            return -1;
         }
      }
      else
      {
         int zero=0;
         xdr_int(xdrs,&zero);
      }
      if (this1->bcalTDCHits != (s_BcalTDCHits_t*)&hddm_s_nullTarget)
      {
         if (pack_s_BcalTDCHits(xdrs,this1->bcalTDCHits) < 0) {
            return -1;
         }
      }
      else
      {
         int zero=0;
         xdr_int(xdrs,&zero);
      }
      if (this1->bcalTruthShowers != (s_BcalTruthShowers_t*)&hddm_s_nullTarget)
      {
         if (pack_s_BcalTruthShowers(xdrs,this1->bcalTruthShowers) < 0) {
            return -1;
         }
      }
      else
      {
         int zero=0;
         xdr_int(xdrs,&zero);
      }
   }
   FREE(this1);
   end = xdr_getpos64(xdrs);
   xdr_setpos64(xdrs,base);
   size = end-start;
   xdr_u_int(xdrs,&size);
   xdr_setpos64(xdrs,end);
   return size;
}

static int pack_s_BcalCells(XDR* xdrs, s_BcalCells_t* this1)
{
   int m=0;
   unsigned int size=0;
   off_t base,start,end;
   base = xdr_getpos64(xdrs);
   xdr_u_int(xdrs,&size);
   start = xdr_getpos64(xdrs);

   xdr_u_int(xdrs,&this1->mult);
   for (m = 0; m < this1->mult; m++)
   {
      xdr_int(xdrs,&this1->in[m].layer);
      xdr_int(xdrs,&this1->in[m].module);
      xdr_int(xdrs,&this1->in[m].sector);
      if (this1->in[m].bcalSiPMUpHits != (s_BcalSiPMUpHits_t*)&hddm_s_nullTarget)
      {
         if (pack_s_BcalSiPMUpHits(xdrs,this1->in[m].bcalSiPMUpHits) < 0) {
            return -1;
         }
      }
      else
      {
         int zero=0;
         xdr_int(xdrs,&zero);
      }
      if (this1->in[m].bcalSiPMDownHits != (s_BcalSiPMDownHits_t*)&hddm_s_nullTarget)
      {
         if (pack_s_BcalSiPMDownHits(xdrs,this1->in[m].bcalSiPMDownHits) < 0) {
            return -1;
         }
      }
      else
      {
         int zero=0;
         xdr_int(xdrs,&zero);
      }
      if (this1->in[m].bcalHits != (s_BcalHits_t*)&hddm_s_nullTarget)
      {
         if (pack_s_BcalHits(xdrs,this1->in[m].bcalHits) < 0) {
            return -1;
         }
      }
      else
      {
         int zero=0;
         xdr_int(xdrs,&zero);
      }
   }
   FREE(this1);
   end = xdr_getpos64(xdrs);
   xdr_setpos64(xdrs,base);
   size = end-start;
   xdr_u_int(xdrs,&size);
   xdr_setpos64(xdrs,end);
   return size;
}

static int pack_s_BcalSiPMUpHits(XDR* xdrs, s_BcalSiPMUpHits_t* this1)
{
   int m=0;
   unsigned int size=0;
   off_t base,start,end;
   base = xdr_getpos64(xdrs);
   xdr_u_int(xdrs,&size);
   start = xdr_getpos64(xdrs);

   xdr_u_int(xdrs,&this1->mult);
   for (m = 0; m < this1->mult; m++)
   {
      xdr_float(xdrs,&this1->in[m].E);
      xdr_float(xdrs,&this1->in[m].t);
   }
   FREE(this1);
   end = xdr_getpos64(xdrs);
   xdr_setpos64(xdrs,base);
   size = end-start;
   xdr_u_int(xdrs,&size);
   xdr_setpos64(xdrs,end);
   return size;
}

static int pack_s_BcalSiPMDownHits(XDR* xdrs, s_BcalSiPMDownHits_t* this1)
{
   int m=0;
   unsigned int size=0;
   off_t base,start,end;
   base = xdr_getpos64(xdrs);
   xdr_u_int(xdrs,&size);
   start = xdr_getpos64(xdrs);

   xdr_u_int(xdrs,&this1->mult);
   for (m = 0; m < this1->mult; m++)
   {
      xdr_float(xdrs,&this1->in[m].E);
      xdr_float(xdrs,&this1->in[m].t);
   }
   FREE(this1);
   end = xdr_getpos64(xdrs);
   xdr_setpos64(xdrs,base);
   size = end-start;
   xdr_u_int(xdrs,&size);
   xdr_setpos64(xdrs,end);
   return size;
}

static int pack_s_BcalHits(XDR* xdrs, s_BcalHits_t* this1)
{
   int m=0;
   unsigned int size=0;
   off_t base,start,end;
   base = xdr_getpos64(xdrs);
   xdr_u_int(xdrs,&size);
   start = xdr_getpos64(xdrs);

   xdr_u_int(xdrs,&this1->mult);
   for (m = 0; m < this1->mult; m++)
   {
      xdr_float(xdrs,&this1->in[m].E);
      xdr_float(xdrs,&this1->in[m].t);
      xdr_float(xdrs,&this1->in[m].zLocal);
   }
   FREE(this1);
   end = xdr_getpos64(xdrs);
   xdr_setpos64(xdrs,base);
   size = end-start;
   xdr_u_int(xdrs,&size);
   xdr_setpos64(xdrs,end);
   return size;
}

static int pack_s_BcalIncidentParticles(XDR* xdrs, s_BcalIncidentParticles_t* this1)
{
   int m=0;
   unsigned int size=0;
   off_t base,start,end;
   base = xdr_getpos64(xdrs);
   xdr_u_int(xdrs,&size);
   start = xdr_getpos64(xdrs);

   xdr_u_int(xdrs,&this1->mult);
   for (m = 0; m < this1->mult; m++)
   {
      xdr_int(xdrs,&this1->in[m].id);
      xdr_int(xdrs,&this1->in[m].ptype);
      xdr_float(xdrs,&this1->in[m].px);
      xdr_float(xdrs,&this1->in[m].py);
      xdr_float(xdrs,&this1->in[m].pz);
      xdr_float(xdrs,&this1->in[m].x);
      xdr_float(xdrs,&this1->in[m].y);
      xdr_float(xdrs,&this1->in[m].z);
   }
   FREE(this1);
   end = xdr_getpos64(xdrs);
   xdr_setpos64(xdrs,base);
   size = end-start;
   xdr_u_int(xdrs,&size);
   xdr_setpos64(xdrs,end);
   return size;
}

static int pack_s_BcalSiPMSpectrums(XDR* xdrs, s_BcalSiPMSpectrums_t* this1)
{
   int m=0;
   unsigned int size=0;
   off_t base,start,end;
   base = xdr_getpos64(xdrs);
   xdr_u_int(xdrs,&size);
   start = xdr_getpos64(xdrs);

   xdr_u_int(xdrs,&this1->mult);
   for (m = 0; m < this1->mult; m++)
   {
      xdr_float(xdrs,&this1->in[m].Etruth);
      xdr_float(xdrs,&this1->in[m].bin_width);
      xdr_int(xdrs,&this1->in[m].end);
      xdr_int(xdrs,&this1->in[m].incident_id);
      xdr_int(xdrs,&this1->in[m].layer);
      xdr_int(xdrs,&this1->in[m].module);
      xdr_int(xdrs,&this1->in[m].sector);
      xdr_float(xdrs,&this1->in[m].tstart);
      xdr_string(xdrs,&this1->in[m].vals, 1000000);
      FREE(this1->in[m].vals);
   }
   FREE(this1);
   end = xdr_getpos64(xdrs);
   xdr_setpos64(xdrs,base);
   size = end-start;
   xdr_u_int(xdrs,&size);
   xdr_setpos64(xdrs,end);
   return size;
}

static int pack_s_BcalfADCCells(XDR* xdrs, s_BcalfADCCells_t* this1)
{
   int m=0;
   unsigned int size=0;
   off_t base,start,end;
   base = xdr_getpos64(xdrs);
   xdr_u_int(xdrs,&size);
   start = xdr_getpos64(xdrs);

   xdr_u_int(xdrs,&this1->mult);
   for (m = 0; m < this1->mult; m++)
   {
      xdr_int(xdrs,&this1->in[m].layer);
      xdr_int(xdrs,&this1->in[m].module);
      xdr_int(xdrs,&this1->in[m].sector);
      if (this1->in[m].bcalfADCUpHits != (s_BcalfADCUpHits_t*)&hddm_s_nullTarget)
      {
         if (pack_s_BcalfADCUpHits(xdrs,this1->in[m].bcalfADCUpHits) < 0) {
            return -1;
         }
      }
      else
      {
         int zero=0;
         xdr_int(xdrs,&zero);
      }
      if (this1->in[m].bcalfADCDownHits != (s_BcalfADCDownHits_t*)&hddm_s_nullTarget)
      {
         if (pack_s_BcalfADCDownHits(xdrs,this1->in[m].bcalfADCDownHits) < 0) {
            return -1;
         }
      }
      else
      {
         int zero=0;
         xdr_int(xdrs,&zero);
      }
   }
   FREE(this1);
   end = xdr_getpos64(xdrs);
   xdr_setpos64(xdrs,base);
   size = end-start;
   xdr_u_int(xdrs,&size);
   xdr_setpos64(xdrs,end);
   return size;
}

static int pack_s_BcalfADCUpHits(XDR* xdrs, s_BcalfADCUpHits_t* this1)
{
   int m=0;
   unsigned int size=0;
   off_t base,start,end;
   base = xdr_getpos64(xdrs);
   xdr_u_int(xdrs,&size);
   start = xdr_getpos64(xdrs);

   xdr_u_int(xdrs,&this1->mult);
   for (m = 0; m < this1->mult; m++)
   {
      xdr_float(xdrs,&this1->in[m].E);
      xdr_float(xdrs,&this1->in[m].t);
   }
   FREE(this1);
   end = xdr_getpos64(xdrs);
   xdr_setpos64(xdrs,base);
   size = end-start;
   xdr_u_int(xdrs,&size);
   xdr_setpos64(xdrs,end);
   return size;
}

static int pack_s_BcalfADCDownHits(XDR* xdrs, s_BcalfADCDownHits_t* this1)
{
   int m=0;
   unsigned int size=0;
   off_t base,start,end;
   base = xdr_getpos64(xdrs);
   xdr_u_int(xdrs,&size);
   start = xdr_getpos64(xdrs);

   xdr_u_int(xdrs,&this1->mult);
   for (m = 0; m < this1->mult; m++)
   {
      xdr_float(xdrs,&this1->in[m].E);
      xdr_float(xdrs,&this1->in[m].t);
   }
   FREE(this1);
   end = xdr_getpos64(xdrs);
   xdr_setpos64(xdrs,base);
   size = end-start;
   xdr_u_int(xdrs,&size);
   xdr_setpos64(xdrs,end);
   return size;
}

static int pack_s_BcalTDCHits(XDR* xdrs, s_BcalTDCHits_t* this1)
{
   int m=0;
   unsigned int size=0;
   off_t base,start,end;
   base = xdr_getpos64(xdrs);
   xdr_u_int(xdrs,&size);
   start = xdr_getpos64(xdrs);

   xdr_u_int(xdrs,&this1->mult);
   for (m = 0; m < this1->mult; m++)
   {
      xdr_int(xdrs,&this1->in[m].end);
      xdr_int(xdrs,&this1->in[m].layer);
      xdr_int(xdrs,&this1->in[m].module);
      xdr_int(xdrs,&this1->in[m].sector);
      xdr_float(xdrs,&this1->in[m].t);
   }
   FREE(this1);
   end = xdr_getpos64(xdrs);
   xdr_setpos64(xdrs,base);
   size = end-start;
   xdr_u_int(xdrs,&size);
   xdr_setpos64(xdrs,end);
   return size;
}

static int pack_s_BcalTruthShowers(XDR* xdrs, s_BcalTruthShowers_t* this1)
{
   int m=0;
   unsigned int size=0;
   off_t base,start,end;
   base = xdr_getpos64(xdrs);
   xdr_u_int(xdrs,&size);
   start = xdr_getpos64(xdrs);

   xdr_u_int(xdrs,&this1->mult);
   for (m = 0; m < this1->mult; m++)
   {
      xdr_float(xdrs,&this1->in[m].E);
      xdr_float(xdrs,&this1->in[m].phi);
      xdr_bool(xdrs,&this1->in[m].primary);
      xdr_int(xdrs,&this1->in[m].ptype);
      xdr_float(xdrs,&this1->in[m].px);
      xdr_float(xdrs,&this1->in[m].py);
      xdr_float(xdrs,&this1->in[m].pz);
      xdr_float(xdrs,&this1->in[m].r);
      xdr_float(xdrs,&this1->in[m].t);
      xdr_int(xdrs,&this1->in[m].track);
      xdr_float(xdrs,&this1->in[m].z);
   }
   FREE(this1);
   end = xdr_getpos64(xdrs);
   xdr_setpos64(xdrs,base);
   size = end-start;
   xdr_u_int(xdrs,&size);
   xdr_setpos64(xdrs,end);
   return size;
}

static int pack_s_GapEMcal(XDR* xdrs, s_GapEMcal_t* this1)
{
   int m=0;
   unsigned int size=0;
   off_t base,start,end;
   base = xdr_getpos64(xdrs);
   xdr_u_int(xdrs,&size);
   start = xdr_getpos64(xdrs);

   {
      if (this1->gcalCells != (s_GcalCells_t*)&hddm_s_nullTarget)
      {
         if (pack_s_GcalCells(xdrs,this1->gcalCells) < 0) {
            return -1;
         }
      }
      else
      {
         int zero=0;
         xdr_int(xdrs,&zero);
      }
      if (this1->gcalTruthShowers != (s_GcalTruthShowers_t*)&hddm_s_nullTarget)
      {
         if (pack_s_GcalTruthShowers(xdrs,this1->gcalTruthShowers) < 0) {
            return -1;
         }
      }
      else
      {
         int zero=0;
         xdr_int(xdrs,&zero);
      }
   }
   FREE(this1);
   end = xdr_getpos64(xdrs);
   xdr_setpos64(xdrs,base);
   size = end-start;
   xdr_u_int(xdrs,&size);
   xdr_setpos64(xdrs,end);
   return size;
}

static int pack_s_GcalCells(XDR* xdrs, s_GcalCells_t* this1)
{
   int m=0;
   unsigned int size=0;
   off_t base,start,end;
   base = xdr_getpos64(xdrs);
   xdr_u_int(xdrs,&size);
   start = xdr_getpos64(xdrs);

   xdr_u_int(xdrs,&this1->mult);
   for (m = 0; m < this1->mult; m++)
   {
      xdr_int(xdrs,&this1->in[m].module);
      if (this1->in[m].gcalHits != (s_GcalHits_t*)&hddm_s_nullTarget)
      {
         if (pack_s_GcalHits(xdrs,this1->in[m].gcalHits) < 0) {
            return -1;
         }
      }
      else
      {
         int zero=0;
         xdr_int(xdrs,&zero);
      }
   }
   FREE(this1);
   end = xdr_getpos64(xdrs);
   xdr_setpos64(xdrs,base);
   size = end-start;
   xdr_u_int(xdrs,&size);
   xdr_setpos64(xdrs,end);
   return size;
}

static int pack_s_GcalHits(XDR* xdrs, s_GcalHits_t* this1)
{
   int m=0;
   unsigned int size=0;
   off_t base,start,end;
   base = xdr_getpos64(xdrs);
   xdr_u_int(xdrs,&size);
   start = xdr_getpos64(xdrs);

   xdr_u_int(xdrs,&this1->mult);
   for (m = 0; m < this1->mult; m++)
   {
      xdr_float(xdrs,&this1->in[m].E);
      xdr_float(xdrs,&this1->in[m].t);
      xdr_float(xdrs,&this1->in[m].zLocal);
   }
   FREE(this1);
   end = xdr_getpos64(xdrs);
   xdr_setpos64(xdrs,base);
   size = end-start;
   xdr_u_int(xdrs,&size);
   xdr_setpos64(xdrs,end);
   return size;
}

static int pack_s_GcalTruthShowers(XDR* xdrs, s_GcalTruthShowers_t* this1)
{
   int m=0;
   unsigned int size=0;
   off_t base,start,end;
   base = xdr_getpos64(xdrs);
   xdr_u_int(xdrs,&size);
   start = xdr_getpos64(xdrs);

   xdr_u_int(xdrs,&this1->mult);
   for (m = 0; m < this1->mult; m++)
   {
      xdr_float(xdrs,&this1->in[m].E);
      xdr_float(xdrs,&this1->in[m].phi);
      xdr_bool(xdrs,&this1->in[m].primary);
      xdr_int(xdrs,&this1->in[m].ptype);
      xdr_float(xdrs,&this1->in[m].px);
      xdr_float(xdrs,&this1->in[m].py);
      xdr_float(xdrs,&this1->in[m].pz);
      xdr_float(xdrs,&this1->in[m].r);
      xdr_float(xdrs,&this1->in[m].t);
      xdr_int(xdrs,&this1->in[m].track);
      xdr_float(xdrs,&this1->in[m].z);
   }
   FREE(this1);
   end = xdr_getpos64(xdrs);
   xdr_setpos64(xdrs,base);
   size = end-start;
   xdr_u_int(xdrs,&size);
   xdr_setpos64(xdrs,end);
   return size;
}

static int pack_s_Cerenkov(XDR* xdrs, s_Cerenkov_t* this1)
{
   int m=0;
   unsigned int size=0;
   off_t base,start,end;
   base = xdr_getpos64(xdrs);
   xdr_u_int(xdrs,&size);
   start = xdr_getpos64(xdrs);

   {
      if (this1->cereSections != (s_CereSections_t*)&hddm_s_nullTarget)
      {
         if (pack_s_CereSections(xdrs,this1->cereSections) < 0) {
            return -1;
         }
      }
      else
      {
         int zero=0;
         xdr_int(xdrs,&zero);
      }
      if (this1->cereRichHits != (s_CereRichHits_t*)&hddm_s_nullTarget)
      {
         if (pack_s_CereRichHits(xdrs,this1->cereRichHits) < 0) {
            return -1;
         }
      }
      else
      {
         int zero=0;
         xdr_int(xdrs,&zero);
      }
      if (this1->cereTruthPoints != (s_CereTruthPoints_t*)&hddm_s_nullTarget)
      {
         if (pack_s_CereTruthPoints(xdrs,this1->cereTruthPoints) < 0) {
            return -1;
         }
      }
      else
      {
         int zero=0;
         xdr_int(xdrs,&zero);
      }
   }
   FREE(this1);
   end = xdr_getpos64(xdrs);
   xdr_setpos64(xdrs,base);
   size = end-start;
   xdr_u_int(xdrs,&size);
   xdr_setpos64(xdrs,end);
   return size;
}

static int pack_s_CereSections(XDR* xdrs, s_CereSections_t* this1)
{
   int m=0;
   unsigned int size=0;
   off_t base,start,end;
   base = xdr_getpos64(xdrs);
   xdr_u_int(xdrs,&size);
   start = xdr_getpos64(xdrs);

   xdr_u_int(xdrs,&this1->mult);
   for (m = 0; m < this1->mult; m++)
   {
      xdr_int(xdrs,&this1->in[m].sector);
      if (this1->in[m].cereHits != (s_CereHits_t*)&hddm_s_nullTarget)
      {
         if (pack_s_CereHits(xdrs,this1->in[m].cereHits) < 0) {
            return -1;
         }
      }
      else
      {
         int zero=0;
         xdr_int(xdrs,&zero);
      }
   }
   FREE(this1);
   end = xdr_getpos64(xdrs);
   xdr_setpos64(xdrs,base);
   size = end-start;
   xdr_u_int(xdrs,&size);
   xdr_setpos64(xdrs,end);
   return size;
}

static int pack_s_CereHits(XDR* xdrs, s_CereHits_t* this1)
{
   int m=0;
   unsigned int size=0;
   off_t base,start,end;
   base = xdr_getpos64(xdrs);
   xdr_u_int(xdrs,&size);
   start = xdr_getpos64(xdrs);

   xdr_u_int(xdrs,&this1->mult);
   for (m = 0; m < this1->mult; m++)
   {
      xdr_float(xdrs,&this1->in[m].pe);
      xdr_float(xdrs,&this1->in[m].t);
   }
   FREE(this1);
   end = xdr_getpos64(xdrs);
   xdr_setpos64(xdrs,base);
   size = end-start;
   xdr_u_int(xdrs,&size);
   xdr_setpos64(xdrs,end);
   return size;
}

static int pack_s_CereRichHits(XDR* xdrs, s_CereRichHits_t* this1)
{
   int m=0;
   unsigned int size=0;
   off_t base,start,end;
   base = xdr_getpos64(xdrs);
   xdr_u_int(xdrs,&size);
   start = xdr_getpos64(xdrs);

   xdr_u_int(xdrs,&this1->mult);
   for (m = 0; m < this1->mult; m++)
   {
      xdr_float(xdrs,&this1->in[m].t);
      xdr_float(xdrs,&this1->in[m].x);
      xdr_float(xdrs,&this1->in[m].y);
      xdr_float(xdrs,&this1->in[m].z);
   }
   FREE(this1);
   end = xdr_getpos64(xdrs);
   xdr_setpos64(xdrs,base);
   size = end-start;
   xdr_u_int(xdrs,&size);
   xdr_setpos64(xdrs,end);
   return size;
}

static int pack_s_CereTruthPoints(XDR* xdrs, s_CereTruthPoints_t* this1)
{
   int m=0;
   unsigned int size=0;
   off_t base,start,end;
   base = xdr_getpos64(xdrs);
   xdr_u_int(xdrs,&size);
   start = xdr_getpos64(xdrs);

   xdr_u_int(xdrs,&this1->mult);
   for (m = 0; m < this1->mult; m++)
   {
      xdr_float(xdrs,&this1->in[m].E);
      xdr_bool(xdrs,&this1->in[m].primary);
      xdr_int(xdrs,&this1->in[m].ptype);
      xdr_float(xdrs,&this1->in[m].px);
      xdr_float(xdrs,&this1->in[m].py);
      xdr_float(xdrs,&this1->in[m].pz);
      xdr_float(xdrs,&this1->in[m].t);
      xdr_int(xdrs,&this1->in[m].track);
      xdr_float(xdrs,&this1->in[m].x);
      xdr_float(xdrs,&this1->in[m].y);
      xdr_float(xdrs,&this1->in[m].z);
   }
   FREE(this1);
   end = xdr_getpos64(xdrs);
   xdr_setpos64(xdrs,base);
   size = end-start;
   xdr_u_int(xdrs,&size);
   xdr_setpos64(xdrs,end);
   return size;
}

static int pack_s_ForwardTOF(XDR* xdrs, s_ForwardTOF_t* this1)
{
   int m=0;
   unsigned int size=0;
   off_t base,start,end;
   base = xdr_getpos64(xdrs);
   xdr_u_int(xdrs,&size);
   start = xdr_getpos64(xdrs);

   {
      if (this1->ftofCounters != (s_FtofCounters_t*)&hddm_s_nullTarget)
      {
         if (pack_s_FtofCounters(xdrs,this1->ftofCounters) < 0) {
            return -1;
         }
      }
      else
      {
         int zero=0;
         xdr_int(xdrs,&zero);
      }
      if (this1->ftofTruthPoints != (s_FtofTruthPoints_t*)&hddm_s_nullTarget)
      {
         if (pack_s_FtofTruthPoints(xdrs,this1->ftofTruthPoints) < 0) {
            return -1;
         }
      }
      else
      {
         int zero=0;
         xdr_int(xdrs,&zero);
      }
   }
   FREE(this1);
   end = xdr_getpos64(xdrs);
   xdr_setpos64(xdrs,base);
   size = end-start;
   xdr_u_int(xdrs,&size);
   xdr_setpos64(xdrs,end);
   return size;
}

static int pack_s_FtofCounters(XDR* xdrs, s_FtofCounters_t* this1)
{
   int m=0;
   unsigned int size=0;
   off_t base,start,end;
   base = xdr_getpos64(xdrs);
   xdr_u_int(xdrs,&size);
   start = xdr_getpos64(xdrs);

   xdr_u_int(xdrs,&this1->mult);
   for (m = 0; m < this1->mult; m++)
   {
      xdr_int(xdrs,&this1->in[m].bar);
      xdr_int(xdrs,&this1->in[m].plane);
      if (this1->in[m].ftofNorthTruthHits != (s_FtofNorthTruthHits_t*)&hddm_s_nullTarget)
      {
         if (pack_s_FtofNorthTruthHits(xdrs,this1->in[m].ftofNorthTruthHits) < 0) {
            return -1;
         }
      }
      else
      {
         int zero=0;
         xdr_int(xdrs,&zero);
      }
      if (this1->in[m].ftofSouthTruthHits != (s_FtofSouthTruthHits_t*)&hddm_s_nullTarget)
      {
         if (pack_s_FtofSouthTruthHits(xdrs,this1->in[m].ftofSouthTruthHits) < 0) {
            return -1;
         }
      }
      else
      {
         int zero=0;
         xdr_int(xdrs,&zero);
      }
      if (this1->in[m].ftofNorthHits != (s_FtofNorthHits_t*)&hddm_s_nullTarget)
      {
         if (pack_s_FtofNorthHits(xdrs,this1->in[m].ftofNorthHits) < 0) {
            return -1;
         }
      }
      else
      {
         int zero=0;
         xdr_int(xdrs,&zero);
      }
      if (this1->in[m].ftofSouthHits != (s_FtofSouthHits_t*)&hddm_s_nullTarget)
      {
         if (pack_s_FtofSouthHits(xdrs,this1->in[m].ftofSouthHits) < 0) {
            return -1;
         }
      }
      else
      {
         int zero=0;
         xdr_int(xdrs,&zero);
      }
   }
   FREE(this1);
   end = xdr_getpos64(xdrs);
   xdr_setpos64(xdrs,base);
   size = end-start;
   xdr_u_int(xdrs,&size);
   xdr_setpos64(xdrs,end);
   return size;
}

static int pack_s_FtofNorthTruthHits(XDR* xdrs, s_FtofNorthTruthHits_t* this1)
{
   int m=0;
   unsigned int size=0;
   off_t base,start,end;
   base = xdr_getpos64(xdrs);
   xdr_u_int(xdrs,&size);
   start = xdr_getpos64(xdrs);

   xdr_u_int(xdrs,&this1->mult);
   for (m = 0; m < this1->mult; m++)
   {
      xdr_float(xdrs,&this1->in[m].dE);
      xdr_float(xdrs,&this1->in[m].t);
      if (this1->in[m].ftofMCHits != (s_FtofMCHits_t*)&hddm_s_nullTarget)
      {
         if (pack_s_FtofMCHits(xdrs,this1->in[m].ftofMCHits) < 0) {
            return -1;
         }
      }
      else
      {
         int zero=0;
         xdr_int(xdrs,&zero);
      }
   }
   FREE(this1);
   end = xdr_getpos64(xdrs);
   xdr_setpos64(xdrs,base);
   size = end-start;
   xdr_u_int(xdrs,&size);
   xdr_setpos64(xdrs,end);
   return size;
}

static int pack_s_FtofMCHits(XDR* xdrs, s_FtofMCHits_t* this1)
{
   int m=0;
   unsigned int size=0;
   off_t base,start,end;
   base = xdr_getpos64(xdrs);
   xdr_u_int(xdrs,&size);
   start = xdr_getpos64(xdrs);

   xdr_u_int(xdrs,&this1->mult);
   for (m = 0; m < this1->mult; m++)
   {
      xdr_float(xdrs,&this1->in[m].E);
      xdr_float(xdrs,&this1->in[m].dist);
      xdr_int(xdrs,&this1->in[m].itrack);
      xdr_int(xdrs,&this1->in[m].ptype);
      xdr_float(xdrs,&this1->in[m].px);
      xdr_float(xdrs,&this1->in[m].py);
      xdr_float(xdrs,&this1->in[m].pz);
      xdr_float(xdrs,&this1->in[m].x);
      xdr_float(xdrs,&this1->in[m].y);
      xdr_float(xdrs,&this1->in[m].z);
   }
   FREE(this1);
   end = xdr_getpos64(xdrs);
   xdr_setpos64(xdrs,base);
   size = end-start;
   xdr_u_int(xdrs,&size);
   xdr_setpos64(xdrs,end);
   return size;
}

static int pack_s_FtofSouthTruthHits(XDR* xdrs, s_FtofSouthTruthHits_t* this1)
{
   int m=0;
   unsigned int size=0;
   off_t base,start,end;
   base = xdr_getpos64(xdrs);
   xdr_u_int(xdrs,&size);
   start = xdr_getpos64(xdrs);

   xdr_u_int(xdrs,&this1->mult);
   for (m = 0; m < this1->mult; m++)
   {
      xdr_float(xdrs,&this1->in[m].dE);
      xdr_float(xdrs,&this1->in[m].t);
      if (this1->in[m].ftofMCHits != (s_FtofMCHits_t*)&hddm_s_nullTarget)
      {
         if (pack_s_FtofMCHits(xdrs,this1->in[m].ftofMCHits) < 0) {
            return -1;
         }
      }
      else
      {
         int zero=0;
         xdr_int(xdrs,&zero);
      }
   }
   FREE(this1);
   end = xdr_getpos64(xdrs);
   xdr_setpos64(xdrs,base);
   size = end-start;
   xdr_u_int(xdrs,&size);
   xdr_setpos64(xdrs,end);
   return size;
}

static int pack_s_FtofNorthHits(XDR* xdrs, s_FtofNorthHits_t* this1)
{
   int m=0;
   unsigned int size=0;
   off_t base,start,end;
   base = xdr_getpos64(xdrs);
   xdr_u_int(xdrs,&size);
   start = xdr_getpos64(xdrs);

   xdr_u_int(xdrs,&this1->mult);
   for (m = 0; m < this1->mult; m++)
   {
      xdr_float(xdrs,&this1->in[m].dE);
      xdr_float(xdrs,&this1->in[m].t);
   }
   FREE(this1);
   end = xdr_getpos64(xdrs);
   xdr_setpos64(xdrs,base);
   size = end-start;
   xdr_u_int(xdrs,&size);
   xdr_setpos64(xdrs,end);
   return size;
}

static int pack_s_FtofSouthHits(XDR* xdrs, s_FtofSouthHits_t* this1)
{
   int m=0;
   unsigned int size=0;
   off_t base,start,end;
   base = xdr_getpos64(xdrs);
   xdr_u_int(xdrs,&size);
   start = xdr_getpos64(xdrs);

   xdr_u_int(xdrs,&this1->mult);
   for (m = 0; m < this1->mult; m++)
   {
      xdr_float(xdrs,&this1->in[m].dE);
      xdr_float(xdrs,&this1->in[m].t);
   }
   FREE(this1);
   end = xdr_getpos64(xdrs);
   xdr_setpos64(xdrs,base);
   size = end-start;
   xdr_u_int(xdrs,&size);
   xdr_setpos64(xdrs,end);
   return size;
}

static int pack_s_FtofTruthPoints(XDR* xdrs, s_FtofTruthPoints_t* this1)
{
   int m=0;
   unsigned int size=0;
   off_t base,start,end;
   base = xdr_getpos64(xdrs);
   xdr_u_int(xdrs,&size);
   start = xdr_getpos64(xdrs);

   xdr_u_int(xdrs,&this1->mult);
   for (m = 0; m < this1->mult; m++)
   {
      xdr_float(xdrs,&this1->in[m].E);
      xdr_bool(xdrs,&this1->in[m].primary);
      xdr_int(xdrs,&this1->in[m].ptype);
      xdr_float(xdrs,&this1->in[m].px);
      xdr_float(xdrs,&this1->in[m].py);
      xdr_float(xdrs,&this1->in[m].pz);
      xdr_float(xdrs,&this1->in[m].t);
      xdr_int(xdrs,&this1->in[m].track);
      xdr_float(xdrs,&this1->in[m].x);
      xdr_float(xdrs,&this1->in[m].y);
      xdr_float(xdrs,&this1->in[m].z);
   }
   FREE(this1);
   end = xdr_getpos64(xdrs);
   xdr_setpos64(xdrs,base);
   size = end-start;
   xdr_u_int(xdrs,&size);
   xdr_setpos64(xdrs,end);
   return size;
}

static int pack_s_ForwardEMcal(XDR* xdrs, s_ForwardEMcal_t* this1)
{
   int m=0;
   unsigned int size=0;
   off_t base,start,end;
   base = xdr_getpos64(xdrs);
   xdr_u_int(xdrs,&size);
   start = xdr_getpos64(xdrs);

   {
      if (this1->fcalBlocks != (s_FcalBlocks_t*)&hddm_s_nullTarget)
      {
         if (pack_s_FcalBlocks(xdrs,this1->fcalBlocks) < 0) {
            return -1;
         }
      }
      else
      {
         int zero=0;
         xdr_int(xdrs,&zero);
      }
      if (this1->fcalTruthShowers != (s_FcalTruthShowers_t*)&hddm_s_nullTarget)
      {
         if (pack_s_FcalTruthShowers(xdrs,this1->fcalTruthShowers) < 0) {
            return -1;
         }
      }
      else
      {
         int zero=0;
         xdr_int(xdrs,&zero);
      }
   }
   FREE(this1);
   end = xdr_getpos64(xdrs);
   xdr_setpos64(xdrs,base);
   size = end-start;
   xdr_u_int(xdrs,&size);
   xdr_setpos64(xdrs,end);
   return size;
}

static int pack_s_FcalBlocks(XDR* xdrs, s_FcalBlocks_t* this1)
{
   int m=0;
   unsigned int size=0;
   off_t base,start,end;
   base = xdr_getpos64(xdrs);
   xdr_u_int(xdrs,&size);
   start = xdr_getpos64(xdrs);

   xdr_u_int(xdrs,&this1->mult);
   for (m = 0; m < this1->mult; m++)
   {
      xdr_int(xdrs,&this1->in[m].column);
      xdr_int(xdrs,&this1->in[m].row);
      if (this1->in[m].fcalHits != (s_FcalHits_t*)&hddm_s_nullTarget)
      {
         if (pack_s_FcalHits(xdrs,this1->in[m].fcalHits) < 0) {
            return -1;
         }
      }
      else
      {
         int zero=0;
         xdr_int(xdrs,&zero);
      }
      if (this1->in[m].fcalTruthHits != (s_FcalTruthHits_t*)&hddm_s_nullTarget)
      {
         if (pack_s_FcalTruthHits(xdrs,this1->in[m].fcalTruthHits) < 0) {
            return -1;
         }
      }
      else
      {
         int zero=0;
         xdr_int(xdrs,&zero);
      }
   }
   FREE(this1);
   end = xdr_getpos64(xdrs);
   xdr_setpos64(xdrs,base);
   size = end-start;
   xdr_u_int(xdrs,&size);
   xdr_setpos64(xdrs,end);
   return size;
}

static int pack_s_FcalHits(XDR* xdrs, s_FcalHits_t* this1)
{
   int m=0;
   unsigned int size=0;
   off_t base,start,end;
   base = xdr_getpos64(xdrs);
   xdr_u_int(xdrs,&size);
   start = xdr_getpos64(xdrs);

   xdr_u_int(xdrs,&this1->mult);
   for (m = 0; m < this1->mult; m++)
   {
      xdr_float(xdrs,&this1->in[m].E);
      xdr_float(xdrs,&this1->in[m].t);
   }
   FREE(this1);
   end = xdr_getpos64(xdrs);
   xdr_setpos64(xdrs,base);
   size = end-start;
   xdr_u_int(xdrs,&size);
   xdr_setpos64(xdrs,end);
   return size;
}

static int pack_s_FcalTruthHits(XDR* xdrs, s_FcalTruthHits_t* this1)
{
   int m=0;
   unsigned int size=0;
   off_t base,start,end;
   base = xdr_getpos64(xdrs);
   xdr_u_int(xdrs,&size);
   start = xdr_getpos64(xdrs);

   xdr_u_int(xdrs,&this1->mult);
   for (m = 0; m < this1->mult; m++)
   {
      xdr_float(xdrs,&this1->in[m].E);
      xdr_float(xdrs,&this1->in[m].t);
   }
   FREE(this1);
   end = xdr_getpos64(xdrs);
   xdr_setpos64(xdrs,base);
   size = end-start;
   xdr_u_int(xdrs,&size);
   xdr_setpos64(xdrs,end);
   return size;
}

static int pack_s_FcalTruthShowers(XDR* xdrs, s_FcalTruthShowers_t* this1)
{
   int m=0;
   unsigned int size=0;
   off_t base,start,end;
   base = xdr_getpos64(xdrs);
   xdr_u_int(xdrs,&size);
   start = xdr_getpos64(xdrs);

   xdr_u_int(xdrs,&this1->mult);
   for (m = 0; m < this1->mult; m++)
   {
      xdr_float(xdrs,&this1->in[m].E);
      xdr_bool(xdrs,&this1->in[m].primary);
      xdr_int(xdrs,&this1->in[m].ptype);
      xdr_float(xdrs,&this1->in[m].px);
      xdr_float(xdrs,&this1->in[m].py);
      xdr_float(xdrs,&this1->in[m].pz);
      xdr_float(xdrs,&this1->in[m].t);
      xdr_int(xdrs,&this1->in[m].track);
      xdr_float(xdrs,&this1->in[m].x);
      xdr_float(xdrs,&this1->in[m].y);
      xdr_float(xdrs,&this1->in[m].z);
   }
   FREE(this1);
   end = xdr_getpos64(xdrs);
   xdr_setpos64(xdrs,base);
   size = end-start;
   xdr_u_int(xdrs,&size);
   xdr_setpos64(xdrs,end);
   return size;
}

static int pack_s_ComptonEMcal(XDR* xdrs, s_ComptonEMcal_t* this1)
{
   int m=0;
   unsigned int size=0;
   off_t base,start,end;
   base = xdr_getpos64(xdrs);
   xdr_u_int(xdrs,&size);
   start = xdr_getpos64(xdrs);

   {
      if (this1->ccalBlocks != (s_CcalBlocks_t*)&hddm_s_nullTarget)
      {
         if (pack_s_CcalBlocks(xdrs,this1->ccalBlocks) < 0) {
            return -1;
         }
      }
      else
      {
         int zero=0;
         xdr_int(xdrs,&zero);
      }
      if (this1->ccalTruthShowers != (s_CcalTruthShowers_t*)&hddm_s_nullTarget)
      {
         if (pack_s_CcalTruthShowers(xdrs,this1->ccalTruthShowers) < 0) {
            return -1;
         }
      }
      else
      {
         int zero=0;
         xdr_int(xdrs,&zero);
      }
   }
   FREE(this1);
   end = xdr_getpos64(xdrs);
   xdr_setpos64(xdrs,base);
   size = end-start;
   xdr_u_int(xdrs,&size);
   xdr_setpos64(xdrs,end);
   return size;
}

static int pack_s_CcalBlocks(XDR* xdrs, s_CcalBlocks_t* this1)
{
   int m=0;
   unsigned int size=0;
   off_t base,start,end;
   base = xdr_getpos64(xdrs);
   xdr_u_int(xdrs,&size);
   start = xdr_getpos64(xdrs);

   xdr_u_int(xdrs,&this1->mult);
   for (m = 0; m < this1->mult; m++)
   {
      xdr_int(xdrs,&this1->in[m].column);
      xdr_int(xdrs,&this1->in[m].row);
      if (this1->in[m].ccalHits != (s_CcalHits_t*)&hddm_s_nullTarget)
      {
         if (pack_s_CcalHits(xdrs,this1->in[m].ccalHits) < 0) {
            return -1;
         }
      }
      else
      {
         int zero=0;
         xdr_int(xdrs,&zero);
      }
      if (this1->in[m].ccalTruthHits != (s_CcalTruthHits_t*)&hddm_s_nullTarget)
      {
         if (pack_s_CcalTruthHits(xdrs,this1->in[m].ccalTruthHits) < 0) {
            return -1;
         }
      }
      else
      {
         int zero=0;
         xdr_int(xdrs,&zero);
      }
   }
   FREE(this1);
   end = xdr_getpos64(xdrs);
   xdr_setpos64(xdrs,base);
   size = end-start;
   xdr_u_int(xdrs,&size);
   xdr_setpos64(xdrs,end);
   return size;
}

static int pack_s_CcalHits(XDR* xdrs, s_CcalHits_t* this1)
{
   int m=0;
   unsigned int size=0;
   off_t base,start,end;
   base = xdr_getpos64(xdrs);
   xdr_u_int(xdrs,&size);
   start = xdr_getpos64(xdrs);

   xdr_u_int(xdrs,&this1->mult);
   for (m = 0; m < this1->mult; m++)
   {
      xdr_float(xdrs,&this1->in[m].E);
      xdr_float(xdrs,&this1->in[m].t);
   }
   FREE(this1);
   end = xdr_getpos64(xdrs);
   xdr_setpos64(xdrs,base);
   size = end-start;
   xdr_u_int(xdrs,&size);
   xdr_setpos64(xdrs,end);
   return size;
}

static int pack_s_CcalTruthHits(XDR* xdrs, s_CcalTruthHits_t* this1)
{
   int m=0;
   unsigned int size=0;
   off_t base,start,end;
   base = xdr_getpos64(xdrs);
   xdr_u_int(xdrs,&size);
   start = xdr_getpos64(xdrs);

   xdr_u_int(xdrs,&this1->mult);
   for (m = 0; m < this1->mult; m++)
   {
      xdr_float(xdrs,&this1->in[m].E);
      xdr_float(xdrs,&this1->in[m].t);
   }
   FREE(this1);
   end = xdr_getpos64(xdrs);
   xdr_setpos64(xdrs,base);
   size = end-start;
   xdr_u_int(xdrs,&size);
   xdr_setpos64(xdrs,end);
   return size;
}

static int pack_s_CcalTruthShowers(XDR* xdrs, s_CcalTruthShowers_t* this1)
{
   int m=0;
   unsigned int size=0;
   off_t base,start,end;
   base = xdr_getpos64(xdrs);
   xdr_u_int(xdrs,&size);
   start = xdr_getpos64(xdrs);

   xdr_u_int(xdrs,&this1->mult);
   for (m = 0; m < this1->mult; m++)
   {
      xdr_float(xdrs,&this1->in[m].E);
      xdr_bool(xdrs,&this1->in[m].primary);
      xdr_int(xdrs,&this1->in[m].ptype);
      xdr_float(xdrs,&this1->in[m].px);
      xdr_float(xdrs,&this1->in[m].py);
      xdr_float(xdrs,&this1->in[m].pz);
      xdr_float(xdrs,&this1->in[m].t);
      xdr_int(xdrs,&this1->in[m].track);
      xdr_float(xdrs,&this1->in[m].x);
      xdr_float(xdrs,&this1->in[m].y);
      xdr_float(xdrs,&this1->in[m].z);
   }
   FREE(this1);
   end = xdr_getpos64(xdrs);
   xdr_setpos64(xdrs,base);
   size = end-start;
   xdr_u_int(xdrs,&size);
   xdr_setpos64(xdrs,end);
   return size;
}

static int pack_s_UpstreamEMveto(XDR* xdrs, s_UpstreamEMveto_t* this1)
{
   int m=0;
   unsigned int size=0;
   off_t base,start,end;
   base = xdr_getpos64(xdrs);
   xdr_u_int(xdrs,&size);
   start = xdr_getpos64(xdrs);

   {
      if (this1->upvPaddles != (s_UpvPaddles_t*)&hddm_s_nullTarget)
      {
         if (pack_s_UpvPaddles(xdrs,this1->upvPaddles) < 0) {
            return -1;
         }
      }
      else
      {
         int zero=0;
         xdr_int(xdrs,&zero);
      }
      if (this1->upvTruthShowers != (s_UpvTruthShowers_t*)&hddm_s_nullTarget)
      {
         if (pack_s_UpvTruthShowers(xdrs,this1->upvTruthShowers) < 0) {
            return -1;
         }
      }
      else
      {
         int zero=0;
         xdr_int(xdrs,&zero);
      }
   }
   FREE(this1);
   end = xdr_getpos64(xdrs);
   xdr_setpos64(xdrs,base);
   size = end-start;
   xdr_u_int(xdrs,&size);
   xdr_setpos64(xdrs,end);
   return size;
}

static int pack_s_UpvPaddles(XDR* xdrs, s_UpvPaddles_t* this1)
{
   int m=0;
   unsigned int size=0;
   off_t base,start,end;
   base = xdr_getpos64(xdrs);
   xdr_u_int(xdrs,&size);
   start = xdr_getpos64(xdrs);

   xdr_u_int(xdrs,&this1->mult);
   for (m = 0; m < this1->mult; m++)
   {
      xdr_int(xdrs,&this1->in[m].layer);
      xdr_int(xdrs,&this1->in[m].row);
      if (this1->in[m].upvLeftHits != (s_UpvLeftHits_t*)&hddm_s_nullTarget)
      {
         if (pack_s_UpvLeftHits(xdrs,this1->in[m].upvLeftHits) < 0) {
            return -1;
         }
      }
      else
      {
         int zero=0;
         xdr_int(xdrs,&zero);
      }
      if (this1->in[m].upvRightHits != (s_UpvRightHits_t*)&hddm_s_nullTarget)
      {
         if (pack_s_UpvRightHits(xdrs,this1->in[m].upvRightHits) < 0) {
            return -1;
         }
      }
      else
      {
         int zero=0;
         xdr_int(xdrs,&zero);
      }
   }
   FREE(this1);
   end = xdr_getpos64(xdrs);
   xdr_setpos64(xdrs,base);
   size = end-start;
   xdr_u_int(xdrs,&size);
   xdr_setpos64(xdrs,end);
   return size;
}

static int pack_s_UpvLeftHits(XDR* xdrs, s_UpvLeftHits_t* this1)
{
   int m=0;
   unsigned int size=0;
   off_t base,start,end;
   base = xdr_getpos64(xdrs);
   xdr_u_int(xdrs,&size);
   start = xdr_getpos64(xdrs);

   xdr_u_int(xdrs,&this1->mult);
   for (m = 0; m < this1->mult; m++)
   {
      xdr_float(xdrs,&this1->in[m].E);
      xdr_float(xdrs,&this1->in[m].t);
   }
   FREE(this1);
   end = xdr_getpos64(xdrs);
   xdr_setpos64(xdrs,base);
   size = end-start;
   xdr_u_int(xdrs,&size);
   xdr_setpos64(xdrs,end);
   return size;
}

static int pack_s_UpvRightHits(XDR* xdrs, s_UpvRightHits_t* this1)
{
   int m=0;
   unsigned int size=0;
   off_t base,start,end;
   base = xdr_getpos64(xdrs);
   xdr_u_int(xdrs,&size);
   start = xdr_getpos64(xdrs);

   xdr_u_int(xdrs,&this1->mult);
   for (m = 0; m < this1->mult; m++)
   {
      xdr_float(xdrs,&this1->in[m].E);
      xdr_float(xdrs,&this1->in[m].t);
   }
   FREE(this1);
   end = xdr_getpos64(xdrs);
   xdr_setpos64(xdrs,base);
   size = end-start;
   xdr_u_int(xdrs,&size);
   xdr_setpos64(xdrs,end);
   return size;
}

static int pack_s_UpvTruthShowers(XDR* xdrs, s_UpvTruthShowers_t* this1)
{
   int m=0;
   unsigned int size=0;
   off_t base,start,end;
   base = xdr_getpos64(xdrs);
   xdr_u_int(xdrs,&size);
   start = xdr_getpos64(xdrs);

   xdr_u_int(xdrs,&this1->mult);
   for (m = 0; m < this1->mult; m++)
   {
      xdr_float(xdrs,&this1->in[m].E);
      xdr_bool(xdrs,&this1->in[m].primary);
      xdr_int(xdrs,&this1->in[m].ptype);
      xdr_float(xdrs,&this1->in[m].px);
      xdr_float(xdrs,&this1->in[m].py);
      xdr_float(xdrs,&this1->in[m].pz);
      xdr_float(xdrs,&this1->in[m].t);
      xdr_int(xdrs,&this1->in[m].track);
      xdr_float(xdrs,&this1->in[m].x);
      xdr_float(xdrs,&this1->in[m].y);
      xdr_float(xdrs,&this1->in[m].z);
   }
   FREE(this1);
   end = xdr_getpos64(xdrs);
   xdr_setpos64(xdrs,base);
   size = end-start;
   xdr_u_int(xdrs,&size);
   xdr_setpos64(xdrs,end);
   return size;
}

static int pack_s_Tagger(XDR* xdrs, s_Tagger_t* this1)
{
   int m=0;
   unsigned int size=0;
   off_t base,start,end;
   base = xdr_getpos64(xdrs);
   xdr_u_int(xdrs,&size);
   start = xdr_getpos64(xdrs);

   {
      if (this1->microChannels != (s_MicroChannels_t*)&hddm_s_nullTarget)
      {
         if (pack_s_MicroChannels(xdrs,this1->microChannels) < 0) {
            return -1;
         }
      }
      else
      {
         int zero=0;
         xdr_int(xdrs,&zero);
      }
   }
   FREE(this1);
   end = xdr_getpos64(xdrs);
   xdr_setpos64(xdrs,base);
   size = end-start;
   xdr_u_int(xdrs,&size);
   xdr_setpos64(xdrs,end);
   return size;
}

static int pack_s_MicroChannels(XDR* xdrs, s_MicroChannels_t* this1)
{
   int m=0;
   unsigned int size=0;
   off_t base,start,end;
   base = xdr_getpos64(xdrs);
   xdr_u_int(xdrs,&size);
   start = xdr_getpos64(xdrs);

   xdr_u_int(xdrs,&this1->mult);
   for (m = 0; m < this1->mult; m++)
   {
      xdr_float(xdrs,&this1->in[m].E);
      xdr_int(xdrs,&this1->in[m].column);
      xdr_int(xdrs,&this1->in[m].row);
      if (this1->in[m].taggerHits != (s_TaggerHits_t*)&hddm_s_nullTarget)
      {
         if (pack_s_TaggerHits(xdrs,this1->in[m].taggerHits) < 0) {
            return -1;
         }
      }
      else
      {
         int zero=0;
         xdr_int(xdrs,&zero);
      }
   }
   FREE(this1);
   end = xdr_getpos64(xdrs);
   xdr_setpos64(xdrs,base);
   size = end-start;
   xdr_u_int(xdrs,&size);
   xdr_setpos64(xdrs,end);
   return size;
}

static int pack_s_TaggerHits(XDR* xdrs, s_TaggerHits_t* this1)
{
   int m=0;
   unsigned int size=0;
   off_t base,start,end;
   base = xdr_getpos64(xdrs);
   xdr_u_int(xdrs,&size);
   start = xdr_getpos64(xdrs);

   xdr_u_int(xdrs,&this1->mult);
   for (m = 0; m < this1->mult; m++)
   {
      xdr_float(xdrs,&this1->in[m].t);
   }
   FREE(this1);
   end = xdr_getpos64(xdrs);
   xdr_setpos64(xdrs,base);
   size = end-start;
   xdr_u_int(xdrs,&size);
   xdr_setpos64(xdrs,end);
   return size;
}

static int pack_s_McTrajectory(XDR* xdrs, s_McTrajectory_t* this1)
{
   int m=0;
   unsigned int size=0;
   off_t base,start,end;
   base = xdr_getpos64(xdrs);
   xdr_u_int(xdrs,&size);
   start = xdr_getpos64(xdrs);

   {
      if (this1->mcTrajectoryPoints != (s_McTrajectoryPoints_t*)&hddm_s_nullTarget)
      {
         if (pack_s_McTrajectoryPoints(xdrs,this1->mcTrajectoryPoints) < 0) {
            return -1;
         }
      }
      else
      {
         int zero=0;
         xdr_int(xdrs,&zero);
      }
   }
   FREE(this1);
   end = xdr_getpos64(xdrs);
   xdr_setpos64(xdrs,base);
   size = end-start;
   xdr_u_int(xdrs,&size);
   xdr_setpos64(xdrs,end);
   return size;
}

static int pack_s_McTrajectoryPoints(XDR* xdrs, s_McTrajectoryPoints_t* this1)
{
   int m=0;
   unsigned int size=0;
   off_t base,start,end;
   base = xdr_getpos64(xdrs);
   xdr_u_int(xdrs,&size);
   start = xdr_getpos64(xdrs);

   xdr_u_int(xdrs,&this1->mult);
   for (m = 0; m < this1->mult; m++)
   {
      xdr_float(xdrs,&this1->in[m].E);
      xdr_float(xdrs,&this1->in[m].dE);
      xdr_int(xdrs,&this1->in[m].mech);
      xdr_int(xdrs,&this1->in[m].part);
      xdr_int(xdrs,&this1->in[m].primary_track);
      xdr_float(xdrs,&this1->in[m].px);
      xdr_float(xdrs,&this1->in[m].py);
      xdr_float(xdrs,&this1->in[m].pz);
      xdr_float(xdrs,&this1->in[m].radlen);
      xdr_float(xdrs,&this1->in[m].step);
      xdr_float(xdrs,&this1->in[m].t);
      xdr_int(xdrs,&this1->in[m].track);
      xdr_float(xdrs,&this1->in[m].x);
      xdr_float(xdrs,&this1->in[m].y);
      xdr_float(xdrs,&this1->in[m].z);
   }
   FREE(this1);
   end = xdr_getpos64(xdrs);
   xdr_setpos64(xdrs,base);
   size = end-start;
   xdr_u_int(xdrs,&size);
   xdr_setpos64(xdrs,end);
   return size;
}

static int pack_s_ReconView(XDR* xdrs, s_ReconView_t* this1)
{
   int m=0;
   unsigned int size=0;
   off_t base,start,end;
   base = xdr_getpos64(xdrs);
   xdr_u_int(xdrs,&size);
   start = xdr_getpos64(xdrs);

   {
      if (this1->tracktimebaseds != (s_Tracktimebaseds_t*)&hddm_s_nullTarget)
      {
         if (pack_s_Tracktimebaseds(xdrs,this1->tracktimebaseds) < 0) {
            return -1;
         }
      }
      else
      {
         int zero=0;
         xdr_int(xdrs,&zero);
      }
   }
   FREE(this1);
   end = xdr_getpos64(xdrs);
   xdr_setpos64(xdrs,base);
   size = end-start;
   xdr_u_int(xdrs,&size);
   xdr_setpos64(xdrs,end);
   return size;
}

static int pack_s_Tracktimebaseds(XDR* xdrs, s_Tracktimebaseds_t* this1)
{
   int m=0;
   unsigned int size=0;
   off_t base,start,end;
   base = xdr_getpos64(xdrs);
   xdr_u_int(xdrs,&size);
   start = xdr_getpos64(xdrs);

   xdr_u_int(xdrs,&this1->mult);
   for (m = 0; m < this1->mult; m++)
   {
      xdr_float(xdrs,&this1->in[m].FOM);
      xdr_int(xdrs,&this1->in[m].Ndof);
      xdr_int(xdrs,&this1->in[m].candidateid);
      xdr_float(xdrs,&this1->in[m].chisq);
      xdr_int(xdrs,&this1->in[m].id);
      xdr_int(xdrs,&this1->in[m].trackid);
      if (this1->in[m].momentum != (s_Momentum_t*)&hddm_s_nullTarget)
      {
         if (pack_s_Momentum(xdrs,this1->in[m].momentum) < 0) {
            return -1;
         }
      }
      else
      {
         int zero=0;
         xdr_int(xdrs,&zero);
      }
      if (this1->in[m].properties != (s_Properties_t*)&hddm_s_nullTarget)
      {
         if (pack_s_Properties(xdrs,this1->in[m].properties) < 0) {
            return -1;
         }
      }
      else
      {
         int zero=0;
         xdr_int(xdrs,&zero);
      }
      if (this1->in[m].origin != (s_Origin_t*)&hddm_s_nullTarget)
      {
         if (pack_s_Origin(xdrs,this1->in[m].origin) < 0) {
            return -1;
         }
      }
      else
      {
         int zero=0;
         xdr_int(xdrs,&zero);
      }
      if (this1->in[m].errorMatrix != (s_ErrorMatrix_t*)&hddm_s_nullTarget)
      {
         if (pack_s_ErrorMatrix(xdrs,this1->in[m].errorMatrix) < 0) {
            return -1;
         }
      }
      else
      {
         int zero=0;
         xdr_int(xdrs,&zero);
      }
      if (this1->in[m].TrackingErrorMatrix != (s_TrackingErrorMatrix_t*)&hddm_s_nullTarget)
      {
         if (pack_s_TrackingErrorMatrix(xdrs,this1->in[m].TrackingErrorMatrix) < 0) {
            return -1;
         }
      }
      else
      {
         int zero=0;
         xdr_int(xdrs,&zero);
      }
   }
   FREE(this1);
   end = xdr_getpos64(xdrs);
   xdr_setpos64(xdrs,base);
   size = end-start;
   xdr_u_int(xdrs,&size);
   xdr_setpos64(xdrs,end);
   return size;
}

static int pack_s_ErrorMatrix(XDR* xdrs, s_ErrorMatrix_t* this1)
{
   int m=0;
   unsigned int size=0;
   off_t base,start,end;
   base = xdr_getpos64(xdrs);
   xdr_u_int(xdrs,&size);
   start = xdr_getpos64(xdrs);

   {
      xdr_int(xdrs,&this1->Ncols);
      xdr_int(xdrs,&this1->Nrows);
      xdr_string(xdrs,&this1->type, 1000000);
      FREE(this1->type);
      xdr_string(xdrs,&this1->vals, 1000000);
      FREE(this1->vals);
   }
   FREE(this1);
   end = xdr_getpos64(xdrs);
   xdr_setpos64(xdrs,base);
   size = end-start;
   xdr_u_int(xdrs,&size);
   xdr_setpos64(xdrs,end);
   return size;
}

static int pack_s_TrackingErrorMatrix(XDR* xdrs, s_TrackingErrorMatrix_t* this1)
{
   int m=0;
   unsigned int size=0;
   off_t base,start,end;
   base = xdr_getpos64(xdrs);
   xdr_u_int(xdrs,&size);
   start = xdr_getpos64(xdrs);

   {
      xdr_int(xdrs,&this1->Ncols);
      xdr_int(xdrs,&this1->Nrows);
      xdr_string(xdrs,&this1->type, 1000000);
      FREE(this1->type);
      xdr_string(xdrs,&this1->vals, 1000000);
      FREE(this1->vals);
   }
   FREE(this1);
   end = xdr_getpos64(xdrs);
   xdr_setpos64(xdrs,base);
   size = end-start;
   xdr_u_int(xdrs,&size);
   xdr_setpos64(xdrs,end);
   return size;
}

int flush_s_HDDM(s_HDDM_t* this1,s_iostream_t* fp)
{
   if (this1 == 0)
   {
      return 0;
   }
   else if (fp == 0)
   {
      XDR* xdrs = (XDR*)malloc(sizeof(XDR));
      int max_buffer_size = 1000000;
      char* dump = (char*)malloc(max_buffer_size);
      xdrmem_create(xdrs,dump,max_buffer_size,XDR_ENCODE);
      pack_s_HDDM(xdrs,this1);
      xdr_destroy(xdrs);
      free(xdrs);
      free(dump);
   }
   else if (fp->iomode == HDDM_STREAM_OUTPUT)
   {
      if (pack_s_HDDM(fp->xdrs,this1) < 0) {
         fp->lerrno = errno;
         return -1;
      }
   }
   return 0;
}

static int getTag(char* d, char* tag)
{
   int level;
   char* token;
   char line[500];
   strncpy(line,d,500);
   line[499] = 0;
   level = index(line,'<')-line;
   if (level < 500 &&
      (token = strtok(line+level+1," >")))
   {
      strncpy(tag,token,500);
      return level/2;
   }
   return -1;
}

static char* getEndTag(char* d, char* tag)
{
   char line[500];
   char endTag[510];
   strncpy(line,d,500);
   line[499] = 0;
   if (strstr(strtok(line,"\n"),"/>") == 0)
   {
      sprintf(endTag,"</%s>",tag);
   }
   else
   {
      strcpy(endTag,"/>");
   }
   return strstr(d,endTag);
}

static void collide(char* b, char* c)
{
   char btag[500];
   getTag(b,btag);
   b = index(b,'<');
   c = index(c,'<');
   *(index(b,'\n')) = 0;
   *(index(c,'\n')) = 0;
   fprintf(stderr,"HDDM warning: ");
   fprintf(stderr,"tag %s in input file ", btag);
   fprintf(stderr,"does not match c header hddm_s.h\n");
   fprintf(stderr,"  input file: %s\n", b);
   fprintf(stderr,"  c header: %s\n", c);
   fprintf(stderr,"  === Tag %s will be ignored,", btag);
   fprintf(stderr," rebuild to cure the problem ===\n");
   *(index(b,0)) = '\n';
   *(index(c,0)) = '\n';
}

static popNode* matches(char* b, char* c)
{
   char btag[500];
   char ctag[500];
   int blevel, clevel;
   int ptrSeqNo = 0;
   blevel = getTag(b,btag);
   while ((clevel = getTag(c,ctag)) == blevel)
   {
      if ((clevel == blevel) && (strcmp(ctag,btag) == 0))
      {
         popNode* this1 = (popNode*)malloc(sizeof(popNode));
         int len = index(c+1,'\n') - c;
         if (strncmp(c,b,len) != 0)
         {
            collide(b,c);
            return 0;
         }
         else if (strcmp(btag,"HDDM") == 0)
         {
            this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_HDDM;
         }
         else if (strcmp(btag,"physicsEvent") == 0)
         {
            this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_PhysicsEvents;
         }
         else if (strcmp(btag,"reaction") == 0)
         {
            this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_Reactions;
         }
         else if (strcmp(btag,"beam") == 0)
         {
            this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_Beam;
         }
         else if (strcmp(btag,"momentum") == 0)
         {
            this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_Momentum;
         }
         else if (strcmp(btag,"properties") == 0)
         {
            this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_Properties;
         }
         else if (strcmp(btag,"target") == 0)
         {
            this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_Target;
         }
         else if (strcmp(btag,"vertex") == 0)
         {
            this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_Vertices;
         }
         else if (strcmp(btag,"product") == 0)
         {
            this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_Products;
         }
         else if (strcmp(btag,"origin") == 0)
         {
            this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_Origin;
         }
         else if (strcmp(btag,"random") == 0)
         {
            this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_Random;
         }
         else if (strcmp(btag,"hitView") == 0)
         {
            this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_HitView;
         }
         else if (strcmp(btag,"centralDC") == 0)
         {
            this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_CentralDC;
         }
         else if (strcmp(btag,"cdcStraw") == 0)
         {
            this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_CdcStraws;
         }
         else if (strcmp(btag,"cdcStrawHit") == 0)
         {
            this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_CdcStrawHits;
         }
         else if (strcmp(btag,"cdcStrawTruthHit") == 0)
         {
            this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_CdcStrawTruthHits;
         }
         else if (strcmp(btag,"cdcTruthPoint") == 0)
         {
            this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_CdcTruthPoints;
         }
         else if (strcmp(btag,"forwardDC") == 0)
         {
            this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_ForwardDC;
         }
         else if (strcmp(btag,"fdcChamber") == 0)
         {
            this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_FdcChambers;
         }
         else if (strcmp(btag,"fdcAnodeWire") == 0)
         {
            this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_FdcAnodeWires;
         }
         else if (strcmp(btag,"fdcAnodeHit") == 0)
         {
            this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_FdcAnodeHits;
         }
         else if (strcmp(btag,"fdcAnodeTruthHit") == 0)
         {
            this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_FdcAnodeTruthHits;
         }
         else if (strcmp(btag,"fdcCathodeStrip") == 0)
         {
            this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_FdcCathodeStrips;
         }
         else if (strcmp(btag,"fdcCathodeHit") == 0)
         {
            this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_FdcCathodeHits;
         }
         else if (strcmp(btag,"fdcCathodeTruthHit") == 0)
         {
            this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_FdcCathodeTruthHits;
         }
         else if (strcmp(btag,"fdcTruthPoint") == 0)
         {
            this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_FdcTruthPoints;
         }
         else if (strcmp(btag,"startCntr") == 0)
         {
            this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_StartCntr;
         }
         else if (strcmp(btag,"stcPaddle") == 0)
         {
            this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_StcPaddles;
         }
         else if (strcmp(btag,"stcHit") == 0)
         {
            this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_StcHits;
         }
         else if (strcmp(btag,"stcTruthHit") == 0)
         {
            this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_StcTruthHits;
         }
         else if (strcmp(btag,"stcTruthPoint") == 0)
         {
            this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_StcTruthPoints;
         }
         else if (strcmp(btag,"barrelEMcal") == 0)
         {
            this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_BarrelEMcal;
         }
         else if (strcmp(btag,"bcalCell") == 0)
         {
            this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_BcalCells;
         }
         else if (strcmp(btag,"bcalSiPMUpHit") == 0)
         {
            this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_BcalSiPMUpHits;
         }
         else if (strcmp(btag,"bcalSiPMDownHit") == 0)
         {
            this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_BcalSiPMDownHits;
         }
         else if (strcmp(btag,"bcalHit") == 0)
         {
            this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_BcalHits;
         }
         else if (strcmp(btag,"bcalIncidentParticle") == 0)
         {
            this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_BcalIncidentParticles;
         }
         else if (strcmp(btag,"bcalSiPMSpectrum") == 0)
         {
            this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_BcalSiPMSpectrums;
         }
         else if (strcmp(btag,"bcalfADCCell") == 0)
         {
            this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_BcalfADCCells;
         }
         else if (strcmp(btag,"bcalfADCUpHit") == 0)
         {
            this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_BcalfADCUpHits;
         }
         else if (strcmp(btag,"bcalfADCDownHit") == 0)
         {
            this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_BcalfADCDownHits;
         }
         else if (strcmp(btag,"bcalTDCHit") == 0)
         {
            this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_BcalTDCHits;
         }
         else if (strcmp(btag,"bcalTruthShower") == 0)
         {
            this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_BcalTruthShowers;
         }
         else if (strcmp(btag,"gapEMcal") == 0)
         {
            this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_GapEMcal;
         }
         else if (strcmp(btag,"gcalCell") == 0)
         {
            this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_GcalCells;
         }
         else if (strcmp(btag,"gcalHit") == 0)
         {
            this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_GcalHits;
         }
         else if (strcmp(btag,"gcalTruthShower") == 0)
         {
            this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_GcalTruthShowers;
         }
         else if (strcmp(btag,"Cerenkov") == 0)
         {
            this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_Cerenkov;
         }
         else if (strcmp(btag,"cereSection") == 0)
         {
            this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_CereSections;
         }
         else if (strcmp(btag,"cereHit") == 0)
         {
            this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_CereHits;
         }
         else if (strcmp(btag,"cereRichHit") == 0)
         {
            this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_CereRichHits;
         }
         else if (strcmp(btag,"cereTruthPoint") == 0)
         {
            this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_CereTruthPoints;
         }
         else if (strcmp(btag,"forwardTOF") == 0)
         {
            this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_ForwardTOF;
         }
         else if (strcmp(btag,"ftofCounter") == 0)
         {
            this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_FtofCounters;
         }
         else if (strcmp(btag,"ftofNorthTruthHit") == 0)
         {
            this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_FtofNorthTruthHits;
         }
         else if (strcmp(btag,"ftofMCHit") == 0)
         {
            this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_FtofMCHits;
         }
         else if (strcmp(btag,"ftofSouthTruthHit") == 0)
         {
            this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_FtofSouthTruthHits;
         }
         else if (strcmp(btag,"ftofNorthHit") == 0)
         {
            this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_FtofNorthHits;
         }
         else if (strcmp(btag,"ftofSouthHit") == 0)
         {
            this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_FtofSouthHits;
         }
         else if (strcmp(btag,"ftofTruthPoint") == 0)
         {
            this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_FtofTruthPoints;
         }
         else if (strcmp(btag,"forwardEMcal") == 0)
         {
            this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_ForwardEMcal;
         }
         else if (strcmp(btag,"fcalBlock") == 0)
         {
            this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_FcalBlocks;
         }
         else if (strcmp(btag,"fcalHit") == 0)
         {
            this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_FcalHits;
         }
         else if (strcmp(btag,"fcalTruthHit") == 0)
         {
            this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_FcalTruthHits;
         }
         else if (strcmp(btag,"fcalTruthShower") == 0)
         {
            this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_FcalTruthShowers;
         }
         else if (strcmp(btag,"ComptonEMcal") == 0)
         {
            this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_ComptonEMcal;
         }
         else if (strcmp(btag,"ccalBlock") == 0)
         {
            this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_CcalBlocks;
         }
         else if (strcmp(btag,"ccalHit") == 0)
         {
            this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_CcalHits;
         }
         else if (strcmp(btag,"ccalTruthHit") == 0)
         {
            this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_CcalTruthHits;
         }
         else if (strcmp(btag,"ccalTruthShower") == 0)
         {
            this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_CcalTruthShowers;
         }
         else if (strcmp(btag,"upstreamEMveto") == 0)
         {
            this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_UpstreamEMveto;
         }
         else if (strcmp(btag,"upvPaddle") == 0)
         {
            this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_UpvPaddles;
         }
         else if (strcmp(btag,"upvLeftHit") == 0)
         {
            this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_UpvLeftHits;
         }
         else if (strcmp(btag,"upvRightHit") == 0)
         {
            this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_UpvRightHits;
         }
         else if (strcmp(btag,"upvTruthShower") == 0)
         {
            this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_UpvTruthShowers;
         }
         else if (strcmp(btag,"tagger") == 0)
         {
            this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_Tagger;
         }
         else if (strcmp(btag,"microChannel") == 0)
         {
            this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_MicroChannels;
         }
         else if (strcmp(btag,"taggerHit") == 0)
         {
            this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_TaggerHits;
         }
         else if (strcmp(btag,"mcTrajectory") == 0)
         {
            this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_McTrajectory;
         }
         else if (strcmp(btag,"mcTrajectoryPoint") == 0)
         {
            this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_McTrajectoryPoints;
         }
         else if (strcmp(btag,"reconView") == 0)
         {
            this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_ReconView;
         }
         else if (strcmp(btag,"tracktimebased") == 0)
         {
            this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_Tracktimebaseds;
         }
         else if (strcmp(btag,"errorMatrix") == 0)
         {
            this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_ErrorMatrix;
         }
         else if (strcmp(btag,"TrackingErrorMatrix") == 0)
         {
            this1->unpacker = (void*(*)(XDR*,popNode*))unpack_s_TrackingErrorMatrix;
         }
         this1->inParent = ptrSeqNo;
         this1->popListLength = 0;
         c = index(c+1,'\n');
         b = index(b+1,'\n');
         while (getTag(b,btag) > blevel)
         {
            this1->popList[this1->popListLength++] = matches(b,c);
            if (this1->popListLength > 99)
            {
               fprintf(stderr,"hddm error - popList overflow.\n");
               fprintf(stderr,"Increase MAX_POPLIST_LENGTH and recompile.\n");
               exit(9);
            }
            b = getEndTag(b,btag);
            b = index(b+1,'\n');
         }
         return this1;
      }
      else
      {
         c = getEndTag(c,ctag);
         c = index(c+1,'\n');
         ++ptrSeqNo;
      }
   }
   return 0;
}

s_iostream_t* open_s_HDDM(char* filename)
{
   s_iostream_t* fp = (s_iostream_t*)malloc(sizeof(s_iostream_t));
   char* p;
   char* head;
   char* nullfilename="";
   if (filename)
   {
      fp->fd = fopen(filename,"r");
   }
   else
   {
      fp->fd = fdopen(0,"r");
      filename = nullfilename;
   }
   if (fp->fd == 0)
   {
      free(fp);
      return 0;
   }
   fp->iomode = HDDM_STREAM_INPUT;
   head = (char*)malloc(1000000);
   *head = 0;
   for (p = head;
        strstr(head,"</HDDM>") == 0;
        p += strlen(p))
   {
      if (p-head < 999000)
      {
         fgets(p,1000,fp->fd);
      }
      else
      {
         break;
      }
   }
   fp->popTop = matches(head,HDDM_s_DocumentString);
   free(head);
   if (fp->popTop == 0 || fp->popTop->popListLength == 0)
   {
      fprintf(stderr,"HDDM Error: ");
      fprintf(stderr,"input template model ");
      fprintf(stderr,"does not match c header.");
      fprintf(stderr,"  Please recompile.\n");
      exit(9);
   }
   fp->filename = (char*)malloc(strlen(filename) + 1);
   strcpy(fp->filename,filename);
   fp->xdrs = (XDR*)malloc(sizeof(XDR));
   xdrstdio_create(fp->xdrs,fp->fd,XDR_DECODE);
   return fp;
}

s_iostream_t* init_s_HDDM(char* filename)
{
   int len;
   char* head;
   char* nullfilename="";
   s_iostream_t* fp = (s_iostream_t*)malloc(sizeof(s_iostream_t));
   if (filename)
   {
      fp->fd = fopen(filename,"w");
   }
   else
   {
      fp->fd = fdopen(1,"w");
      filename = nullfilename;
   }
   if (fp->fd == 0)
   {
      free(fp);
      return 0;
   }
   fp->iomode = HDDM_STREAM_OUTPUT;
   len = strlen(HDDM_s_DocumentString);
   head = (char*)malloc(len+1);
   strcpy(head,HDDM_s_DocumentString);
   if (fwrite(head,1,len,fp->fd) != len)
   {
      fprintf(stderr,"HDDM Error: ");
      fprintf(stderr,"error writing to ");
      fprintf(stderr,"output file %s\n",filename);
      exit(9);
   }
   fp->filename = (char*)malloc(strlen(filename) + 1);
   strcpy(fp->filename,filename);
   fp->popTop = 0;
   fp->xdrs = (XDR*)malloc(sizeof(XDR));
   xdrstdio_create(fp->xdrs,fp->fd,XDR_ENCODE);
   free(head);
   return fp;
}

static void popaway(popNode* p)
{
   if (p)
   {
      int n;
      for (n = 0; n < p->popListLength; n++)
      {
         popaway(p->popList[n]);
      }
      free(p);
   }
}

void close_s_HDDM(s_iostream_t* fp)
{
   xdr_destroy(fp->xdrs);
   free(fp->xdrs);
   fclose(fp->fd);
   free(fp->filename);
   popaway(fp->popTop);
   free(fp);
}