*CD AvailNuclei                     
#ifndef  __AvailNuclei_LOADED
#define  __AvailNuclei_LOADED
typedef struct {
int availnuclei;
int              ID;
int              Material;
int              Z;
int              A;
float            PathLength;
float            NucleiDensity;
float            SumNuclei;
float            Sigma;
float            AZWgt;
float            SumWgt;
int _9999;
} AVAILNUCLEI_DEF;
#ifdef __TAP_CREOBJ__
AVAILNUCLEI_DEF AvailNuclei;
#else
extern AVAILNUCLEI_DEF AvailNuclei;
#endif
#endif

*CD BeamSystem                      
#ifndef  __BeamSystem_LOADED
#define  __BeamSystem_LOADED
typedef struct {
int beamsystem;
int              ID;
float            X0;
float            Y0;
float            Z0;
float            dXdZ;
float            dYdZ;
int              KineMethod;
int              FluxMethod;
float            Emin;
float            Emax;
char             FluxFile[64];
int _9999;
} BEAMSYSTEM_DEF;
#ifdef __TAP_CREOBJ__
BEAMSYSTEM_DEF BeamSystem;
#else
extern BEAMSYSTEM_DEF BeamSystem;
#endif
#endif

*CD CellPos                         
#ifndef  __CellPos_LOADED
#define  __CellPos_LOADED
typedef struct {
int cellpos;
int              ID;
char             PlnName[4];
int              IStrip;
int              IExtr;
int              ICell;
float            XYZReadout[3];
float            XYZCenter[3];
float            XYZFarend[3];
float            FiberTailA;
float            FiberTailB;
float            ClearFiberA;
float            ClearFiberB;
int _9999;
} CELLPOS_DEF;
#ifdef __TAP_CREOBJ__
CELLPOS_DEF CellPos;
#else
extern CELLPOS_DEF CellPos;
#endif
#endif

*CD CoilTube                        
#ifndef  __CoilTube_LOADED
#define  __CoilTube_LOADED
typedef struct {
int coiltube;
int              ID;
int              ISuper;
char             Name[4];
int              ICopy;
int              ITreeDepth;
float            XYZ1[3];
float            XYZ2[3];
float            OuterRadius;
float            InnerRadius;
char             ShapeName[4];
int              IRotm;
char             TMedium[4];
float            Zmin;
float            Zmax;
int _9999;
} COILTUBE_DEF;
#ifdef __TAP_CREOBJ__
COILTUBE_DEF CoilTube;
#else
extern COILTUBE_DEF CoilTube;
#endif
#endif

*CD DigitPln                        
#ifndef  __DigitPln_LOADED
#define  __DigitPln_LOADED
typedef struct {
int digitpln;
int              ID;
int              IPln;
int              NDigitPln;
int _9999;
} DIGITPLN_DEF;
#ifdef __TAP_CREOBJ__
DIGITPLN_DEF DigitPln;
#else
extern DIGITPLN_DEF DigitPln;
#endif
#endif

*CD EmuDigit                        
#ifndef  __EmuDigit_LOADED
#define  __EmuDigit_LOADED
typedef struct {
int emudigit;
int              ID;
int              IPln;
int              ISheet;
int              ILayer;
float            XCenter;
float            YCenter;
float            ZCenter;
float            GrainSize;
int              CellPos;
int              PlanePos;
int _9999;
} EMUDIGIT_DEF;
#ifdef __TAP_CREOBJ__
EMUDIGIT_DEF EmuDigit;
#else
extern EMUDIGIT_DEF EmuDigit;
#endif
#endif

*CD EmuHit                          
#ifndef  __EmuHit_LOADED
#define  __EmuHit_LOADED
typedef struct {
int emuhit;
int              ID;
int              IPln;
int              ISheet;
int              ILayer;
int              ITrack;
float            TOFG;
float            XBegin;
float            YBegin;
float            ZBegin;
float            XEnd;
float            YEnd;
float            ZEnd;
float            ELoss;
float            Ptot;
int              IPDG;
int              CellPos;
int              PlanePos;
int _9999;
} EMUHIT_DEF;
#ifdef __TAP_CREOBJ__
EMUHIT_DEF EmuHit;
#else
extern EMUHIT_DEF EmuHit;
#endif
#endif

*CD EventHistory                    
#ifndef  __EventHistory_LOADED
#define  __EventHistory_LOADED
typedef struct {
int eventhistory;
int              ID;
char             TableName[32];
int              EntryNumber;
char             Routine[32];
char             VersionString[8];
char             DateFilled[16];
int _9999;
} EVENTHISTORY_DEF;
#ifdef __TAP_CREOBJ__
EVENTHISTORY_DEF EventHistory;
#else
extern EVENTHISTORY_DEF EventHistory;
#endif
#endif

*CD FLSDigiCell                     
#ifndef  __FLSDigiCell_LOADED
#define  __FLSDigiCell_LOADED
typedef struct {
int flsdigicell;
int              ID;
int              IPln;
int              IExtr;
int              ICell;
int              IView;
float            XYZBase[3];
float            XYZDir[3];
float            TPos;
float            CPos;
float            CellLength;
float            DirScale;
float            XPhysicalA;
float            XPhysicalB;
float            XFiberA;
float            XFiberB;
float            ClrTransmitA;
float            ClrTransmitB;
float            RawAdcA;
float            RawAdcB;
float            CorrAdcA;
float            CorrAdcB;
float            CorrAdcSum;
int              IsMuon;
int _9999;
} FLSDIGICELL_DEF;
#ifdef __TAP_CREOBJ__
FLSDIGICELL_DEF FLSDigiCell;
#else
extern FLSDIGICELL_DEF FLSDigiCell;
#endif
#endif

*CD FLSDigiPln                      
#ifndef  __FLSDigiPln_LOADED
#define  __FLSDigiPln_LOADED
typedef struct {
int flsdigipln;
int              ID;
int              IPln;
char             Rotm[4];
int              NCells;
float            XYZBase[3];
float            XYZDir[3];
float            DirScale;
float            SumRawAdc;
float            SumCorrAdc;
int _9999;
} FLSDIGIPLN_DEF;
#ifdef __TAP_CREOBJ__
FLSDIGIPLN_DEF FLSDigiPln;
#else
extern FLSDIGIPLN_DEF FLSDigiPln;
#endif
#endif

*CD FLSDigiView                     
#ifndef  __FLSDigiView_LOADED
#define  __FLSDigiView_LOADED
typedef struct {
int flsdigiview;
int              ID;
char             Rotm[4];
int              NPlns;
int              NCells;
float            XYZBase[3];
float            XYZDir[3];
float            DirScale;
float            SumRawAdc;
float            SumOldAdc;
float            SumCorrAdc;
int _9999;
} FLSDIGIVIEW_DEF;
#ifdef __TAP_CREOBJ__
FLSDIGIVIEW_DEF FLSDigiView;
#else
extern FLSDIGIVIEW_DEF FLSDigiView;
#endif
#endif

*CD FLSDigit                        
#ifndef  __FLSDigit_LOADED
#define  __FLSDigit_LOADED
typedef struct {
int flsdigit;
int              ID;
int              IPln;
int              IExtr;
int              ICell;
float            TPos;
float            RawA;
float            RawB;
float            CorrA;
float            CorrB;
float            CorrSum;
float            TDCA;
float            TDCB;
int              TubePixelA;
int              TubePixelB;
float            SignalPEA;
float            SignalPEB;
float            InitialTDCA;
float            InitialTDCB;
float            SumETrue;
float            AveDistTrueA;
float            AveDistTrueB;
int              HitBits;
int              CellPos;
int              PlanePos;
int _9999;
} FLSDIGIT_DEF;
#ifdef __TAP_CREOBJ__
FLSDIGIT_DEF FLSDigit;
#else
extern FLSDIGIT_DEF FLSDigit;
#endif
#endif

*CD FLSHit                          
#ifndef  __FLSHit_LOADED
#define  __FLSHit_LOADED
typedef struct {
int flshit;
int              ID;
int              IPackedPEC;
int              ITrack;
float            TOFG;
float            XBegin;
float            YBegin;
float            ZBegin;
float            XEnd;
float            YEnd;
float            ZEnd;
float            ELoss;
float            Ptot;
int              IPDG;
int              CellPos;
int              PlanePos;
int _9999;
} FLSHIT_DEF;
#ifdef __TAP_CREOBJ__
FLSHIT_DEF FLSHit;
#else
extern FLSHIT_DEF FLSHit;
#endif
#endif

*CD FLSParam                        
#ifndef  __FLSParam_LOADED
#define  __FLSParam_LOADED
typedef struct {
int flsparam;
int              ID;
char             Name[32];
char             Type[4];
float            Value;
int              IUsageSet;
int _9999;
} FLSPARAM_DEF;
#ifdef __TAP_CREOBJ__
FLSPARAM_DEF FLSParam;
#else
extern FLSPARAM_DEF FLSParam;
#endif
#endif

*CD FluxWgt                         
#ifndef  __FluxWgt_LOADED
#define  __FluxWgt_LOADED
typedef struct {
int fluxwgt;
int              ID;
char             Beam[32];
int              Version;
float            Weight;
float            WeightErr;
int _9999;
} FLUXWGT_DEF;
#ifdef __TAP_CREOBJ__
FLUXWGT_DEF FluxWgt;
#else
extern FLUXWGT_DEF FluxWgt;
#endif
#endif

*CD GAFKey                          
#ifndef  __GAFKey_LOADED
#define  __GAFKey_LOADED
typedef struct {
int gafkey;
int              ID;
char             Type[4];
int              Version;
int              RunNo;
int              EventNo;
char             Name[32];
int _9999;
} GAFKEY_DEF;
#ifdef __TAP_CREOBJ__
GAFKEY_DEF GAFKey;
#else
extern GAFKEY_DEF GAFKey;
#endif
#endif

*CD GeomMisc                        
#ifndef  __GeomMisc_LOADED
#define  __GeomMisc_LOADED
typedef struct {
int geommisc;
int              ID;
int              NearFar;
int              NSupmdl;
int              NPlanes;
float            VMARS[3];
float            VHall[3];
float            LINRThick;
float            HallXmin;
float            HallXmax;
float            HallYmin;
float            HallYmax;
float            HallZmin;
float            HallZmax;
int _9999;
} GEOMMISC_DEF;
#ifdef __TAP_CREOBJ__
GEOMMISC_DEF GeomMisc;
#else
extern GEOMMISC_DEF GeomMisc;
#endif
#endif

*CD HitPln                          
#ifndef  __HitPln_LOADED
#define  __HitPln_LOADED
typedef struct {
int hitpln;
int              ID;
int              IPln;
int              NHitPln;
int _9999;
} HITPLN_DEF;
#ifdef __TAP_CREOBJ__
HITPLN_DEF HitPln;
#else
extern HITPLN_DEF HitPln;
#endif
#endif

*CD LSTHit                          
#ifndef  __LSTHit_LOADED
#define  __LSTHit_LOADED
typedef struct {
int lsthit;
int              ID;
int              IPln;
int              IExtr;
int              ICell;
int              ITrack;
float            TOFG;
float            XBegin;
float            YBegin;
float            ZBegin;
float            XEnd;
float            YEnd;
float            ZEnd;
float            ELoss;
float            Ptot;
int              IPDG;
int              CellPos;
int              PlanePos;
int _9999;
} LSTHIT_DEF;
#ifdef __TAP_CREOBJ__
LSTHIT_DEF LSTHit;
#else
extern LSTHIT_DEF LSTHit;
#endif
#endif

*CD LSTProto                        
#ifndef  __LSTProto_LOADED
#define  __LSTProto_LOADED
typedef struct {
int lstproto;
int              ID;
int              IPln;
int              IExtr;
int              ICell;
int              ITrack;
float            XGlobal;
float            YGlobal;
float            ZGlobal;
float            TOFG;
float            Charge;
float            XLocal;
int _9999;
} LSTPROTO_DEF;
#ifdef __TAP_CREOBJ__
LSTPROTO_DEF LSTProto;
#else
extern LSTPROTO_DEF LSTProto;
#endif
#endif

*CD LSTStrip                        
#ifndef  __LSTStrip_LOADED
#define  __LSTStrip_LOADED
typedef struct {
int lststrip;
int              ID;
int              IPln;
int              IStrip;
float            CPos;
float            Charge;
int _9999;
} LSTSTRIP_DEF;
#ifdef __TAP_CREOBJ__
LSTSTRIP_DEF LSTStrip;
#else
extern LSTSTRIP_DEF LSTStrip;
#endif
#endif

*CD LSTWire                         
#ifndef  __LSTWire_LOADED
#define  __LSTWire_LOADED
typedef struct {
int lstwire;
int              ID;
int              IPln;
int              IChan;
float            TPos;
float            Charge;
int _9999;
} LSTWIRE_DEF;
#ifdef __TAP_CREOBJ__
LSTWIRE_DEF LSTWire;
#else
extern LSTWIRE_DEF LSTWire;
#endif
#endif

*CD MassDistrib                     
#ifndef  __MassDistrib_LOADED
#define  __MassDistrib_LOADED
typedef struct {
int massdistrib;
int              ID;
int              Material;
float            SBegin;
float            SEnd;
float            PathSumMat;
char             Type[4];
int _9999;
} MASSDISTRIB_DEF;
#ifdef __TAP_CREOBJ__
MASSDISTRIB_DEF MassDistrib;
#else
extern MASSDISTRIB_DEF MassDistrib;
#endif
#endif

*CD Material                        
#ifndef  __Material_LOADED
#define  __Material_LOADED
typedef struct {
int material;
int              ID;
char             Name[32];
float            A;
float            Z;
float            Density;
float            RadLen;
float            AbsLen;
int              NMix;
int _9999;
} MATERIAL_DEF;
#ifdef __TAP_CREOBJ__
MATERIAL_DEF Material;
#else
extern MATERIAL_DEF Material;
#endif
#endif

*CD MdlOrg                          
#ifndef  __MdlOrg_LOADED
#define  __MdlOrg_LOADED
typedef struct {
int mdlorg;
int              ID;
int              ISup;
int              InMdl;
char             PasvType[4];
char             ActvType[4];
char             ActvRotm[4];
int _9999;
} MDLORG_DEF;
#ifdef __TAP_CREOBJ__
MDLORG_DEF MdlOrg;
#else
extern MDLORG_DEF MdlOrg;
#endif
#endif

*CD Mixture                         
#ifndef  __Mixture_LOADED
#define  __Mixture_LOADED
typedef struct {
int mixture;
int              ID;
int              Material;
int              IElement;
float            A;
float            Z;
float            Fraction;
int _9999;
} MIXTURE_DEF;
#ifdef __TAP_CREOBJ__
MIXTURE_DEF Mixture;
#else
extern MIXTURE_DEF Mixture;
#endif
#endif

*CD MuonTrkHeader                   
#ifndef  __MuonTrkHeader_LOADED
#define  __MuonTrkHeader_LOADED
typedef struct {
int muontrkheader;
int              ID;
int              NPoints;
char             Routine[64];
int _9999;
} MUONTRKHEADER_DEF;
#ifdef __TAP_CREOBJ__
MUONTRKHEADER_DEF MuonTrkHeader;
#else
extern MUONTRKHEADER_DEF MuonTrkHeader;
#endif
#endif

*CD MuonTrkPoint                    
#ifndef  __MuonTrkPoint_LOADED
#define  __MuonTrkPoint_LOADED
typedef struct {
int muontrkpoint;
int              ID;
int              Index;
float            X;
float            Y;
float            Z;
float            Weight;
float            transv;
char             Rotm[4];
int _9999;
} MUONTRKPOINT_DEF;
#ifdef __TAP_CREOBJ__
MUONTRKPOINT_DEF MuonTrkPoint;
#else
extern MUONTRKPOINT_DEF MuonTrkPoint;
#endif
#endif

*CD NeuKin                          
#ifndef  __NeuKin_LOADED
#define  __NeuKin_LOADED
typedef struct {
int neukin;
int              ID;
int              INu;
int              INuNoOsc;
int              ITg;
int              IBoson;
int              IResonance;
int              IAction;
float            A;
float            Z;
float            Sigma;
float            P4Neu[4];
float            P4NeuNoOsc[4];
float            P4Tgt[4];
float            X;
float            Y;
float            Q2;
float            W2;
float            P4Shw[4];
float            P4Mu1[4];
float            P4Mu2[4];
float            EMFrac;
float            P4El1[4];
float            P4El2[4];
float            P4Tau[4];
int _9999;
} NEUKIN_DEF;
#ifdef __TAP_CREOBJ__
NEUKIN_DEF NeuKin;
#else
extern NEUKIN_DEF NeuKin;
#endif
#endif

*CD NeuVtx                          
#ifndef  __NeuVtx_LOADED
#define  __NeuVtx_LOADED
typedef struct {
int neuvtx;
int              ID;
float            X;
float            Y;
float            Z;
int _9999;
} NEUVTX_DEF;
#ifdef __TAP_CREOBJ__
NEUVTX_DEF NeuVtx;
#else
extern NEUVTX_DEF NeuVtx;
#endif
#endif

*CD PEArrival                       
#ifndef  __PEArrival_LOADED
#define  __PEArrival_LOADED
typedef struct {
int pearrival;
int              ID;
int              IPln;
int              IStrip;
int              IAB;
int              IEvent;
int              TubePixel;
float            Time;
float            Response;
int              FLSDigit1;
int              FLSDigit2;
int              FLSHit;
int _9999;
} PEARRIVAL_DEF;
#ifdef __TAP_CREOBJ__
PEARRIVAL_DEF PEArrival;
#else
extern PEARRIVAL_DEF PEArrival;
#endif
#endif

*CD PlanePos                        
#ifndef  __PlanePos_LOADED
#define  __PlanePos_LOADED
typedef struct {
int planepos;
int              ID;
int              ISuper;
int              IModule;
int              InMdl;
float            PairZmin;
float            PairZmax;
char             PasvName[4];
float            XYPasv[2];
float            ZFrntPasv;
char             ActvName[4];
float            XYActv[2];
float            ZFrntActv;
char             Rotm[4];
int              ActvSpec;
int              PasvSpec;
int              RotmID;
int _9999;
} PLANEPOS_DEF;
#ifdef __TAP_CREOBJ__
PLANEPOS_DEF PlanePos;
#else
extern PLANEPOS_DEF PlanePos;
#endif
#endif

*CD PlaneSpec                       
#ifndef  __PlaneSpec_LOADED
#define  __PlaneSpec_LOADED
typedef struct {
int planespec;
int              ID;
char             PlnName[4];
char             Shape[4];
float            Width;
float            Length;
float            Thickness;
float            AirGap[2];
char             TMedium[4];
int              BMap;
int              DigiType;
float            AbsLen;
float            RadLen;
float            Density;
int              NStrip;
int              NExtru;
int              NCell;
float            CellWidth;
float            CellThick;
int              CoverSide;
int              NGSVol;
float            GSVol[10];
int              NLevel;
char             NamePth[9][4];
int              NumbPth[9];
float            RSquash[8];
int              FirstStrip;
int              LastStrip;
int _9999;
} PLANESPEC_DEF;
#ifdef __TAP_CREOBJ__
PLANESPEC_DEF PlaneSpec;
#else
extern PLANESPEC_DEF PlaneSpec;
#endif
#endif

*CD PlexusAdd                       
#ifndef  __PlexusAdd_LOADED
#define  __PlexusAdd_LOADED
typedef struct {
int plexusadd;
int              ID;
int              IPln;
int              IExtr;
int              ICell;
int              IExist;
int _9999;
} PLEXUSADD_DEF;
#ifdef __TAP_CREOBJ__
PLEXUSADD_DEF PlexusAdd;
#else
extern PLEXUSADD_DEF PlexusAdd;
#endif
#endif

*CD Pln2MUX                         
#ifndef  __Pln2MUX_LOADED
#define  __Pln2MUX_LOADED
typedef struct {
int pln2mux;
int              ID;
int              IPln;
int              MUXA;
int              MUXMapA;
int              MUXB;
int              MUXMapB;
int _9999;
} PLN2MUX_DEF;
#ifdef __TAP_CREOBJ__
PLN2MUX_DEF Pln2MUX;
#else
extern PLN2MUX_DEF Pln2MUX;
#endif
#endif

*CD RPCHit                          
#ifndef  __RPCHit_LOADED
#define  __RPCHit_LOADED
typedef struct {
int rpchit;
int              ID;
int              IPln;
int              IExtr;
int              ICell;
int              ITrack;
float            XGlobal;
float            YGlobal;
float            ZGlobal;
float            TOFG;
float            XBegin;
float            YBegin;
float            ZBegin;
float            XEnd;
float            YEnd;
float            ZEnd;
float            ELoss;
float            Ptot;
int              IPDG;
int _9999;
} RPCHIT_DEF;
#ifdef __TAP_CREOBJ__
RPCHIT_DEF RPCHit;
#else
extern RPCHIT_DEF RPCHit;
#endif
#endif

*CD RecoMuon                        
#ifndef  __RecoMuon_LOADED
#define  __RecoMuon_LOADED
typedef struct {
int recomuon;
int              ID;
int              Index;
float            Origin[3];
float            dxdz;
float            dydz;
float            qp0;
float            DX0;
float            DY0;
float            Ddxdz;
float            Ddydz;
float            Dp0;
float            P[4];
int              Method;
int              Exit;
float            PathLength;
char             TrkRoutine[64];
char             FitRoutine[64];
int              error;
float            ChiFit;
int _9999;
} RECOMUON_DEF;
#ifdef __TAP_CREOBJ__
RECOMUON_DEF RecoMuon;
#else
extern RECOMUON_DEF RecoMuon;
#endif
#endif

*CD RecoShwDir                      
#ifndef  __RecoShwDir_LOADED
#define  __RecoShwDir_LOADED
typedef struct {
int recoshwdir;
int              ID;
float            DirCosX;
float            DirCosY;
float            DirCosZ;
float            Theta;
float            Phi;
float            ThetaBeam;
char             Routine[64];
int _9999;
} RECOSHWDIR_DEF;
#ifdef __TAP_CREOBJ__
RECOSHWDIR_DEF RecoShwDir;
#else
extern RECOSHWDIR_DEF RecoShwDir;
#endif
#endif

*CD RecoShwEnergy                   
#ifndef  __RecoShwEnergy_LOADED
#define  __RecoShwEnergy_LOADED
typedef struct {
int recoshwenergy;
int              ID;
float            Energy;
float            SignalSum;
char             Routine[64];
int _9999;
} RECOSHWENERGY_DEF;
#ifdef __TAP_CREOBJ__
RECOSHWENERGY_DEF RecoShwEnergy;
#else
extern RECOSHWENERGY_DEF RecoShwEnergy;
#endif
#endif

*CD RecoVtx                         
#ifndef  __RecoVtx_LOADED
#define  __RecoVtx_LOADED
typedef struct {
int recovtx;
int              ID;
float            X;
float            Y;
float            Z;
int              IPln;
char             Routine[64];
int _9999;
} RECOVTX_DEF;
#ifdef __TAP_CREOBJ__
RECOVTX_DEF RecoVtx;
#else
extern RECOVTX_DEF RecoVtx;
#endif
#endif

*CD ResponseVar                     
#ifndef  __ResponseVar_LOADED
#define  __ResponseVar_LOADED
typedef struct {
int responsevar;
int              ID;
int              IPackedPEC;
float            StripVarGen;
float            StripVarReco;
float            QEVarA;
float            QEVarB;
int _9999;
} RESPONSEVAR_DEF;
#ifdef __TAP_CREOBJ__
RESPONSEVAR_DEF ResponseVar;
#else
extern RESPONSEVAR_DEF ResponseVar;
#endif
#endif

*CD Rotm                            
#ifndef  __Rotm_LOADED
#define  __Rotm_LOADED
typedef struct {
int rotm;
int              ID;
char             Name[4];
float            Theta1;
float            Phi1;
float            Theta2;
float            Phi2;
float            Theta3;
float            Phi3;
float            r11;
float            r12;
float            r13;
float            r21;
float            r22;
float            r23;
float            r31;
float            r32;
float            r33;
int _9999;
} ROTM_DEF;
#ifdef __TAP_CREOBJ__
ROTM_DEF Rotm;
#else
extern ROTM_DEF Rotm;
#endif
#endif

*CD StdHep                          
#ifndef  __StdHep_LOADED
#define  __StdHep_LOADED
typedef struct {
int stdhep;
int              ID;
int              IstHEP;
int              IdHEP;
int              JmoHEP[2];
int              JdaHEP[2];
float            PHEP[5];
float            VHEP[4];
int _9999;
} STDHEP_DEF;
#ifdef __TAP_CREOBJ__
STDHEP_DEF StdHep;
#else
extern STDHEP_DEF StdHep;
#endif
#endif

*CD StdHepHead                      
#ifndef  __StdHepHead_LOADED
#define  __StdHepHead_LOADED
typedef struct {
int stdhephead;
int              ID;
int              NevHEP;
int              NHEP;
int _9999;
} STDHEPHEAD_DEF;
#ifdef __TAP_CREOBJ__
STDHEPHEAD_DEF StdHepHead;
#else
extern STDHEPHEAD_DEF StdHepHead;
#endif
#endif

*CD SubVolPos                       
#ifndef  __SubVolPos_LOADED
#define  __SubVolPos_LOADED
typedef struct {
int subvolpos;
int              ID;
char             VolName[4];
int              ICopy;
char             VolMother[4];
float            XPos;
float            YPos;
float            ZPos;
int              IRot;
char             Only[4];
int _9999;
} SUBVOLPOS_DEF;
#ifdef __TAP_CREOBJ__
SUBVOLPOS_DEF SubVolPos;
#else
extern SUBVOLPOS_DEF SubVolPos;
#endif
#endif

*CD SubVolSpec                      
#ifndef  __SubVolSpec_LOADED
#define  __SubVolSpec_LOADED
typedef struct {
int subvolspec;
int              ID;
char             VolName[4];
char             Shape[4];
char             TMedium[4];
int              NGSVol;
float            GSVol[10];
int _9999;
} SUBVOLSPEC_DEF;
#ifdef __TAP_CREOBJ__
SUBVOLSPEC_DEF SubVolSpec;
#else
extern SUBVOLSPEC_DEF SubVolSpec;
#endif
#endif

*CD SuperModule                     
#ifndef  __SuperModule_LOADED
#define  __SuperModule_LOADED
typedef struct {
int supermodule;
int              ID;
int              NActvPln;
int              NAPlnMdl;
int              NMdl;
int              CoilSet;
float            CoilI;
float            KATurn;
float            SupX0;
float            SupY0;
float            UpSpace;
float            DnSpace;
float            Xmin;
float            Xmax;
float            Ymin;
float            Ymax;
float            Zmin;
float            Zmax;
int _9999;
} SUPERMODULE_DEF;
#ifdef __TAP_CREOBJ__
SUPERMODULE_DEF SuperModule;
#else
extern SUPERMODULE_DEF SuperModule;
#endif
#endif

*CD TMedium                         
#ifndef  __TMedium_LOADED
#define  __TMedium_LOADED
typedef struct {
int tmedium;
int              ID;
char             Name[32];
int              Material;
int              ISVol;
int              IField;
float            FieldMax;
float            TMaxFD;
float            StepMax;
float            DEEmax;
float            Epsil;
float            StepMin;
int _9999;
} TMEDIUM_DEF;
#ifdef __TAP_CREOBJ__
TMEDIUM_DEF TMedium;
#else
extern TMEDIUM_DEF TMedium;
#endif
#endif

*CD TPar                            
#ifndef  __TPar_LOADED
#define  __TPar_LOADED
typedef struct {
int tpar;
int              ID;
int              TMedium;
float            CutGam;
float            CutEle;
float            CutNeu;
float            CutHad;
float            CutMuo;
float            BCutE;
float            BCutM;
float            DCutE;
float            DCutM;
float            PPCutM;
int              iPair;
int              iComp;
int              iPhot;
int              iPFis;
int              iDRay;
int              iAnni;
int              iBrem;
int              iHadr;
int              iMuNu;
int              iDcay;
int              iLoss;
int              iMuls;
int              iRayl;
float            GhCor1;
int              iBirk;
float            Birk1;
float            Birk2;
int              iLabs;
int              iSync;
int              iStra;
int _9999;
} TPAR_DEF;
#ifdef __TAP_CREOBJ__
TPAR_DEF TPar;
#else
extern TPAR_DEF TPar;
#endif
#endif

*CD TstHit                          
#ifndef  __TstHit_LOADED
#define  __TstHit_LOADED
typedef struct {
int tsthit;
int              ID;
int              IPln;
int              IExtr;
int              ICell;
int              ITrack;
float            XGlobal;
float            YGlobal;
float            ZGlobal;
float            TOFG;
float            XBegin;
float            YBegin;
float            ZBegin;
float            XEnd;
float            YEnd;
float            ZEnd;
float            ELoss;
float            Ptot;
int              IPDG;
int _9999;
} TSTHIT_DEF;
#ifdef __TAP_CREOBJ__
TSTHIT_DEF TstHit;
#else
extern TSTHIT_DEF TstHit;
#endif
#endif

*CD TubePixelInfo                   
#ifndef  __TubePixelInfo_LOADED
#define  __TubePixelInfo_LOADED
typedef struct {
int tubepixelinfo;
int              ID;
int              IPlexus;
int              NSides;
int              NFiberPerPixel;
int              NPlanesPerMux;
int              NPixelsPerPlane;
int              NTubesPerMUX;
int              NRowsPerTube;
int              NColsPerTube;
int              NPixelsPerTube;
int              MUXPackMult;
int _9999;
} TUBEPIXELINFO_DEF;
#ifdef __TAP_CREOBJ__
TUBEPIXELINFO_DEF TubePixelInfo;
#else
extern TUBEPIXELINFO_DEF TubePixelInfo;
#endif
#endif

*CD TubePixelMap                    
#ifndef  __TubePixelMap_LOADED
#define  __TubePixelMap_LOADED
typedef struct {
int tubepixelmap;
int              ID;
int              MUXMap;
int              IExtr;
int              ICell;
int              ITubePixel;
int _9999;
} TUBEPIXELMAP_DEF;
#ifdef __TAP_CREOBJ__
TUBEPIXELMAP_DEF TubePixelMap;
#else
extern TUBEPIXELMAP_DEF TubePixelMap;
#endif
#endif

*CD VarParam                        
#ifndef  __VarParam_LOADED
#define  __VarParam_LOADED
typedef struct {
int varparam;
int              ID;
int              RunNo;
float            S2SScale;
float            S2SFlat;
float            S2SGauss;
float            S2SMax;
float            QEScale;
float            QEFlat;
float            QEGauss;
float            QEMaxUsr;
float            QEMax;
float            QEMean;
int _9999;
} VARPARAM_DEF;
#ifdef __TAP_CREOBJ__
VARPARAM_DEF VarParam;
#else
extern VARPARAM_DEF VarParam;
#endif
#endif

*DK CREOBJ
#define __TAP_CREOBJ__

*CA AvailNuclei
*CA BeamSystem
*CA CellPos
*CA CoilTube
*CA DigitPln
*CA EmuDigit
*CA EmuHit
*CA EventHistory
*CA FLSDigiCell
*CA FLSDigiPln
*CA FLSDigiView
*CA FLSDigit
*CA FLSHit
*CA FLSParam
*CA FluxWgt
*CA GAFKey
*CA GeomMisc
*CA HitPln
*CA LSTHit
*CA LSTProto
*CA LSTStrip
*CA LSTWire
*CA MassDistrib
*CA Material
*CA MdlOrg
*CA Mixture
*CA MuonTrkHeader
*CA MuonTrkPoint
*CA NeuKin
*CA NeuVtx
*CA PEArrival
*CA PlanePos
*CA PlaneSpec
*CA PlexusAdd
*CA Pln2MUX
*CA RPCHit
*CA RecoMuon
*CA RecoShwDir
*CA RecoShwEnergy
*CA RecoVtx
*CA ResponseVar
*CA Rotm
*CA StdHep
*CA StdHepHead
*CA SubVolPos
*CA SubVolSpec
*CA SuperModule
*CA TMedium
*CA TPar
*CA TstHit
*CA TubePixelInfo
*CA TubePixelMap
*CA VarParam

#undef __TAP_CREOBJ__
*CA partap

void CREOBJ ()
{
int inir__,maxr__,iacc__,ncol__,chmin__,one__,ch__,chmax__;
char type__[5];

/* Creation of table AvailNuclei */

{ static char cnam__[][17] = {
"ID",
"Material",
"Z",
"A",
"PathLength",
"NucleiDensity",
"SumNuclei",
"Sigma",
"AZWgt",
"SumWgt"
};
static char ctyp__[][5] = {
"SNUM",
"INTE",
"INTE",
"INTE",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL"
};
CRETAB(AvailNuclei,"AvailNuclei",10,cnam__,ctyp__,INULL,INULL);

}

/* Creation of table BeamSystem */

{ static char cnam__[][17] = {
"ID",
"X0",
"Y0",
"Z0",
"dXdZ",
"dYdZ",
"KineMethod",
"FluxMethod",
"Emin",
"Emax",
"FluxFile"
};
static char ctyp__[][5] = {
"SNUM",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"INTE",
"INTE",
"REAL",
"REAL",
"CH64"
};
CRETAB(BeamSystem,"BeamSystem",11,cnam__,ctyp__,INULL,INULL);

}

/* Creation of table CellPos */

{ static char cnam__[][17] = {
"ID",
"PlnName",
"IStrip",
"IExtr",
"ICell",
"XYZReadout(3)",
"XYZCenter(3)",
"XYZFarend(3)",
"FiberTailA",
"FiberTailB",
"ClearFiberA",
"ClearFiberB"
};
static char ctyp__[][5] = {
"SNUM",
"CHA4",
"INTE",
"INTE",
"INTE",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL"
};
CRETAB(CellPos,"CellPos",12,cnam__,ctyp__,INULL,INULL);

}

/* Creation of index CellPlnStrip on table CellPos */

{ static char cnam__[][17] = {
"PlnName",
"IStrip"
};
static char cord__[][5] = {
"ASC",
"ASC"
};
ncol__ =    2;
CREIND(CellPos,iacc__,"CellPlnStrip",ncol__,cnam__,cord__);
}

/* Creation of index CellIndex on table CellPos */

{ static char cnam__[][17] = {
"PlnName",
"IExtr",
"ICell"
};
static char cord__[][5] = {
"ASC",
"ASC",
"ASC"
};
ncol__ =    3;
CREIND(CellPos,iacc__,"CellIndex",ncol__,cnam__,cord__);
}

/* Creation of table CoilTube */

{ static char cnam__[][17] = {
"ID",
"ISuper",
"Name",
"ICopy",
"ITreeDepth",
"XYZ1(3)",
"XYZ2(3)",
"OuterRadius",
"InnerRadius",
"ShapeName",
"IRotm",
"TMedium",
"Zmin",
"Zmax"
};
static char ctyp__[][5] = {
"SNUM",
"INTE",
"CHA4",
"INTE",
"INTE",
"REAL",
"REAL",
"REAL",
"REAL",
"CHA4",
"INTE",
"CHA4",
"REAL",
"REAL"
};
CRETAB(CoilTube,"CoilTube",14,cnam__,ctyp__,INULL,INULL);

}
SETFOR(CoilTube,"ISuper","I2");


/* Creation of table DigitPln */

{ static char cnam__[][17] = {
"ID",
"IPln",
"NDigitPln"
};
static char ctyp__[][5] = {
"SNUM",
"INTE",
"INTE"
};
CRETAB(DigitPln,"DigitPln",3,cnam__,ctyp__,INULL,INULL);

}

/* Creation of table EmuDigit */

{ static char cnam__[][17] = {
"ID",
"IPln",
"ISheet",
"ILayer",
"XCenter",
"YCenter",
"ZCenter",
"GrainSize",
"CellPos",
"PlanePos"
};
static char ctyp__[][5] = {
"SNUM",
"INTE",
"INTE",
"INTE",
"REAL",
"REAL",
"REAL",
"REAL",
"REL",
"REL"
};
CRETAB(EmuDigit,"EmuDigit",10,cnam__,ctyp__,INULL,INULL);

}

/* Creation of table EmuHit */

{ static char cnam__[][17] = {
"ID",
"IPln",
"ISheet",
"ILayer",
"ITrack",
"TOFG",
"XBegin",
"YBegin",
"ZBegin",
"XEnd",
"YEnd",
"ZEnd",
"ELoss",
"Ptot",
"IPDG",
"CellPos",
"PlanePos"
};
static char ctyp__[][5] = {
"SNUM",
"INTE",
"INTE",
"INTE",
"INTE",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"INTE",
"REL",
"REL"
};
CRETAB(EmuHit,"EmuHit",17,cnam__,ctyp__,INULL,INULL);

}

/* Creation of table EventHistory */

{ static char cnam__[][17] = {
"ID",
"TableName",
"EntryNumber",
"Routine",
"VersionString",
"DateFilled"
};
static char ctyp__[][5] = {
"SNUM",
"CH32",
"INTE",
"CH32",
"CHA8",
"CH16"
};
CRETAB(EventHistory,"EventHistory",6,cnam__,ctyp__,INULL,INULL);

}

/* Creation of table FLSDigiCell */

{ static char cnam__[][17] = {
"ID",
"IPln",
"IExtr",
"ICell",
"IView",
"XYZBase(3)",
"XYZDir(3)",
"TPos",
"CPos",
"CellLength",
"DirScale",
"XPhysicalA",
"XPhysicalB",
"XFiberA",
"XFiberB",
"ClrTransmitA",
"ClrTransmitB",
"RawAdcA",
"RawAdcB",
"CorrAdcA",
"CorrAdcB",
"CorrAdcSum",
"IsMuon"
};
static char ctyp__[][5] = {
"SNUM",
"INTE",
"INTE",
"INTE",
"INTE",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"INTE"
};
CRETAB(FLSDigiCell,"FLSDigiCell",23,cnam__,ctyp__,INULL,INULL);

}

/* Creation of table FLSDigiPln */

{ static char cnam__[][17] = {
"ID",
"IPln",
"Rotm",
"NCells",
"XYZBase(3)",
"XYZDir(3)",
"DirScale",
"SumRawAdc",
"SumCorrAdc"
};
static char ctyp__[][5] = {
"SNUM",
"INTE",
"CHA4",
"INTE",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL"
};
CRETAB(FLSDigiPln,"FLSDigiPln",9,cnam__,ctyp__,INULL,INULL);

}

/* Creation of table FLSDigiView */

{ static char cnam__[][17] = {
"ID",
"Rotm",
"NPlns",
"NCells",
"XYZBase(3)",
"XYZDir(3)",
"DirScale",
"SumRawAdc",
"SumOldAdc",
"SumCorrAdc"
};
static char ctyp__[][5] = {
"SNUM",
"CHA4",
"INTE",
"INTE",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL"
};
CRETAB(FLSDigiView,"FLSDigiView",10,cnam__,ctyp__,INULL,INULL);

}

/* Creation of table FLSDigit */

{ static char cnam__[][17] = {
"ID",
"IPln",
"IExtr",
"ICell",
"TPos",
"RawA",
"RawB",
"CorrA",
"CorrB",
"CorrSum",
"TDCA",
"TDCB",
"TubePixelA",
"TubePixelB",
"SignalPEA",
"SignalPEB",
"InitialTDCA",
"InitialTDCB",
"SumETrue",
"AveDistTrueA",
"AveDistTrueB",
"HitBits",
"CellPos",
"PlanePos"
};
static char ctyp__[][5] = {
"SNUM",
"INTE",
"INTE",
"INTE",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"INTE",
"INTE",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"BITP",
"REL",
"REL"
};
CRETAB(FLSDigit,"FLSDigit",24,cnam__,ctyp__,INULL,INULL);

}

/* Creation of index IndxPEC on table FLSDigit */

{ static char cnam__[][17] = {
"IPln",
"IExtr",
"ICell"
};
static char cord__[][5] = {
"ASC",
"ASC",
"ASC"
};
ncol__ =    3;
CREIND(FLSDigit,iacc__,"IndxPEC",ncol__,cnam__,cord__);
}

/* Creation of index IndxPlnTPos on table FLSDigit */

{ static char cnam__[][17] = {
"IPln",
"TPos"
};
static char cord__[][5] = {
"ASC",
"ASC"
};
ncol__ =    2;
CREIND(FLSDigit,iacc__,"IndxPlnTPos",ncol__,cnam__,cord__);
}

/* Creation of table FLSHit */

{ static char cnam__[][17] = {
"ID",
"IPackedPEC",
"ITrack",
"TOFG",
"XBegin",
"YBegin",
"ZBegin",
"XEnd",
"YEnd",
"ZEnd",
"ELoss",
"Ptot",
"IPDG",
"CellPos",
"PlanePos"
};
static char ctyp__[][5] = {
"SNUM",
"INTE",
"INTE",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"INTE",
"REL",
"REL"
};
CRETAB(FLSHit,"FLSHit",15,cnam__,ctyp__,INULL,INULL);

}

/* Creation of table FLSParam */

{ static char cnam__[][17] = {
"ID",
"Name",
"Type",
"Value",
"IUsageSet"
};
static char ctyp__[][5] = {
"SNUM",
"CH32",
"CHA4",
"REAL",
"INTE"
};
CRETAB(FLSParam,"FLSParam",5,cnam__,ctyp__,INULL,INULL);

}

/* Creation of index IndxNameSet on table FLSParam */

{ static char cnam__[][17] = {
"Name",
"IUsageSet"
};
static char cord__[][5] = {
"ASC",
"ASC"
};
ncol__ =    2;
CREIND(FLSParam,iacc__,"IndxNameSet",ncol__,cnam__,cord__);
}

/* Creation of table FluxWgt */

{ static char cnam__[][17] = {
"ID",
"Beam",
"Version",
"Weight",
"WeightErr"
};
static char ctyp__[][5] = {
"SNUM",
"CH32",
"INTE",
"REAL",
"REAL"
};
CRETAB(FluxWgt,"FluxWgt",5,cnam__,ctyp__,INULL,INULL);

}

/* Creation of table GAFKey */

{ static char cnam__[][17] = {
"ID",
"Type",
"Version",
"RunNo",
"EventNo",
"Name"
};
static char ctyp__[][5] = {
"SNUM",
"CHA4",
"INTE",
"INTE",
"INTE",
"CH32"
};
CRETAB(GAFKey,"GAFKey",6,cnam__,ctyp__,INULL,INULL);

}
SETFOR(GAFKey,"Type","A4");


/* Creation of table GeomMisc */

{ static char cnam__[][17] = {
"ID",
"NearFar",
"NSupmdl",
"NPlanes",
"VMARS(3)",
"VHall(3)",
"LINRThick",
"HallXmin",
"HallXmax",
"HallYmin",
"HallYmax",
"HallZmin",
"HallZmax"
};
static char ctyp__[][5] = {
"SNUM",
"INTE",
"INTE",
"INTE",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL"
};
CRETAB(GeomMisc,"GeomMisc",13,cnam__,ctyp__,INULL,INULL);

}
SETFOR(GeomMisc,"NSupmdl","I2");


/* Creation of table HitPln */

{ static char cnam__[][17] = {
"ID",
"IPln",
"NHitPln"
};
static char ctyp__[][5] = {
"SNUM",
"INTE",
"INTE"
};
CRETAB(HitPln,"HitPln",3,cnam__,ctyp__,INULL,INULL);

}

/* Creation of table LSTHit */

{ static char cnam__[][17] = {
"ID",
"IPln",
"IExtr",
"ICell",
"ITrack",
"TOFG",
"XBegin",
"YBegin",
"ZBegin",
"XEnd",
"YEnd",
"ZEnd",
"ELoss",
"Ptot",
"IPDG",
"CellPos",
"PlanePos"
};
static char ctyp__[][5] = {
"SNUM",
"INTE",
"INTE",
"INTE",
"INTE",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"INTE",
"REL",
"REL"
};
CRETAB(LSTHit,"LSTHit",17,cnam__,ctyp__,INULL,INULL);

}

/* Creation of index IndxPEC on table LSTHit */

{ static char cnam__[][17] = {
"IPln",
"IExtr",
"ICell"
};
static char cord__[][5] = {
"ASC",
"ASC",
"ASC"
};
ncol__ =    3;
CREIND(LSTHit,iacc__,"IndxPEC",ncol__,cnam__,cord__);
}

/* Creation of table LSTProto */

{ static char cnam__[][17] = {
"ID",
"IPln",
"IExtr",
"ICell",
"ITrack",
"XGlobal",
"YGlobal",
"ZGlobal",
"TOFG",
"Charge",
"XLocal"
};
static char ctyp__[][5] = {
"SNUM",
"INTE",
"INTE",
"INTE",
"INTE",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL"
};
CRETAB(LSTProto,"LSTProto",11,cnam__,ctyp__,INULL,INULL);

}

/* Creation of table LSTStrip */

{ static char cnam__[][17] = {
"ID",
"IPln",
"IStrip",
"CPos",
"Charge"
};
static char ctyp__[][5] = {
"SNUM",
"INTE",
"INTE",
"REAL",
"REAL"
};
CRETAB(LSTStrip,"LSTStrip",5,cnam__,ctyp__,INULL,INULL);

}

/* Creation of index IndxPS on table LSTStrip */

{ static char cnam__[][17] = {
"IPln",
"IStrip"
};
static char cord__[][5] = {
"ASC",
"ASC"
};
ncol__ =    2;
CREIND(LSTStrip,iacc__,"IndxPS",ncol__,cnam__,cord__);
}

/* Creation of index IndxPlnCPos on table LSTStrip */

{ static char cnam__[][17] = {
"IPln",
"CPos"
};
static char cord__[][5] = {
"ASC",
"ASC"
};
ncol__ =    2;
CREIND(LSTStrip,iacc__,"IndxPlnCPos",ncol__,cnam__,cord__);
}

/* Creation of table LSTWire */

{ static char cnam__[][17] = {
"ID",
"IPln",
"IChan",
"TPos",
"Charge"
};
static char ctyp__[][5] = {
"SNUM",
"INTE",
"INTE",
"REAL",
"REAL"
};
CRETAB(LSTWire,"LSTWire",5,cnam__,ctyp__,INULL,INULL);

}

/* Creation of index IndxPC on table LSTWire */

{ static char cnam__[][17] = {
"IPln",
"IChan"
};
static char cord__[][5] = {
"ASC",
"ASC"
};
ncol__ =    2;
CREIND(LSTWire,iacc__,"IndxPC",ncol__,cnam__,cord__);
}

/* Creation of index IndxPlnTPos on table LSTWire */

{ static char cnam__[][17] = {
"IPln",
"TPos"
};
static char cord__[][5] = {
"ASC",
"ASC"
};
ncol__ =    2;
CREIND(LSTWire,iacc__,"IndxPlnTPos",ncol__,cnam__,cord__);
}

/* Creation of table MassDistrib */

{ static char cnam__[][17] = {
"ID",
"Material",
"SBegin",
"SEnd",
"PathSumMat",
"Type"
};
static char ctyp__[][5] = {
"SNUM",
"INTE",
"REAL",
"REAL",
"REAL",
"CHA4"
};
CRETAB(MassDistrib,"MassDistrib",6,cnam__,ctyp__,INULL,INULL);

}

/* Creation of table Material */

{ static char cnam__[][17] = {
"ID",
"Name",
"A",
"Z",
"Density",
"RadLen",
"AbsLen",
"NMix"
};
static char ctyp__[][5] = {
"SNUM",
"CH32",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"INTE"
};
CRETAB(Material,"Material",8,cnam__,ctyp__,INULL,INULL);

}

/* Creation of table MdlOrg */

{ static char cnam__[][17] = {
"ID",
"ISup",
"InMdl",
"PasvType",
"ActvType",
"ActvRotm"
};
static char ctyp__[][5] = {
"SNUM",
"INTE",
"INTE",
"CHA4",
"CHA4",
"CHA4"
};
CRETAB(MdlOrg,"MdlOrg",6,cnam__,ctyp__,INULL,INULL);

}

/* Creation of index ISupInMdl on table MdlOrg */

{ static char cnam__[][17] = {
"ISup",
"InMdl"
};
static char cord__[][5] = {
"ASC",
"ASC"
};
ncol__ =    2;
CREIND(MdlOrg,iacc__,"ISupInMdl",ncol__,cnam__,cord__);
}
SETFOR(MdlOrg,"ISup","I2");
SETFOR(MdlOrg,"InMdl","I2");
SETFOR(MdlOrg,"ActvRotm","A1");


/* Creation of table Mixture */

{ static char cnam__[][17] = {
"ID",
"Material",
"IElement",
"A",
"Z",
"Fraction"
};
static char ctyp__[][5] = {
"SNUM",
"INTE",
"INTE",
"REAL",
"REAL",
"REAL"
};
CRETAB(Mixture,"Mixture",6,cnam__,ctyp__,INULL,INULL);

}

/* Creation of table MuonTrkHeader */

{ static char cnam__[][17] = {
"ID",
"NPoints",
"Routine"
};
static char ctyp__[][5] = {
"SNUM",
"INTE",
"CH64"
};
CRETAB(MuonTrkHeader,"MuonTrkHeader",3,cnam__,ctyp__,INULL,INULL);

}

/* Creation of table MuonTrkPoint */

{ static char cnam__[][17] = {
"ID",
"Index",
"X",
"Y",
"Z",
"Weight",
"transv",
"Rotm"
};
static char ctyp__[][5] = {
"SNUM",
"INTE",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"CHA4"
};
CRETAB(MuonTrkPoint,"MuonTrkPoint",8,cnam__,ctyp__,INULL,INULL);

}

/* Creation of table NeuKin */

{ static char cnam__[][17] = {
"ID",
"INu",
"INuNoOsc",
"ITg",
"IBoson",
"IResonance",
"IAction",
"A",
"Z",
"Sigma",
"P4Neu(4)",
"P4NeuNoOsc(4)",
"P4Tgt(4)",
"X",
"Y",
"Q2",
"W2",
"P4Shw(4)",
"P4Mu1(4)",
"P4Mu2(4)",
"EMFrac",
"P4El1(4)",
"P4El2(4)",
"P4Tau(4)"
};
static char ctyp__[][5] = {
"SNUM",
"INTE",
"INTE",
"INTE",
"INTE",
"INTE",
"INTE",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL"
};
CRETAB(NeuKin,"NeuKin",24,cnam__,ctyp__,INULL,INULL);

}

/* Creation of table NeuVtx */

{ static char cnam__[][17] = {
"ID",
"X",
"Y",
"Z"
};
static char ctyp__[][5] = {
"SNUM",
"REAL",
"REAL",
"REAL"
};
CRETAB(NeuVtx,"NeuVtx",4,cnam__,ctyp__,INULL,INULL);

}

/* Creation of table PEArrival */

{ static char cnam__[][17] = {
"ID",
"IPln",
"IStrip",
"IAB",
"IEvent",
"TubePixel",
"Time",
"Response",
"FLSDigit1",
"FLSDigit2",
"FLSHit"
};
static char ctyp__[][5] = {
"SNUM",
"INTE",
"INTE",
"INTE",
"INTE",
"INTE",
"REAL",
"REAL",
"REL",
"REL",
"REL"
};
CRETAB(PEArrival,"PEArrival",11,cnam__,ctyp__,INULL,INULL);

}

/* Creation of index IndxTPT on table PEArrival */

{ static char cnam__[][17] = {
"TubePixel",
"Time"
};
static char cord__[][5] = {
"ASC",
"ASC"
};
ncol__ =    2;
CREIND(PEArrival,iacc__,"IndxTPT",ncol__,cnam__,cord__);
}

/* Creation of table PlanePos */

{ static char cnam__[][17] = {
"ID",
"ISuper",
"IModule",
"InMdl",
"PairZmin",
"PairZmax",
"PasvName",
"XYPasv(2)",
"ZFrntPasv",
"ActvName",
"XYActv(2)",
"ZFrntActv",
"Rotm",
"ActvSpec",
"PasvSpec",
"RotmID"
};
static char ctyp__[][5] = {
"SNUM",
"INTE",
"INTE",
"INTE",
"REAL",
"REAL",
"CHA4",
"REAL",
"REAL",
"CHA4",
"REAL",
"REAL",
"CHA4",
"REL",
"REL",
"REL"
};
CRETAB(PlanePos,"PlanePos",16,cnam__,ctyp__,INULL,INULL);

}

/* Creation of index IndxSMI on table PlanePos */

{ static char cnam__[][17] = {
"ISuper",
"IModule",
"InMdl"
};
static char cord__[][5] = {
"ASC",
"ASC",
"ASC"
};
ncol__ =    3;
CREIND(PlanePos,iacc__,"IndxSMI",ncol__,cnam__,cord__);
}
SETFOR(PlanePos,"ISuper","I2");
SETFOR(PlanePos,"IModule","I3");
SETFOR(PlanePos,"InMdl","I2");


/* Creation of table PlaneSpec */

{ static char cnam__[][17] = {
"ID",
"PlnName",
"Shape",
"Width",
"Length",
"Thickness",
"AirGap(2)",
"TMedium",
"BMap",
"DigiType",
"AbsLen",
"RadLen",
"Density",
"NStrip",
"NExtru",
"NCell",
"CellWidth",
"CellThick",
"CoverSide",
"NGSVol",
"GSVol(10)",
"NLevel",
"NamePth(9)",
"NumbPth(9)",
"RSquash(8)",
"FirstStrip",
"LastStrip"
};
static char ctyp__[][5] = {
"SNUM",
"CHA4",
"CHA4",
"REAL",
"REAL",
"REAL",
"REAL",
"CHA4",
"INTE",
"INTE",
"REAL",
"REAL",
"REAL",
"INTE",
"INTE",
"INTE",
"REAL",
"REAL",
"INTE",
"INTE",
"REAL",
"INTE",
"CHA4",
"INTE",
"REAL",
"REL",
"REL"
};
CRETAB(PlaneSpec,"PlaneSpec",27,cnam__,ctyp__,INULL,INULL);

}
SETFOR(PlaneSpec,"Shape","A4");
SETFOR(PlaneSpec,"BMap","I10");
SETFOR(PlaneSpec,"DigiType","I1");
SETFOR(PlaneSpec,"NExtru","I10");
SETFOR(PlaneSpec,"NCell","I10");
SETFOR(PlaneSpec,"CoverSide","I2");
SETFOR(PlaneSpec,"NGSVol","I2");
SETFOR(PlaneSpec,"NLevel","I1");
SETFOR(PlaneSpec,"NumbPth","I10");


/* Creation of table PlexusAdd */

{ static char cnam__[][17] = {
"ID",
"IPln",
"IExtr",
"ICell",
"IExist"
};
static char ctyp__[][5] = {
"SNUM",
"INTE",
"INTE",
"INTE",
"INTE"
};
CRETAB(PlexusAdd,"PlexusAdd",5,cnam__,ctyp__,INULL,INULL);

}

/* Creation of index IndxPEC on table PlexusAdd */

{ static char cnam__[][17] = {
"IPln",
"IExtr",
"ICell"
};
static char cord__[][5] = {
"ASC",
"ASC",
"ASC"
};
ncol__ =    3;
CREIND(PlexusAdd,iacc__,"IndxPEC",ncol__,cnam__,cord__);
}

/* Creation of table Pln2MUX */

{ static char cnam__[][17] = {
"ID",
"IPln",
"MUXA",
"MUXMapA",
"MUXB",
"MUXMapB"
};
static char ctyp__[][5] = {
"SNUM",
"INTE",
"INTE",
"INTE",
"INTE",
"INTE"
};
CRETAB(Pln2MUX,"Pln2MUX",6,cnam__,ctyp__,INULL,INULL);

}

/* Creation of table RPCHit */

{ static char cnam__[][17] = {
"ID",
"IPln",
"IExtr",
"ICell",
"ITrack",
"XGlobal",
"YGlobal",
"ZGlobal",
"TOFG",
"XBegin",
"YBegin",
"ZBegin",
"XEnd",
"YEnd",
"ZEnd",
"ELoss",
"Ptot",
"IPDG"
};
static char ctyp__[][5] = {
"SNUM",
"INTE",
"INTE",
"INTE",
"INTE",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"INTE"
};
CRETAB(RPCHit,"RPCHit",18,cnam__,ctyp__,INULL,INULL);

}

/* Creation of table RecoMuon */

{ static char cnam__[][17] = {
"ID",
"Index",
"Origin(3)",
"dxdz",
"dydz",
"qp0",
"DX0",
"DY0",
"Ddxdz",
"Ddydz",
"Dp0",
"P(4)",
"Method",
"Exit",
"PathLength",
"TrkRoutine",
"FitRoutine",
"error",
"ChiFit"
};
static char ctyp__[][5] = {
"SNUM",
"INTE",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"INTE",
"INTE",
"REAL",
"CH64",
"CH64",
"INTE",
"REAL"
};
CRETAB(RecoMuon,"RecoMuon",19,cnam__,ctyp__,INULL,INULL);

}

/* Creation of table RecoShwDir */

{ static char cnam__[][17] = {
"ID",
"DirCosX",
"DirCosY",
"DirCosZ",
"Theta",
"Phi",
"ThetaBeam",
"Routine"
};
static char ctyp__[][5] = {
"SNUM",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"CH64"
};
CRETAB(RecoShwDir,"RecoShwDir",8,cnam__,ctyp__,INULL,INULL);

}

/* Creation of table RecoShwEnergy */

{ static char cnam__[][17] = {
"ID",
"Energy",
"SignalSum",
"Routine"
};
static char ctyp__[][5] = {
"SNUM",
"REAL",
"REAL",
"CH64"
};
CRETAB(RecoShwEnergy,"RecoShwEnergy",4,cnam__,ctyp__,INULL,INULL);

}

/* Creation of table RecoVtx */

{ static char cnam__[][17] = {
"ID",
"X",
"Y",
"Z",
"IPln",
"Routine"
};
static char ctyp__[][5] = {
"SNUM",
"REAL",
"REAL",
"REAL",
"INTE",
"CH64"
};
CRETAB(RecoVtx,"RecoVtx",6,cnam__,ctyp__,INULL,INULL);

}

/* Creation of table ResponseVar */

{ static char cnam__[][17] = {
"ID",
"IPackedPEC",
"StripVarGen",
"StripVarReco",
"QEVarA",
"QEVarB"
};
static char ctyp__[][5] = {
"SNUM",
"INTE",
"REAL",
"REAL",
"REAL",
"REAL"
};
CRETAB(ResponseVar,"ResponseVar",6,cnam__,ctyp__,INULL,INULL);

}

/* Creation of table Rotm */

{ static char cnam__[][17] = {
"ID",
"Name",
"Theta1",
"Phi1",
"Theta2",
"Phi2",
"Theta3",
"Phi3",
"r11",
"r12",
"r13",
"r21",
"r22",
"r23",
"r31",
"r32",
"r33"
};
static char ctyp__[][5] = {
"SNUM",
"CHA4",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL"
};
CRETAB(Rotm,"Rotm",17,cnam__,ctyp__,INULL,INULL);

}
SETFOR(Rotm,"Theta1","F5.1");
SETFOR(Rotm,"Phi1","F5.1");
SETFOR(Rotm,"Theta2","F5.1");
SETFOR(Rotm,"Phi2","F5.1");
SETFOR(Rotm,"Theta3","F5.1");
SETFOR(Rotm,"Phi3","F5.1");


/* Creation of table StdHep */

{ static char cnam__[][17] = {
"ID",
"IstHEP",
"IdHEP",
"JmoHEP(2)",
"JdaHEP(2)",
"PHEP(5)",
"VHEP(4)"
};
static char ctyp__[][5] = {
"SNUM",
"INTE",
"INTE",
"INTE",
"INTE",
"REAL",
"REAL"
};
CRETAB(StdHep,"StdHep",7,cnam__,ctyp__,INULL,INULL);

}

/* Creation of table StdHepHead */

{ static char cnam__[][17] = {
"ID",
"NevHEP",
"NHEP"
};
static char ctyp__[][5] = {
"SNUM",
"INTE",
"INTE"
};
CRETAB(StdHepHead,"StdHepHead",3,cnam__,ctyp__,INULL,INULL);

}

/* Creation of table SubVolPos */

{ static char cnam__[][17] = {
"ID",
"VolName",
"ICopy",
"VolMother",
"XPos",
"YPos",
"ZPos",
"IRot",
"Only"
};
static char ctyp__[][5] = {
"SNUM",
"CHA4",
"INTE",
"CHA4",
"REAL",
"REAL",
"REAL",
"INTE",
"CHA4"
};
CRETAB(SubVolPos,"SubVolPos",9,cnam__,ctyp__,INULL,INULL);

}
SETFOR(SubVolPos,"ICopy","I10");
SETFOR(SubVolPos,"Only","A4");


/* Creation of table SubVolSpec */

{ static char cnam__[][17] = {
"ID",
"VolName",
"Shape",
"TMedium",
"NGSVol",
"GSVol(10)"
};
static char ctyp__[][5] = {
"SNUM",
"CHA4",
"CHA4",
"CHA4",
"INTE",
"REAL"
};
CRETAB(SubVolSpec,"SubVolSpec",6,cnam__,ctyp__,INULL,INULL);

}
SETFOR(SubVolSpec,"Shape","A4");
SETFOR(SubVolSpec,"NGSVol","I2");


/* Creation of table SuperModule */

{ static char cnam__[][17] = {
"ID",
"NActvPln",
"NAPlnMdl",
"NMdl",
"CoilSet",
"CoilI",
"KATurn",
"SupX0",
"SupY0",
"UpSpace",
"DnSpace",
"Xmin",
"Xmax",
"Ymin",
"Ymax",
"Zmin",
"Zmax"
};
static char ctyp__[][5] = {
"SNUM",
"INTE",
"INTE",
"INTE",
"INTE",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL"
};
CRETAB(SuperModule,"SuperModule",17,cnam__,ctyp__,INULL,INULL);

}
SETFOR(SuperModule,"NAPlnMdl","I2");
SETFOR(SuperModule,"NMdl","I3");


/* Creation of table TMedium */

{ static char cnam__[][17] = {
"ID",
"Name",
"Material",
"ISVol",
"IField",
"FieldMax",
"TMaxFD",
"StepMax",
"DEEmax",
"Epsil",
"StepMin"
};
static char ctyp__[][5] = {
"SNUM",
"CH32",
"INTE",
"INTE",
"INTE",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL"
};
CRETAB(TMedium,"TMedium",11,cnam__,ctyp__,INULL,INULL);

}

/* Creation of table TPar */

{ static char cnam__[][17] = {
"ID",
"TMedium",
"CutGam",
"CutEle",
"CutNeu",
"CutHad",
"CutMuo",
"BCutE",
"BCutM",
"DCutE",
"DCutM",
"PPCutM",
"iPair",
"iComp",
"iPhot",
"iPFis",
"iDRay",
"iAnni",
"iBrem",
"iHadr",
"iMuNu",
"iDcay",
"iLoss",
"iMuls",
"iRayl",
"GhCor1",
"iBirk",
"Birk1",
"Birk2",
"iLabs",
"iSync",
"iStra"
};
static char ctyp__[][5] = {
"SNUM",
"INTE",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"INTE",
"INTE",
"INTE",
"INTE",
"INTE",
"INTE",
"INTE",
"INTE",
"INTE",
"INTE",
"INTE",
"INTE",
"INTE",
"REAL",
"INTE",
"REAL",
"REAL",
"INTE",
"INTE",
"INTE"
};
CRETAB(TPar,"TPar",32,cnam__,ctyp__,INULL,INULL);

}
SETFOR(TPar,"iPair","I1");
SETFOR(TPar,"iComp","I1");
SETFOR(TPar,"iPhot","I1");
SETFOR(TPar,"iPFis","I1");
SETFOR(TPar,"iDRay","I1");
SETFOR(TPar,"iAnni","I1");
SETFOR(TPar,"iBrem","I1");
SETFOR(TPar,"iHadr","I1");
SETFOR(TPar,"iMuNu","I1");
SETFOR(TPar,"iDcay","I1");
SETFOR(TPar,"iLoss","I1");
SETFOR(TPar,"iMuls","I1");
SETFOR(TPar,"iRayl","I1");
SETFOR(TPar,"iLabs","I1");
SETFOR(TPar,"iSync","I1");
SETFOR(TPar,"iStra","I1");


/* Creation of table TstHit */

{ static char cnam__[][17] = {
"ID",
"IPln",
"IExtr",
"ICell",
"ITrack",
"XGlobal",
"YGlobal",
"ZGlobal",
"TOFG",
"XBegin",
"YBegin",
"ZBegin",
"XEnd",
"YEnd",
"ZEnd",
"ELoss",
"Ptot",
"IPDG"
};
static char ctyp__[][5] = {
"SNUM",
"INTE",
"INTE",
"INTE",
"INTE",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"INTE"
};
CRETAB(TstHit,"TstHit",18,cnam__,ctyp__,INULL,INULL);

}

/* Creation of table TubePixelInfo */

{ static char cnam__[][17] = {
"ID",
"IPlexus",
"NSides",
"NFiberPerPixel",
"NPlanesPerMux",
"NPixelsPerPlane",
"NTubesPerMUX",
"NRowsPerTube",
"NColsPerTube",
"NPixelsPerTube",
"MUXPackMult"
};
static char ctyp__[][5] = {
"SNUM",
"INTE",
"INTE",
"INTE",
"INTE",
"INTE",
"INTE",
"INTE",
"INTE",
"INTE",
"INTE"
};
CRETAB(TubePixelInfo,"TubePixelInfo",11,cnam__,ctyp__,INULL,INULL);

}

/* Creation of table TubePixelMap */

{ static char cnam__[][17] = {
"ID",
"MUXMap",
"IExtr",
"ICell",
"ITubePixel"
};
static char ctyp__[][5] = {
"SNUM",
"INTE",
"INTE",
"INTE",
"INTE"
};
CRETAB(TubePixelMap,"TubePixelMap",5,cnam__,ctyp__,INULL,INULL);

}

/* Creation of index IndxMEC on table TubePixelMap */

{ static char cnam__[][17] = {
"MUXMap",
"IExtr",
"ICell"
};
static char cord__[][5] = {
"ASC",
"ASC",
"ASC"
};
ncol__ =    3;
CREIND(TubePixelMap,iacc__,"IndxMEC",ncol__,cnam__,cord__);
}

/* Creation of index IndxMapTP on table TubePixelMap */

{ static char cnam__[][17] = {
"MUXMap",
"ITubePixel"
};
static char cord__[][5] = {
"ASC",
"ASC"
};
ncol__ =    2;
CREIND(TubePixelMap,iacc__,"IndxMapTP",ncol__,cnam__,cord__);
}

/* Creation of table VarParam */

{ static char cnam__[][17] = {
"ID",
"RunNo",
"S2SScale",
"S2SFlat",
"S2SGauss",
"S2SMax",
"QEScale",
"QEFlat",
"QEGauss",
"QEMaxUsr",
"QEMax",
"QEMean"
};
static char ctyp__[][5] = {
"SNUM",
"INTE",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL",
"REAL"
};
CRETAB(VarParam,"VarParam",12,cnam__,ctyp__,INULL,INULL);

}
    CREREL(PlaneSpec,0,"FirstStrip",1,0,1,CellPos);
    CREREL(PlaneSpec,0,"LastStrip",1,0,1,CellPos);
    CREREL(FLSHit,1,"CellPos",1,1,INULL,CellPos);
    CREREL(FLSDigit,1,"CellPos",1,1,INULL,CellPos);
    CREREL(EmuHit,1,"CellPos",1,1,INULL,CellPos);
    CREREL(EmuDigit,1,"CellPos",1,1,INULL,CellPos);
    CREREL(LSTHit,1,"CellPos",1,1,INULL,CellPos);
    CREREL(EmuDigit,1,"PlanePos",1,1,INULL,PlanePos);
    CREREL(EmuHit,1,"PlanePos",1,1,INULL,PlanePos);
    CREREL(PEArrival,0,"FLSDigit1",1,0,INULL,FLSDigit);
    CREREL(PEArrival,0,"FLSDigit2",1,0,INULL,FLSDigit);
    CREREL(FLSDigit,1,"PlanePos",1,1,INULL,PlanePos);
    CREREL(PEArrival,0,"FLSHit",1,0,INULL,FLSHit);
    CREREL(FLSHit,1,"PlanePos",1,1,INULL,PlanePos);
    CREREL(LSTHit,1,"PlanePos",1,1,INULL,PlanePos);
    CREREL(PlanePos,1,"PasvSpec",1,1,INULL,PlaneSpec);
    CREREL(PlanePos,1,"ActvSpec",1,1,INULL,PlaneSpec);
    CREREL(PlanePos,1,"RotmID",1,1,INULL,Rotm);

CREDFL(iacc__,"GeantEvent");
CREDFL(iacc__,"GeantEventV002");
CREDFL(iacc__,"GeantEventV003");
CREDFL(iacc__,"GeantEventV004");
CREDFL(iacc__,"GeantEventV005");
CREDFL(iacc__,"GeantEventV006");
CREDFL(iacc__,"MinosGeom");
CREDFL(iacc__,"MinosGeomV002");
CREDFL(iacc__,"MinosGeomV003");
CREDFL(iacc__,"MinosGeomV004");
CREDFL(iacc__,"MinosGeomV005");
CREDFL(iacc__,"MinosGeomV006");

{ int dfl__;
  dfl__= GETDFL("GeantEvent");
  INSDFL(dfl__,NeuVtx);}
{ int dfl__;
  dfl__= GETDFL("GeantEvent");
  INSDFL(dfl__,NeuKin);}
{ int dfl__;
  dfl__= GETDFL("GeantEvent");
  INSDFL(dfl__,StdHepHead);}
{ int dfl__;
  dfl__= GETDFL("GeantEvent");
  INSDFL(dfl__,StdHep);}
{ int dfl__;
  dfl__= GETDFL("GeantEvent");
  INSDFL(dfl__,HitPln);}
{ int dfl__;
  dfl__= GETDFL("GeantEvent");
  INSDFL(dfl__,DigitPln);}
{ int dfl__;
  dfl__= GETDFL("GeantEvent");
  INSDFL(dfl__,FLSHit);}
{ int dfl__;
  dfl__= GETDFL("GeantEvent");
  INSDFL(dfl__,FLSDigit);}
{ int dfl__;
  dfl__= GETDFL("GeantEvent");
  INSDFL(dfl__,LSTHit);}
{ int dfl__;
  dfl__= GETDFL("GeantEvent");
  INSDFL(dfl__,LSTProto);}
{ int dfl__;
  dfl__= GETDFL("GeantEvent");
  INSDFL(dfl__,LSTWire);}
{ int dfl__;
  dfl__= GETDFL("GeantEvent");
  INSDFL(dfl__,LSTStrip);}
{ int dfl__;
  dfl__= GETDFL("GeantEventV002");
  INSDFL(dfl__,NeuVtx);}
{ int dfl__;
  dfl__= GETDFL("GeantEventV002");
  INSDFL(dfl__,NeuKin);}
{ int dfl__;
  dfl__= GETDFL("GeantEventV002");
  INSDFL(dfl__,StdHepHead);}
{ int dfl__;
  dfl__= GETDFL("GeantEventV002");
  INSDFL(dfl__,StdHep);}
{ int dfl__;
  dfl__= GETDFL("GeantEventV002");
  INSDFL(dfl__,HitPln);}
{ int dfl__;
  dfl__= GETDFL("GeantEventV002");
  INSDFL(dfl__,DigitPln);}
{ int dfl__;
  dfl__= GETDFL("GeantEventV002");
  INSDFL(dfl__,FLSHit);}
{ int dfl__;
  dfl__= GETDFL("GeantEventV002");
  INSDFL(dfl__,FLSDigit);}
{ int dfl__;
  dfl__= GETDFL("GeantEventV002");
  INSDFL(dfl__,LSTHit);}
{ int dfl__;
  dfl__= GETDFL("GeantEventV002");
  INSDFL(dfl__,LSTProto);}
{ int dfl__;
  dfl__= GETDFL("GeantEventV002");
  INSDFL(dfl__,LSTWire);}
{ int dfl__;
  dfl__= GETDFL("GeantEventV002");
  INSDFL(dfl__,LSTStrip);}
{ int dfl__;
  dfl__= GETDFL("GeantEventV002");
  INSDFL(dfl__,RPCHit);}
{ int dfl__;
  dfl__= GETDFL("GeantEventV002");
  INSDFL(dfl__,EmuHit);}
{ int dfl__;
  dfl__= GETDFL("GeantEventV002");
  INSDFL(dfl__,TstHit);}
{ int dfl__;
  dfl__= GETDFL("GeantEventV003");
  INSDFL(dfl__,NeuVtx);}
{ int dfl__;
  dfl__= GETDFL("GeantEventV003");
  INSDFL(dfl__,NeuKin);}
{ int dfl__;
  dfl__= GETDFL("GeantEventV003");
  INSDFL(dfl__,StdHepHead);}
{ int dfl__;
  dfl__= GETDFL("GeantEventV003");
  INSDFL(dfl__,StdHep);}
{ int dfl__;
  dfl__= GETDFL("GeantEventV003");
  INSDFL(dfl__,HitPln);}
{ int dfl__;
  dfl__= GETDFL("GeantEventV003");
  INSDFL(dfl__,DigitPln);}
{ int dfl__;
  dfl__= GETDFL("GeantEventV003");
  INSDFL(dfl__,FLSHit);}
{ int dfl__;
  dfl__= GETDFL("GeantEventV003");
  INSDFL(dfl__,FLSDigit);}
{ int dfl__;
  dfl__= GETDFL("GeantEventV003");
  INSDFL(dfl__,LSTHit);}
{ int dfl__;
  dfl__= GETDFL("GeantEventV003");
  INSDFL(dfl__,LSTWire);}
{ int dfl__;
  dfl__= GETDFL("GeantEventV003");
  INSDFL(dfl__,LSTStrip);}
{ int dfl__;
  dfl__= GETDFL("GeantEventV003");
  INSDFL(dfl__,RPCHit);}
{ int dfl__;
  dfl__= GETDFL("GeantEventV003");
  INSDFL(dfl__,EmuHit);}
{ int dfl__;
  dfl__= GETDFL("GeantEventV003");
  INSDFL(dfl__,TstHit);}
{ int dfl__;
  dfl__= GETDFL("GeantEventV004");
  INSDFL(dfl__,EventHistory);}
{ int dfl__;
  dfl__= GETDFL("GeantEventV004");
  INSDFL(dfl__,NeuVtx);}
{ int dfl__;
  dfl__= GETDFL("GeantEventV004");
  INSDFL(dfl__,NeuKin);}
{ int dfl__;
  dfl__= GETDFL("GeantEventV004");
  INSDFL(dfl__,StdHepHead);}
{ int dfl__;
  dfl__= GETDFL("GeantEventV004");
  INSDFL(dfl__,StdHep);}
{ int dfl__;
  dfl__= GETDFL("GeantEventV004");
  INSDFL(dfl__,HitPln);}
{ int dfl__;
  dfl__= GETDFL("GeantEventV004");
  INSDFL(dfl__,FLSHit);}
{ int dfl__;
  dfl__= GETDFL("GeantEventV004");
  INSDFL(dfl__,LSTHit);}
{ int dfl__;
  dfl__= GETDFL("GeantEventV004");
  INSDFL(dfl__,RPCHit);}
{ int dfl__;
  dfl__= GETDFL("GeantEventV004");
  INSDFL(dfl__,EmuHit);}
{ int dfl__;
  dfl__= GETDFL("GeantEventV004");
  INSDFL(dfl__,TstHit);}
{ int dfl__;
  dfl__= GETDFL("GeantEventV004");
  INSDFL(dfl__,DigitPln);}
{ int dfl__;
  dfl__= GETDFL("GeantEventV004");
  INSDFL(dfl__,FLSDigit);}
{ int dfl__;
  dfl__= GETDFL("GeantEventV004");
  INSDFL(dfl__,LSTWire);}
{ int dfl__;
  dfl__= GETDFL("GeantEventV004");
  INSDFL(dfl__,LSTStrip);}
{ int dfl__;
  dfl__= GETDFL("GeantEventV004");
  INSDFL(dfl__,RecoVtx);}
{ int dfl__;
  dfl__= GETDFL("GeantEventV004");
  INSDFL(dfl__,RecoShwEnergy);}
{ int dfl__;
  dfl__= GETDFL("GeantEventV004");
  INSDFL(dfl__,RecoShwDir);}
{ int dfl__;
  dfl__= GETDFL("GeantEventV004");
  INSDFL(dfl__,RecoMuon);}
{ int dfl__;
  dfl__= GETDFL("GeantEventV004");
  INSDFL(dfl__,MuonTrkHeader);}
{ int dfl__;
  dfl__= GETDFL("GeantEventV004");
  INSDFL(dfl__,MuonTrkPoint);}
{ int dfl__;
  dfl__= GETDFL("GeantEventV004");
  INSDFL(dfl__,FLSDigiCell);}
{ int dfl__;
  dfl__= GETDFL("GeantEventV004");
  INSDFL(dfl__,FLSDigiPln);}
{ int dfl__;
  dfl__= GETDFL("GeantEventV004");
  INSDFL(dfl__,FLSDigiView);}
{ int dfl__;
  dfl__= GETDFL("GeantEventV005");
  INSDFL(dfl__,EventHistory);}
{ int dfl__;
  dfl__= GETDFL("GeantEventV005");
  INSDFL(dfl__,FluxWgt);}
{ int dfl__;
  dfl__= GETDFL("GeantEventV005");
  INSDFL(dfl__,NeuVtx);}
{ int dfl__;
  dfl__= GETDFL("GeantEventV005");
  INSDFL(dfl__,NeuKin);}
{ int dfl__;
  dfl__= GETDFL("GeantEventV005");
  INSDFL(dfl__,StdHepHead);}
{ int dfl__;
  dfl__= GETDFL("GeantEventV005");
  INSDFL(dfl__,StdHep);}
{ int dfl__;
  dfl__= GETDFL("GeantEventV005");
  INSDFL(dfl__,HitPln);}
{ int dfl__;
  dfl__= GETDFL("GeantEventV005");
  INSDFL(dfl__,FLSHit);}
{ int dfl__;
  dfl__= GETDFL("GeantEventV005");
  INSDFL(dfl__,LSTHit);}
{ int dfl__;
  dfl__= GETDFL("GeantEventV005");
  INSDFL(dfl__,RPCHit);}
{ int dfl__;
  dfl__= GETDFL("GeantEventV005");
  INSDFL(dfl__,EmuHit);}
{ int dfl__;
  dfl__= GETDFL("GeantEventV005");
  INSDFL(dfl__,TstHit);}
{ int dfl__;
  dfl__= GETDFL("GeantEventV005");
  INSDFL(dfl__,DigitPln);}
{ int dfl__;
  dfl__= GETDFL("GeantEventV005");
  INSDFL(dfl__,FLSDigit);}
{ int dfl__;
  dfl__= GETDFL("GeantEventV005");
  INSDFL(dfl__,LSTWire);}
{ int dfl__;
  dfl__= GETDFL("GeantEventV005");
  INSDFL(dfl__,LSTStrip);}
{ int dfl__;
  dfl__= GETDFL("GeantEventV005");
  INSDFL(dfl__,EmuDigit);}
{ int dfl__;
  dfl__= GETDFL("GeantEventV005");
  INSDFL(dfl__,RecoVtx);}
{ int dfl__;
  dfl__= GETDFL("GeantEventV005");
  INSDFL(dfl__,RecoShwEnergy);}
{ int dfl__;
  dfl__= GETDFL("GeantEventV005");
  INSDFL(dfl__,RecoShwDir);}
{ int dfl__;
  dfl__= GETDFL("GeantEventV005");
  INSDFL(dfl__,RecoMuon);}
{ int dfl__;
  dfl__= GETDFL("GeantEventV005");
  INSDFL(dfl__,MuonTrkHeader);}
{ int dfl__;
  dfl__= GETDFL("GeantEventV005");
  INSDFL(dfl__,MuonTrkPoint);}
{ int dfl__;
  dfl__= GETDFL("GeantEventV005");
  INSDFL(dfl__,FLSDigiCell);}
{ int dfl__;
  dfl__= GETDFL("GeantEventV005");
  INSDFL(dfl__,FLSDigiPln);}
{ int dfl__;
  dfl__= GETDFL("GeantEventV005");
  INSDFL(dfl__,FLSDigiView);}
{ int dfl__;
  dfl__= GETDFL("GeantEventV006");
  INSDFL(dfl__,EventHistory);}
{ int dfl__;
  dfl__= GETDFL("GeantEventV006");
  INSDFL(dfl__,FluxWgt);}
{ int dfl__;
  dfl__= GETDFL("GeantEventV006");
  INSDFL(dfl__,NeuVtx);}
{ int dfl__;
  dfl__= GETDFL("GeantEventV006");
  INSDFL(dfl__,NeuKin);}
{ int dfl__;
  dfl__= GETDFL("GeantEventV006");
  INSDFL(dfl__,StdHepHead);}
{ int dfl__;
  dfl__= GETDFL("GeantEventV006");
  INSDFL(dfl__,StdHep);}
{ int dfl__;
  dfl__= GETDFL("GeantEventV006");
  INSDFL(dfl__,HitPln);}
{ int dfl__;
  dfl__= GETDFL("GeantEventV006");
  INSDFL(dfl__,FLSHit);}
{ int dfl__;
  dfl__= GETDFL("GeantEventV006");
  INSDFL(dfl__,LSTHit);}
{ int dfl__;
  dfl__= GETDFL("GeantEventV006");
  INSDFL(dfl__,RPCHit);}
{ int dfl__;
  dfl__= GETDFL("GeantEventV006");
  INSDFL(dfl__,EmuHit);}
{ int dfl__;
  dfl__= GETDFL("GeantEventV006");
  INSDFL(dfl__,TstHit);}
{ int dfl__;
  dfl__= GETDFL("GeantEventV006");
  INSDFL(dfl__,DigitPln);}
{ int dfl__;
  dfl__= GETDFL("GeantEventV006");
  INSDFL(dfl__,FLSDigit);}
{ int dfl__;
  dfl__= GETDFL("GeantEventV006");
  INSDFL(dfl__,LSTWire);}
{ int dfl__;
  dfl__= GETDFL("GeantEventV006");
  INSDFL(dfl__,LSTStrip);}
{ int dfl__;
  dfl__= GETDFL("GeantEventV006");
  INSDFL(dfl__,EmuDigit);}
{ int dfl__;
  dfl__= GETDFL("GeantEventV006");
  INSDFL(dfl__,RecoVtx);}
{ int dfl__;
  dfl__= GETDFL("GeantEventV006");
  INSDFL(dfl__,RecoShwEnergy);}
{ int dfl__;
  dfl__= GETDFL("GeantEventV006");
  INSDFL(dfl__,RecoShwDir);}
{ int dfl__;
  dfl__= GETDFL("GeantEventV006");
  INSDFL(dfl__,RecoMuon);}
{ int dfl__;
  dfl__= GETDFL("GeantEventV006");
  INSDFL(dfl__,MuonTrkHeader);}
{ int dfl__;
  dfl__= GETDFL("GeantEventV006");
  INSDFL(dfl__,MuonTrkPoint);}
{ int dfl__;
  dfl__= GETDFL("GeantEventV006");
  INSDFL(dfl__,FLSDigiCell);}
{ int dfl__;
  dfl__= GETDFL("GeantEventV006");
  INSDFL(dfl__,FLSDigiPln);}
{ int dfl__;
  dfl__= GETDFL("GeantEventV006");
  INSDFL(dfl__,FLSDigiView);}
{ int dfl__;
  dfl__= GETDFL("GeantEventV006");
  INSDFL(dfl__,PEArrival);}
{ int dfl__;
  dfl__= GETDFL("MinosGeom");
  INSDFL(dfl__,GeomMisc);}
{ int dfl__;
  dfl__= GETDFL("MinosGeom");
  INSDFL(dfl__,SuperModule);}
{ int dfl__;
  dfl__= GETDFL("MinosGeom");
  INSDFL(dfl__,MdlOrg);}
{ int dfl__;
  dfl__= GETDFL("MinosGeom");
  INSDFL(dfl__,PlanePos);}
{ int dfl__;
  dfl__= GETDFL("MinosGeom");
  INSDFL(dfl__,PlaneSpec);}
{ int dfl__;
  dfl__= GETDFL("MinosGeom");
  INSDFL(dfl__,CellPos);}
{ int dfl__;
  dfl__= GETDFL("MinosGeom");
  INSDFL(dfl__,SubVolSpec);}
{ int dfl__;
  dfl__= GETDFL("MinosGeom");
  INSDFL(dfl__,Material);}
{ int dfl__;
  dfl__= GETDFL("MinosGeom");
  INSDFL(dfl__,Mixture);}
{ int dfl__;
  dfl__= GETDFL("MinosGeom");
  INSDFL(dfl__,TMedium);}
{ int dfl__;
  dfl__= GETDFL("MinosGeom");
  INSDFL(dfl__,TPar);}
{ int dfl__;
  dfl__= GETDFL("MinosGeom");
  INSDFL(dfl__,Rotm);}
{ int dfl__;
  dfl__= GETDFL("MinosGeom");
  INSDFL(dfl__,BeamSystem);}
{ int dfl__;
  dfl__= GETDFL("MinosGeomV002");
  INSDFL(dfl__,GeomMisc);}
{ int dfl__;
  dfl__= GETDFL("MinosGeomV002");
  INSDFL(dfl__,SuperModule);}
{ int dfl__;
  dfl__= GETDFL("MinosGeomV002");
  INSDFL(dfl__,MdlOrg);}
{ int dfl__;
  dfl__= GETDFL("MinosGeomV002");
  INSDFL(dfl__,PlanePos);}
{ int dfl__;
  dfl__= GETDFL("MinosGeomV002");
  INSDFL(dfl__,PlaneSpec);}
{ int dfl__;
  dfl__= GETDFL("MinosGeomV002");
  INSDFL(dfl__,CellPos);}
{ int dfl__;
  dfl__= GETDFL("MinosGeomV002");
  INSDFL(dfl__,SubVolSpec);}
{ int dfl__;
  dfl__= GETDFL("MinosGeomV002");
  INSDFL(dfl__,Material);}
{ int dfl__;
  dfl__= GETDFL("MinosGeomV002");
  INSDFL(dfl__,Mixture);}
{ int dfl__;
  dfl__= GETDFL("MinosGeomV002");
  INSDFL(dfl__,TMedium);}
{ int dfl__;
  dfl__= GETDFL("MinosGeomV002");
  INSDFL(dfl__,TPar);}
{ int dfl__;
  dfl__= GETDFL("MinosGeomV002");
  INSDFL(dfl__,Rotm);}
{ int dfl__;
  dfl__= GETDFL("MinosGeomV002");
  INSDFL(dfl__,BeamSystem);}
{ int dfl__;
  dfl__= GETDFL("MinosGeomV003");
  INSDFL(dfl__,GeomMisc);}
{ int dfl__;
  dfl__= GETDFL("MinosGeomV003");
  INSDFL(dfl__,SuperModule);}
{ int dfl__;
  dfl__= GETDFL("MinosGeomV003");
  INSDFL(dfl__,MdlOrg);}
{ int dfl__;
  dfl__= GETDFL("MinosGeomV003");
  INSDFL(dfl__,PlanePos);}
{ int dfl__;
  dfl__= GETDFL("MinosGeomV003");
  INSDFL(dfl__,PlaneSpec);}
{ int dfl__;
  dfl__= GETDFL("MinosGeomV003");
  INSDFL(dfl__,CellPos);}
{ int dfl__;
  dfl__= GETDFL("MinosGeomV003");
  INSDFL(dfl__,SubVolSpec);}
{ int dfl__;
  dfl__= GETDFL("MinosGeomV003");
  INSDFL(dfl__,CoilTube);}
{ int dfl__;
  dfl__= GETDFL("MinosGeomV003");
  INSDFL(dfl__,Material);}
{ int dfl__;
  dfl__= GETDFL("MinosGeomV003");
  INSDFL(dfl__,Mixture);}
{ int dfl__;
  dfl__= GETDFL("MinosGeomV003");
  INSDFL(dfl__,TMedium);}
{ int dfl__;
  dfl__= GETDFL("MinosGeomV003");
  INSDFL(dfl__,TPar);}
{ int dfl__;
  dfl__= GETDFL("MinosGeomV003");
  INSDFL(dfl__,Rotm);}
{ int dfl__;
  dfl__= GETDFL("MinosGeomV003");
  INSDFL(dfl__,BeamSystem);}
{ int dfl__;
  dfl__= GETDFL("MinosGeomV004");
  INSDFL(dfl__,GeomMisc);}
{ int dfl__;
  dfl__= GETDFL("MinosGeomV004");
  INSDFL(dfl__,SuperModule);}
{ int dfl__;
  dfl__= GETDFL("MinosGeomV004");
  INSDFL(dfl__,MdlOrg);}
{ int dfl__;
  dfl__= GETDFL("MinosGeomV004");
  INSDFL(dfl__,PlanePos);}
{ int dfl__;
  dfl__= GETDFL("MinosGeomV004");
  INSDFL(dfl__,PlaneSpec);}
{ int dfl__;
  dfl__= GETDFL("MinosGeomV004");
  INSDFL(dfl__,CellPos);}
{ int dfl__;
  dfl__= GETDFL("MinosGeomV004");
  INSDFL(dfl__,SubVolSpec);}
{ int dfl__;
  dfl__= GETDFL("MinosGeomV004");
  INSDFL(dfl__,CoilTube);}
{ int dfl__;
  dfl__= GETDFL("MinosGeomV004");
  INSDFL(dfl__,Material);}
{ int dfl__;
  dfl__= GETDFL("MinosGeomV004");
  INSDFL(dfl__,Mixture);}
{ int dfl__;
  dfl__= GETDFL("MinosGeomV004");
  INSDFL(dfl__,TMedium);}
{ int dfl__;
  dfl__= GETDFL("MinosGeomV004");
  INSDFL(dfl__,TPar);}
{ int dfl__;
  dfl__= GETDFL("MinosGeomV004");
  INSDFL(dfl__,Rotm);}
{ int dfl__;
  dfl__= GETDFL("MinosGeomV004");
  INSDFL(dfl__,BeamSystem);}
{ int dfl__;
  dfl__= GETDFL("MinosGeomV004");
  INSDFL(dfl__,FLSParam);}
{ int dfl__;
  dfl__= GETDFL("MinosGeomV004");
  INSDFL(dfl__,TubePixelInfo);}
{ int dfl__;
  dfl__= GETDFL("MinosGeomV004");
  INSDFL(dfl__,Pln2MUX);}
{ int dfl__;
  dfl__= GETDFL("MinosGeomV004");
  INSDFL(dfl__,TubePixelMap);}
{ int dfl__;
  dfl__= GETDFL("MinosGeomV005");
  INSDFL(dfl__,GeomMisc);}
{ int dfl__;
  dfl__= GETDFL("MinosGeomV005");
  INSDFL(dfl__,SuperModule);}
{ int dfl__;
  dfl__= GETDFL("MinosGeomV005");
  INSDFL(dfl__,MdlOrg);}
{ int dfl__;
  dfl__= GETDFL("MinosGeomV005");
  INSDFL(dfl__,PlanePos);}
{ int dfl__;
  dfl__= GETDFL("MinosGeomV005");
  INSDFL(dfl__,PlaneSpec);}
{ int dfl__;
  dfl__= GETDFL("MinosGeomV005");
  INSDFL(dfl__,CellPos);}
{ int dfl__;
  dfl__= GETDFL("MinosGeomV005");
  INSDFL(dfl__,SubVolSpec);}
{ int dfl__;
  dfl__= GETDFL("MinosGeomV005");
  INSDFL(dfl__,CoilTube);}
{ int dfl__;
  dfl__= GETDFL("MinosGeomV005");
  INSDFL(dfl__,Material);}
{ int dfl__;
  dfl__= GETDFL("MinosGeomV005");
  INSDFL(dfl__,Mixture);}
{ int dfl__;
  dfl__= GETDFL("MinosGeomV005");
  INSDFL(dfl__,TMedium);}
{ int dfl__;
  dfl__= GETDFL("MinosGeomV005");
  INSDFL(dfl__,TPar);}
{ int dfl__;
  dfl__= GETDFL("MinosGeomV005");
  INSDFL(dfl__,Rotm);}
{ int dfl__;
  dfl__= GETDFL("MinosGeomV005");
  INSDFL(dfl__,BeamSystem);}
{ int dfl__;
  dfl__= GETDFL("MinosGeomV005");
  INSDFL(dfl__,FLSParam);}
{ int dfl__;
  dfl__= GETDFL("MinosGeomV005");
  INSDFL(dfl__,TubePixelInfo);}
{ int dfl__;
  dfl__= GETDFL("MinosGeomV005");
  INSDFL(dfl__,Pln2MUX);}
{ int dfl__;
  dfl__= GETDFL("MinosGeomV005");
  INSDFL(dfl__,TubePixelMap);}
{ int dfl__;
  dfl__= GETDFL("MinosGeomV006");
  INSDFL(dfl__,GeomMisc);}
{ int dfl__;
  dfl__= GETDFL("MinosGeomV006");
  INSDFL(dfl__,SuperModule);}
{ int dfl__;
  dfl__= GETDFL("MinosGeomV006");
  INSDFL(dfl__,MdlOrg);}
{ int dfl__;
  dfl__= GETDFL("MinosGeomV006");
  INSDFL(dfl__,PlanePos);}
{ int dfl__;
  dfl__= GETDFL("MinosGeomV006");
  INSDFL(dfl__,PlaneSpec);}
{ int dfl__;
  dfl__= GETDFL("MinosGeomV006");
  INSDFL(dfl__,CellPos);}
{ int dfl__;
  dfl__= GETDFL("MinosGeomV006");
  INSDFL(dfl__,SubVolSpec);}
{ int dfl__;
  dfl__= GETDFL("MinosGeomV006");
  INSDFL(dfl__,CoilTube);}
{ int dfl__;
  dfl__= GETDFL("MinosGeomV006");
  INSDFL(dfl__,Material);}
{ int dfl__;
  dfl__= GETDFL("MinosGeomV006");
  INSDFL(dfl__,Mixture);}
{ int dfl__;
  dfl__= GETDFL("MinosGeomV006");
  INSDFL(dfl__,TMedium);}
{ int dfl__;
  dfl__= GETDFL("MinosGeomV006");
  INSDFL(dfl__,TPar);}
{ int dfl__;
  dfl__= GETDFL("MinosGeomV006");
  INSDFL(dfl__,Rotm);}
{ int dfl__;
  dfl__= GETDFL("MinosGeomV006");
  INSDFL(dfl__,BeamSystem);}
{ int dfl__;
  dfl__= GETDFL("MinosGeomV006");
  INSDFL(dfl__,FLSParam);}
{ int dfl__;
  dfl__= GETDFL("MinosGeomV006");
  INSDFL(dfl__,TubePixelInfo);}
{ int dfl__;
  dfl__= GETDFL("MinosGeomV006");
  INSDFL(dfl__,Pln2MUX);}
{ int dfl__;
  dfl__= GETDFL("MinosGeomV006");
  INSDFL(dfl__,TubePixelMap);}

} /* End of CREOBJ */
*DK INITAP
/*
        Define memory size (words)
*/
#define MEMSZ    1000000
#include "initap.h"
 
void INITAP() {
/*
        Generated on: 23-Feb-20 1 at: 12:11
*/
static char tapver[]="12345678",gafver[]="12345678";
static int io[] = {3,-2,-1,-1};
/*
        Initialise ZEBRA
*/
MZEBRA(io);
/*      MZVERS();
 
         Open TAP and create objects
*/
OPETAP(MEMSZ);
GETVER(tapver,gafver);
printf("ADAMO/TAP version %s with GAF version %s starting
",
                         tapver,gafver);
CREOBJ();
 
}