ROOT logo
//*--- Author : V.Pechenov
//*--- Modified: 16.08.05 V.Pechenov

using namespace std;
#include <iostream>
#include <iomanip>

#include "hmdcwiredata.h"
#include "hmdccal1sim.h"
#include "hmdcdrifttimepar.h"
#include "hmdctrackparam.h"
#include "hmdcwirefitsim.h"
#include "hmdcclusfitsim.h"
#include "hmdctrackfitter.h"
#include "hmdcclussim.h"
#include "hmatrixcategory.h"
#include "hmdclistcells.h"
#include "hmdctrackdset.h"
#include "hgeantkine.h"
#include "hgeantmdc.h"
#include "hmdcsizescells.h"

//_HADES_CLASS_DESCRIPTION 
//////////////////////////////////////////////////////////////////////////////
//
//  HMdcWireData
//
//    Class keep one wire data for track fitter.
//
//  HMdcWireArr
//
//    Array of HMdcWireData objects.
//
//////////////////////////////////////////////////////////////////////////////

ClassImp(HMdcWireData)
ClassImp(HMdcWiresArr)

HMdcDriftTimePar* HMdcWireData::pDrTimePar = NULL;

HMdcWireData::HMdcWireData(void) {
  drTimeDist = -1.;
}

void HMdcWireData::setCell(Int_t s, Int_t m, Int_t l, Int_t c, Int_t it, Float_t t, Int_t si) {
  sector      = s;
  module      = m;
  layer       = l;
  cell        = c;
  timeIndx    = it;
  tdcTimeCal1 = t;
  tdcTime     = t;
  fMdcCal1    = 0;
  secInd      = si;
  modInd      = module+4*si;
  setInitVal();
}

void HMdcWireData::setCell(HMdcCal1* cal1, Int_t it, Bool_t isGeant, Int_t si) {
  cal1->getAddress(sector, module,layer,cell);
  timeIndx    = it;
  if(timeIndx==1) tdcTimeCal1 = cal1->getTime1();
  else            tdcTimeCal1 = cal1->getTime2();
  tdcTime     = tdcTimeCal1;
  fMdcCal1    = cal1;
  secInd      = si;
  modInd      = module+4*si;
  setInitVal();
  if(isGeant) {
    HMdcCal1Sim* c=(HMdcCal1Sim*)cal1;
    if(timeIndx==1) {
      geantTrackNum = c->getNTrack1();
      tof           = c->getTof1();
    } else {
      geantTrackNum = c->getNTrack2();
      tof           = c->getTof2();
    }
  } else geantTrackNum = -1;
}

void HMdcWireData::setInitVal(void) {
  weight           = 1.;
  hitStatus        = 1;
  errTdcTime       = 1.;
  oneDErrTdcTime2  = 1.;
  wtNorm           = weight*oneDErrTdcTime2;
  signalTimeOffset = 0.;
  isWireUsed       = kTRUE;
  distanceSign     = 0;
  useInFit         = kTRUE;
}

void HMdcWireData::setUnitWeight(void) {
  // For target scan only!
  if(hitStatus==0) return;
  weight           = useInFit ? 1.:0.;
  errTdcTime       = oneDErrTdcTime2 = 1.;
  wtNorm           = weight*oneDErrTdcTime2;
  signalTimeOffset = 0.;
}

void HMdcWireData::reinitWtSt(void) {
  weight           = 1.;
  hitStatus        = 1;
  isWireUsed       = kTRUE;
  useInFit         = kTRUE;
}

void HMdcWireData::setNegTdcTimeTo0(void) {
  if(tdcTime<0.) tdcTime = 0.;
}

void HMdcWireData::setSignalTimeOffset(Double_t offset) {
  // must be called after setCell !
  signalTimeOffset = offset;
  tdcTime          = tdcTimeCal1-signalTimeOffset;
}

void HMdcWireData::calcTdcErrors(HMdcTrackParam& par) {
  if(hitStatus==0) return;
  Double_t drtime = tdcTime-par.getTimeOffset(modInd);
  if(drtime < 0.) drtime = 0.;
  Double_t dist   = pDrTimePar->calcDistance(sector,module,alpha,drtime);
  if(dist < 0.) dist = 0.;
  errTdcTime      = pDrTimePar->calcTimeErr(sector,module,alpha,dist);
  oneDErrTdcTime2 = 1./(errTdcTime*errTdcTime);
  wtNorm          = weight*oneDErrTdcTime2;
}

void HMdcWireData::calcTdcErrors(void) {
  // Function calculates drift time error by measure tdcTime and impact angle alpha
  // Time offset is not used.
  if(hitStatus==0) return;
  Double_t drtime   = tdcTime < 0. ? 0. : tdcTime;
  Double_t distance = pDrTimePar->calcDistance(sector,module,alpha,drtime);
  if(distance < 0.) distance = 0.;
  errTdcTime        = pDrTimePar->calcTimeErr(sector,module,alpha,distance);
  oneDErrTdcTime2   = 1./(errTdcTime*errTdcTime);
  wtNorm            = weight*oneDErrTdcTime2;
}

Bool_t HMdcWireData::setWeightTo1or0(Double_t maxChi2, Double_t minWeight) {
  isWireUsedPr = isWireUsed;
  if(chi2<maxChi2 || weight>minWeight) {
    setWeightEq1();
    if(hitStatus==1) return kTRUE;
  } else setWeightEq0();
  return kFALSE;
}

void HMdcWireData::setWeightEq1(void) {
  weight     = useInFit ? 1.:0.;
  wtNorm     = weight*oneDErrTdcTime2;
  isWireUsed = kTRUE;
}

void HMdcWireData::setWeightEq0(void) {
  weight     = 0.;
  wtNorm     = 0.;
  isWireUsed = kFALSE;
}

Bool_t HMdcWireData::testWeight1or0(void) {
  return hitStatus!=1 || isWireUsedPr!=isWireUsed;
}

void HMdcWireData::calcDistanceSign(HMdcTrackParam& par) {
  if(hitStatus != 0) distanceSign = pSCLayer->distanceSign(par,cell);
  else distanceSign = 0;
}

void HMdcWireData::calcDriftTime(HMdcTrackParam& par) {
  // calculation of distance to the wire, impact ang. and drift time
  if(hitStatus != 0) {
    distance      = pSCLayer->getImpact(par,cell,alpha,y,z,dirY,dirZ);
//!    driftTime     = pDrTimePar->calcTime(sector,module,alpha,distance);
if(TMath::IsNaN(alpha)) {printf("!!!!!!!!!!! 1. alpha=nan !!!!!!!!!!!!!!!!!\n"); par.printParam();}
    pDrTimeParBin = pDrTimePar->getBinDist(sector,module,alpha,distance);
    driftTime     = pDrTimeParBin->calcTime(alpha,distance);
    dev0          = driftTime - tdcTime;
    if(hitStatus==1) par.addToSumsDevWt(modInd,dev0,wtNorm);
  }
}

void HMdcWireData::calcDriftTimeAndErr(HMdcTrackParam& par) {
  // calculation of distance to the wire, impact ang., drift time
  // and drift time error
  if(hitStatus != 0) {
    distance        = pSCLayer->getImpact(par,cell,alpha,y,z,dirY,dirZ);
//!    driftTime       = pDrTimePar->calcTime(sector,module,alpha,distance);
if(TMath::IsNaN(alpha)) {printf("!!!!!!!!!!! 2. alpha=nan !!!!!!!!!!!!!!!!!\n"); par.printParam();}
    pDrTimeParBin   = pDrTimePar->getBinDist(sector,module,alpha,distance);
    driftTime       = pDrTimeParBin->calcTime(alpha,distance);
    dev0            = driftTime - tdcTime;
    errTdcTime      = pDrTimeParBin->calcTimeErr(alpha,distance);
    oneDErrTdcTime2 = 1./(errTdcTime*errTdcTime);
    wtNorm          = weight*oneDErrTdcTime2;
    if(hitStatus==1) par.addToSumsDevWt(modInd,dev0,wtNorm);
  }
}

void HMdcWireData::calcDriftTimeAndInCell(HMdcTrackParam& par) {
  // calculation of distance to the wire, impact ang. and drift time
  if(hitStatus != 0) {
    inCell        = pSCLayer->getImpact(par,cell,alpha,distance,y,z,dirY,dirZ);
//!    driftTime     = pDrTimePar->calcTime(sector,module,alpha,distance);
if(TMath::IsNaN(alpha)) {printf("!!!!!!!!!!! 3. alpha=nan !!!!!!!!!!!!!!!!!\n"); par.printParam();}
    pDrTimeParBin = pDrTimePar->getBinDist(sector,module,alpha,distance);
    driftTime     = pDrTimeParBin->calcTime(alpha,distance);
    dev0          = driftTime - tdcTime;
    if(hitStatus==1) par.addToSumsDevWt(modInd,dev0,wtNorm);
  }
}

void HMdcWireData::calcDriftTimeAndErrAndInCell(HMdcTrackParam& par) {
  // calculation of distance to the wire, impact ang., drift time
  // and drift time error
  if(hitStatus != 0) {
    inCell          = pSCLayer->getImpact(par,cell,alpha,distance,y,z,dirY,dirZ);
if(TMath::IsNaN(alpha)) {printf("!!!!!!!!!!! 4. alpha=nan !!!!!!!!!!!!!!!!!\n"); par.printParam();}
    pDrTimeParBin   = pDrTimePar->getBinDist(sector,module,alpha,distance);
    driftTime       = pDrTimeParBin->calcTime(alpha,distance);
    dev0            = driftTime - tdcTime;
    errTdcTime      = pDrTimeParBin->calcTimeErr(alpha,distance);
    oneDErrTdcTime2 = 1./(errTdcTime*errTdcTime);
    wtNorm          = weight*oneDErrTdcTime2;
    if(hitStatus==1) par.addToSumsDevWt(modInd,dev0,wtNorm);
  }
}

void HMdcWireData::calcDriftTimeForDeriv(HMdcTrackParam& par) {
  // calculation drift time for derivatives
  if(hitStatus==1) {
    Double_t alphaD;
    Double_t distD = pSCLayer->getImpact(par,cell,alphaD,y,z,dirY,dirZ);
//if(TMath::IsNaN(alphaD)) {printf("!!!!!!!!!!! 5. alphaD=nan !!!!!!!!!!!!!!!!!\n"); par.printParam();}
    driftTimeDer   = pDrTimeParBin->calcTime(alphaD,distD);
    devDer         = driftTimeDer - tdcTime;
    par.addToSumsDevWt(modInd,devDer,wtNorm);
  }
}

Double_t HMdcWireData::calcDriftTimeForAlign(const HGeomVector& p1,const HGeomVector& p2,
                                             Int_t& distSign) {
  // p1,p2 - in ROTATED LAYER COOR.SYS.!!!
  // For calculation of alignment parameters derivatives only
  if(hitStatus != 1) return 0;
  Double_t alphaD;
  Double_t distD  = pSCLayer->getImpactLSys(p1,p2,cell,alphaD,distSign);
if(TMath::IsNaN(alphaD)) {printf("!!!!!!!!!!! 6. alphaD=nan !!!!!!!!!!!!!!!!!\n");}
  return pDrTimeParBin->calcTime(alphaD,distD);
}

void HMdcWireData::fillLookupTableForDer(HMdcTrackParam& par) {
  Int_t parSec = par.getSec();
  if(parSec==sector || parSec<0) fillLookupTableForDer(pSCLayer->getRotLaySysRSec(cell),par);
  else {
    HGeomTransform trans;
    pSCLayer->getRotLSysForOtherSecSys(parSec,cell,trans);
    fillLookupTableForDer(trans,par);
  }
}

void HMdcWireData::fillLookupTableForDer(const HGeomTransform& trans,HMdcTrackParam& par) { 
  const HGeomRotation& rot=trans.getRotMatrix();
  dYdP[0] = rot(1)+rot(7)*par.dZ1dX1();
  dYdP[1] = rot(4)+rot(7)*par.dZ1dY1();
  dYdP[2] = dYdP[3] = 0.;
  dZdP[0] = rot(2)+rot(8)*par.dZ1dX1();
  dZdP[1] = rot(5)+rot(8)*par.dZ1dY1();
  dZdP[2] = dZdP[3] = 0.;
  
  dDirYdP[0] = rot(1)*par.dDirXdX1()+rot(7)*par.dDirZdX1();
  dDirYdP[1] = rot(4)*par.dDirYdY1()+rot(7)*par.dDirZdY1();
  dDirYdP[2] = rot(1)*par.dDirXdX2()+rot(7)*par.dDirZdX2();
  dDirYdP[3] = rot(4)*par.dDirYdY2()+rot(7)*par.dDirZdY2();
  
  dDirZdP[0] = rot(2)*par.dDirXdX1()+rot(8)*par.dDirZdX1();
  dDirZdP[1] = rot(5)*par.dDirYdY1()+rot(8)*par.dDirZdY1();
  dDirZdP[2] = rot(2)*par.dDirXdX2()+rot(8)*par.dDirZdX2();
  dDirZdP[3] = rot(5)*par.dDirYdY2()+rot(8)*par.dDirZdY2();

  for(Int_t k=0; k<4; k++) {
    cd2DsdP2[k]=dDirZdP[k]*dYdP[k]-dDirYdP[k]*dZdP[k];
    Int_t kn=(k<3) ? k-1:k;
    for(Int_t l=0; l<k; l++) {
      Int_t i=kn+l;
      cd2DsdPkdPl[i]=dDirZdP[l]*dYdP[k]-dDirYdP[l]*dZdP[k];
      cdVkdPl[i]=dDirYdP[l]*dDirZdP[k] - dDirZdP[l]*dDirYdP[k];
      cdUkdPl[i]=dDirZdP[l]*dDirZdP[k] + dDirYdP[l]*dDirYdP[k];
    }
  }
}

void HMdcWireData::calcAnalytDeriv(HMdcTrackParam& par,Int_t flag) {
  // calculation of the first and second derivatives
  // flag=0 - grad calculation only
  // flag=1 - calculation first derivatives only
  // flag=2 - calculation first and second derivatives
  // flag=3 - calculation first and second derivatives +  errors
  if(hitStatus!=1) return;
  Double_t dirZY2    = 1./(dirZ*dirZ+dirY*dirY);
  Double_t dirZY     = TMath::Sqrt(dirZY2); 
  if(y*dirZ < z*dirY) dirZY=-dirZY;        // +sign 
  Double_t yDrYzDrZ  = y*dirY+z*dirZ;
  Double_t c2wtNr    = 2.*wtNorm;
  Double_t c2wtNrDev = c2wtNr*dev;
  Double_t radToDeg  = TMath::RadToDeg();
  if(dirY*dirZ <0.) radToDeg=-radToDeg;    // +sign
  
  Double_t cdAl,cdDs,cdAldDs;
  pDrTimeParBin->coeffForDer(alpha,distance,cdAl,cdDs,cdAldDs);
  Double_t cDb=2*cdAldDs;
  
  Double_t u[4],w[4],dDsdP[4],dAldP[4];
  Double_t dirYn=dirY*dirZY2;
  Double_t dirZn=dirZ*dirZY2;

  for(Int_t k=0;k<4;k++) {
    Double_t& dDsdPk=dDsdP[k];
    Double_t& uk=u[k];
    Double_t& dAldPk=dAldP[k];
    Double_t& dTdPk=dTdP[k];
    
    Double_t vk     = dirYn*dDirZdP[k] - dirZn*dDirYdP[k];
    dDsdPk = (dirZ*dYdP[k]-dirY*dZdP[k]+yDrYzDrZ*vk)*dirZY;      // dDist/dPk^2
    dAldPk = vk*radToDeg;                                        // dAlpha/dPk^2
    dTdPk  = cdDs*dDsdPk + cdAl*dAldPk;                          // dTime/dPk
    if(flag!=3) {
      grad[k] += c2wtNrDev*dTdPk;
      if(flag==0) continue;
    } else (*matrH)(k,k) += 4.*wtNorm*dTdPk*dTdPk;
    par.addToTOffsetDer(modInd,k,dTdPk*wtNorm);
    uk=dirZn*dDirZdP[k]+dirYn*dDirYdP[k];
    Double_t dVdP=-2.*vk*uk;                                     // dV/dPk
    w[k]=dirY*dYdP[k]+dirZ*dZdP[k]+y*dDirYdP[k]+z*dDirZdP[k];    // d(yDrYzDrZ)/dPk
    Double_t d2DsdP=(cd2DsdP2[k]+vk*w[k]+yDrYzDrZ*dVdP)*dirZY - 
        dDsdPk*uk;                                               // d2Dist/dPk^2
    Double_t d2AldP=dVdP*radToDeg;                               // d2Alpha/dPk^2
    Double_t d2TdP2=cdDs*d2DsdP+cdAl*d2AldP+cDb*dAldPk*dDsdPk;   // d2Tm/dPk^2
    (*grad2)(k,k) += c2wtNr*(dev*d2TdP2 + dTdPk*dTdPk);
    
    if(flag<2) continue;
    
    Int_t kn=(k<3) ? k-1:k;
    for(Int_t l=0;l<k;l++) {
      Int_t i=kn+l;
      Double_t dVkdPl     = cdVkdPl[i]*dirZY2 - 2.*vk*u[l];    // dVk/dPl
      Double_t d2DsdPkdPl = (cd2DsdPkdPl[i] + w[l]*vk + 
          yDrYzDrZ*dVkdPl)*dirZY - dDsdPk*u[l];                // d2Dist/dPkdPl
      Double_t dUkdPl     = cdUkdPl[i]*dirZY2 - 2.*vk*u[l];    // dUk/dPl
      Double_t dVkdPkdPl  = -2.*(uk*dVkdPl+vk*dUkdPl);         // d2Vk/dPkdPl
      Double_t d2AlPkdPl  = dVkdPkdPl*radToDeg;                // d2Alpha/dPkdPl
      Double_t d2TdPkdPl  = cdDs*d2DsdPkdPl + cdAl*d2AlPkdPl + 
          cdAldDs*(dAldPk*dDsdP[l] + dDsdPk*dAldP[l]);         // d2Tm/dPkdPl
      (*grad2)(k,l) += c2wtNr*(dev*d2TdPkdPl + dTdPk*dTdP[l]);
      if(flag==3) (*matrH)(k,l) += 4.*wtNorm*dTdPk*dTdP[l];
    }
  }
}

Bool_t HMdcWireData::getAnalytDeriv(Float_t* der,HMdcTrackParam* par) {
  // This funct. is used in alignment only & must be called after track seg.fit.
  // "par" - track parameters after track seg.fit.
  // Return the derivatives dTcalc/dPk. k = 0,1,2,3
  // If par==0 - time offset is assumed constant,
  // else - dTof/dPk is added to dTcalc/dPk.
  // Size of "der" must be >=4 !
  if(hitStatus!=1 || der==0 ) return kFALSE;
  if(par) {
    Double_t dTofdP[4];
    par->getTimeOffsetDer(dTofdP);
    for(Int_t k=0;k<4;k++) der[k] = dTdP[k] + dTofdP[k];
  } else for(Int_t k=0;k<4;k++) der[k] = dTdP[k];
  return kTRUE;
}

void HMdcWireData::recalcFunctional(HMdcTrackParam& par) {
  // Recalculation of finctional without calculation of ditances
  // (for the same parameters as before)
  if(hitStatus!=0) {
    dev0 = driftTime - tdcTime;
    if(hitStatus==1) par.addToSumsDevWt(modInd,dev0,wtNorm);
  }
}

void HMdcWireData::calcFunctional(HMdcTrackParam& par) {
  if(hitStatus!=0) {
    dev          = dev0 + par.getTimeOffset(modInd);
    Double_t chi = dev/errTdcTime;
    chi2         = chi*chi;
    if(hitStatus==1) par.addToFunct(chi2*weight,weight);
  }
}

void HMdcWireData::calcFunctionalForDer(HMdcTrackParam& par) {
  if(hitStatus==1) {
    Double_t chi=(devDer+par.getTimeOffset(modInd))/errTdcTime;
    par.addToFunct(chi*chi*weight,weight);
  }
}

void HMdcWireData::calcDevAndFunct(HMdcTrackParam& par) {
  if(hitStatus!=0) {
    dev0         = driftTime - tdcTime;
    dev          = dev0 + par.getTimeOffset(modInd);
    Double_t chi = dev/errTdcTime;
    chi2         = chi*chi;
    if(hitStatus==1) par.addToFunct(chi2*weight,weight);
  }
}

void HMdcWireData::getAddress(Int_t& s,Int_t& m,Int_t& l,Int_t& c,Int_t& it) {
  s  = sector;
  m  = module;
  l  = layer;
  c  = cell;
  it = timeIndx;
}

Bool_t HMdcWireData::removeIfWeightLess(Double_t wtCut) {
  // function return kTRUE if hit is removed
  if(hitStatus==1 && weight<wtCut) {
    removeThisWire();
    return kTRUE;
  }
  return kFALSE;
}

Int_t HMdcWireData::unsetFittedHit(void) {
  if(hitStatus!=1) return 0;
  lInCl->delTime(module*6+layer,cell,timeIndx);
  return 1;
}

void HMdcWireData::getLocation(HLocation& loc) const {
  loc.set(4,sector,module,layer,cell);
}

void HMdcWireData::fillWireFitCont(HMdcWireFit* fWireFit) const {
  // Filling of HMdcWireFit container
  fWireFit->setAddress(sector,module,layer,cell);
  fWireFit->setTimeNum(timeIndx);
  fWireFit->setDev(dev);
  fWireFit->setDriftTime(driftTime);
  fWireFit->setFullTime(tdcTime+dev);
  fWireFit->setCal1Time(tdcTimeCal1);
  fWireFit->setTdcTime(tdcTimeCal1-signalTimeOffset);
  fWireFit->setMinDist(distanceSign==-1 ? -distance : distance);
  fWireFit->setAlpha(alpha);
  fWireFit->setIsInCell(inCell);
  fWireFit->setTdcTimeErr(errTdcTime);
  fWireFit->setWeight((hitStatus==1) ? weight:0.);
  fWireFit->setIsUsedFlag(useInFit);
  fWireFit->setToT(fMdcCal1->getNHits()==2 ? fMdcCal1->getTime2()-fMdcCal1->getTime1() : 0.);
}

void HMdcWireData::fillWireFitSimCont(HMdcWireFit* fWireFit,
    Int_t trackNum) const {
  // Filling of HMdcWireFit container
  if(!fWireFit->isGeant() || fMdcCal1==0) return;
  HMdcCal1Sim    *c = (HMdcCal1Sim*)fMdcCal1;
  HMdcWireFitSim *fWFSim = (HMdcWireFitSim*)fWireFit;
  Int_t track=(timeIndx==1) ? c->getNTrack1() : c->getNTrack2();
  fWFSim->setGeantTrackNum(track);
  fWFSim->setGeantMinDist (timeIndx==1 ? c->getMinDist1(): c->getMinDist2());
  fWFSim->setGeantAlpha   (timeIndx==1 ? c->getAngle1()  : c->getAngle2());
  fWFSim->setDigiTimeErr  (timeIndx==1 ? c->getError1()  : c->getError2());
  fWFSim->setGeantTof     (timeIndx==1 ? c->getTof1()    : c->getTof2());
  fWFSim->setClusFitTrFlag(track==trackNum);
}

void HMdcWireData::removeThisWire(void) {
  // Removing of wire from list of cells and setting hitStatus to -1
  lOutCl->delTime(layer+module*6,cell,timeIndx);
  hitStatus=-1;
}

Bool_t HMdcWireData::removeOneTimeIfItDoubleTime(HMdcWireData* time1) {
  // Removing time1 or time2 from one wire for double hit
  // "this" must be for time2 !
  if(hitStatus!=1 || timeIndx!=2 || lOutCl->getTime(module*6+layer,cell)!=3) return kFALSE;
  if(TMath::Abs(time1->dev) <= TMath::Abs(dev)) removeThisWire();
  else time1->removeThisWire();
  return kTRUE;
}

Bool_t HMdcWireData::removeIfOneDistOutCell(HMdcWireData* wire2) {
  // Removing "this" or wire2 from the same layer in "distance" out of cell
  // return kTRUE if one wire is removed
  if(abs(cell-wire2->cell)<=1 || (inCell && wire2->inCell)) return kFALSE;
  if(wire2->inCell) removeThisWire();
  else if(inCell) wire2->removeThisWire();
  else if(wire2->distance<distance) removeThisWire();
  else wire2->removeThisWire();
  return kTRUE;
}

void HMdcWireData::calcDriftTimeAndFunct(HMdcTrackParam& par) {
  // Calculation of functional without recalculation of time offset!
  // (for investigation of finctional)
  if(hitStatus != 0) {
    distance      = pSCLayer->getImpact(par,cell,alpha,y,z,dirY,dirZ);
//    driftTime      =pDrTimePar->calcTime(sector,module,alpha,distance);
if(TMath::IsNaN(alpha)) {printf("!!!!!!!!!!! 7. alpha=nan !!!!!!!!!!!!!!!!!\n"); par.printParam();}
    pDrTimeParBin = pDrTimePar->getBinDist(sector,module,alpha,distance);
    driftTime     = pDrTimeParBin->calcTime(alpha,distance);
    dev0          = driftTime - tdcTime;
    dev           = dev0 + par.getTimeOffset(modInd);
    Double_t chi  = dev/errTdcTime;
    chi2          = chi*chi;
    if(hitStatus==1) par.addToFunct(chi2*weight,weight);
  }
}

void HMdcWireData::calcDTdPar(Int_t par, Double_t oneDv2Step) {
  if(hitStatus!=1) return;
  dTdPar[par] -= driftTimeDer;
  dTdPar[par] *= oneDv2Step;
}

void HMdcWireData::printIfDeleted(void) const {
  if(weight>0.01 && hitStatus<0) printf("Warn.!  HIT %i is deleted\n",sequentialIndex);
}

void HMdcWireData::subtractWireOffset(HMdcTrackParam& par, Double_t sigSpeed) {
  // Subtraction of wire time offset
//! Function getSignPath(,,,,,,,Float_t outside) can be used for fake finding
  signalTimeOffset = pSCLayer->getSignPath(par,cell) * sigSpeed;
  tdcTime          = tdcTimeCal1-signalTimeOffset;
}

void HMdcWireData::addToTOffsetErr(HMdcTrackParam& par) {
  if(hitStatus==1) par.addToTOffsetErr(modInd,dTdPar,wtNorm);
}

void HMdcWireData::printTime(Int_t iflag,HMdcTrackParam& par,Bool_t isGeant) {
  calcDistanceSign(par);
  printf("%c%2i)%c %iS%iM%iL%3iC %+5.2fmm",(iflag==2) ? '!':' ',sequentialIndex,
      (hitStatus==1)?'+':'-',sector+1,module+1,layer+1,cell+1,distance*distanceSign);
  if(iflag==2) printf(" %c",inCell ? 'I':'O');
  printf(" dev=%5.1f%+4.1f%+6.1f=%5.1fns dT=%4.1f chi2=%6.1f WT=%-5.3g",
      driftTime,par.getTimeOffset(modInd),-tdcTime,dev,errTdcTime,chi2,weight);

  if(geantTrackNum>0) {
    printf("%5i trk. TOF=%.2f",geantTrackNum,tof);
    HMdcCal1Sim* cal1 = (HMdcCal1Sim*)fMdcCal1;
    printf(" MD=%5.2fmm",cal1->getMinDist1());
  }
  printf("\n");
}

Int_t HMdcWireData::setTukeyWeight(Double_t cwSig,Double_t c2Sig,Double_t c4Sig,
    Double_t tukeyScale, Double_t& sumWt, Double_t& funct) {
  if(hitStatus==0) return 0;
  Double_t sChi2 = chi2*tukeyScale;
  if(hitStatus!=1 || chi2 >= c2Sig || !useInFit) {
    weight = 0.;
    wtNorm = 0.;
    return 0;
  }
  if(sChi2 < cwSig) {
    weight = sChi2/c4Sig;
    weight = 1. - weight*weight;
  } else weight = 1. - sChi2/c2Sig;
  weight *= weight;
  wtNorm  = weight*oneDErrTdcTime2;
  sumWt  += weight;
  funct  += chi2*weight;
  return 1;
}

Int_t HMdcWireData::setTukeyWeight(Double_t cwSig,Double_t c2Sig,Double_t c4Sig,
    Double_t tukeyScale) {
  if(hitStatus==0) return 0;
  Double_t sChi2 = chi2*tukeyScale;
  if(hitStatus!=1 || chi2 >= c2Sig || !useInFit) {
    weight = 0.;
    wtNorm = 0.;
    return 0;
  }
  if(sChi2 < cwSig) {
    weight = sChi2/c4Sig;
    weight = 1. - weight*weight;
  } else weight = 1. - sChi2/c2Sig;
  weight *= weight;
  wtNorm  = weight*oneDErrTdcTime2;
  return 1;
}

// Bool_t HMdcWireData::testTukeyWeight(Double_t cwSig,Double_t c2Sig,
//     Double_t c4Sig, Double_t maxChi2, Double_t minWeight) {
//   if(hitStatus!=1 || weight>0.5) return kFALSE;
//   if(chi2 >= c2Sig || chi2>maxChi2) return kFALSE;
//   Double_t wt=0.;
//   if(chi2 < cwSig) {
//     wt=chi2/c4Sig;
//     wt = 1. - wt*wt;
//   } else wt = 1. - chi2/c2Sig;
//   wt*=wt;
//   if(wt>minWeight) return kFALSE;
//   weight=1.;
//   wtNorm=oneDErrTdcTime2;
//   return kTRUE;
// }

// Bool_t HMdcWireData::testTukeyWeight(Double_t cwSig,Double_t c2Sig,
//     Double_t c4Sig, Double_t maxChi2, Double_t minWeight) {
//   if(hitStatus==0) return kFALSE;
//   Double_t wtOld=weight;
// //  if(hitStatus!=1 || weight>0.5) return kFALSE;
//   if(chi2 >= c2Sig || chi2>maxChi2) return kFALSE;
//   Double_t wt=0.;
//   if(chi2 < cwSig) {
//     wt=chi2/c4Sig;
//     wt = 1. - wt*wt;
//   } else wt = 1. - chi2/c2Sig;
//   wt*=wt;
//   if(wt>minWeight && wtOld<0.5) {
//     wtNorm=oneDErrTdcTime2;
//     weight=1.;
// printf("add wire %iM %iL %iC\n",module+1,layer+1,cell+1);
//     return kFALSE;
//   } else if(wt<minWeight && wtOld>0.5) {
//     weight=wtNorm=0.;
// printf("remove wire %iM %iL %iC\n",module+1,layer+1,cell+1);
//     return kFALSE;
//   }
//   return kTRUE;
// }

Bool_t HMdcWireData::isAddressEq(Int_t s, Int_t m, Int_t l, Int_t c) {
  if(s>=0 && s!=sector) return kFALSE;
  if(m>=0 && m!=module) return kFALSE;
  if(l>=0 && l!=layer)  return kFALSE;
  if(c>=0 && c!=cell)   return kFALSE;
  return kTRUE;
}

void HMdcWireData::calcLeftRight(HMdcTrackParam& par) {
  // This method is used for calcInitialValue only.
  
   const HGeomVector* p1 = (*pSCLayer)[cell].getWirePoint(0);
   const HGeomVector* p2 = (*pSCLayer)[cell].getWirePoint(1);

   const HGeomVector& Vt = par.getDir();
   dir = *p2 - *p1;
   dir /= dir.length();
   HGeomVector V = Vt.vectorProduct(dir);
   V /= V.length();
   Double_t alpha    = pSCLayer->getAlpha(par,cell);
   Double_t drtime   = tdcTime < 0. ? 0. : tdcTime;
   Double_t distance = pDrTimePar->calcDistance(sector,module,alpha,drtime);
   if(distance < 0.) distance = 0.;
   else if(pSCLayer->getMaxDriftDist() < distance) distance = pSCLayer->getMaxDriftDist();
   V *= distance;
   pL = *p1 - V;
   pR = *p1 + V;
drTimeDist = distance;
}

Double_t HMdcWireData::dDist(const HMdcTrackParam& par) const {
  // This method is used for calcInitialValue only.
  return TMath::Abs(pSCLayer->getDist(par,cell) - drTimeDist);
}

//-----------------------------------------------------------

HMdcWiresArr::HMdcWiresArr(void) {
  arraySize = 0;
  wires     = NULL;
  fClst1    = NULL;
  fClst2    = NULL;
  fClst3    = NULL;
  fClst4    = NULL;
  fClst5    = NULL;
  fClst6    = NULL;
  fClst7    = NULL;
  fClst8    = NULL;
  setNumDriftTimes(500);
  fitInOut  = NULL;
  sector2   = -1;
  sector3   = -1;
  sector4   = -1;
  locCal1.set(4,0,0,0,0);
  dDistCut  = 1.8;
  meanDDist = -1.;
  event     = HMdcEvntListCells::getExObject();
}

HMdcWiresArr::~HMdcWiresArr(void) {
  if(wires) delete [] wires;
  wires = NULL;
  HMdcEvntListCells::deleteCont();
}

void HMdcWiresArr::setNumDriftTimes(Int_t nDrTm) {
  nDriftTimes = nDrTm;
  if(nDriftTimes>arraySize) {
    if(wires) delete [] wires;
    arraySize = arraySize<=0 ? nDriftTimes : (Int_t)(1.3*nDriftTimes);
    wires = new HMdcWireData [arraySize];
    for(Int_t i=0;i<arraySize;i++) {
      wires[i].setSequentialIndex(i);
      wires[i].setGradP(grad,&grad2,&matrH);
    }
  }
}

Bool_t HMdcWiresArr::fillListHits(HMdcClus* fCl1, HMdcClus* fCl2) {
  // Filling list of wires from cluster(s)
  setListCells(fCl1,fCl2);
  if(getNLayOrientInput()<3) return kFALSE;
  nClTimes      = 0;
  nDrTmFirstSec = 0;
  if(sector  >=0 && !fillListHits(0,sector, lInputCells, lOutputCells )) return kFALSE;
  if(nDriftTimes != nClTimes) return kFALSE;
  return kTRUE;
}

Bool_t HMdcWiresArr::fillListHits(HMdcClus* fCl1, HMdcClus* fCl2,HMdcClus* fCl3, HMdcClus* fCl4,
                                  HMdcClus* fCl5, HMdcClus* fCl6,HMdcClus* fCl7, HMdcClus* fCl8) {
  // Filling list of wires from cluster(s)
  setListCells(fCl1,fCl2,fCl3,fCl4,fCl5,fCl6,fCl7,fCl8);
  if(getNLayOrientInput()<3) return kFALSE;
  nClTimes      = 0;
  nDrTmFirstSec = 0;
    
  if(sector  >=0 && !fillListHits(0,sector, lInputCells, lOutputCells )) return kFALSE;
  if(sector2 >=0 && !fillListHits(1,sector2,lInputCells2,lOutputCells2)) return kFALSE;
  if(sector3 >=0 && !fillListHits(2,sector3,lInputCells3,lOutputCells3)) return kFALSE;
  if(sector4 >=0 && !fillListHits(3,sector4,lInputCells4,lOutputCells4)) return kFALSE;
 
  if(nDriftTimes != nClTimes) return kFALSE;
  return kTRUE;
}

Bool_t HMdcWiresArr::fillListHits(Int_t isec,Int_t sec,HMdcList24GroupCells& lInCells,
                                                       HMdcList24GroupCells& lOutCells) {
  if(sec<0) return kTRUE;
  if(isec == 0)  nDrTmFirstSec = 0;
  HCategory          *fCal1Cat = fitInOut->getMdcCal1Cat();
  HMdcSizesCellsMod **fSCModAr = fitInOut->getSCellsModArr(sec);
  locCal1[0] = sec;
  for(Int_t layer=0;layer<24;layer++) {
    Int_t ilay = layer + 24*isec;
    Int_t nDrTimes = lInCells.getNDrTimes(layer);
    if(nDrTimes<=0) {
      firstWireInLay[ilay] = NULL;
      lastWireInLay[ilay]  = NULL;
      continue;
    }
    firstWireInLay[ilay] = wires+nClTimes;
    lastWireInLay[ilay]  = wires+nClTimes+nDrTimes-1;
    Int_t modr = layer/6;
    Int_t lay  = layer%6;
    locCal1[1] = modr;
    locCal1[2] = lay;
    Int_t cell = -1;
    if(fSCModAr[modr]==0) return kFALSE;
    HMdcSizesCellsLayer& fSCLay=(*(fSCModAr[modr]))[lay];
    Bool_t excludeLay = fitInOut->isLayerExcluded(sec,modr,lay);
    while((cell=lInCells.next(layer,cell)) > -1) if(fSCLay[cell].getStatus()) {
      Int_t nTimes  = lInCells.getTime(layer,cell);
      locCal1[3]    = cell;
      HMdcCal1* cal = (HMdcCal1*)fCal1Cat->getObject(locCal1);
      if(!cal) {
        Error("fillListHits","S.%i M.%i L.%i  Cell %i is not fired",sec+1,modr+1,lay+1,cell+1);
        return kFALSE;
      }
      for(Int_t time=1; time<3; time++) {
        if((time&nTimes) == 0) continue;
        wires[nClTimes].setCell(cal,time,fitInOut->isGeant(),isec);
        wires[nClTimes].setSizesCellsLayer(&fSCLay);
        wires[nClTimes].setCellsLists(&lInCells,&lOutCells);
        if(excludeLay) wires[nClTimes].excludeWire(); // must be after setCell!!!
        nClTimes++;
        if(isec==0) nDrTmFirstSec++;
      }
    }
  }
  return kTRUE;
}

void HMdcWiresArr::setNegTdcTimeTo0(void) {
  for(HMdcWireData* w=firstWire;w<=lastWire;w++) w->setNegTdcTimeTo0(); 
}

Bool_t HMdcWiresArr::fillListHits(HMdcEvntListCells* store, HMdcClus* fCl1, HMdcClus* fCl2) {
  // Filling list of wires from cluster(s),
  // drift times from HMdcEvntListCells
  setListCells(fCl1,fCl2);
  HMdcSecListCells& storeSec=(*store)[sector];
  HMdcSizesCellsMod** fSCModAr=fitInOut->getSCellsModArr(sector);
  Int_t nClTms=0;
  for(Int_t layer=0;layer<24;layer++) {
    Int_t nDrTimes = lInputCells.getNDrTimes(layer);
    if(nDrTimes<=0) {
      firstWireInLay[layer] = NULL;
      lastWireInLay[layer]  = NULL;
      continue;
    }
    firstWireInLay[layer] = wires+nClTms;
    lastWireInLay[layer]  = wires+nClTms+nDrTimes-1;
    Int_t modr = layer/6;
    Int_t lay  = layer%6;
    Int_t cell = -1;
    if(fSCModAr[modr]==0) return kFALSE;
    HMdcSizesCellsLayer &fSCLay   =(*(fSCModAr[modr]))[lay];
    HMdcLayListCells    &storeLay = storeSec[modr][lay];
    Bool_t excludeLay = fitInOut->isLayerExcluded(sector,modr,lay);
    while((cell=lInputCells.next(layer,cell)) > -1)  if(fSCLay[cell].getStatus()) {
      if(lInputCells.getTime(layer,cell) == 0) continue;
      wires[nClTms].setCell(sector,modr,lay,cell,1,storeLay.getTimeValue(cell)); // index of time =1 !!!!???
      wires[nClTms].setSizesCellsLayer(&fSCLay);
      wires[nClTms].setCellsLists(&lInputCells,&lOutputCells);
      if(excludeLay) wires[nClTms].excludeWire(); // must be after setCell!!!
      nClTms++;
    }
  }
  if(nDriftTimes != nClTms) return kFALSE;
  return kTRUE;
}

void HMdcWiresArr::setListCells(HMdcClus* fCl1, HMdcClus* fCl2, HMdcClus* fCl3, HMdcClus* fCl4,
                                HMdcClus* fCl5, HMdcClus* fCl6, HMdcClus* fCl7, HMdcClus* fCl8) {
  sigma2   = -1.;
  fClst1   = fCl1;
  fClst2   = fCl2;
  sector   = fClst1->getSec();
  segment  = fClst1->getIOSeg();
  dDistCut = HMdcTrackDSet::getCalcInitValueCut(segment);
  if(fClst2 != 0) segment = 3;
  if(segment==0)      lInputCells.set(fClst1,0);
  else if(segment==1) lInputCells.set(0,fClst1);
  else                lInputCells.set(fClst1,fClst2);
  xClst        = fClst1->getX();
  yClst        = fClst1->getY();
  zClst        = fClst1->getZ();
  lOutputCells = lInputCells;
  nDriftTimes  = 0;
  for(Int_t m=0;m<4;m++) nDriftTimes += nMdcTimes[m] = lInputCells.getNDrTimesMod(m);
  
  sector2 = -1;
  sector3 = -1;
  sector4 = -1;
  if(fCl3 != NULL) {
    // For cosmic:
    fClst3  = fCl3;
    fClst4  = fCl4;
    fClst5  = fCl5;
    fClst6  = fCl6;
    fClst7  = fCl7;
    fClst8  = fCl8;
    sector2  = fClst3->getSec();
    segment2 = fClst3->getIOSeg();
    if(fClst4 != NULL) segment2 = 3;
    if(segment2==0)      lInputCells2.set(fClst3,0);
    else if(segment2==1) lInputCells2.set(0,fClst3);
    else lInputCells2.set(fClst3,fClst4);
    lOutputCells2 = lInputCells2;
    for(Int_t m=0;m<4;m++) {
      nMdcTimes[m+4] = lInputCells2.getNDrTimesMod(m);
      nDriftTimes   += nMdcTimes[m+4];
    }
    //+++++++++++++:
    if(fClst5 != NULL) {
      sector3  = fClst5->getSec();
      segment3 = fClst5->getIOSeg();
      if(fClst6 != NULL) segment3 = 3;
      if(segment3==0)      lInputCells3.set(fClst5,0);
      else if(segment3==1) lInputCells3.set(0,fClst5);
      else lInputCells3.set(fClst5,fClst6);
      lOutputCells3 = lInputCells3;
      for(Int_t m=0;m<4;m++) {
        nMdcTimes[m+8] = lInputCells3.getNDrTimesMod(m);
        nDriftTimes   += nMdcTimes[m+8];
      }
      if(fClst7 != NULL) {
        sector4  = fClst7->getSec();
        segment4 = fClst7->getIOSeg();
        if(fClst8 != NULL) segment4 = 3;
        if(segment4==0)      lInputCells4.set(fClst7,0);
        else if(segment4==1) lInputCells4.set(0,fClst7);
        else lInputCells4.set(fClst7,fClst8);
        lOutputCells4 = lInputCells4;
        for(Int_t m=0;m<4;m++) {
          nMdcTimes[m+12] = lInputCells4.getNDrTimesMod(m);
          nDriftTimes    += nMdcTimes[m+12];
        }
      }
    }
      //+++++++++++++.
  }
  
  setNumDriftTimes(nDriftTimes);
  firstTime = 0;
  lastTime  = nDriftTimes;
  firstWire = wires;
  lastWire  = wires+nDriftTimes-1;
}

Bool_t HMdcWiresArr::fillListHits(HMdcEvntListCells* store) {
  // Filling list of wires from cluster(s),
  // drift times from HMdcEvntListCells
  setListCells(store);
  HMdcSecListCells& storeSec=(*store)[sector];
  HMdcSizesCellsMod** fSCModAr=fitInOut->getSCellsModArr(sector);
  Int_t nClTms = 0;
  for(Int_t layer=0;layer<24;layer++) {
    Int_t nDrTimes = lInputCells.getNDrTimes(layer);
    if(nDrTimes<=0) {
      firstWireInLay[layer] = NULL;
      lastWireInLay[layer]  = NULL;
      continue;
    }
    firstWireInLay[layer] = wires+nClTms;
    lastWireInLay[layer]  = wires+nClTms+nDrTimes-1;
    Int_t modr = layer/6;
    Int_t lay  = layer%6;
    Int_t cell = -1;
    if(fSCModAr[modr]==0) return kFALSE;
    HMdcSizesCellsLayer& fSCLay=(*(fSCModAr[modr]))[lay];
    HMdcLayListCells& storeLay=storeSec[modr][lay];
    Bool_t excludeLay = fitInOut->isLayerExcluded(sector,modr,lay);
    while((cell=lInputCells.next(layer,cell)) > -1) if(fSCLay[cell].getStatus()) {
      if(lInputCells.getTime(layer,cell) == 0) continue;
      wires[nClTms].setCell(sector,modr,lay,cell,1,storeLay.getTimeValue(cell)); // index of time =1 !!!!???
      wires[nClTms].setSizesCellsLayer(&fSCLay);
      wires[nClTms].setCellsLists(&lInputCells,&lOutputCells);
      if(excludeLay) wires[nClTms].excludeWire(); // must be after setCell!!!
      nClTms++;
    }
  }
  if(nDriftTimes != nClTms) return kFALSE;
  return kTRUE;
}

void HMdcWiresArr::setListCells(HMdcEvntListCells* store) {
  Int_t s,m,l,c;
  s=m=l=c=-1;
  UChar_t t   = 0;
  nDriftTimes = 0;
  sector2     = -1;
  lInputCells.clear();
  while(store->nextCell(s, m, l, c, t)) {
    sector = s;
    lInputCells.setTime(m*6+l,c,t);
  }
  for(Int_t m=0;m<4;m++) nDriftTimes += nMdcTimes[m] = lInputCells.getNDrTimesMod(m);
  if(nMdcTimes[2]+nMdcTimes[3] == 0)      segment = 0;
  else if(nMdcTimes[0]+nMdcTimes[1] == 0) segment = 1;
  else                                    segment = 3;  
  setNumDriftTimes(nDriftTimes);
  nDrTmFirstSec = nDriftTimes;
  firstTime     = 0;
  lastTime      = nDriftTimes;
  firstWire     = wires;
  lastWire      = wires+nDriftTimes-1;
  lOutputCells  = lInputCells;
}

void HMdcWiresArr::fillLookupTableForDer(HMdcTrackParam& par) {
  for(HMdcWireData* w=firstWire;w<=lastWire;w++) w->fillLookupTableForDer(par);
}
    
Double_t HMdcWiresArr::testFitResult(void) {
  // Removing cells which has small weight or
  // if min.distance outside of this cell for case when more than on wires
  // in this layer passed fit and so on
// Can be tuned and checked ???).
  Double_t sumDelWeight=0.;
  for(HMdcWireData* w=firstWire;w<=lastWire;w++) {
    // Test for Tukey weight:
    if(w->removeIfWeightLess(fitInOut->getWeightCut())) {
        sumDelWeight += w->getWeight();
        numOfGoodWires--;
      //Test on double time (time==2 - weight are tested already):
    } else if(w>firstWire && w->removeOneTimeIfItDoubleTime(w-1)) {
      sumDelWeight += 1.;  // +=weight[dHit] ???
      numOfGoodWires--;
    }
  }

  // Test for layers which have > 2 wires:
// !!!!!!!! Nado perepisat' i sdelat' proverku tol'ko na inCell !!!
  Int_t l1 = firstWire->getSequentialLayNum();
  Int_t l2 =  lastWire->getSequentialLayNum();
  for(Int_t lay=l1;lay<=l2;lay++) {
    HMdcWireData* fWire = firstWireInLay[lay];
    if(fWire==0) continue;
    HMdcWireData* lWire = lastWireInLay[lay];
    while(fWire<lWire) {
      if(fWire->getHitStatus()==1) {
        if(lWire->getHitStatus()==1) {
          if(fWire->removeIfOneDistOutCell(lWire)) {
            sumDelWeight+=1.;
            numOfGoodWires--;
          } else break;
        } else lWire--;
      } else fWire++;
    }
  }
  if(fprint) for(HMdcWireData* w=firstWire;w<=lastWire;w++) w->printIfDeleted();
  return sumDelWeight;
}

void HMdcWiresArr::subtractWireOffset(HMdcTrackParam& par) {
  // Must be called after setCell !
  if(!fitInOut->useWireOffset()) return;
  for(HMdcWireData* w=firstWire;w<=lastWire;w++)
      w->subtractWireOffset(par,fitInOut->getSignalSpeed());
}

void HMdcWiresArr::setHitStatM1toP1(void) {
  // if(hitStatus==-1) hitStatus=1
  for(HMdcWireData* w=firstWire;w<=lastWire;w++) w->setHitStatM1toP1();
}

void HMdcWiresArr::switchOff(Int_t sec, Int_t mod, Int_t lay, Int_t cell) {
  for(HMdcWireData* w=firstWire;w<=lastWire;w++)
    if(w->isAddressEq(sec,mod,lay,cell)) {
      w->setHitStatus(-2);
      w->removeThisWire();
  }
}

Int_t HMdcWiresArr::unsetHits(void) {
  // removing cells passed fit
  Int_t nFitedTimes=0;
  for(HMdcWireData* w=firstWire;w<=lastWire;w++)
      nFitedTimes +=w->unsetFittedHit();
  return nFitedTimes;
}

Int_t HMdcWiresArr::getNCellsInInput(Int_t mod,Int_t isec) {
  // Return number of cells in mdc module =mod in input list
  // if mod<0 return number of cells in all mdc's of segment
  // isec - sector index (0 or 1) for cosmic data only
  // isec<0 && mod<0 return number of cells in all mdc's of two sectors
  if(mod<0) {
    if(isec < 0) {
      Int_t            nCells  = lInputCells.getNCells();
      if(sector2 >= 0) nCells += lInputCells2.getNCells();
      if(sector3 >= 0) nCells += lInputCells3.getNCells();
      if(sector4 >= 0) nCells += lInputCells4.getNCells();
      return nCells;
    } else {
      if(isec==0)                 return lInputCells.getNCells();
      if(isec==1 && sector2 >= 0) return lInputCells2.getNCells();
      if(isec==2 && sector3 >= 0) return lInputCells3.getNCells();
      if(isec==3 && sector4 >= 0) return lInputCells4.getNCells(); 
    }
  }
  if(isec==0)                 return lInputCells.getNCellsMod(mod);
  if(isec==1 && sector2 >= 0) return lInputCells2.getNCellsMod(mod);
  if(isec==2 && sector3 >= 0) return lInputCells3.getNCellsMod(mod);
  if(isec==3 && sector4 >= 0) return lInputCells4.getNCellsMod(mod); 
  return 0;
}

UChar_t HMdcWiresArr::getNLayOrientInput(void) {
  // Return list of layer: 6 bits, one bit per layer
  UChar_t listLayers = 0;
  for(Int_t mod=0;mod<4;mod++) {
    listLayers                |= lInputCells.getListLayers(mod);
    if(sector2>=0) listLayers |= lInputCells2.getListLayers(mod);
    if(sector3>=0) listLayers |= lInputCells3.getListLayers(mod);
    if(sector4>=0) listLayers |= lInputCells4.getListLayers(mod);
  }
  return HMdcBArray::getNLayOrientation(listLayers);
}

UChar_t HMdcWiresArr::getNLayOrientOutput(void) {
  // Return list of layer: 6 bits, one bit per layer
  UChar_t listLayers = 0;
  for(Int_t mod=0;mod<4;mod++) {
    listLayers                |= lOutputCells.getListLayers(mod);
    if(sector2>=0) listLayers |= lOutputCells2.getListLayers(mod);
    if(sector3>=0) listLayers |= lOutputCells3.getListLayers(mod);
    if(sector4>=0) listLayers |= lOutputCells4.getListLayers(mod);
  }
  return HMdcBArray::getNLayOrientation(listLayers);
}

Int_t HMdcWiresArr::getNCellsInOutput(Int_t mod,Int_t isec) {
  // Return valid value after calling testFitResult() only !
  // Return number of cells in mdc module =mod passed fit
  // if mod<0 return number of cells in all mdc's of segment
  if(mod<0) {
    if(isec < 0) {
      Int_t            nCells = lOutputCells.getNCells();
      if(sector2 >= 0) nCells += lOutputCells2.getNCells();
      if(sector3 >= 0) nCells += lOutputCells3.getNCells();
      if(sector4 >= 0) nCells += lOutputCells4.getNCells();
      return nCells;
    } else {
      if(isec==0)                 return lOutputCells.getNCells();
      if(isec==1 && sector2 >= 0) return lOutputCells2.getNCells();
      if(isec==2 && sector3 >= 0) return lOutputCells3.getNCells();
      if(isec==3 && sector4 >= 0) return lOutputCells4.getNCells(); 
    }
  }
  if(isec==0)                 return lOutputCells.getNCellsMod(mod);
  if(isec==1 && sector2 >= 0) return lOutputCells2.getNCellsMod(mod);
  if(isec==2 && sector3 >= 0) return lOutputCells3.getNCellsMod(mod);
  if(isec==3 && sector4 >= 0) return lOutputCells4.getNCellsMod(mod); 
  return 0;
  
}

Bool_t HMdcWiresArr::calcNGoodWiresAndChi2(HMdcTrackParam& par) {
  numOfGoodWires = 0;
  for(HMdcWireData* w=firstWire;w<=lastWire;w++) if(w->isPassedFit()) numOfGoodWires++;
  return par.calcChi2PerDF(numOfGoodWires) >= 0.;
}

Double_t HMdcWiresArr::calcTrackChi2(Int_t trackNum) {
   // trackNum - geant track numer
  Int_t    nWr  = 0;
  Double_t chi2 = 0.;
  for(HMdcWireData* w=firstWire;w<=lastWire;w++) if(w->getGeantTrackNum() == trackNum &&
                                                    w->isPassedFit()) {
    chi2 += w->getChi2();
    nWr++;
  }
  if(nWr>1) chi2 /= nWr;
  return chi2;
}

Double_t HMdcWiresArr::calcChi2(HMdcList12GroupCells &listCells) {
   // calculate chi2/ndf for wires from listCells
  Int_t    nWr  = 0;
  Double_t chi2 = 0.;
  for(HMdcWireData* w=firstWire;w<=lastWire;w++) if(w->isPassedFit()) {
    Int_t s,m,l,c,it;
    w->getAddress(s,m,l,c,it);
    if((listCells.getTime((m&1)*6+l,c) & it) != 0) {
      chi2 += w->getChi2();
      nWr++;
    }
  }
  if(nWr>1) chi2 /= nWr;
  return chi2;
}

void HMdcWiresArr::fillClusFitAndWireFit(HMdcClusFit* fClusFit) {
  fClusFit->setSec(sector);
  fClusFit->setIOSeg(segment);
  fClusFit->setFitAuthor(HMdcTrackDSet::getFitAuthor());
  fClusFit->setDistTimeVer(fitInOut->getDrTimeCalcVer());
  fClusFit->setFitType(HMdcTrackDSet::getFitType());
  fClusFit->setClustCatIndex(fClst1->getOwnIndex()); // ???? for 2 segm. ???
  Int_t firstMod=firstWire->getModule();
  Int_t lastMod=lastWire->getModule();
  fClusFit->setMod((firstMod==lastMod) ? firstMod:-1);
  Int_t nLayers=0;
  for(Int_t m=firstMod;m<=lastMod;m++) nLayers += lOutputCells.getNLayersMod(m);
  fClusFit->setNumOfLayers(nLayers);
  Int_t   indFirstWireFit = -1;
  Int_t   indLastWireFit  = -1;
  
  Int_t   indLayer = -1;
  Int_t   firstCell,lastCell;
  Float_t firstCellPath,midCellPath,lastCellPath;
  for(HMdcWireData* w=firstWire;w<=lastWire;w++) {
    if(w->getHitStatus() == 0) continue;
    HMdcWireFit *fWireFit=fitInOut->getNewWireFitSlot(&indLastWireFit);
    if(fWireFit == NULL) break;
    Int_t indl = w->getSector()*100 + w->getModule()*10 + w->getLayer();
    if(indl != indLayer) {
      indLayer = indl;
      HMdcSizesCellsLayer *fSCLay = w->getSCLayer();
      if( !fSCLay->calcCrossedCells(fClusFit->getX1(),fClusFit->getY1(),fClusFit->getZ1(),
                                    fClusFit->getX2(),fClusFit->getY2(),fClusFit->getZ2(),
          firstCell,lastCell,firstCellPath,midCellPath,lastCellPath) ) firstCell = lastCell = -1;
    }
    Int_t c = w->getCell();
    Float_t path = -1.;
    if(c >= firstCell && c <= lastCell) {
      if     (c == firstCell) path = firstCellPath;
      else if(c == lastCell)  path = lastCellPath;
      else                    path = midCellPath;
    }
    fWireFit->setCellPath(path);
    if(indFirstWireFit<0) indFirstWireFit=indLastWireFit;
    w->fillWireFitCont(fWireFit);
    if(fClusFit->isGeant()) w->fillWireFitSimCont(fWireFit,
          ((HMdcClusFitSim*)fClusFit)->getGeantTrackNum());
  }
  fClusFit->setFirstWireFitInd(indFirstWireFit);
  fClusFit->setLastWireFitInd(indLastWireFit);
  fClusFit->setSigmaChi2(sigma2>=0. ? TMath::Sqrt(sigma2):-1.);
}

void HMdcWiresArr::countFittedWires(Double_t chi2cut) {
// Is not used and may be will not used
  // Mark fitted wires HMdcEvntListCells with chi2<chi2cut
  for(HMdcWireData* w=firstWire;w<=lastWire;w++) if(w->getHitStatus()>0 && w->getChi2()<chi2cut) {
    event->increaseFittedCount(w->getSector(),w->getModule(),w->getLayer(),w->getCell());
  }  
}

void HMdcWiresArr::fillClusFitSim(HMdcClusFit* fClusFit,HMdcTrackParam& par) {
  if(!fClusFit->isGeant()) return;
  Int_t nTrcksClus=0;
  for(HMdcWireData* w=firstWire;w<=lastWire;w++) {
    if(w->getHitStatus() == 0) continue;
    Int_t track=w->getGeantTrackNum();
    Int_t indx=0;
    for(;indx<nTrcksClus;indx++) if(trackNum[indx]==track) break;
    if(indx==nTrcksClus) {
      if(indx==200) continue; //!!!!!!!!!
      numWiresClus[indx] = 0;
      numWiresFit[indx]  = 0;
      trackNum[indx]     = track;
      nTrcksClus++;
    }
    numWiresClus[indx]++;
    if(w->getHitStatus()==1) numWiresFit[indx]++;
  }
  Int_t indxMax=0;
  Int_t nTrcksFit=0;
  for(Int_t i=0;i<nTrcksClus;i++) {
    if(numWiresFit[i]==0) continue;
    nTrcksFit++;
    if(numWiresFit[indxMax]<numWiresFit[i]) indxMax=i;
  }
  Int_t geantTrack=trackNum[indxMax];
  HMdcClusFitSim* fClusFitSim=(HMdcClusFitSim*)fClusFit;
  fClusFitSim->setNumTracks(nTrcksFit);  
  fClusFitSim->setNumTracksClus(nTrcksClus);
  fClusFitSim->setGeantTrackNum(geantTrack);
  fClusFitSim->setNumWiresTrack(numWiresFit[indxMax]);
  fClusFitSim->setNumWiresTrClus(numWiresClus[indxMax]);
  if(fClusFitSim->isFake()) {
    fClusFitSim->setFakeTrack();
    return;
  }
  
  HMdcWireData* firstTrWire=NULL;
  for(HMdcWireData* w=firstWire;w<=lastWire;w++) {
    if(w->getGeantTrackNum()!=geantTrack || w->getHitStatus()!=1) continue;
    firstTrWire=w;
    break;
  }
  HMdcWireData* lastTrWire=NULL;
  for(HMdcWireData* w=lastWire;w>=firstWire;w--) {
    if(w->getGeantTrackNum()!=geantTrack || w->getHitStatus()!=1) continue;
    lastTrWire=w;
    break;
  }

  if(firstTrWire==0 || lastTrWire==0) {
    fClusFitSim->setXYZ1Geant(-1000.,-1000.,-1000.);
    fClusFitSim->setXYZ2Geant(-1000.,-1000.,-1000.);
    Error("fillClusFitSim","Sec.%i Seg.%i bad track parameters or weights!",
        sector+1,segment+1);
    par.printParam("Bad track:");
    return;
  }
  
  if(fitInOut->getGeantKineCat()==0 || trackNum[indxMax]<1) return;
  HGeantKine* fGeantKine=(HGeantKine*)fitInOut->getGeantKineCat()->getObject(trackNum[indxMax]-1);
  if(fGeantKine==0) return;
  fClusFitSim->setParticleID(fGeantKine->getID());
  fClusFitSim->setMomentum(fGeantKine->getTotalMomentum());
  fClusFitSim->setPrimaryFlag(fGeantKine->isPrimary());
  if(fitInOut->getGeantMdcCat()==0) return;

  fGeantKine->resetMdcIter();
  HGeantMdc* hit = NULL;
  HGeantMdc* firstHit = NULL;
  HGeantMdc* lastHit  = NULL;
  Int_t modF=firstTrWire->getModule();
  Int_t modL=lastTrWire ->getModule();
  Int_t layF=firstTrWire->getLayer();
  Int_t layL=lastTrWire ->getLayer();
  while((hit = (HGeantMdc*) fGeantKine->nextMdcHit()) != NULL) {
    if(sector!=hit->getSector()) break;
    if(firstHit==NULL && hit->getModule()==modF &&
        hit->getLayer()==layF) firstHit=hit;
    if(hit->getModule()<modL) continue;
    if(hit->getModule()==modL) {
      if(hit->getLayer()!=layL) continue;
      lastHit=hit;
    }
    break;
  }
  if(firstHit==0 || lastHit==0 || firstHit==lastHit) {
    fClusFitSim->setFakeTrack(kFALSE);
    return;
  }
  Double_t x1,y1,z1;
  getGeantHitPoint(firstTrWire,firstHit,x1,y1,z1);
  Double_t x2,y2,z2;
  getGeantHitPoint(lastTrWire,lastHit,x2,y2,z2);
  Double_t xc,yc,zc;
  par.getFirstPlane()->calcIntersection(x1,y1,z1,x2,y2,z2, xc,yc,zc);
  fClusFitSim->setXYZ1Geant(xc,yc,zc);
  par.getSecondPlane()->calcIntersection(x1,y1,z1,x2,y2,z2, xc,yc,zc);
  fClusFitSim->setXYZ2Geant(xc,yc,zc);
  if(fprint) fClusFitSim->printSimVsRec();
}

void HMdcWiresArr::getGeantHitPoint(HMdcWireData* w, HGeantMdc* hit,
    Double_t& x,Double_t& y,Double_t& z) {
  // Transformation of geant mdc hit in coor.sys. of sector.
  // x,y,z - [mm]
  Float_t ax,ay,atof,ptof;
  hit->getHit(ax,ay,atof,ptof);
  x = ax;
  y = ay;
  z = w->getSCLayer()->getZGeantHits();
  w->getSCLayer()->transFrom(x,y,z);
}

void HMdcWiresArr::calcTdcErrorsAndFunct(HMdcTrackParam& par, Int_t iflag) {
  // alphaDrDist and timeOffsets must be calculated befor this function!
  for(HMdcWireData* w=firstWire;w<=lastWire;w++) w->calcTdcErrors(par);
  if(fprint) par.saveFunct();
  recalcFunctional(par,iflag);
  if(fprint && iflag>=0) par.printFunctChange(" TdcErr.Recalc.:");
  par.saveFunct();
}

void HMdcWiresArr::recalcFunct(HMdcTrackParam& par, Int_t iflag) {
  if(fprint) par.saveFunct();
  recalcFunctional(par,iflag);
  if(fprint && iflag>=0) par.printFunctChange(" TdcErr.Recalc.:");
  par.saveFunct();
}

void HMdcWiresArr::calcTdcErrorsTOff0AndFunct(HMdcTrackParam& par, Int_t iflag) {
  // alphaDrDist and timeOffsets must be calculated befor this function!
  // timeOffsets is not used for error calculation (see HMdcWireData::calcTdcErrors(void))
  for(HMdcWireData* w=firstWire;w<=lastWire;w++) w->calcTdcErrors();
  if(fprint) par.saveFunct();
  recalcFunctional(par,iflag);
  if(fprint && iflag>=0) par.printFunctChange(" TdcErr.Recalc.:");
  par.saveFunct();
}

Double_t HMdcWiresArr::valueOfFunctional(HMdcTrackParam& par, Int_t iflag) {
  // iflag:
  //   0 - setting minimal val. of time offset    and no print (default value)
  //   1 - setting minimal val. of time offset    and print if fprint=kTRUE
  //   2 - no setting minimal val. of time offset, calculation of inCell[time]
  //                                              and print if fprint=kTRUE
  calcDriftTime(par,iflag);
  par.calcTimeOffsets(fitInOut->getTofFlag());
  calcFunctional(par,iflag);
  return par.functional();
}

Double_t HMdcWiresArr::valueOfFunctAndErr(HMdcTrackParam& par, Int_t iflag) {
  // iflag:
  //   0 - setting minimal val. of time offset    and no print (default value)
  //   1 - setting minimal val. of time offset    and print if fprint=kTRUE
  //   2 - no setting minimal val. of time offset, calculation of inCell[time]
  //                                              and print if fprint=kTRUE
  calcDriftTimeAndErr(par,iflag);
  par.calcTimeOffsets(fitInOut->getTofFlag());
  calcFunctional(par,iflag);
  return par.functional();
}

Bool_t HMdcWiresArr::setRegionOfWires(Int_t mod,Int_t isec) {
  if(mod<0 || mod>3) {
    Int_t mInd1 = 0;
    Int_t mInd2 = 4;
    if(isec < 0) {
      if(sector2>=0) mInd2 += 4;
      if(sector3>=0) mInd2 += 4;
      if(sector4>=0) mInd2 += 4;
    } else {
      mInd1 += isec*4;
      mInd2 += isec*4;
    }
    firstWire  = wires;
    lastWire   = wires-1;
    nModsInFit = 0;
    for(Int_t m=0;m<mInd2;m++) if(nMdcTimes[m]>0) {
      if(m < mInd1) firstWire += nMdcTimes[m];
      else          nModsInFit++;
      lastWire += nMdcTimes[m];
    }
  } else {
    Int_t mInd = mod;
    if(isec>0) mInd += isec*4;
    firstWire = wires;
    for(Int_t m=0;m<mInd;m++) firstWire += nMdcTimes[m];
    lastWire   = firstWire + nMdcTimes[mInd]-1;
    nModsInFit = 1;
  }
  if(firstWire==0 || lastWire==0) {
    Warning("setFittingTimesList","No fired wires in MDC %i",mod+1);
    return kFALSE;
  }
  firstTime = firstWire->getSequentialIndex();
  lastTime  = lastWire->getSequentialIndex()+1;
  return kTRUE;
}

void HMdcWiresArr::setWeightsTo1or0(Double_t maxChi2, Double_t minWeight) {
  Int_t   nDrTimes = 0;
  UChar_t nLayList= 0;
  for(HMdcWireData* w=firstWire;w<=lastWire;w++) {
    if(w->setWeightTo1or0(maxChi2,minWeight)) {
      nDrTimes++;
      nLayList |= 1<<w->getLayer();
    }
  }
  if(nDrTimes<5) {
    Int_t ntm=5-nDrTimes;
    for(Int_t nw=0;nw<ntm;nw++) {
      HMdcWireData* wmin=findMinChi2();
      if(wmin==0) {
        Error("setWeightsTo1or0","Number of wires for fit=%i",nDrTimes);
        return;
      }
      wmin->setWeightEq1();
      nLayList |= 1<<wmin->getLayer();
      nDrTimes++;
    }
  }
  
  while(HMdcBArray::getNLayOrientation(nLayList) < 3) {
    HMdcWireData* wmin = findMinChi2();
    if(wmin==0) {
      Error("setWeightsTo1or0","Number of wires orientations = %i (<3)",
          HMdcBArray::getNLayOrientation(nLayList));
      return;
    }
    wmin->setWeightEq1();
    nLayList |= 1<<wmin->getLayer();
  }
}

Bool_t HMdcWiresArr::testTukeyWeights(HMdcTrackParam& par) {
  filterOfHitsV2(par); 
  setWeightsTo1or0(fitInOut->getMaxChi2(),fitInOut->getMinWeight());
  Bool_t exitFlag=kFALSE;
  for(HMdcWireData* w=firstWire;w<=lastWire;w++) if(w->testWeight1or0()) {
    if(fprint) printf("Reset: %is%im%il%3ic %s\n",w->getSector()+1,w->getModule()+1,
        w->getLayer()+1,w->getCell()+1,w->getIsWireUsed() ? "ON":"OFF");
    exitFlag=kTRUE;
  }
  recalcFunctional(par);
  par.saveFunct();
  return exitFlag;
}

HMdcWireData* HMdcWiresArr::findMinChi2(void) {
  // finding wire with minimal chi2
  HMdcWireData* wmin = 0; 
  Double_t chi2min   = 1.e+200;
  for(HMdcWireData* w=firstWire;w<=lastWire;w++) {
    if(w->getIsWireUsed() || w->getHitStatus()!=1) continue;
    Double_t chi2=w->getChi2();
    if(chi2>chi2min) continue;
    wmin    = w;
    chi2min = chi2;
  }
  return wmin;
}

void HMdcWiresArr::initDTdPar(Int_t k) {
  for(HMdcWireData* w=firstWire;w<=lastWire;w++) w->initDTdPar(k);
}

void HMdcWiresArr::calcDTdPar(Int_t k, Double_t oneDv2StepD) {
  for(HMdcWireData* w=firstWire;w<=lastWire;w++) w->calcDTdPar(k,oneDv2StepD);
}

void HMdcWiresArr::calcDriftTime(HMdcTrackParam& par, Int_t iflag) {
  par.clearFunct();
  if(iflag != 2) for(HMdcWireData* w=firstWire;w<=lastWire;w++) w->calcDriftTime(par);
  else for(HMdcWireData* w=firstWire;w<=lastWire;w++) w->calcDriftTimeAndInCell(par);
}

void HMdcWiresArr::calcDriftTimeAndErr(HMdcTrackParam& par, Int_t iflag) {
  par.clearFunct();
  if(iflag != 2) for(HMdcWireData* w=firstWire;w<=lastWire;w++) w->calcDriftTimeAndErr(par);
  else for(HMdcWireData* w=firstWire;w<=lastWire;w++) w->calcDriftTimeAndErrAndInCell(par);
}

void HMdcWiresArr::calcFunctional(HMdcTrackParam& par, Int_t iflag) {
  if(iflag!=2) par.correctMinTimeOffsets(fitInOut->getMinTOffsetIter());
  for(HMdcWireData* w=firstWire;w<=lastWire;w++) w->calcFunctional(par);
  if(fprint && (iflag==1 || iflag==2)) printTimes(iflag,par);
}

void HMdcWiresArr::recalcFunctional(HMdcTrackParam& par, Int_t iflag) {
  // Recalculation of finctional without calculation of ditances
  // (for the same parameters as before)
  // iflag:
  //   0 - setting minimal val. of time offset    and no print (default value)
  //   1 - setting minimal val. of time offset    and print if fprint=kTRUE
  //   2 - no setting minimal val. of time offset and print if fprint=kTRUE
  par.clearFunct();
  for(HMdcWireData* w=firstWire;w<=lastWire;w++) w->recalcFunctional(par);
  par.calcTimeOffsets(fitInOut->getTofFlag());
  calcFunctional(par,iflag);
}

Double_t HMdcWiresArr::functForDeriv(HMdcTrackParam& par, Int_t iflag) {
  // Calculation of finctional for derivatives.
  // functional for par must be calc. before this !!!
  // iflag:
  //   !=2 - setting minimal val. of time offset
  //    =2 - no setting minimal val. of time offset
  par.clearFunct();
  for(HMdcWireData* w=firstWire;w<=lastWire;w++) w->calcDriftTimeForDeriv(par);
  par.calcTimeOffsets(fitInOut->getTofFlag());
  if(iflag!=2) par.correctMinTimeOffsets(fitInOut->getMinTOffsetIter());
  for(HMdcWireData* w=firstWire;w<=lastWire;w++) w->calcFunctionalForDer(par);
  return par.functional();
}

void HMdcWiresArr::calcDistanceSign(HMdcTrackParam& par) {
  for(HMdcWireData* w=firstWire;w<=lastWire;w++) w->calcDistanceSign(par);
}

void HMdcWiresArr::reinitWtSt(void) {
  for(HMdcWireData* w=firstWire;w<=lastWire;w++) w->reinitWtSt();
}

Bool_t HMdcWiresArr::calcErrorsAnalyt(HMdcTrackParam& par) {
  // calculation of fit parameters errors analyticaly
  matrH.Zero();
  grad2.Zero();
  par.clearTOffsetDer();
  for(HMdcWireData* w=firstWire;w<=lastWire;w++) w->calcAnalytDeriv(par,3);
  par.addTimeOffsetDer2(grad2);
  if(!calcErrs(par)) return kFALSE;
  par.calcTimeOffsetsErr();
  if(fprint) par.printErrors();
  return kTRUE;
}

Bool_t HMdcWiresArr::calculateErrors(HMdcTrackParam& par) {
  // calculation of fit parameters errors numer.
  calcSecondDeriv(par);
  if(!calcErrs(par)) return kFALSE;
  calcTimeOffsetsErr(par);
  if(fprint) par.printErrors();
  return kTRUE;
}

Bool_t HMdcWiresArr::calcErrs(HMdcTrackParam& par) {
  Int_t numOfParam=par.getNumParam();
  for(Int_t k=0; k<numOfParam; k++) {
    if(TMath::Abs(grad2(k,k))<3.e-16) {
      grad2(k,k)=3.e-16;
      if(matrH(k,k)==0.) matrH(k,k)=1.;
    }
    for(Int_t l=0; l<k; l++) {
      grad2(l,k) = grad2(k,l);
      matrH(l,k) = matrH(k,l);
    }
  }
  grad2.InvertFast();
  if(!grad2.IsValid()) {
    Error("calcErrs","Inverted matrix is not valid!");
    grad2.MakeValid();
    return kFALSE;
  }
  matrH=grad2*matrH*grad2.T(); //!!!  matrH.Similarity(grad2);
  if(!matrH.IsValid()) {
    Error("calcErrs","Errors matrix is not valid!");
    matrH.MakeValid();
    return kFALSE;
  }
  par.fillErrorsMatr(matrH);
  return kTRUE;
}

void HMdcWiresArr::calcTimeOffsetsErr(HMdcTrackParam& par) {
  // Calculation of time offset error
  par.clearTOffsetDer();
  for(HMdcWireData* w=firstWire;w<=lastWire;w++) w->addToTOffsetErr(par);
  par.calcTimeOffsetsErr();
  if(fprint) par.printErrors();
}

void HMdcWiresArr::printTimes(Int_t iflag, HMdcTrackParam& par) {
  for(HMdcWireData* w=firstWire;w<=lastWire;w++)
      w->printTime(iflag,par,fitInOut->isGeant());
}

Double_t HMdcWiresArr::getSumOfWeights(void) {
  Double_t sum=0.;
  for(HMdcWireData* w=firstWire;w<=lastWire;w++)
      if(w->getHitStatus()==1) sum += w->getWeight();
  return sum;
}

Double_t HMdcWiresArr::findNewSigm2(Int_t ntm) {
  Double_t chi2buf[ntm];
  Int_t nwr=0;
  for(HMdcWireData* w=firstWire;w<=lastWire;w++) {
    if(w->getWeight()>0. || w->getHitStatus()!=1) continue;
    Double_t chi2 = w->getChi2();
    if(nwr==0 || chi2>=chi2buf[nwr-1]) {
      if(nwr<ntm) {
        chi2buf[nwr++] = chi2;
      }
    } else {
      for(Int_t i=0;i<nwr;i++) if(chi2<chi2buf[i]) {
        Int_t j=(nwr<ntm) ? nwr:ntm-1;
        for(;j>i;j--) chi2buf[j]=chi2buf[j-1];
        chi2buf[i]=chi2;
        if(nwr<ntm) nwr++;
        break;
      }
    }
  }
  Double_t sigma2 = (nwr==ntm) ? chi2buf[nwr-1]*1.1 : 1000000; // +10%
  return sigma2/fitInOut->getTukeyConst2s();
}

Double_t HMdcWiresArr::setTukeyWeightsAndCalcSigma2(Double_t sigma2) {
  Double_t cwSig  = sigma2*fitInOut->getTukeyConstWs();
  Double_t c2Sig  = sigma2*fitInOut->getTukeyConst2s();
  Double_t c4Sig  = sigma2*fitInOut->getTukeyConst4s();
  Double_t tukeyScale = fitInOut->getTukeyScale();
  Double_t sumWt  = 0.;
  Double_t funct  = 0.;
  Int_t    nwires = 0;
  for(HMdcWireData* w=firstWire;w<=lastWire;w++)
      nwires += w->setTukeyWeight(cwSig,c2Sig,c4Sig,tukeyScale,sumWt,funct);
  
  if(nwires>=5) return funct/sumWt;
  return setTukeyWeightsAndCalcSigma2(findNewSigm2(5-nwires)); //???
}

Bool_t HMdcWiresArr::setTukeyWeights(Double_t sigma2) {
  // return kTRUE if sigma2 was increased due to small amount of wires after filtering (<5)
  Double_t cwSig  = sigma2*fitInOut->getTukeyConstWs();
  Double_t c2Sig  = sigma2*fitInOut->getTukeyConst2s();
  Double_t c4Sig  = sigma2*fitInOut->getTukeyConst4s();
  Double_t tukeyScale = fitInOut->getTukeyScale();
  Int_t    nwires = 0;
  for(HMdcWireData* w=firstWire;w<=lastWire;w++)
      nwires += w->setTukeyWeight(cwSig,c2Sig,c4Sig,tukeyScale);
  
  if(nwires >= 5 || cwSig > 50000) return kFALSE;
  setTukeyWeights(findNewSigm2(5-nwires)); //???
  return kTRUE;
}

Bool_t HMdcWiresArr::filterOfHits(HMdcTrackParam& par, Int_t iflag) {
  // It was used in HTrackFitterA only.
  // Filtering of hits using Tukey weights
  // return kTRUE new weights was calculated
  if(getNWiresInFit()<=5) {
    if(fprint) printf(" num.wires=%i => No filtering!\n",getNWiresInFit());
    return kFALSE;
  }
  Double_t sigma2n = par.getNormFunctional();
  if(sigma2n <= fitInOut->getTukeyWtMinSigma2()) {
    if(fprint) printf(" sigma=%f => Not filtering!\n",TMath::Sqrt(sigma2n));
    return kFALSE;
  }
  Bool_t exitFlag = kTRUE;
  for(Int_t j=0; j<fitInOut->maxNumFilterIter(); j++) {
//    A esli sigma2n <fitInOut->getTukeyWtMinSigma2() pri pervom zhe prohode ???
    if(sigma2n < fitInOut->getTukeyWtMinSigma2()) {
      exitFlag = kFALSE;
//????            =kFALSE - eto bug??? //????? Kak chasto nado fil'trovat' ?????
      break;
    }
//    Mozhet nado delat' tak???
//    if(sigma2n < fitInOut->getTukeyWtMinSigma2()) {
//      sigma2n=fitInOut->getTukeyWtMinSigma2();
//      j=4;
//    }
    sigma2  = sigma2n;
    sigma2n = setTukeyWeightsAndCalcSigma2(sigma2);
    if(sigma2n>sigma2) break;
//Pochemu ne pereschitiyvaetsya funcional dlya kazhdogo j ??? Proverit' !!!
  }
  par.saveFunct();
  recalcFunctional(par,iflag);
  if(fprint) {
    printf(" sigma=%f => FILTER! ",TMath::Sqrt(sigma2n));
    par.printFunctChange();
  }
  par.saveFunct();
  return exitFlag;
}

Bool_t HMdcWiresArr::filterOfHitsV2(HMdcTrackParam& par, Int_t iflag) {
  // Filtering of hits using Tukey weights
  // return kTRUE new weights was calculated
// seychas eto ne tak!!!
  if(getNWiresInFit() <= 5) {
    if(fprint) printf(" num.wires=%i => No filtering!\n",getNWiresInFit());
    return kFALSE;
  }
  Double_t sigma2n = par.getNormFunctional();
  if(sigma2n <= fitInOut->getTukeyWtMinSigma2()) {
    if(fprint) printf(" sigma=%f => No filtering!\n",TMath::Sqrt(sigma2n));
    return kFALSE;
  }
  Int_t maxIter = fitInOut->maxNumFilterIter()-1;
  Int_t iter    = 0;
  par.saveFunct();
  for(; iter<=maxIter; iter++) {
    sigma2      = sigma2n;
    Bool_t exit = setTukeyWeights(sigma2);
    recalcFunctional(par);
    sigma2n     = par.getNormFunctional();
    if(sigma2n < fitInOut->getTukeyWtMinSigma2() || exit) break;
  }
  if(fprint) {
    if(iflag>0) printTimes(iflag,par);
    printf(" sigma=%f => FILTER! ",TMath::Sqrt(sigma2n));
    par.printFunctChange();
  }
  return iter >= maxIter;
}

void HMdcWiresArr::filterOfHitsConstSig(HMdcTrackParam& par, Double_t sig) {
  // Filtering of hits using Tukey weights
  // return kTRUE new weights was calculated
  if(getNWiresInFit()<=5) {
    if(fprint) printf(" num.wires=%i => No filtering!\n",getNWiresInFit());
    return;
  }
  setTukeyWeightsAndCalcSigma2(sig*sig);
  recalcFunctional(par);
  par.saveFunct();
}

void HMdcWiresArr::setWeightsTo1or0(HMdcTrackParam& par, Int_t iflag) {
  setWeightsTo1or0(fitInOut->getMaxChi2(),fitInOut->getMinWeight());

  if(fprint && iflag>=0) par.saveFunct();
  recalcFunctional(par);
  if(fprint && iflag>=0) par.printFunctChange(" Weights=>0/1:");
  par.saveFunct();

//? poka rabotaet huzhe ???
// recalcFunctional(par);
// calcTdcErrorsAndFunct(par);
// ....
//-----------------------
}

void HMdcWiresArr::setUnitWeights(void) {
  // For target scan only!
  // Setting all weights to 1.
  for(HMdcWireData* w=firstWire;w<=lastWire;w++) w->setUnitWeight();
}

void HMdcWiresArr::setSizeGrad2Matr(HMdcTrackParam& par) {
  // Seting of sizes of gradient matrix.
  grad2.ResizeTo(par.getNumParam(),par.getNumParam());
  matrH.ResizeTo(par.getNumParam(),par.getNumParam());
}

void HMdcWiresArr::calcDerivatives(HMdcTrackParam& par,Int_t iflag) {
  // Numerical calculation of the fit parameters derivatives
  // iflag<2 - calculate the diagonal elements of the grad2 matrix only
  // else    - calculate the full grad2 matrix
  Double_t funMin=par.functional();
  Double_t stepD=fitInOut->getStepDer(funMin);
  Double_t oneDv2StepD=1./(2.*stepD);
  Double_t oneDvStepD2=1./(stepD*stepD);
  HMdcTrackParam tPar;
  tPar.copyPlanes(par);
  Int_t numOfParam=par.getNumParam();
  agrad=0;
  for(Int_t k = 0; k < numOfParam; k++) {
    Double_t func0 = functForDeriv(tPar(par,k, stepD));
    Double_t func1 = functForDeriv(tPar(par,k,-stepD));
    grad2(k,k)=(func0 + func1 - 2.0*funMin)*oneDvStepD2;
    grad[k] = (func0 - func1)*oneDv2StepD;
    agrad += grad[k]*grad[k];
    if(iflag < 2) continue;
    for(Int_t l = k+1; l < numOfParam; l++) {
      Double_t func2 = functForDeriv(tPar(par,k,stepD,l,stepD));
      Double_t func3 = functForDeriv(tPar(par,l,stepD));
      grad2(k,l)=(funMin - func0 + func2 - func3) * oneDvStepD2;
    }
  }
  agrad=TMath::Sqrt(agrad);
}

void HMdcWiresArr::calcAnalyticDerivatives1(HMdcTrackParam& par) {
  // Analytical calculation of the fit parameters derivatives 
  // for the first min.method:
  // calculate the first der. and the diagonal elements of the grad2 matrix
  Int_t numOfParam=par.getNumParam();
  for(Int_t n=0; n<numOfParam; n++) grad[n]=0.;
  grad2.Zero();
  par.clearTOffsetDer();
  for(HMdcWireData* w=firstWire;w<=lastWire;w++) w->calcAnalytDeriv(par,1);
  par.addTimeOffsetDer1(grad2);
  // dTof/dP == 0 - no need to correct grad!
  agrad=0;
  for(Int_t k=0; k<numOfParam; k++) agrad += grad[k]*grad[k];
  agrad=TMath::Sqrt(agrad);
}

Double_t HMdcWiresArr::calcAGradAnalyt(HMdcTrackParam& par) {
  for(Int_t k=0; k<4; k++) grad[k]=0.;
  for(HMdcWireData* w=firstWire;w<=lastWire;w++) w->calcAnalytDeriv(par,0);
  Double_t agrd=0;
  for(Int_t k=0; k<4; k++) agrd += grad[k]*grad[k];
  return TMath::Sqrt(agrd);
}

void HMdcWiresArr::calcAnalyticDerivatives2(HMdcTrackParam& par) {
  // Analytical calculation of the fit parameters derivatives 
  // for the second min.method.
  // Calculate the first der. and all elements of the grad2 matrix
  Int_t numOfParam=par.getNumParam();
  for(Int_t n=0; n<numOfParam; n++) grad[n]=0.;
  grad2.Zero();
  par.clearTOffsetDer();
  for(HMdcWireData* w=firstWire;w<=lastWire;w++) w->calcAnalytDeriv(par,2);
  par.addTimeOffsetDer2(grad2);
  agrad=0;
  for(Int_t k=0; k<numOfParam; k++) {
    agrad += grad[k]*grad[k];
    for(Int_t l=0; l<k; l++) grad2(l,k)=grad2(k,l);
  }
  agrad=TMath::Sqrt(agrad);
}

void HMdcWiresArr::calcSecondDeriv(HMdcTrackParam& par) {
  // For errors calculation
  Double_t funMin      = par.functional();
  Double_t stepD       = fitInOut->getStepDer(funMin);
  Double_t oneDv2StepD = 1./(2.*stepD);
  Double_t oneDvStepD2 = 1./(stepD*stepD);
  Int_t numOfParam=par.getNumParam();
  HMdcTrackParam tPar;
  tPar.copyPlanes(par);
  for(Int_t k = 0; k < numOfParam; k++) {
    Double_t func0 = functForDeriv(tPar(par,k, stepD),2);//functForDeriv(tPar,2);
    initDTdPar(k);
    Double_t func1  = functForDeriv(tPar(par,k,-stepD),2);//functForDeriv(tPar,2);
    calcDTdPar(k,oneDv2StepD);
    grad2(k,k)= (func0 + func1 - 2.0*funMin)*oneDvStepD2;
    for(Int_t l=k+1; l<numOfParam; l++) {
      Double_t func2 = functForDeriv(tPar(par,k,stepD,l,stepD),2);
      Double_t func3 = functForDeriv(tPar(par,l,stepD),2);
      grad2(k,l) = grad2(l,k) = (funMin - func0 + func2 - func3) * oneDvStepD2;
    }
  }
}

void HMdcWiresArr::setInitWeghts(HMdcTrackParam& par) {
  Int_t layMax = 24;
  if(sector2 >= 0) {
    layMax += 24;
    if(sector3 >= 0) {
      layMax += 24;
      if(sector4 >= 0) layMax += 24;
    }
  }
  for(Int_t layer=0;layer<layMax;layer++) {
    if(firstWireInLay[layer]==NULL || lastWireInLay[layer]==NULL) continue;
    if(firstWireInLay[layer] == lastWireInLay[layer]) continue;
    Int_t nWires=0;
    HMdcWireData* fWr = firstWireInLay[layer];
    HMdcWireData* lWr = lastWireInLay[layer];
    for(HMdcWireData* w=fWr;w<=lWr;w++) if(w->getHitStatus() == 1) nWires++;
    if(nWires<=2) continue;
    HMdcSizesCellsLayer* pSCLayer = fWr->getSCLayer();
    Float_t cell1,cell2;
    pSCLayer->calcCrossedCells(par,cell1,cell2);
    Double_t cell=(cell1+cell2)/2.;
    for(HMdcWireData* w=fWr;w<=lWr;w++) {
      if(w->getHitStatus() != 1) continue;
      Double_t dCell=TMath::Abs(w->getCell()-cell);
      if(dCell>1.) w->setWeightAndWtNorm(w->getWeight()/dCell);
    }
  }
}

Int_t HMdcWiresArr::getOutputNLayers(void) const {
  Int_t nLays = lOutputCells.getNLayers();
  if(sector2>=0) {
    nLays += lOutputCells2.getNLayers();
    if(sector3>=0) {
      nLays += lOutputCells3.getNLayers();
      if(sector4>=0) nLays += lOutputCells4.getNLayers();
    }
  }  
  return nLays;
}

Bool_t HMdcWiresArr::calcInitialValue(HMdcTrackParam& par) {
  if(getNWiresInFit() > 30) return kFALSE;
  useNewParam   = kFALSE;
  meanDDist     = 0.;
  maxNGoodWires = 0;
  newListCells.clear();
  maxAddWr = 0;
 
  maxNGoodWires = collectAllWires(par,maxAddWr,meanDDist);

  if(maxNGoodWires > 7) newListCells = tmpList;
  else {
    newListCells = lInputCells;
    maxNGoodWires = 0;
    meanDDist = 0.;
    for(HMdcWireData* w=firstWire;w<=lastWire;w++) {
      Double_t dDist = w->dDist(par);
      if(dDist < dDistCut) {
        meanDDist += dDist;
        maxNGoodWires++;
      }
    }
  }

  if(maxNGoodWires == 0) meanDDist = 10000000.;
  else                   meanDDist /= maxNGoodWires; 

  HMdcTrackParam minPar = par;
  findGoodComb(par,minPar);

  if(!useNewParam || meanDDist > 9000000.) return kFALSE;
  if(maxNGoodWires <= 7) newListCells.add(&lInputCells);
  par = minPar;
  reinitWireArr();
  subtractWireOffset(par);
  return kTRUE;
}

Bool_t HMdcWiresArr::reinitWireArr(void) {
  if(lInputCells.getNCells() == newListCells.getNCells()) {
    if(lInputCells.isIncluded(newListCells)) return kFALSE;  // lInputCells == newListCells
  }

  lInputCells  = newListCells;
  lOutputCells = newListCells;

  nDriftTimes  = 0;
  nClTimes     = 0;
  for(Int_t m=0;m<4;m++) nDriftTimes += nMdcTimes[m] = lInputCells.getNDrTimesMod(m);

  setNumDriftTimes(nDriftTimes);
  lastTime  = nDriftTimes;
  firstWire = wires;
  lastWire  = wires+nDriftTimes-1;
  
  nDrTmFirstSec = 0;
  if(sector  >=0 && fillListHits(0,sector, lInputCells, lOutputCells )) return kTRUE;
  return kFALSE;
}

Int_t HMdcWiresArr::collectAllWires(HMdcTrackParam &par,Int_t &nAddWires,Double_t &dDistSum) {
  HMdcSizesCellsMod **fSCModAr = fitInOut->getSCellsModArr(sector);
  HMdcEvntListCells  *store    = HMdcEvntListCells::getExObject();
  HMdcSecListCells   &storeSec = (*store)[sector];
  HMdcDriftTimeParSec* drTimeParSec = HMdcWireData::getDriftTimePar()->at(sector);
  Int_t iLayer  = segment != 1 ?  0 : 12;
  Int_t lastLay = segment == 0 ? 12 : 24;
  Int_t nWires  = 0;
  nAddWires = 0;
  tmpList.clear();
  dDistSum  = 0.;

  Double_t vo[6] = {0.,0.,0.,0.,0.,0.};
  Double_t v[6];
  par.getLinePar(v);

  for(;iLayer<lastLay;iLayer++) {
    Int_t mod = iLayer/6;
    if(fSCModAr[mod]==0) continue;
    Int_t lay = iLayer%6;
    if(lay == 0) {
      fSCModAr[mod]->transTo(v,vo);
      vo[3] /= vo[5];
      vo[4] /= vo[5];
    }
    HMdcSizesCellsLayer &fSCLay       = (*(fSCModAr[mod]))[lay];
    HMdcLayListCells    &storeLay     = storeSec[mod][lay];
    HMdcDriftTimeParMod *drTimeParMod = drTimeParSec->at(mod);
    Int_t cell1,cell2,cell3;
    Double_t al[2],md[2],st[2];
    if( !fSCLay.calcCrossedCellsPar(vo,0.49999,cell1,cell2,cell3,al,md,st) ) continue;
   
    for(Int_t pt=0;pt<2;pt++) {
      Int_t c1 = pt == 0 ? cell1 : cell2;
      Int_t c2 = pt == 0 ? cell2 : cell3;
      if(c1 < 0 || c2 < 0) continue;
      for(Int_t c=c1;c<c2;c++) if(storeLay.isCell(c) && fSCLay[c].getStatus()) {
        Double_t  tdcTime    = storeLay.getTimeValue(c);
        if(tdcTime < -100.) continue;

if(mod<2) tdcTime -= 7; // inner mdc
else      tdcTime -= 8; // outer mdc

        if(tdcTime < 0.) tdcTime = 0.;

        Double_t drTmDist = drTimeParMod->calcDistance(al[pt],tdcTime);
        if(drTmDist < 0.) drTmDist = 0.;
        else if(fSCLay.getMaxDriftDist() < drTmDist) drTmDist = fSCLay.getMaxDriftDist();
        
        Double_t minDist = TMath::Abs(md[pt] + st[pt]*(c-c1));
        Double_t dDist   = TMath::Abs(minDist - drTmDist);

        Double_t corCut = 2.5;  // mod < 2 ? 2.5 : 2.5;
        if( dDist < dDistCut*corCut ) {
          tmpList.setTime(iLayer,c,1);
          if(dDist < dDistCut) {
            dDistSum += dDist;
            nWires++;
            if(lInputCells.getTime(iLayer,c)==0) nAddWires++;
          }
        } 
      }
    }
  }
  return nWires;
}

Bool_t HMdcWiresArr::getComb4layers(UInt_t c,Int_t add12,Int_t &l1,Int_t &l2,
                                             Int_t add34,Int_t &l3,Int_t &l4) {
  if(c >= 20) return kFALSE;
  static Int_t comb[20][4] = {{0,1,10,11},{0,1, 9,11},{0,1, 8,11},{0,2,10,11},{0,2, 7,10},
                              {0,3,10,11},{0,3, 7,10},{0,5, 7,10},{1,4, 9,11},{1,4, 8,11},
                              {1,4, 6,11},{1,4, 6, 9},{1,4, 6, 8},{2,5, 7,10},{2,5, 6, 7},
                              {3,5, 7,10},{3,5, 6, 7},{4,5, 6, 9},{4,5, 6, 8},{4,5, 6, 7}};
  l1 = comb[c][0] + add12;
  l2 = comb[c][1] + add12;
  l3 = comb[c][2] + add34;
  l4 = comb[c][3] + add34;
  return kTRUE;
}

void HMdcWiresArr::findGoodComb(HMdcTrackParam& par,HMdcTrackParam& minPar) {
  if(segment > 1) return; // "findGoodComb" is not implemented for field off data 
  Int_t nWiresTot = getNWiresInFit();
  calcLeftRight(par);
  Int_t nFirstWrDone = 0;
  Int_t add = segment!=1 ? 0:12;
 
  Int_t layerIndx1,layerIndx2,layerIndx3,layerIndx4;
  UInt_t icomb = 0;
  while( getComb4layers(icomb,add,layerIndx1,layerIndx2,add,layerIndx3,layerIndx4) ) {
    icomb++;
    if(firstWireInLay[layerIndx1] == NULL) continue;
    if(firstWireInLay[layerIndx2] == NULL) continue;
    if(firstWireInLay[layerIndx3] == NULL) continue;
    if(firstWireInLay[layerIndx4] == NULL) continue;
    HMdcWireData* fWr1 = firstWireInLay[layerIndx1];
    HMdcWireData* fWr2 = firstWireInLay[layerIndx2];
    HMdcWireData* fWr3 = firstWireInLay[layerIndx3];
    HMdcWireData* fWr4 = firstWireInLay[layerIndx4];
    HMdcWireData* lWr1 = lastWireInLay[layerIndx1];
    HMdcWireData* lWr2 = lastWireInLay[layerIndx2];
    HMdcWireData* lWr3 = lastWireInLay[layerIndx3];
    HMdcWireData* lWr4 = lastWireInLay[layerIndx4];
    for(HMdcWireData* w1=fWr1;w1<=lWr1;w1++) {
      if( nWiresTot-nFirstWrDone+3 < maxNGoodWires-maxAddWr) return;
      nFirstWrDone++;
      for(HMdcWireData* w2=fWr2;w2<=lWr2;w2++)
          for(HMdcWireData* w3=fWr3;w3<=lWr3;w3++)
              for(HMdcWireData* w4=fWr4;w4<=lWr4;w4++) {
                getTrack(par,w1,w2,w3,w4,minPar);
              }
    }
  }
}

void HMdcWiresArr::getTrack(HMdcTrackParam& par,
                            HMdcWireData* w1, HMdcWireData* w2,
                            HMdcWireData* w3, HMdcWireData* w4,
			    HMdcTrackParam& minPar) {
   Int_t    nWiresTot = getNWiresInFit();
   Int_t    nWiresCut = nWiresTot/2 + 1;   // At list 1/2 wires

   HMdcTrackParam tmpPar(par);
   HGeomVector& v1 = w1->getDirection();
   HGeomVector& v2 = w2->getDirection();
   HGeomVector& v3 = w3->getDirection();
   HGeomVector& v4 = w4->getDirection();
   HGeomVector V13(v1.vectorProduct(v3));
   HGeomVector V14(v1.vectorProduct(v4));
   HGeomVector V23(v2.vectorProduct(v3));
   HGeomVector V24(v2.vectorProduct(v4));
   Double_t B1 = v2.scalarProduct(V13);
   Double_t B2 = v2.scalarProduct(V14);
   for(Int_t side1=0;side1<2;side1++) {
      HGeomVector& p1 = w1->getPoint(side1);
      for(Int_t side2=0;side2<2;side2++) {     
 	 HGeomVector& p2 = w2->getPoint(side2);
         HGeomVector  P21(p2 - p1);
	 for(Int_t side3=0;side3<2;side3++) {     
 	    HGeomVector& p3 = w3->getPoint(side3);
            HGeomVector  P31(p3 - p1);
            Double_t D1 = (p2 - p3).scalarProduct(V13);
            Double_t F1 = v3.scalarProduct(P31.vectorProduct(P21));
            Double_t E1 = P31.scalarProduct(V23);
  
	    for(Int_t side4=0;side4<2;side4++) {     
 	       HGeomVector& p4 = w4->getPoint(side4);
               HGeomVector  P41(p4 - p1);
               Double_t D2    = (p2 - p4).scalarProduct(V14);
               Double_t F2    = v4.scalarProduct(P41.vectorProduct(P21));
               Double_t E2    = P41.scalarProduct(V24);
               
               Double_t BE    = B1*E2 - B2*E1;
               Double_t BC    = 0.5/BE;
               Double_t DEpBF = D1*E2 - D2*E1 + B1*F2 - B2*F1;
               Double_t SQ    = TMath::Sqrt(DEpBF*DEpBF - 4*BE*(D1*F2 - D2*F1));
               Double_t t2    = (SQ - DEpBF)*BC;  
               Double_t t1    = -(E2*t2 + F2)/(B2*t2 + D2);
               Double_t t2b   = (-SQ - DEpBF)*BC;  
               Double_t t1b   = -(E2*t2b + F2)/(B2*t2b + D2);
               if(TMath::Abs(t1b) < TMath::Abs(t1)) {
                 t2=t2b;
                 t1=t1b;
               }
               HGeomVector P5(v1);
               P5 *= t1;
               P5 += p1;
               HGeomVector Q(v2);
               Q *= t2;
               Q += p2;
               Q -= P5;
               tmpPar.setParam(P5,Q);

//calcTrackN(p1,v1,p2,v2,p3,v3,p4,v4,tmpPar);
               
	       Double_t sumMod     = 0;
	       Int_t    nGoodWires = 4; // For wires is on the track already
               
               //++++++++++++++++++++++++++++++++++++++++++++++
               Int_t nAddWr;
               nGoodWires = collectAllWires(tmpPar,nAddWr,sumMod);
               //++++++++++++++++++++++++++++++++++++++++++++++
               
               if(nGoodWires < maxNGoodWires) continue;
	       if(nGoodWires > nWiresCut) {
                  Double_t sMod = sumMod/nGoodWires;
		  if(sMod < meanDDist) {
                     useNewParam   = kTRUE;
		     meanDDist     = sMod;
		     minPar        = tmpPar;
		     maxNGoodWires = nGoodWires;
                     newListCells = tmpList;
                     maxAddWr = nAddWr;
		  }
	       }
	    }
	 }
      }  
   }
}

void HMdcWiresArr::calcLeftRight (HMdcTrackParam& par) {
   
  for(HMdcWireData* w=firstWire;w<=lastWire;w++) w->calcLeftRight(par);

}

void HMdcWiresArr::calcTrack(HGeomVector& P1, HGeomVector& V1,
                             HGeomVector& P2, HGeomVector& V2,
			     HGeomVector& P3, HGeomVector& V3,
                             HGeomVector& P4, HGeomVector& V4,
			     HMdcTrackParam& par) {
  HGeomVector V13(V1.vectorProduct(V3));
  HGeomVector V14(V1.vectorProduct(V4));
  HGeomVector V23(V2.vectorProduct(V3));
  HGeomVector V24(V2.vectorProduct(V4));
  Double_t B1 = V2.scalarProduct(V13);
  Double_t B2 = V2.scalarProduct(V14);

//--------- After loop 2
  HGeomVector P21(P2 - P1);

//--------- After loop 3
    
  Double_t D1 = (P2 - P3).scalarProduct(V13);
  HGeomVector P31(P3 - P1);
  Double_t F1 = V3.scalarProduct(P31.vectorProduct(P21));
  Double_t E1 = P31.scalarProduct(V23);
  
//--------- After loop 4
  Double_t D2 = (P2 - P4).scalarProduct(V14);
  HGeomVector P41(P4 - P1);
  Double_t F2 = V4.scalarProduct(P41.vectorProduct(P21));
  Double_t E2 = P41.scalarProduct(V24);

  Double_t BE = B1*E2 - B2*E1;
  Double_t BC = 0.5/BE;

  Double_t DEpBF = D1*E2 - D2*E1 + B1*F2 - B2*F1;
  Double_t SQ =TMath::Sqrt(DEpBF*DEpBF - 4*BE*(D1*F2 - D2*F1));
  
    
  Double_t t2 = (SQ - DEpBF)*BC;  
  Double_t t1 = -(E2*t2 + F2)/(B2*t2 + D2);
  
  Double_t t2b = (-SQ - DEpBF)*BC;  
  Double_t t1b = -(E2*t2b + F2)/(B2*t2b + D2);
  if(TMath::Abs(t1b) < TMath::Abs(t1)) {
    t2=t2b;
    t1=t1b;
  }
  
  HGeomVector P5(V1);
  P5 *= t1;
  P5 += P1;
  
  HGeomVector Q(V2);
  Q *= t2;
  Q += P2;
  Q -= P5;

  par.setParam(P5,Q);
}

Int_t HMdcWiresArr::testRestForTrack(Int_t sec,HMdcLineParam &lineParam,
    HMdcList12GroupCells &listCells, Int_t nLayersMax,Int_t nWiresMax) {
  
  listCells.clear();
  Int_t nLaysBest  = 0; 
  Int_t nCellsBest = 0;
  
  HMdcSizesCellsSec &pSCSec   = (*HMdcSizesCells::getExObject())[sec];
//  const HGeomVector &targMPnt = pSCSec.getTargetMiddlePoint();
  HMdcSecListCells &pSListCells = (*event)[sec];
//  HMdcSizesCellsMod **fSCModAr = fitInOut->getSCellsModArr(sec);
  Double_t zTarget = pSCSec.getTargetMiddlePoint().getZ();
   
  Int_t mod1 = 0;
  Int_t mod2 = 0;
  Int_t mod3 = 1;
  Int_t mod4 = 1;
  
  Int_t wind = HMdcTrackDSet::getNCellsCutOVT();
        
  HMdcLineParam tmpLineParam;
  tmpLineParam.setFirstPlane (&(pSCSec[mod1][0]));
  tmpLineParam.setSecondPlane(&(pSCSec[mod4][5]));
//   tmpLineParam.setFirstPlane (&((*(fSCModAr[0]))[0]));
//   tmpLineParam.setSecondPlane(&((*(fSCModAr[1]))[5]));
  tmpLineParam.setCoorSys(sec);
  HMdcList12GroupCells tmpListCells;
    
  Int_t lay1,lay2,lay3,lay4;
  Int_t icomb = 0;
  while( getComb4layers(icomb,0,lay1,lay2,-6,lay3,lay4) ) {
    icomb++;
    HMdcLayListCells &pLay1list   = pSListCells[mod1][lay1]; 
    HMdcLayListCells &pLay2list   = pSListCells[mod2][lay2]; 
    HMdcLayListCells &pLay3list   = pSListCells[mod3][lay3]; 
    HMdcLayListCells &pLay4list   = pSListCells[mod4][lay4];

    if(pLay1list.getNumNotFitted() == 0) continue;
    if(pLay2list.getNumNotFitted() == 0) continue;
    if(pLay3list.getNumNotFitted() == 0) continue;
    if(pLay4list.getNumNotFitted() == 0) continue;

    Double_t tY2[4],tY3[4],tY4[4];
    pSCSec[mod2][lay2].getPntToCell(tY2);
    pSCSec[mod3][lay3].getPntToCell(tY3);
    pSCSec[mod4][lay4].getPntToCell(tY4);
    
    Double_t parA = pSCSec[mod3][lay3].A();  // Parmeters of a layer plane in MDCII
    Double_t parB = pSCSec[mod3][lay3].B();
    Double_t parD = pSCSec[mod3][lay3].D();
    
    Int_t cell1 = 1000;
    while( pLay1list.previousNonFittedCell(cell1) ) {
      HMdcSizesCellsCell &scell1 = pSCSec[mod1][lay1][cell1];
      HGeomVector &p1  = scell1.getWirePnt1();
      HGeomVector &pe1 = scell1.getWirePnt2();
      HGeomVector  v1  = pe1 - p1;

      // Calculate cells region in [mod2][lay2]:
      Int_t c1 = tY2[0]*p1.X()  + tY2[1]*p1.Y()  + tY2[2]*p1.Z()  + tY2[3];
      Int_t c2 = tY2[0]*pe1.X() + tY2[1]*pe1.Y() + tY2[2]*pe1.Z() + tY2[3];
      if(c1 > c2) std::swap(c1,c2);
      
      Int_t cell2 = c2+1;
      while( pLay2list.previousNonFittedCell(cell2) && cell2>=c1 ) {
        HMdcSizesCellsCell &scell2 = pSCSec[mod2][lay2][cell2];
        HGeomVector &p2  = scell2.getWirePnt1();
        HGeomVector &pe2 = scell2.getWirePnt2();
        HGeomVector  v2 = pe2 - p2;

        HGeomVector P21(p2 - p1);
        
        // Calc. of 2 wires cross on X-Y plane
        Double_t a1  = (p1.Y() - pe1.Y())/(p1.X() - pe1.X());
        Double_t b1  =  p1.Y() - a1*p1.X();
        Double_t a2  = (p2.Y() - pe2.Y())/(p2.X() - pe2.X());
        Double_t b2  =  p2.Y() - a2*p2.X();
        
        
        Double_t x   = -(b1-b2)/(a1-a2);
        Double_t y   = a1*x+b1;  //= -a1*(b1-b2)/(a1-a2)+b1 = (a1*b2 - b1*a2)/(a1-a2);
        Double_t z   = pSCSec[mod2][lay2].getZOnPlane(x,y);
        
        Double_t del = 1/(parA*x+parB*y+z-zTarget);
        Double_t xc  = x*(parD-zTarget)*del;
        Double_t yc  = y*(parD-zTarget)*del;
        Double_t zc  = parD-parA*xc-parB*yc;

        Int_t crC3   = tY3[0]*xc  + tY3[1]*yc  + tY3[2]*zc  + tY3[3];
        Int_t cell3e = crC3+wind;
        Int_t cell3m = crC3-wind;
        
        Int_t cell3  = cell3e+1;
        while( pLay3list.previousNonFittedCell(cell3) && cell3>=cell3m ) {
          HMdcSizesCellsCell &scell3 = pSCSec[mod3][lay3][cell3];
          HGeomVector &p3  = scell3.getWirePnt1();
          HGeomVector &pe3 = scell3.getWirePnt2();
          HGeomVector v3 = pe3 - p3;
          HGeomVector P31(p3 - p1);
          HGeomVector V13(v1.vectorProduct(v3));
          HGeomVector V23(v2.vectorProduct(v3));
          Double_t B1 = v2.scalarProduct(V13);
          Double_t D1 = (p2 - p3).scalarProduct(V13);
          Double_t F1 = v3.scalarProduct(P31.vectorProduct(P21));
          Double_t E1 = P31.scalarProduct(V23);
          
          // Calculate cells region in [mod4][lay4]:
          Int_t c3 = tY4[0]*p3.X()  + tY4[1]*p3.Y()  + tY4[2]*p3.Z()  + tY4[3];
          Int_t c4 = tY4[0]*pe3.X() + tY4[1]*pe3.Y() + tY4[2]*pe3.Z() + tY4[3];
          if(c3 > c4) std::swap(c3,c4);

          Int_t cell4 = c4+1;
          while( pLay4list.previousNonFittedCell(cell4) && cell4>=c3 ) {
            HMdcSizesCellsCell &scell4 = pSCSec[mod4][lay4][cell4];
            HGeomVector &p4  = scell4.getWirePnt1();
            HGeomVector &pe4 = scell4.getWirePnt2();
            HGeomVector v4 = pe4 - p4;
            HGeomVector P41(p4 - p1);
            HGeomVector V14(v1.vectorProduct(v4));
            HGeomVector V24(v2.vectorProduct(v4));
            Double_t B2 = v2.scalarProduct(V14);
            Double_t D2    = (p2 - p4).scalarProduct(V14);
            Double_t F2    = v4.scalarProduct(P41.vectorProduct(P21));
            Double_t E2    = P41.scalarProduct(V24);

            Double_t BE    = B1*E2 - B2*E1;
            Double_t BC    = 0.5/BE;
            Double_t DEpBF = D1*E2 - D2*E1 + B1*F2 - B2*F1;
            Double_t SQ    = TMath::Sqrt(DEpBF*DEpBF - 4*BE*(D1*F2 - D2*F1));
            Double_t t2    = (SQ - DEpBF)*BC;  
            Double_t t1    = -(E2*t2 + F2)/(B2*t2 + D2);
            Double_t t2b   = (-SQ - DEpBF)*BC;  
            Double_t t1b   = -(E2*t2b + F2)/(B2*t2b + D2);
            if(TMath::Abs(t1b) < TMath::Abs(t1)) {
              t2=t2b;
              t1=t1b;
            }
            HGeomVector P5(v1);
            P5 *= t1;
            P5 += p1;
            HGeomVector Q(v2);
            Q *= t2;
            Q += p2;
            Q -= P5;
            tmpLineParam.setParam(P5,Q);


            // Collecting wires:
            Int_t iLayer  = 0; //seg != 1 ?  0 : 12;
            Int_t lastLay = 12; //seg == 0 ? 12 : 24;

            tmpListCells.clear();
            for(;iLayer<lastLay;iLayer++) {
              Int_t mod = iLayer/6;
// ????              if(fSCModAr[mod]==0) continue;
              Int_t lay = iLayer%6;
              HMdcSizesCellsLayer &fSCLay   = pSCSec[mod][lay];
              HMdcLayListCells    &pLaylist = pSListCells[mod][lay]; 
              Float_t fcell1,fcell2;
              if( !fSCLay.calcCrossedCells(tmpLineParam,fcell1,fcell2) ) continue;
              Int_t c1 = fcell1 - 0.5;
              Int_t c2 = fcell2 + 0.5;
              for(Int_t c=c1;c<=c2;c++) {
                if(pLaylist.isCell(c) && pLaylist.getNFitted(c)==0 && fSCLay[c].getStatus()) {
                  tmpListCells.setTime(iLayer,c,1);
                }
              }
            }
            Int_t nLays = tmpListCells.getNLayers();

            if(nLays <  nLaysBest) continue;
            if(nLays == nLaysBest && nCellsBest >= tmpListCells.getNCells()) continue;  //?????????????

            listCells  = tmpListCells;
            nLaysBest  = nLays; 
            nCellsBest = listCells.getNCells();
            lineParam  = tmpLineParam;
            //  if(nLayersMax==nLaysBest && nCellsBest+1 >= nWiresMax) return nLaysBest; // Old version.
            if(nLayersMax==nLaysBest) return nLaysBest; // ????????????
          }
        }
      }
    }
  }
  return nLaysBest;
}
 hmdcwiredata.cc:1
 hmdcwiredata.cc:2
 hmdcwiredata.cc:3
 hmdcwiredata.cc:4
 hmdcwiredata.cc:5
 hmdcwiredata.cc:6
 hmdcwiredata.cc:7
 hmdcwiredata.cc:8
 hmdcwiredata.cc:9
 hmdcwiredata.cc:10
 hmdcwiredata.cc:11
 hmdcwiredata.cc:12
 hmdcwiredata.cc:13
 hmdcwiredata.cc:14
 hmdcwiredata.cc:15
 hmdcwiredata.cc:16
 hmdcwiredata.cc:17
 hmdcwiredata.cc:18
 hmdcwiredata.cc:19
 hmdcwiredata.cc:20
 hmdcwiredata.cc:21
 hmdcwiredata.cc:22
 hmdcwiredata.cc:23
 hmdcwiredata.cc:24
 hmdcwiredata.cc:25
 hmdcwiredata.cc:26
 hmdcwiredata.cc:27
 hmdcwiredata.cc:28
 hmdcwiredata.cc:29
 hmdcwiredata.cc:30
 hmdcwiredata.cc:31
 hmdcwiredata.cc:32
 hmdcwiredata.cc:33
 hmdcwiredata.cc:34
 hmdcwiredata.cc:35
 hmdcwiredata.cc:36
 hmdcwiredata.cc:37
 hmdcwiredata.cc:38
 hmdcwiredata.cc:39
 hmdcwiredata.cc:40
 hmdcwiredata.cc:41
 hmdcwiredata.cc:42
 hmdcwiredata.cc:43
 hmdcwiredata.cc:44
 hmdcwiredata.cc:45
 hmdcwiredata.cc:46
 hmdcwiredata.cc:47
 hmdcwiredata.cc:48
 hmdcwiredata.cc:49
 hmdcwiredata.cc:50
 hmdcwiredata.cc:51
 hmdcwiredata.cc:52
 hmdcwiredata.cc:53
 hmdcwiredata.cc:54
 hmdcwiredata.cc:55
 hmdcwiredata.cc:56
 hmdcwiredata.cc:57
 hmdcwiredata.cc:58
 hmdcwiredata.cc:59
 hmdcwiredata.cc:60
 hmdcwiredata.cc:61
 hmdcwiredata.cc:62
 hmdcwiredata.cc:63
 hmdcwiredata.cc:64
 hmdcwiredata.cc:65
 hmdcwiredata.cc:66
 hmdcwiredata.cc:67
 hmdcwiredata.cc:68
 hmdcwiredata.cc:69
 hmdcwiredata.cc:70
 hmdcwiredata.cc:71
 hmdcwiredata.cc:72
 hmdcwiredata.cc:73
 hmdcwiredata.cc:74
 hmdcwiredata.cc:75
 hmdcwiredata.cc:76
 hmdcwiredata.cc:77
 hmdcwiredata.cc:78
 hmdcwiredata.cc:79
 hmdcwiredata.cc:80
 hmdcwiredata.cc:81
 hmdcwiredata.cc:82
 hmdcwiredata.cc:83
 hmdcwiredata.cc:84
 hmdcwiredata.cc:85
 hmdcwiredata.cc:86
 hmdcwiredata.cc:87
 hmdcwiredata.cc:88
 hmdcwiredata.cc:89
 hmdcwiredata.cc:90
 hmdcwiredata.cc:91
 hmdcwiredata.cc:92
 hmdcwiredata.cc:93
 hmdcwiredata.cc:94
 hmdcwiredata.cc:95
 hmdcwiredata.cc:96
 hmdcwiredata.cc:97
 hmdcwiredata.cc:98
 hmdcwiredata.cc:99
 hmdcwiredata.cc:100
 hmdcwiredata.cc:101
 hmdcwiredata.cc:102
 hmdcwiredata.cc:103
 hmdcwiredata.cc:104
 hmdcwiredata.cc:105
 hmdcwiredata.cc:106
 hmdcwiredata.cc:107
 hmdcwiredata.cc:108
 hmdcwiredata.cc:109
 hmdcwiredata.cc:110
 hmdcwiredata.cc:111
 hmdcwiredata.cc:112
 hmdcwiredata.cc:113
 hmdcwiredata.cc:114
 hmdcwiredata.cc:115
 hmdcwiredata.cc:116
 hmdcwiredata.cc:117
 hmdcwiredata.cc:118
 hmdcwiredata.cc:119
 hmdcwiredata.cc:120
 hmdcwiredata.cc:121
 hmdcwiredata.cc:122
 hmdcwiredata.cc:123
 hmdcwiredata.cc:124
 hmdcwiredata.cc:125
 hmdcwiredata.cc:126
 hmdcwiredata.cc:127
 hmdcwiredata.cc:128
 hmdcwiredata.cc:129
 hmdcwiredata.cc:130
 hmdcwiredata.cc:131
 hmdcwiredata.cc:132
 hmdcwiredata.cc:133
 hmdcwiredata.cc:134
 hmdcwiredata.cc:135
 hmdcwiredata.cc:136
 hmdcwiredata.cc:137
 hmdcwiredata.cc:138
 hmdcwiredata.cc:139
 hmdcwiredata.cc:140
 hmdcwiredata.cc:141
 hmdcwiredata.cc:142
 hmdcwiredata.cc:143
 hmdcwiredata.cc:144
 hmdcwiredata.cc:145
 hmdcwiredata.cc:146
 hmdcwiredata.cc:147
 hmdcwiredata.cc:148
 hmdcwiredata.cc:149
 hmdcwiredata.cc:150
 hmdcwiredata.cc:151
 hmdcwiredata.cc:152
 hmdcwiredata.cc:153
 hmdcwiredata.cc:154
 hmdcwiredata.cc:155
 hmdcwiredata.cc:156
 hmdcwiredata.cc:157
 hmdcwiredata.cc:158
 hmdcwiredata.cc:159
 hmdcwiredata.cc:160
 hmdcwiredata.cc:161
 hmdcwiredata.cc:162
 hmdcwiredata.cc:163
 hmdcwiredata.cc:164
 hmdcwiredata.cc:165
 hmdcwiredata.cc:166
 hmdcwiredata.cc:167
 hmdcwiredata.cc:168
 hmdcwiredata.cc:169
 hmdcwiredata.cc:170
 hmdcwiredata.cc:171
 hmdcwiredata.cc:172
 hmdcwiredata.cc:173
 hmdcwiredata.cc:174
 hmdcwiredata.cc:175
 hmdcwiredata.cc:176
 hmdcwiredata.cc:177
 hmdcwiredata.cc:178
 hmdcwiredata.cc:179
 hmdcwiredata.cc:180
 hmdcwiredata.cc:181
 hmdcwiredata.cc:182
 hmdcwiredata.cc:183
 hmdcwiredata.cc:184
 hmdcwiredata.cc:185
 hmdcwiredata.cc:186
 hmdcwiredata.cc:187
 hmdcwiredata.cc:188
 hmdcwiredata.cc:189
 hmdcwiredata.cc:190
 hmdcwiredata.cc:191
 hmdcwiredata.cc:192
 hmdcwiredata.cc:193
 hmdcwiredata.cc:194
 hmdcwiredata.cc:195
 hmdcwiredata.cc:196
 hmdcwiredata.cc:197
 hmdcwiredata.cc:198
 hmdcwiredata.cc:199
 hmdcwiredata.cc:200
 hmdcwiredata.cc:201
 hmdcwiredata.cc:202
 hmdcwiredata.cc:203
 hmdcwiredata.cc:204
 hmdcwiredata.cc:205
 hmdcwiredata.cc:206
 hmdcwiredata.cc:207
 hmdcwiredata.cc:208
 hmdcwiredata.cc:209
 hmdcwiredata.cc:210
 hmdcwiredata.cc:211
 hmdcwiredata.cc:212
 hmdcwiredata.cc:213
 hmdcwiredata.cc:214
 hmdcwiredata.cc:215
 hmdcwiredata.cc:216
 hmdcwiredata.cc:217
 hmdcwiredata.cc:218
 hmdcwiredata.cc:219
 hmdcwiredata.cc:220
 hmdcwiredata.cc:221
 hmdcwiredata.cc:222
 hmdcwiredata.cc:223
 hmdcwiredata.cc:224
 hmdcwiredata.cc:225
 hmdcwiredata.cc:226
 hmdcwiredata.cc:227
 hmdcwiredata.cc:228
 hmdcwiredata.cc:229
 hmdcwiredata.cc:230
 hmdcwiredata.cc:231
 hmdcwiredata.cc:232
 hmdcwiredata.cc:233
 hmdcwiredata.cc:234
 hmdcwiredata.cc:235
 hmdcwiredata.cc:236
 hmdcwiredata.cc:237
 hmdcwiredata.cc:238
 hmdcwiredata.cc:239
 hmdcwiredata.cc:240
 hmdcwiredata.cc:241
 hmdcwiredata.cc:242
 hmdcwiredata.cc:243
 hmdcwiredata.cc:244
 hmdcwiredata.cc:245
 hmdcwiredata.cc:246
 hmdcwiredata.cc:247
 hmdcwiredata.cc:248
 hmdcwiredata.cc:249
 hmdcwiredata.cc:250
 hmdcwiredata.cc:251
 hmdcwiredata.cc:252
 hmdcwiredata.cc:253
 hmdcwiredata.cc:254
 hmdcwiredata.cc:255
 hmdcwiredata.cc:256
 hmdcwiredata.cc:257
 hmdcwiredata.cc:258
 hmdcwiredata.cc:259
 hmdcwiredata.cc:260
 hmdcwiredata.cc:261
 hmdcwiredata.cc:262
 hmdcwiredata.cc:263
 hmdcwiredata.cc:264
 hmdcwiredata.cc:265
 hmdcwiredata.cc:266
 hmdcwiredata.cc:267
 hmdcwiredata.cc:268
 hmdcwiredata.cc:269
 hmdcwiredata.cc:270
 hmdcwiredata.cc:271
 hmdcwiredata.cc:272
 hmdcwiredata.cc:273
 hmdcwiredata.cc:274
 hmdcwiredata.cc:275
 hmdcwiredata.cc:276
 hmdcwiredata.cc:277
 hmdcwiredata.cc:278
 hmdcwiredata.cc:279
 hmdcwiredata.cc:280
 hmdcwiredata.cc:281
 hmdcwiredata.cc:282
 hmdcwiredata.cc:283
 hmdcwiredata.cc:284
 hmdcwiredata.cc:285
 hmdcwiredata.cc:286
 hmdcwiredata.cc:287
 hmdcwiredata.cc:288
 hmdcwiredata.cc:289
 hmdcwiredata.cc:290
 hmdcwiredata.cc:291
 hmdcwiredata.cc:292
 hmdcwiredata.cc:293
 hmdcwiredata.cc:294
 hmdcwiredata.cc:295
 hmdcwiredata.cc:296
 hmdcwiredata.cc:297
 hmdcwiredata.cc:298
 hmdcwiredata.cc:299
 hmdcwiredata.cc:300
 hmdcwiredata.cc:301
 hmdcwiredata.cc:302
 hmdcwiredata.cc:303
 hmdcwiredata.cc:304
 hmdcwiredata.cc:305
 hmdcwiredata.cc:306
 hmdcwiredata.cc:307
 hmdcwiredata.cc:308
 hmdcwiredata.cc:309
 hmdcwiredata.cc:310
 hmdcwiredata.cc:311
 hmdcwiredata.cc:312
 hmdcwiredata.cc:313
 hmdcwiredata.cc:314
 hmdcwiredata.cc:315
 hmdcwiredata.cc:316
 hmdcwiredata.cc:317
 hmdcwiredata.cc:318
 hmdcwiredata.cc:319
 hmdcwiredata.cc:320
 hmdcwiredata.cc:321
 hmdcwiredata.cc:322
 hmdcwiredata.cc:323
 hmdcwiredata.cc:324
 hmdcwiredata.cc:325
 hmdcwiredata.cc:326
 hmdcwiredata.cc:327
 hmdcwiredata.cc:328
 hmdcwiredata.cc:329
 hmdcwiredata.cc:330
 hmdcwiredata.cc:331
 hmdcwiredata.cc:332
 hmdcwiredata.cc:333
 hmdcwiredata.cc:334
 hmdcwiredata.cc:335
 hmdcwiredata.cc:336
 hmdcwiredata.cc:337
 hmdcwiredata.cc:338
 hmdcwiredata.cc:339
 hmdcwiredata.cc:340
 hmdcwiredata.cc:341
 hmdcwiredata.cc:342
 hmdcwiredata.cc:343
 hmdcwiredata.cc:344
 hmdcwiredata.cc:345
 hmdcwiredata.cc:346
 hmdcwiredata.cc:347
 hmdcwiredata.cc:348
 hmdcwiredata.cc:349
 hmdcwiredata.cc:350
 hmdcwiredata.cc:351
 hmdcwiredata.cc:352
 hmdcwiredata.cc:353
 hmdcwiredata.cc:354
 hmdcwiredata.cc:355
 hmdcwiredata.cc:356
 hmdcwiredata.cc:357
 hmdcwiredata.cc:358
 hmdcwiredata.cc:359
 hmdcwiredata.cc:360
 hmdcwiredata.cc:361
 hmdcwiredata.cc:362
 hmdcwiredata.cc:363
 hmdcwiredata.cc:364
 hmdcwiredata.cc:365
 hmdcwiredata.cc:366
 hmdcwiredata.cc:367
 hmdcwiredata.cc:368
 hmdcwiredata.cc:369
 hmdcwiredata.cc:370
 hmdcwiredata.cc:371
 hmdcwiredata.cc:372
 hmdcwiredata.cc:373
 hmdcwiredata.cc:374
 hmdcwiredata.cc:375
 hmdcwiredata.cc:376
 hmdcwiredata.cc:377
 hmdcwiredata.cc:378
 hmdcwiredata.cc:379
 hmdcwiredata.cc:380
 hmdcwiredata.cc:381
 hmdcwiredata.cc:382
 hmdcwiredata.cc:383
 hmdcwiredata.cc:384
 hmdcwiredata.cc:385
 hmdcwiredata.cc:386
 hmdcwiredata.cc:387
 hmdcwiredata.cc:388
 hmdcwiredata.cc:389
 hmdcwiredata.cc:390
 hmdcwiredata.cc:391
 hmdcwiredata.cc:392
 hmdcwiredata.cc:393
 hmdcwiredata.cc:394
 hmdcwiredata.cc:395
 hmdcwiredata.cc:396
 hmdcwiredata.cc:397
 hmdcwiredata.cc:398
 hmdcwiredata.cc:399
 hmdcwiredata.cc:400
 hmdcwiredata.cc:401
 hmdcwiredata.cc:402
 hmdcwiredata.cc:403
 hmdcwiredata.cc:404
 hmdcwiredata.cc:405
 hmdcwiredata.cc:406
 hmdcwiredata.cc:407
 hmdcwiredata.cc:408
 hmdcwiredata.cc:409
 hmdcwiredata.cc:410
 hmdcwiredata.cc:411
 hmdcwiredata.cc:412
 hmdcwiredata.cc:413
 hmdcwiredata.cc:414
 hmdcwiredata.cc:415
 hmdcwiredata.cc:416
 hmdcwiredata.cc:417
 hmdcwiredata.cc:418
 hmdcwiredata.cc:419
 hmdcwiredata.cc:420
 hmdcwiredata.cc:421
 hmdcwiredata.cc:422
 hmdcwiredata.cc:423
 hmdcwiredata.cc:424
 hmdcwiredata.cc:425
 hmdcwiredata.cc:426
 hmdcwiredata.cc:427
 hmdcwiredata.cc:428
 hmdcwiredata.cc:429
 hmdcwiredata.cc:430
 hmdcwiredata.cc:431
 hmdcwiredata.cc:432
 hmdcwiredata.cc:433
 hmdcwiredata.cc:434
 hmdcwiredata.cc:435
 hmdcwiredata.cc:436
 hmdcwiredata.cc:437
 hmdcwiredata.cc:438
 hmdcwiredata.cc:439
 hmdcwiredata.cc:440
 hmdcwiredata.cc:441
 hmdcwiredata.cc:442
 hmdcwiredata.cc:443
 hmdcwiredata.cc:444
 hmdcwiredata.cc:445
 hmdcwiredata.cc:446
 hmdcwiredata.cc:447
 hmdcwiredata.cc:448
 hmdcwiredata.cc:449
 hmdcwiredata.cc:450
 hmdcwiredata.cc:451
 hmdcwiredata.cc:452
 hmdcwiredata.cc:453
 hmdcwiredata.cc:454
 hmdcwiredata.cc:455
 hmdcwiredata.cc:456
 hmdcwiredata.cc:457
 hmdcwiredata.cc:458
 hmdcwiredata.cc:459
 hmdcwiredata.cc:460
 hmdcwiredata.cc:461
 hmdcwiredata.cc:462
 hmdcwiredata.cc:463
 hmdcwiredata.cc:464
 hmdcwiredata.cc:465
 hmdcwiredata.cc:466
 hmdcwiredata.cc:467
 hmdcwiredata.cc:468
 hmdcwiredata.cc:469
 hmdcwiredata.cc:470
 hmdcwiredata.cc:471
 hmdcwiredata.cc:472
 hmdcwiredata.cc:473
 hmdcwiredata.cc:474
 hmdcwiredata.cc:475
 hmdcwiredata.cc:476
 hmdcwiredata.cc:477
 hmdcwiredata.cc:478
 hmdcwiredata.cc:479
 hmdcwiredata.cc:480
 hmdcwiredata.cc:481
 hmdcwiredata.cc:482
 hmdcwiredata.cc:483
 hmdcwiredata.cc:484
 hmdcwiredata.cc:485
 hmdcwiredata.cc:486
 hmdcwiredata.cc:487
 hmdcwiredata.cc:488
 hmdcwiredata.cc:489
 hmdcwiredata.cc:490
 hmdcwiredata.cc:491
 hmdcwiredata.cc:492
 hmdcwiredata.cc:493
 hmdcwiredata.cc:494
 hmdcwiredata.cc:495
 hmdcwiredata.cc:496
 hmdcwiredata.cc:497
 hmdcwiredata.cc:498
 hmdcwiredata.cc:499
 hmdcwiredata.cc:500
 hmdcwiredata.cc:501
 hmdcwiredata.cc:502
 hmdcwiredata.cc:503
 hmdcwiredata.cc:504
 hmdcwiredata.cc:505
 hmdcwiredata.cc:506
 hmdcwiredata.cc:507
 hmdcwiredata.cc:508
 hmdcwiredata.cc:509
 hmdcwiredata.cc:510
 hmdcwiredata.cc:511
 hmdcwiredata.cc:512
 hmdcwiredata.cc:513
 hmdcwiredata.cc:514
 hmdcwiredata.cc:515
 hmdcwiredata.cc:516
 hmdcwiredata.cc:517
 hmdcwiredata.cc:518
 hmdcwiredata.cc:519
 hmdcwiredata.cc:520
 hmdcwiredata.cc:521
 hmdcwiredata.cc:522
 hmdcwiredata.cc:523
 hmdcwiredata.cc:524
 hmdcwiredata.cc:525
 hmdcwiredata.cc:526
 hmdcwiredata.cc:527
 hmdcwiredata.cc:528
 hmdcwiredata.cc:529
 hmdcwiredata.cc:530
 hmdcwiredata.cc:531
 hmdcwiredata.cc:532
 hmdcwiredata.cc:533
 hmdcwiredata.cc:534
 hmdcwiredata.cc:535
 hmdcwiredata.cc:536
 hmdcwiredata.cc:537
 hmdcwiredata.cc:538
 hmdcwiredata.cc:539
 hmdcwiredata.cc:540
 hmdcwiredata.cc:541
 hmdcwiredata.cc:542
 hmdcwiredata.cc:543
 hmdcwiredata.cc:544
 hmdcwiredata.cc:545
 hmdcwiredata.cc:546
 hmdcwiredata.cc:547
 hmdcwiredata.cc:548
 hmdcwiredata.cc:549
 hmdcwiredata.cc:550
 hmdcwiredata.cc:551
 hmdcwiredata.cc:552
 hmdcwiredata.cc:553
 hmdcwiredata.cc:554
 hmdcwiredata.cc:555
 hmdcwiredata.cc:556
 hmdcwiredata.cc:557
 hmdcwiredata.cc:558
 hmdcwiredata.cc:559
 hmdcwiredata.cc:560
 hmdcwiredata.cc:561
 hmdcwiredata.cc:562
 hmdcwiredata.cc:563
 hmdcwiredata.cc:564
 hmdcwiredata.cc:565
 hmdcwiredata.cc:566
 hmdcwiredata.cc:567
 hmdcwiredata.cc:568
 hmdcwiredata.cc:569
 hmdcwiredata.cc:570
 hmdcwiredata.cc:571
 hmdcwiredata.cc:572
 hmdcwiredata.cc:573
 hmdcwiredata.cc:574
 hmdcwiredata.cc:575
 hmdcwiredata.cc:576
 hmdcwiredata.cc:577
 hmdcwiredata.cc:578
 hmdcwiredata.cc:579
 hmdcwiredata.cc:580
 hmdcwiredata.cc:581
 hmdcwiredata.cc:582
 hmdcwiredata.cc:583
 hmdcwiredata.cc:584
 hmdcwiredata.cc:585
 hmdcwiredata.cc:586
 hmdcwiredata.cc:587
 hmdcwiredata.cc:588
 hmdcwiredata.cc:589
 hmdcwiredata.cc:590
 hmdcwiredata.cc:591
 hmdcwiredata.cc:592
 hmdcwiredata.cc:593
 hmdcwiredata.cc:594
 hmdcwiredata.cc:595
 hmdcwiredata.cc:596
 hmdcwiredata.cc:597
 hmdcwiredata.cc:598
 hmdcwiredata.cc:599
 hmdcwiredata.cc:600
 hmdcwiredata.cc:601
 hmdcwiredata.cc:602
 hmdcwiredata.cc:603
 hmdcwiredata.cc:604
 hmdcwiredata.cc:605
 hmdcwiredata.cc:606
 hmdcwiredata.cc:607
 hmdcwiredata.cc:608
 hmdcwiredata.cc:609
 hmdcwiredata.cc:610
 hmdcwiredata.cc:611
 hmdcwiredata.cc:612
 hmdcwiredata.cc:613
 hmdcwiredata.cc:614
 hmdcwiredata.cc:615
 hmdcwiredata.cc:616
 hmdcwiredata.cc:617
 hmdcwiredata.cc:618
 hmdcwiredata.cc:619
 hmdcwiredata.cc:620
 hmdcwiredata.cc:621
 hmdcwiredata.cc:622
 hmdcwiredata.cc:623
 hmdcwiredata.cc:624
 hmdcwiredata.cc:625
 hmdcwiredata.cc:626
 hmdcwiredata.cc:627
 hmdcwiredata.cc:628
 hmdcwiredata.cc:629
 hmdcwiredata.cc:630
 hmdcwiredata.cc:631
 hmdcwiredata.cc:632
 hmdcwiredata.cc:633
 hmdcwiredata.cc:634
 hmdcwiredata.cc:635
 hmdcwiredata.cc:636
 hmdcwiredata.cc:637
 hmdcwiredata.cc:638
 hmdcwiredata.cc:639
 hmdcwiredata.cc:640
 hmdcwiredata.cc:641
 hmdcwiredata.cc:642
 hmdcwiredata.cc:643
 hmdcwiredata.cc:644
 hmdcwiredata.cc:645
 hmdcwiredata.cc:646
 hmdcwiredata.cc:647
 hmdcwiredata.cc:648
 hmdcwiredata.cc:649
 hmdcwiredata.cc:650
 hmdcwiredata.cc:651
 hmdcwiredata.cc:652
 hmdcwiredata.cc:653
 hmdcwiredata.cc:654
 hmdcwiredata.cc:655
 hmdcwiredata.cc:656
 hmdcwiredata.cc:657
 hmdcwiredata.cc:658
 hmdcwiredata.cc:659
 hmdcwiredata.cc:660
 hmdcwiredata.cc:661
 hmdcwiredata.cc:662
 hmdcwiredata.cc:663
 hmdcwiredata.cc:664
 hmdcwiredata.cc:665
 hmdcwiredata.cc:666
 hmdcwiredata.cc:667
 hmdcwiredata.cc:668
 hmdcwiredata.cc:669
 hmdcwiredata.cc:670
 hmdcwiredata.cc:671
 hmdcwiredata.cc:672
 hmdcwiredata.cc:673
 hmdcwiredata.cc:674
 hmdcwiredata.cc:675
 hmdcwiredata.cc:676
 hmdcwiredata.cc:677
 hmdcwiredata.cc:678
 hmdcwiredata.cc:679
 hmdcwiredata.cc:680
 hmdcwiredata.cc:681
 hmdcwiredata.cc:682
 hmdcwiredata.cc:683
 hmdcwiredata.cc:684
 hmdcwiredata.cc:685
 hmdcwiredata.cc:686
 hmdcwiredata.cc:687
 hmdcwiredata.cc:688
 hmdcwiredata.cc:689
 hmdcwiredata.cc:690
 hmdcwiredata.cc:691
 hmdcwiredata.cc:692
 hmdcwiredata.cc:693
 hmdcwiredata.cc:694
 hmdcwiredata.cc:695
 hmdcwiredata.cc:696
 hmdcwiredata.cc:697
 hmdcwiredata.cc:698
 hmdcwiredata.cc:699
 hmdcwiredata.cc:700
 hmdcwiredata.cc:701
 hmdcwiredata.cc:702
 hmdcwiredata.cc:703
 hmdcwiredata.cc:704
 hmdcwiredata.cc:705
 hmdcwiredata.cc:706
 hmdcwiredata.cc:707
 hmdcwiredata.cc:708
 hmdcwiredata.cc:709
 hmdcwiredata.cc:710
 hmdcwiredata.cc:711
 hmdcwiredata.cc:712
 hmdcwiredata.cc:713
 hmdcwiredata.cc:714
 hmdcwiredata.cc:715
 hmdcwiredata.cc:716
 hmdcwiredata.cc:717
 hmdcwiredata.cc:718
 hmdcwiredata.cc:719
 hmdcwiredata.cc:720
 hmdcwiredata.cc:721
 hmdcwiredata.cc:722
 hmdcwiredata.cc:723
 hmdcwiredata.cc:724
 hmdcwiredata.cc:725
 hmdcwiredata.cc:726
 hmdcwiredata.cc:727
 hmdcwiredata.cc:728
 hmdcwiredata.cc:729
 hmdcwiredata.cc:730
 hmdcwiredata.cc:731
 hmdcwiredata.cc:732
 hmdcwiredata.cc:733
 hmdcwiredata.cc:734
 hmdcwiredata.cc:735
 hmdcwiredata.cc:736
 hmdcwiredata.cc:737
 hmdcwiredata.cc:738
 hmdcwiredata.cc:739
 hmdcwiredata.cc:740
 hmdcwiredata.cc:741
 hmdcwiredata.cc:742
 hmdcwiredata.cc:743
 hmdcwiredata.cc:744
 hmdcwiredata.cc:745
 hmdcwiredata.cc:746
 hmdcwiredata.cc:747
 hmdcwiredata.cc:748
 hmdcwiredata.cc:749
 hmdcwiredata.cc:750
 hmdcwiredata.cc:751
 hmdcwiredata.cc:752
 hmdcwiredata.cc:753
 hmdcwiredata.cc:754
 hmdcwiredata.cc:755
 hmdcwiredata.cc:756
 hmdcwiredata.cc:757
 hmdcwiredata.cc:758
 hmdcwiredata.cc:759
 hmdcwiredata.cc:760
 hmdcwiredata.cc:761
 hmdcwiredata.cc:762
 hmdcwiredata.cc:763
 hmdcwiredata.cc:764
 hmdcwiredata.cc:765
 hmdcwiredata.cc:766
 hmdcwiredata.cc:767
 hmdcwiredata.cc:768
 hmdcwiredata.cc:769
 hmdcwiredata.cc:770
 hmdcwiredata.cc:771
 hmdcwiredata.cc:772
 hmdcwiredata.cc:773
 hmdcwiredata.cc:774
 hmdcwiredata.cc:775
 hmdcwiredata.cc:776
 hmdcwiredata.cc:777
 hmdcwiredata.cc:778
 hmdcwiredata.cc:779
 hmdcwiredata.cc:780
 hmdcwiredata.cc:781
 hmdcwiredata.cc:782
 hmdcwiredata.cc:783
 hmdcwiredata.cc:784
 hmdcwiredata.cc:785
 hmdcwiredata.cc:786
 hmdcwiredata.cc:787
 hmdcwiredata.cc:788
 hmdcwiredata.cc:789
 hmdcwiredata.cc:790
 hmdcwiredata.cc:791
 hmdcwiredata.cc:792
 hmdcwiredata.cc:793
 hmdcwiredata.cc:794
 hmdcwiredata.cc:795
 hmdcwiredata.cc:796
 hmdcwiredata.cc:797
 hmdcwiredata.cc:798
 hmdcwiredata.cc:799
 hmdcwiredata.cc:800
 hmdcwiredata.cc:801
 hmdcwiredata.cc:802
 hmdcwiredata.cc:803
 hmdcwiredata.cc:804
 hmdcwiredata.cc:805
 hmdcwiredata.cc:806
 hmdcwiredata.cc:807
 hmdcwiredata.cc:808
 hmdcwiredata.cc:809
 hmdcwiredata.cc:810
 hmdcwiredata.cc:811
 hmdcwiredata.cc:812
 hmdcwiredata.cc:813
 hmdcwiredata.cc:814
 hmdcwiredata.cc:815
 hmdcwiredata.cc:816
 hmdcwiredata.cc:817
 hmdcwiredata.cc:818
 hmdcwiredata.cc:819
 hmdcwiredata.cc:820
 hmdcwiredata.cc:821
 hmdcwiredata.cc:822
 hmdcwiredata.cc:823
 hmdcwiredata.cc:824
 hmdcwiredata.cc:825
 hmdcwiredata.cc:826
 hmdcwiredata.cc:827
 hmdcwiredata.cc:828
 hmdcwiredata.cc:829
 hmdcwiredata.cc:830
 hmdcwiredata.cc:831
 hmdcwiredata.cc:832
 hmdcwiredata.cc:833
 hmdcwiredata.cc:834
 hmdcwiredata.cc:835
 hmdcwiredata.cc:836
 hmdcwiredata.cc:837
 hmdcwiredata.cc:838
 hmdcwiredata.cc:839
 hmdcwiredata.cc:840
 hmdcwiredata.cc:841
 hmdcwiredata.cc:842
 hmdcwiredata.cc:843
 hmdcwiredata.cc:844
 hmdcwiredata.cc:845
 hmdcwiredata.cc:846
 hmdcwiredata.cc:847
 hmdcwiredata.cc:848
 hmdcwiredata.cc:849
 hmdcwiredata.cc:850
 hmdcwiredata.cc:851
 hmdcwiredata.cc:852
 hmdcwiredata.cc:853
 hmdcwiredata.cc:854
 hmdcwiredata.cc:855
 hmdcwiredata.cc:856
 hmdcwiredata.cc:857
 hmdcwiredata.cc:858
 hmdcwiredata.cc:859
 hmdcwiredata.cc:860
 hmdcwiredata.cc:861
 hmdcwiredata.cc:862
 hmdcwiredata.cc:863
 hmdcwiredata.cc:864
 hmdcwiredata.cc:865
 hmdcwiredata.cc:866
 hmdcwiredata.cc:867
 hmdcwiredata.cc:868
 hmdcwiredata.cc:869
 hmdcwiredata.cc:870
 hmdcwiredata.cc:871
 hmdcwiredata.cc:872
 hmdcwiredata.cc:873
 hmdcwiredata.cc:874
 hmdcwiredata.cc:875
 hmdcwiredata.cc:876
 hmdcwiredata.cc:877
 hmdcwiredata.cc:878
 hmdcwiredata.cc:879
 hmdcwiredata.cc:880
 hmdcwiredata.cc:881
 hmdcwiredata.cc:882
 hmdcwiredata.cc:883
 hmdcwiredata.cc:884
 hmdcwiredata.cc:885
 hmdcwiredata.cc:886
 hmdcwiredata.cc:887
 hmdcwiredata.cc:888
 hmdcwiredata.cc:889
 hmdcwiredata.cc:890
 hmdcwiredata.cc:891
 hmdcwiredata.cc:892
 hmdcwiredata.cc:893
 hmdcwiredata.cc:894
 hmdcwiredata.cc:895
 hmdcwiredata.cc:896
 hmdcwiredata.cc:897
 hmdcwiredata.cc:898
 hmdcwiredata.cc:899
 hmdcwiredata.cc:900
 hmdcwiredata.cc:901
 hmdcwiredata.cc:902
 hmdcwiredata.cc:903
 hmdcwiredata.cc:904
 hmdcwiredata.cc:905
 hmdcwiredata.cc:906
 hmdcwiredata.cc:907
 hmdcwiredata.cc:908
 hmdcwiredata.cc:909
 hmdcwiredata.cc:910
 hmdcwiredata.cc:911
 hmdcwiredata.cc:912
 hmdcwiredata.cc:913
 hmdcwiredata.cc:914
 hmdcwiredata.cc:915
 hmdcwiredata.cc:916
 hmdcwiredata.cc:917
 hmdcwiredata.cc:918
 hmdcwiredata.cc:919
 hmdcwiredata.cc:920
 hmdcwiredata.cc:921
 hmdcwiredata.cc:922
 hmdcwiredata.cc:923
 hmdcwiredata.cc:924
 hmdcwiredata.cc:925
 hmdcwiredata.cc:926
 hmdcwiredata.cc:927
 hmdcwiredata.cc:928
 hmdcwiredata.cc:929
 hmdcwiredata.cc:930
 hmdcwiredata.cc:931
 hmdcwiredata.cc:932
 hmdcwiredata.cc:933
 hmdcwiredata.cc:934
 hmdcwiredata.cc:935
 hmdcwiredata.cc:936
 hmdcwiredata.cc:937
 hmdcwiredata.cc:938
 hmdcwiredata.cc:939
 hmdcwiredata.cc:940
 hmdcwiredata.cc:941
 hmdcwiredata.cc:942
 hmdcwiredata.cc:943
 hmdcwiredata.cc:944
 hmdcwiredata.cc:945
 hmdcwiredata.cc:946
 hmdcwiredata.cc:947
 hmdcwiredata.cc:948
 hmdcwiredata.cc:949
 hmdcwiredata.cc:950
 hmdcwiredata.cc:951
 hmdcwiredata.cc:952
 hmdcwiredata.cc:953
 hmdcwiredata.cc:954
 hmdcwiredata.cc:955
 hmdcwiredata.cc:956
 hmdcwiredata.cc:957
 hmdcwiredata.cc:958
 hmdcwiredata.cc:959
 hmdcwiredata.cc:960
 hmdcwiredata.cc:961
 hmdcwiredata.cc:962
 hmdcwiredata.cc:963
 hmdcwiredata.cc:964
 hmdcwiredata.cc:965
 hmdcwiredata.cc:966
 hmdcwiredata.cc:967
 hmdcwiredata.cc:968
 hmdcwiredata.cc:969
 hmdcwiredata.cc:970
 hmdcwiredata.cc:971
 hmdcwiredata.cc:972
 hmdcwiredata.cc:973
 hmdcwiredata.cc:974
 hmdcwiredata.cc:975
 hmdcwiredata.cc:976
 hmdcwiredata.cc:977
 hmdcwiredata.cc:978
 hmdcwiredata.cc:979
 hmdcwiredata.cc:980
 hmdcwiredata.cc:981
 hmdcwiredata.cc:982
 hmdcwiredata.cc:983
 hmdcwiredata.cc:984
 hmdcwiredata.cc:985
 hmdcwiredata.cc:986
 hmdcwiredata.cc:987
 hmdcwiredata.cc:988
 hmdcwiredata.cc:989
 hmdcwiredata.cc:990
 hmdcwiredata.cc:991
 hmdcwiredata.cc:992
 hmdcwiredata.cc:993
 hmdcwiredata.cc:994
 hmdcwiredata.cc:995
 hmdcwiredata.cc:996
 hmdcwiredata.cc:997
 hmdcwiredata.cc:998
 hmdcwiredata.cc:999
 hmdcwiredata.cc:1000
 hmdcwiredata.cc:1001
 hmdcwiredata.cc:1002
 hmdcwiredata.cc:1003
 hmdcwiredata.cc:1004
 hmdcwiredata.cc:1005
 hmdcwiredata.cc:1006
 hmdcwiredata.cc:1007
 hmdcwiredata.cc:1008
 hmdcwiredata.cc:1009
 hmdcwiredata.cc:1010
 hmdcwiredata.cc:1011
 hmdcwiredata.cc:1012
 hmdcwiredata.cc:1013
 hmdcwiredata.cc:1014
 hmdcwiredata.cc:1015
 hmdcwiredata.cc:1016
 hmdcwiredata.cc:1017
 hmdcwiredata.cc:1018
 hmdcwiredata.cc:1019
 hmdcwiredata.cc:1020
 hmdcwiredata.cc:1021
 hmdcwiredata.cc:1022
 hmdcwiredata.cc:1023
 hmdcwiredata.cc:1024
 hmdcwiredata.cc:1025
 hmdcwiredata.cc:1026
 hmdcwiredata.cc:1027
 hmdcwiredata.cc:1028
 hmdcwiredata.cc:1029
 hmdcwiredata.cc:1030
 hmdcwiredata.cc:1031
 hmdcwiredata.cc:1032
 hmdcwiredata.cc:1033
 hmdcwiredata.cc:1034
 hmdcwiredata.cc:1035
 hmdcwiredata.cc:1036
 hmdcwiredata.cc:1037
 hmdcwiredata.cc:1038
 hmdcwiredata.cc:1039
 hmdcwiredata.cc:1040
 hmdcwiredata.cc:1041
 hmdcwiredata.cc:1042
 hmdcwiredata.cc:1043
 hmdcwiredata.cc:1044
 hmdcwiredata.cc:1045
 hmdcwiredata.cc:1046
 hmdcwiredata.cc:1047
 hmdcwiredata.cc:1048
 hmdcwiredata.cc:1049
 hmdcwiredata.cc:1050
 hmdcwiredata.cc:1051
 hmdcwiredata.cc:1052
 hmdcwiredata.cc:1053
 hmdcwiredata.cc:1054
 hmdcwiredata.cc:1055
 hmdcwiredata.cc:1056
 hmdcwiredata.cc:1057
 hmdcwiredata.cc:1058
 hmdcwiredata.cc:1059
 hmdcwiredata.cc:1060
 hmdcwiredata.cc:1061
 hmdcwiredata.cc:1062
 hmdcwiredata.cc:1063
 hmdcwiredata.cc:1064
 hmdcwiredata.cc:1065
 hmdcwiredata.cc:1066
 hmdcwiredata.cc:1067
 hmdcwiredata.cc:1068
 hmdcwiredata.cc:1069
 hmdcwiredata.cc:1070
 hmdcwiredata.cc:1071
 hmdcwiredata.cc:1072
 hmdcwiredata.cc:1073
 hmdcwiredata.cc:1074
 hmdcwiredata.cc:1075
 hmdcwiredata.cc:1076
 hmdcwiredata.cc:1077
 hmdcwiredata.cc:1078
 hmdcwiredata.cc:1079
 hmdcwiredata.cc:1080
 hmdcwiredata.cc:1081
 hmdcwiredata.cc:1082
 hmdcwiredata.cc:1083
 hmdcwiredata.cc:1084
 hmdcwiredata.cc:1085
 hmdcwiredata.cc:1086
 hmdcwiredata.cc:1087
 hmdcwiredata.cc:1088
 hmdcwiredata.cc:1089
 hmdcwiredata.cc:1090
 hmdcwiredata.cc:1091
 hmdcwiredata.cc:1092
 hmdcwiredata.cc:1093
 hmdcwiredata.cc:1094
 hmdcwiredata.cc:1095
 hmdcwiredata.cc:1096
 hmdcwiredata.cc:1097
 hmdcwiredata.cc:1098
 hmdcwiredata.cc:1099
 hmdcwiredata.cc:1100
 hmdcwiredata.cc:1101
 hmdcwiredata.cc:1102
 hmdcwiredata.cc:1103
 hmdcwiredata.cc:1104
 hmdcwiredata.cc:1105
 hmdcwiredata.cc:1106
 hmdcwiredata.cc:1107
 hmdcwiredata.cc:1108
 hmdcwiredata.cc:1109
 hmdcwiredata.cc:1110
 hmdcwiredata.cc:1111
 hmdcwiredata.cc:1112
 hmdcwiredata.cc:1113
 hmdcwiredata.cc:1114
 hmdcwiredata.cc:1115
 hmdcwiredata.cc:1116
 hmdcwiredata.cc:1117
 hmdcwiredata.cc:1118
 hmdcwiredata.cc:1119
 hmdcwiredata.cc:1120
 hmdcwiredata.cc:1121
 hmdcwiredata.cc:1122
 hmdcwiredata.cc:1123
 hmdcwiredata.cc:1124
 hmdcwiredata.cc:1125
 hmdcwiredata.cc:1126
 hmdcwiredata.cc:1127
 hmdcwiredata.cc:1128
 hmdcwiredata.cc:1129
 hmdcwiredata.cc:1130
 hmdcwiredata.cc:1131
 hmdcwiredata.cc:1132
 hmdcwiredata.cc:1133
 hmdcwiredata.cc:1134
 hmdcwiredata.cc:1135
 hmdcwiredata.cc:1136
 hmdcwiredata.cc:1137
 hmdcwiredata.cc:1138
 hmdcwiredata.cc:1139
 hmdcwiredata.cc:1140
 hmdcwiredata.cc:1141
 hmdcwiredata.cc:1142
 hmdcwiredata.cc:1143
 hmdcwiredata.cc:1144
 hmdcwiredata.cc:1145
 hmdcwiredata.cc:1146
 hmdcwiredata.cc:1147
 hmdcwiredata.cc:1148
 hmdcwiredata.cc:1149
 hmdcwiredata.cc:1150
 hmdcwiredata.cc:1151
 hmdcwiredata.cc:1152
 hmdcwiredata.cc:1153
 hmdcwiredata.cc:1154
 hmdcwiredata.cc:1155
 hmdcwiredata.cc:1156
 hmdcwiredata.cc:1157
 hmdcwiredata.cc:1158
 hmdcwiredata.cc:1159
 hmdcwiredata.cc:1160
 hmdcwiredata.cc:1161
 hmdcwiredata.cc:1162
 hmdcwiredata.cc:1163
 hmdcwiredata.cc:1164
 hmdcwiredata.cc:1165
 hmdcwiredata.cc:1166
 hmdcwiredata.cc:1167
 hmdcwiredata.cc:1168
 hmdcwiredata.cc:1169
 hmdcwiredata.cc:1170
 hmdcwiredata.cc:1171
 hmdcwiredata.cc:1172
 hmdcwiredata.cc:1173
 hmdcwiredata.cc:1174
 hmdcwiredata.cc:1175
 hmdcwiredata.cc:1176
 hmdcwiredata.cc:1177
 hmdcwiredata.cc:1178
 hmdcwiredata.cc:1179
 hmdcwiredata.cc:1180
 hmdcwiredata.cc:1181
 hmdcwiredata.cc:1182
 hmdcwiredata.cc:1183
 hmdcwiredata.cc:1184
 hmdcwiredata.cc:1185
 hmdcwiredata.cc:1186
 hmdcwiredata.cc:1187
 hmdcwiredata.cc:1188
 hmdcwiredata.cc:1189
 hmdcwiredata.cc:1190
 hmdcwiredata.cc:1191
 hmdcwiredata.cc:1192
 hmdcwiredata.cc:1193
 hmdcwiredata.cc:1194
 hmdcwiredata.cc:1195
 hmdcwiredata.cc:1196
 hmdcwiredata.cc:1197
 hmdcwiredata.cc:1198
 hmdcwiredata.cc:1199
 hmdcwiredata.cc:1200
 hmdcwiredata.cc:1201
 hmdcwiredata.cc:1202
 hmdcwiredata.cc:1203
 hmdcwiredata.cc:1204
 hmdcwiredata.cc:1205
 hmdcwiredata.cc:1206
 hmdcwiredata.cc:1207
 hmdcwiredata.cc:1208
 hmdcwiredata.cc:1209
 hmdcwiredata.cc:1210
 hmdcwiredata.cc:1211
 hmdcwiredata.cc:1212
 hmdcwiredata.cc:1213
 hmdcwiredata.cc:1214
 hmdcwiredata.cc:1215
 hmdcwiredata.cc:1216
 hmdcwiredata.cc:1217
 hmdcwiredata.cc:1218
 hmdcwiredata.cc:1219
 hmdcwiredata.cc:1220
 hmdcwiredata.cc:1221
 hmdcwiredata.cc:1222
 hmdcwiredata.cc:1223
 hmdcwiredata.cc:1224
 hmdcwiredata.cc:1225
 hmdcwiredata.cc:1226
 hmdcwiredata.cc:1227
 hmdcwiredata.cc:1228
 hmdcwiredata.cc:1229
 hmdcwiredata.cc:1230
 hmdcwiredata.cc:1231
 hmdcwiredata.cc:1232
 hmdcwiredata.cc:1233
 hmdcwiredata.cc:1234
 hmdcwiredata.cc:1235
 hmdcwiredata.cc:1236
 hmdcwiredata.cc:1237
 hmdcwiredata.cc:1238
 hmdcwiredata.cc:1239
 hmdcwiredata.cc:1240
 hmdcwiredata.cc:1241
 hmdcwiredata.cc:1242
 hmdcwiredata.cc:1243
 hmdcwiredata.cc:1244
 hmdcwiredata.cc:1245
 hmdcwiredata.cc:1246
 hmdcwiredata.cc:1247
 hmdcwiredata.cc:1248
 hmdcwiredata.cc:1249
 hmdcwiredata.cc:1250
 hmdcwiredata.cc:1251
 hmdcwiredata.cc:1252
 hmdcwiredata.cc:1253
 hmdcwiredata.cc:1254
 hmdcwiredata.cc:1255
 hmdcwiredata.cc:1256
 hmdcwiredata.cc:1257
 hmdcwiredata.cc:1258
 hmdcwiredata.cc:1259
 hmdcwiredata.cc:1260
 hmdcwiredata.cc:1261
 hmdcwiredata.cc:1262
 hmdcwiredata.cc:1263
 hmdcwiredata.cc:1264
 hmdcwiredata.cc:1265
 hmdcwiredata.cc:1266
 hmdcwiredata.cc:1267
 hmdcwiredata.cc:1268
 hmdcwiredata.cc:1269
 hmdcwiredata.cc:1270
 hmdcwiredata.cc:1271
 hmdcwiredata.cc:1272
 hmdcwiredata.cc:1273
 hmdcwiredata.cc:1274
 hmdcwiredata.cc:1275
 hmdcwiredata.cc:1276
 hmdcwiredata.cc:1277
 hmdcwiredata.cc:1278
 hmdcwiredata.cc:1279
 hmdcwiredata.cc:1280
 hmdcwiredata.cc:1281
 hmdcwiredata.cc:1282
 hmdcwiredata.cc:1283
 hmdcwiredata.cc:1284
 hmdcwiredata.cc:1285
 hmdcwiredata.cc:1286
 hmdcwiredata.cc:1287
 hmdcwiredata.cc:1288
 hmdcwiredata.cc:1289
 hmdcwiredata.cc:1290
 hmdcwiredata.cc:1291
 hmdcwiredata.cc:1292
 hmdcwiredata.cc:1293
 hmdcwiredata.cc:1294
 hmdcwiredata.cc:1295
 hmdcwiredata.cc:1296
 hmdcwiredata.cc:1297
 hmdcwiredata.cc:1298
 hmdcwiredata.cc:1299
 hmdcwiredata.cc:1300
 hmdcwiredata.cc:1301
 hmdcwiredata.cc:1302
 hmdcwiredata.cc:1303
 hmdcwiredata.cc:1304
 hmdcwiredata.cc:1305
 hmdcwiredata.cc:1306
 hmdcwiredata.cc:1307
 hmdcwiredata.cc:1308
 hmdcwiredata.cc:1309
 hmdcwiredata.cc:1310
 hmdcwiredata.cc:1311
 hmdcwiredata.cc:1312
 hmdcwiredata.cc:1313
 hmdcwiredata.cc:1314
 hmdcwiredata.cc:1315
 hmdcwiredata.cc:1316
 hmdcwiredata.cc:1317
 hmdcwiredata.cc:1318
 hmdcwiredata.cc:1319
 hmdcwiredata.cc:1320
 hmdcwiredata.cc:1321
 hmdcwiredata.cc:1322
 hmdcwiredata.cc:1323
 hmdcwiredata.cc:1324
 hmdcwiredata.cc:1325
 hmdcwiredata.cc:1326
 hmdcwiredata.cc:1327
 hmdcwiredata.cc:1328
 hmdcwiredata.cc:1329
 hmdcwiredata.cc:1330
 hmdcwiredata.cc:1331
 hmdcwiredata.cc:1332
 hmdcwiredata.cc:1333
 hmdcwiredata.cc:1334
 hmdcwiredata.cc:1335
 hmdcwiredata.cc:1336
 hmdcwiredata.cc:1337
 hmdcwiredata.cc:1338
 hmdcwiredata.cc:1339
 hmdcwiredata.cc:1340
 hmdcwiredata.cc:1341
 hmdcwiredata.cc:1342
 hmdcwiredata.cc:1343
 hmdcwiredata.cc:1344
 hmdcwiredata.cc:1345
 hmdcwiredata.cc:1346
 hmdcwiredata.cc:1347
 hmdcwiredata.cc:1348
 hmdcwiredata.cc:1349
 hmdcwiredata.cc:1350
 hmdcwiredata.cc:1351
 hmdcwiredata.cc:1352
 hmdcwiredata.cc:1353
 hmdcwiredata.cc:1354
 hmdcwiredata.cc:1355
 hmdcwiredata.cc:1356
 hmdcwiredata.cc:1357
 hmdcwiredata.cc:1358
 hmdcwiredata.cc:1359
 hmdcwiredata.cc:1360
 hmdcwiredata.cc:1361
 hmdcwiredata.cc:1362
 hmdcwiredata.cc:1363
 hmdcwiredata.cc:1364
 hmdcwiredata.cc:1365
 hmdcwiredata.cc:1366
 hmdcwiredata.cc:1367
 hmdcwiredata.cc:1368
 hmdcwiredata.cc:1369
 hmdcwiredata.cc:1370
 hmdcwiredata.cc:1371
 hmdcwiredata.cc:1372
 hmdcwiredata.cc:1373
 hmdcwiredata.cc:1374
 hmdcwiredata.cc:1375
 hmdcwiredata.cc:1376
 hmdcwiredata.cc:1377
 hmdcwiredata.cc:1378
 hmdcwiredata.cc:1379
 hmdcwiredata.cc:1380
 hmdcwiredata.cc:1381
 hmdcwiredata.cc:1382
 hmdcwiredata.cc:1383
 hmdcwiredata.cc:1384
 hmdcwiredata.cc:1385
 hmdcwiredata.cc:1386
 hmdcwiredata.cc:1387
 hmdcwiredata.cc:1388
 hmdcwiredata.cc:1389
 hmdcwiredata.cc:1390
 hmdcwiredata.cc:1391
 hmdcwiredata.cc:1392
 hmdcwiredata.cc:1393
 hmdcwiredata.cc:1394
 hmdcwiredata.cc:1395
 hmdcwiredata.cc:1396
 hmdcwiredata.cc:1397
 hmdcwiredata.cc:1398
 hmdcwiredata.cc:1399
 hmdcwiredata.cc:1400
 hmdcwiredata.cc:1401
 hmdcwiredata.cc:1402
 hmdcwiredata.cc:1403
 hmdcwiredata.cc:1404
 hmdcwiredata.cc:1405
 hmdcwiredata.cc:1406
 hmdcwiredata.cc:1407
 hmdcwiredata.cc:1408
 hmdcwiredata.cc:1409
 hmdcwiredata.cc:1410
 hmdcwiredata.cc:1411
 hmdcwiredata.cc:1412
 hmdcwiredata.cc:1413
 hmdcwiredata.cc:1414
 hmdcwiredata.cc:1415
 hmdcwiredata.cc:1416
 hmdcwiredata.cc:1417
 hmdcwiredata.cc:1418
 hmdcwiredata.cc:1419
 hmdcwiredata.cc:1420
 hmdcwiredata.cc:1421
 hmdcwiredata.cc:1422
 hmdcwiredata.cc:1423
 hmdcwiredata.cc:1424
 hmdcwiredata.cc:1425
 hmdcwiredata.cc:1426
 hmdcwiredata.cc:1427
 hmdcwiredata.cc:1428
 hmdcwiredata.cc:1429
 hmdcwiredata.cc:1430
 hmdcwiredata.cc:1431
 hmdcwiredata.cc:1432
 hmdcwiredata.cc:1433
 hmdcwiredata.cc:1434
 hmdcwiredata.cc:1435
 hmdcwiredata.cc:1436
 hmdcwiredata.cc:1437
 hmdcwiredata.cc:1438
 hmdcwiredata.cc:1439
 hmdcwiredata.cc:1440
 hmdcwiredata.cc:1441
 hmdcwiredata.cc:1442
 hmdcwiredata.cc:1443
 hmdcwiredata.cc:1444
 hmdcwiredata.cc:1445
 hmdcwiredata.cc:1446
 hmdcwiredata.cc:1447
 hmdcwiredata.cc:1448
 hmdcwiredata.cc:1449
 hmdcwiredata.cc:1450
 hmdcwiredata.cc:1451
 hmdcwiredata.cc:1452
 hmdcwiredata.cc:1453
 hmdcwiredata.cc:1454
 hmdcwiredata.cc:1455
 hmdcwiredata.cc:1456
 hmdcwiredata.cc:1457
 hmdcwiredata.cc:1458
 hmdcwiredata.cc:1459
 hmdcwiredata.cc:1460
 hmdcwiredata.cc:1461
 hmdcwiredata.cc:1462
 hmdcwiredata.cc:1463
 hmdcwiredata.cc:1464
 hmdcwiredata.cc:1465
 hmdcwiredata.cc:1466
 hmdcwiredata.cc:1467
 hmdcwiredata.cc:1468
 hmdcwiredata.cc:1469
 hmdcwiredata.cc:1470
 hmdcwiredata.cc:1471
 hmdcwiredata.cc:1472
 hmdcwiredata.cc:1473
 hmdcwiredata.cc:1474
 hmdcwiredata.cc:1475
 hmdcwiredata.cc:1476
 hmdcwiredata.cc:1477
 hmdcwiredata.cc:1478
 hmdcwiredata.cc:1479
 hmdcwiredata.cc:1480
 hmdcwiredata.cc:1481
 hmdcwiredata.cc:1482
 hmdcwiredata.cc:1483
 hmdcwiredata.cc:1484
 hmdcwiredata.cc:1485
 hmdcwiredata.cc:1486
 hmdcwiredata.cc:1487
 hmdcwiredata.cc:1488
 hmdcwiredata.cc:1489
 hmdcwiredata.cc:1490
 hmdcwiredata.cc:1491
 hmdcwiredata.cc:1492
 hmdcwiredata.cc:1493
 hmdcwiredata.cc:1494
 hmdcwiredata.cc:1495
 hmdcwiredata.cc:1496
 hmdcwiredata.cc:1497
 hmdcwiredata.cc:1498
 hmdcwiredata.cc:1499
 hmdcwiredata.cc:1500
 hmdcwiredata.cc:1501
 hmdcwiredata.cc:1502
 hmdcwiredata.cc:1503
 hmdcwiredata.cc:1504
 hmdcwiredata.cc:1505
 hmdcwiredata.cc:1506
 hmdcwiredata.cc:1507
 hmdcwiredata.cc:1508
 hmdcwiredata.cc:1509
 hmdcwiredata.cc:1510
 hmdcwiredata.cc:1511
 hmdcwiredata.cc:1512
 hmdcwiredata.cc:1513
 hmdcwiredata.cc:1514
 hmdcwiredata.cc:1515
 hmdcwiredata.cc:1516
 hmdcwiredata.cc:1517
 hmdcwiredata.cc:1518
 hmdcwiredata.cc:1519
 hmdcwiredata.cc:1520
 hmdcwiredata.cc:1521
 hmdcwiredata.cc:1522
 hmdcwiredata.cc:1523
 hmdcwiredata.cc:1524
 hmdcwiredata.cc:1525
 hmdcwiredata.cc:1526
 hmdcwiredata.cc:1527
 hmdcwiredata.cc:1528
 hmdcwiredata.cc:1529
 hmdcwiredata.cc:1530
 hmdcwiredata.cc:1531
 hmdcwiredata.cc:1532
 hmdcwiredata.cc:1533
 hmdcwiredata.cc:1534
 hmdcwiredata.cc:1535
 hmdcwiredata.cc:1536
 hmdcwiredata.cc:1537
 hmdcwiredata.cc:1538
 hmdcwiredata.cc:1539
 hmdcwiredata.cc:1540
 hmdcwiredata.cc:1541
 hmdcwiredata.cc:1542
 hmdcwiredata.cc:1543
 hmdcwiredata.cc:1544
 hmdcwiredata.cc:1545
 hmdcwiredata.cc:1546
 hmdcwiredata.cc:1547
 hmdcwiredata.cc:1548
 hmdcwiredata.cc:1549
 hmdcwiredata.cc:1550
 hmdcwiredata.cc:1551
 hmdcwiredata.cc:1552
 hmdcwiredata.cc:1553
 hmdcwiredata.cc:1554
 hmdcwiredata.cc:1555
 hmdcwiredata.cc:1556
 hmdcwiredata.cc:1557
 hmdcwiredata.cc:1558
 hmdcwiredata.cc:1559
 hmdcwiredata.cc:1560
 hmdcwiredata.cc:1561
 hmdcwiredata.cc:1562
 hmdcwiredata.cc:1563
 hmdcwiredata.cc:1564
 hmdcwiredata.cc:1565
 hmdcwiredata.cc:1566
 hmdcwiredata.cc:1567
 hmdcwiredata.cc:1568
 hmdcwiredata.cc:1569
 hmdcwiredata.cc:1570
 hmdcwiredata.cc:1571
 hmdcwiredata.cc:1572
 hmdcwiredata.cc:1573
 hmdcwiredata.cc:1574
 hmdcwiredata.cc:1575
 hmdcwiredata.cc:1576
 hmdcwiredata.cc:1577
 hmdcwiredata.cc:1578
 hmdcwiredata.cc:1579
 hmdcwiredata.cc:1580
 hmdcwiredata.cc:1581
 hmdcwiredata.cc:1582
 hmdcwiredata.cc:1583
 hmdcwiredata.cc:1584
 hmdcwiredata.cc:1585
 hmdcwiredata.cc:1586
 hmdcwiredata.cc:1587
 hmdcwiredata.cc:1588
 hmdcwiredata.cc:1589
 hmdcwiredata.cc:1590
 hmdcwiredata.cc:1591
 hmdcwiredata.cc:1592
 hmdcwiredata.cc:1593
 hmdcwiredata.cc:1594
 hmdcwiredata.cc:1595
 hmdcwiredata.cc:1596
 hmdcwiredata.cc:1597
 hmdcwiredata.cc:1598
 hmdcwiredata.cc:1599
 hmdcwiredata.cc:1600
 hmdcwiredata.cc:1601
 hmdcwiredata.cc:1602
 hmdcwiredata.cc:1603
 hmdcwiredata.cc:1604
 hmdcwiredata.cc:1605
 hmdcwiredata.cc:1606
 hmdcwiredata.cc:1607
 hmdcwiredata.cc:1608
 hmdcwiredata.cc:1609
 hmdcwiredata.cc:1610
 hmdcwiredata.cc:1611
 hmdcwiredata.cc:1612
 hmdcwiredata.cc:1613
 hmdcwiredata.cc:1614
 hmdcwiredata.cc:1615
 hmdcwiredata.cc:1616
 hmdcwiredata.cc:1617
 hmdcwiredata.cc:1618
 hmdcwiredata.cc:1619
 hmdcwiredata.cc:1620
 hmdcwiredata.cc:1621
 hmdcwiredata.cc:1622
 hmdcwiredata.cc:1623
 hmdcwiredata.cc:1624
 hmdcwiredata.cc:1625
 hmdcwiredata.cc:1626
 hmdcwiredata.cc:1627
 hmdcwiredata.cc:1628
 hmdcwiredata.cc:1629
 hmdcwiredata.cc:1630
 hmdcwiredata.cc:1631
 hmdcwiredata.cc:1632
 hmdcwiredata.cc:1633
 hmdcwiredata.cc:1634
 hmdcwiredata.cc:1635
 hmdcwiredata.cc:1636
 hmdcwiredata.cc:1637
 hmdcwiredata.cc:1638
 hmdcwiredata.cc:1639
 hmdcwiredata.cc:1640
 hmdcwiredata.cc:1641
 hmdcwiredata.cc:1642
 hmdcwiredata.cc:1643
 hmdcwiredata.cc:1644
 hmdcwiredata.cc:1645
 hmdcwiredata.cc:1646
 hmdcwiredata.cc:1647
 hmdcwiredata.cc:1648
 hmdcwiredata.cc:1649
 hmdcwiredata.cc:1650
 hmdcwiredata.cc:1651
 hmdcwiredata.cc:1652
 hmdcwiredata.cc:1653
 hmdcwiredata.cc:1654
 hmdcwiredata.cc:1655
 hmdcwiredata.cc:1656
 hmdcwiredata.cc:1657
 hmdcwiredata.cc:1658
 hmdcwiredata.cc:1659
 hmdcwiredata.cc:1660
 hmdcwiredata.cc:1661
 hmdcwiredata.cc:1662
 hmdcwiredata.cc:1663
 hmdcwiredata.cc:1664
 hmdcwiredata.cc:1665
 hmdcwiredata.cc:1666
 hmdcwiredata.cc:1667
 hmdcwiredata.cc:1668
 hmdcwiredata.cc:1669
 hmdcwiredata.cc:1670
 hmdcwiredata.cc:1671
 hmdcwiredata.cc:1672
 hmdcwiredata.cc:1673
 hmdcwiredata.cc:1674
 hmdcwiredata.cc:1675
 hmdcwiredata.cc:1676
 hmdcwiredata.cc:1677
 hmdcwiredata.cc:1678
 hmdcwiredata.cc:1679
 hmdcwiredata.cc:1680
 hmdcwiredata.cc:1681
 hmdcwiredata.cc:1682
 hmdcwiredata.cc:1683
 hmdcwiredata.cc:1684
 hmdcwiredata.cc:1685
 hmdcwiredata.cc:1686
 hmdcwiredata.cc:1687
 hmdcwiredata.cc:1688
 hmdcwiredata.cc:1689
 hmdcwiredata.cc:1690
 hmdcwiredata.cc:1691
 hmdcwiredata.cc:1692
 hmdcwiredata.cc:1693
 hmdcwiredata.cc:1694
 hmdcwiredata.cc:1695
 hmdcwiredata.cc:1696
 hmdcwiredata.cc:1697
 hmdcwiredata.cc:1698
 hmdcwiredata.cc:1699
 hmdcwiredata.cc:1700
 hmdcwiredata.cc:1701
 hmdcwiredata.cc:1702
 hmdcwiredata.cc:1703
 hmdcwiredata.cc:1704
 hmdcwiredata.cc:1705
 hmdcwiredata.cc:1706
 hmdcwiredata.cc:1707
 hmdcwiredata.cc:1708
 hmdcwiredata.cc:1709
 hmdcwiredata.cc:1710
 hmdcwiredata.cc:1711
 hmdcwiredata.cc:1712
 hmdcwiredata.cc:1713
 hmdcwiredata.cc:1714
 hmdcwiredata.cc:1715
 hmdcwiredata.cc:1716
 hmdcwiredata.cc:1717
 hmdcwiredata.cc:1718
 hmdcwiredata.cc:1719
 hmdcwiredata.cc:1720
 hmdcwiredata.cc:1721
 hmdcwiredata.cc:1722
 hmdcwiredata.cc:1723
 hmdcwiredata.cc:1724
 hmdcwiredata.cc:1725
 hmdcwiredata.cc:1726
 hmdcwiredata.cc:1727
 hmdcwiredata.cc:1728
 hmdcwiredata.cc:1729
 hmdcwiredata.cc:1730
 hmdcwiredata.cc:1731
 hmdcwiredata.cc:1732
 hmdcwiredata.cc:1733
 hmdcwiredata.cc:1734
 hmdcwiredata.cc:1735
 hmdcwiredata.cc:1736
 hmdcwiredata.cc:1737
 hmdcwiredata.cc:1738
 hmdcwiredata.cc:1739
 hmdcwiredata.cc:1740
 hmdcwiredata.cc:1741
 hmdcwiredata.cc:1742
 hmdcwiredata.cc:1743
 hmdcwiredata.cc:1744
 hmdcwiredata.cc:1745
 hmdcwiredata.cc:1746
 hmdcwiredata.cc:1747
 hmdcwiredata.cc:1748
 hmdcwiredata.cc:1749
 hmdcwiredata.cc:1750
 hmdcwiredata.cc:1751
 hmdcwiredata.cc:1752
 hmdcwiredata.cc:1753
 hmdcwiredata.cc:1754
 hmdcwiredata.cc:1755
 hmdcwiredata.cc:1756
 hmdcwiredata.cc:1757
 hmdcwiredata.cc:1758
 hmdcwiredata.cc:1759
 hmdcwiredata.cc:1760
 hmdcwiredata.cc:1761
 hmdcwiredata.cc:1762
 hmdcwiredata.cc:1763
 hmdcwiredata.cc:1764
 hmdcwiredata.cc:1765
 hmdcwiredata.cc:1766
 hmdcwiredata.cc:1767
 hmdcwiredata.cc:1768
 hmdcwiredata.cc:1769
 hmdcwiredata.cc:1770
 hmdcwiredata.cc:1771
 hmdcwiredata.cc:1772
 hmdcwiredata.cc:1773
 hmdcwiredata.cc:1774
 hmdcwiredata.cc:1775
 hmdcwiredata.cc:1776
 hmdcwiredata.cc:1777
 hmdcwiredata.cc:1778
 hmdcwiredata.cc:1779
 hmdcwiredata.cc:1780
 hmdcwiredata.cc:1781
 hmdcwiredata.cc:1782
 hmdcwiredata.cc:1783
 hmdcwiredata.cc:1784
 hmdcwiredata.cc:1785
 hmdcwiredata.cc:1786
 hmdcwiredata.cc:1787
 hmdcwiredata.cc:1788
 hmdcwiredata.cc:1789
 hmdcwiredata.cc:1790
 hmdcwiredata.cc:1791
 hmdcwiredata.cc:1792
 hmdcwiredata.cc:1793
 hmdcwiredata.cc:1794
 hmdcwiredata.cc:1795
 hmdcwiredata.cc:1796
 hmdcwiredata.cc:1797
 hmdcwiredata.cc:1798
 hmdcwiredata.cc:1799
 hmdcwiredata.cc:1800
 hmdcwiredata.cc:1801
 hmdcwiredata.cc:1802
 hmdcwiredata.cc:1803
 hmdcwiredata.cc:1804
 hmdcwiredata.cc:1805
 hmdcwiredata.cc:1806
 hmdcwiredata.cc:1807
 hmdcwiredata.cc:1808
 hmdcwiredata.cc:1809
 hmdcwiredata.cc:1810
 hmdcwiredata.cc:1811
 hmdcwiredata.cc:1812
 hmdcwiredata.cc:1813
 hmdcwiredata.cc:1814
 hmdcwiredata.cc:1815
 hmdcwiredata.cc:1816
 hmdcwiredata.cc:1817
 hmdcwiredata.cc:1818
 hmdcwiredata.cc:1819
 hmdcwiredata.cc:1820
 hmdcwiredata.cc:1821
 hmdcwiredata.cc:1822
 hmdcwiredata.cc:1823
 hmdcwiredata.cc:1824
 hmdcwiredata.cc:1825
 hmdcwiredata.cc:1826
 hmdcwiredata.cc:1827
 hmdcwiredata.cc:1828
 hmdcwiredata.cc:1829
 hmdcwiredata.cc:1830
 hmdcwiredata.cc:1831
 hmdcwiredata.cc:1832
 hmdcwiredata.cc:1833
 hmdcwiredata.cc:1834
 hmdcwiredata.cc:1835
 hmdcwiredata.cc:1836
 hmdcwiredata.cc:1837
 hmdcwiredata.cc:1838
 hmdcwiredata.cc:1839
 hmdcwiredata.cc:1840
 hmdcwiredata.cc:1841
 hmdcwiredata.cc:1842
 hmdcwiredata.cc:1843
 hmdcwiredata.cc:1844
 hmdcwiredata.cc:1845
 hmdcwiredata.cc:1846
 hmdcwiredata.cc:1847
 hmdcwiredata.cc:1848
 hmdcwiredata.cc:1849
 hmdcwiredata.cc:1850
 hmdcwiredata.cc:1851
 hmdcwiredata.cc:1852
 hmdcwiredata.cc:1853
 hmdcwiredata.cc:1854
 hmdcwiredata.cc:1855
 hmdcwiredata.cc:1856
 hmdcwiredata.cc:1857
 hmdcwiredata.cc:1858
 hmdcwiredata.cc:1859
 hmdcwiredata.cc:1860
 hmdcwiredata.cc:1861
 hmdcwiredata.cc:1862
 hmdcwiredata.cc:1863
 hmdcwiredata.cc:1864
 hmdcwiredata.cc:1865
 hmdcwiredata.cc:1866
 hmdcwiredata.cc:1867
 hmdcwiredata.cc:1868
 hmdcwiredata.cc:1869
 hmdcwiredata.cc:1870
 hmdcwiredata.cc:1871
 hmdcwiredata.cc:1872
 hmdcwiredata.cc:1873
 hmdcwiredata.cc:1874
 hmdcwiredata.cc:1875
 hmdcwiredata.cc:1876
 hmdcwiredata.cc:1877
 hmdcwiredata.cc:1878
 hmdcwiredata.cc:1879
 hmdcwiredata.cc:1880
 hmdcwiredata.cc:1881
 hmdcwiredata.cc:1882
 hmdcwiredata.cc:1883
 hmdcwiredata.cc:1884
 hmdcwiredata.cc:1885
 hmdcwiredata.cc:1886
 hmdcwiredata.cc:1887
 hmdcwiredata.cc:1888
 hmdcwiredata.cc:1889
 hmdcwiredata.cc:1890
 hmdcwiredata.cc:1891
 hmdcwiredata.cc:1892
 hmdcwiredata.cc:1893
 hmdcwiredata.cc:1894
 hmdcwiredata.cc:1895
 hmdcwiredata.cc:1896
 hmdcwiredata.cc:1897
 hmdcwiredata.cc:1898
 hmdcwiredata.cc:1899
 hmdcwiredata.cc:1900
 hmdcwiredata.cc:1901
 hmdcwiredata.cc:1902
 hmdcwiredata.cc:1903
 hmdcwiredata.cc:1904
 hmdcwiredata.cc:1905
 hmdcwiredata.cc:1906
 hmdcwiredata.cc:1907
 hmdcwiredata.cc:1908
 hmdcwiredata.cc:1909
 hmdcwiredata.cc:1910
 hmdcwiredata.cc:1911
 hmdcwiredata.cc:1912
 hmdcwiredata.cc:1913
 hmdcwiredata.cc:1914
 hmdcwiredata.cc:1915
 hmdcwiredata.cc:1916
 hmdcwiredata.cc:1917
 hmdcwiredata.cc:1918
 hmdcwiredata.cc:1919
 hmdcwiredata.cc:1920
 hmdcwiredata.cc:1921
 hmdcwiredata.cc:1922
 hmdcwiredata.cc:1923
 hmdcwiredata.cc:1924
 hmdcwiredata.cc:1925
 hmdcwiredata.cc:1926
 hmdcwiredata.cc:1927
 hmdcwiredata.cc:1928
 hmdcwiredata.cc:1929
 hmdcwiredata.cc:1930
 hmdcwiredata.cc:1931
 hmdcwiredata.cc:1932
 hmdcwiredata.cc:1933
 hmdcwiredata.cc:1934
 hmdcwiredata.cc:1935
 hmdcwiredata.cc:1936
 hmdcwiredata.cc:1937
 hmdcwiredata.cc:1938
 hmdcwiredata.cc:1939
 hmdcwiredata.cc:1940
 hmdcwiredata.cc:1941
 hmdcwiredata.cc:1942
 hmdcwiredata.cc:1943
 hmdcwiredata.cc:1944
 hmdcwiredata.cc:1945
 hmdcwiredata.cc:1946
 hmdcwiredata.cc:1947
 hmdcwiredata.cc:1948
 hmdcwiredata.cc:1949
 hmdcwiredata.cc:1950
 hmdcwiredata.cc:1951
 hmdcwiredata.cc:1952
 hmdcwiredata.cc:1953
 hmdcwiredata.cc:1954
 hmdcwiredata.cc:1955
 hmdcwiredata.cc:1956
 hmdcwiredata.cc:1957
 hmdcwiredata.cc:1958
 hmdcwiredata.cc:1959
 hmdcwiredata.cc:1960
 hmdcwiredata.cc:1961
 hmdcwiredata.cc:1962
 hmdcwiredata.cc:1963
 hmdcwiredata.cc:1964
 hmdcwiredata.cc:1965
 hmdcwiredata.cc:1966
 hmdcwiredata.cc:1967
 hmdcwiredata.cc:1968
 hmdcwiredata.cc:1969
 hmdcwiredata.cc:1970
 hmdcwiredata.cc:1971
 hmdcwiredata.cc:1972
 hmdcwiredata.cc:1973
 hmdcwiredata.cc:1974
 hmdcwiredata.cc:1975
 hmdcwiredata.cc:1976
 hmdcwiredata.cc:1977
 hmdcwiredata.cc:1978
 hmdcwiredata.cc:1979
 hmdcwiredata.cc:1980
 hmdcwiredata.cc:1981
 hmdcwiredata.cc:1982
 hmdcwiredata.cc:1983
 hmdcwiredata.cc:1984
 hmdcwiredata.cc:1985
 hmdcwiredata.cc:1986
 hmdcwiredata.cc:1987
 hmdcwiredata.cc:1988
 hmdcwiredata.cc:1989
 hmdcwiredata.cc:1990
 hmdcwiredata.cc:1991
 hmdcwiredata.cc:1992
 hmdcwiredata.cc:1993
 hmdcwiredata.cc:1994
 hmdcwiredata.cc:1995
 hmdcwiredata.cc:1996
 hmdcwiredata.cc:1997
 hmdcwiredata.cc:1998
 hmdcwiredata.cc:1999
 hmdcwiredata.cc:2000
 hmdcwiredata.cc:2001
 hmdcwiredata.cc:2002
 hmdcwiredata.cc:2003
 hmdcwiredata.cc:2004
 hmdcwiredata.cc:2005
 hmdcwiredata.cc:2006
 hmdcwiredata.cc:2007
 hmdcwiredata.cc:2008
 hmdcwiredata.cc:2009
 hmdcwiredata.cc:2010
 hmdcwiredata.cc:2011
 hmdcwiredata.cc:2012
 hmdcwiredata.cc:2013
 hmdcwiredata.cc:2014
 hmdcwiredata.cc:2015
 hmdcwiredata.cc:2016
 hmdcwiredata.cc:2017
 hmdcwiredata.cc:2018
 hmdcwiredata.cc:2019
 hmdcwiredata.cc:2020
 hmdcwiredata.cc:2021
 hmdcwiredata.cc:2022
 hmdcwiredata.cc:2023
 hmdcwiredata.cc:2024
 hmdcwiredata.cc:2025
 hmdcwiredata.cc:2026
 hmdcwiredata.cc:2027
 hmdcwiredata.cc:2028
 hmdcwiredata.cc:2029
 hmdcwiredata.cc:2030
 hmdcwiredata.cc:2031
 hmdcwiredata.cc:2032
 hmdcwiredata.cc:2033
 hmdcwiredata.cc:2034
 hmdcwiredata.cc:2035
 hmdcwiredata.cc:2036
 hmdcwiredata.cc:2037
 hmdcwiredata.cc:2038
 hmdcwiredata.cc:2039
 hmdcwiredata.cc:2040
 hmdcwiredata.cc:2041
 hmdcwiredata.cc:2042
 hmdcwiredata.cc:2043
 hmdcwiredata.cc:2044
 hmdcwiredata.cc:2045
 hmdcwiredata.cc:2046
 hmdcwiredata.cc:2047
 hmdcwiredata.cc:2048
 hmdcwiredata.cc:2049
 hmdcwiredata.cc:2050
 hmdcwiredata.cc:2051
 hmdcwiredata.cc:2052
 hmdcwiredata.cc:2053
 hmdcwiredata.cc:2054
 hmdcwiredata.cc:2055
 hmdcwiredata.cc:2056
 hmdcwiredata.cc:2057
 hmdcwiredata.cc:2058
 hmdcwiredata.cc:2059
 hmdcwiredata.cc:2060
 hmdcwiredata.cc:2061
 hmdcwiredata.cc:2062
 hmdcwiredata.cc:2063
 hmdcwiredata.cc:2064
 hmdcwiredata.cc:2065
 hmdcwiredata.cc:2066
 hmdcwiredata.cc:2067
 hmdcwiredata.cc:2068
 hmdcwiredata.cc:2069
 hmdcwiredata.cc:2070
 hmdcwiredata.cc:2071
 hmdcwiredata.cc:2072
 hmdcwiredata.cc:2073
 hmdcwiredata.cc:2074
 hmdcwiredata.cc:2075
 hmdcwiredata.cc:2076
 hmdcwiredata.cc:2077
 hmdcwiredata.cc:2078
 hmdcwiredata.cc:2079
 hmdcwiredata.cc:2080
 hmdcwiredata.cc:2081
 hmdcwiredata.cc:2082
 hmdcwiredata.cc:2083
 hmdcwiredata.cc:2084
 hmdcwiredata.cc:2085
 hmdcwiredata.cc:2086
 hmdcwiredata.cc:2087
 hmdcwiredata.cc:2088
 hmdcwiredata.cc:2089
 hmdcwiredata.cc:2090
 hmdcwiredata.cc:2091
 hmdcwiredata.cc:2092
 hmdcwiredata.cc:2093
 hmdcwiredata.cc:2094
 hmdcwiredata.cc:2095
 hmdcwiredata.cc:2096
 hmdcwiredata.cc:2097
 hmdcwiredata.cc:2098
 hmdcwiredata.cc:2099
 hmdcwiredata.cc:2100
 hmdcwiredata.cc:2101
 hmdcwiredata.cc:2102
 hmdcwiredata.cc:2103
 hmdcwiredata.cc:2104
 hmdcwiredata.cc:2105
 hmdcwiredata.cc:2106
 hmdcwiredata.cc:2107
 hmdcwiredata.cc:2108
 hmdcwiredata.cc:2109
 hmdcwiredata.cc:2110
 hmdcwiredata.cc:2111
 hmdcwiredata.cc:2112
 hmdcwiredata.cc:2113
 hmdcwiredata.cc:2114
 hmdcwiredata.cc:2115
 hmdcwiredata.cc:2116
 hmdcwiredata.cc:2117
 hmdcwiredata.cc:2118
 hmdcwiredata.cc:2119
 hmdcwiredata.cc:2120
 hmdcwiredata.cc:2121
 hmdcwiredata.cc:2122
 hmdcwiredata.cc:2123
 hmdcwiredata.cc:2124
 hmdcwiredata.cc:2125
 hmdcwiredata.cc:2126
 hmdcwiredata.cc:2127
 hmdcwiredata.cc:2128
 hmdcwiredata.cc:2129
 hmdcwiredata.cc:2130
 hmdcwiredata.cc:2131
 hmdcwiredata.cc:2132
 hmdcwiredata.cc:2133
 hmdcwiredata.cc:2134
 hmdcwiredata.cc:2135
 hmdcwiredata.cc:2136
 hmdcwiredata.cc:2137
 hmdcwiredata.cc:2138
 hmdcwiredata.cc:2139
 hmdcwiredata.cc:2140
 hmdcwiredata.cc:2141
 hmdcwiredata.cc:2142
 hmdcwiredata.cc:2143
 hmdcwiredata.cc:2144
 hmdcwiredata.cc:2145
 hmdcwiredata.cc:2146
 hmdcwiredata.cc:2147
 hmdcwiredata.cc:2148
 hmdcwiredata.cc:2149
 hmdcwiredata.cc:2150
 hmdcwiredata.cc:2151
 hmdcwiredata.cc:2152
 hmdcwiredata.cc:2153
 hmdcwiredata.cc:2154
 hmdcwiredata.cc:2155
 hmdcwiredata.cc:2156
 hmdcwiredata.cc:2157
 hmdcwiredata.cc:2158
 hmdcwiredata.cc:2159
 hmdcwiredata.cc:2160
 hmdcwiredata.cc:2161
 hmdcwiredata.cc:2162
 hmdcwiredata.cc:2163
 hmdcwiredata.cc:2164
 hmdcwiredata.cc:2165
 hmdcwiredata.cc:2166
 hmdcwiredata.cc:2167
 hmdcwiredata.cc:2168
 hmdcwiredata.cc:2169
 hmdcwiredata.cc:2170
 hmdcwiredata.cc:2171
 hmdcwiredata.cc:2172
 hmdcwiredata.cc:2173
 hmdcwiredata.cc:2174
 hmdcwiredata.cc:2175
 hmdcwiredata.cc:2176
 hmdcwiredata.cc:2177
 hmdcwiredata.cc:2178
 hmdcwiredata.cc:2179
 hmdcwiredata.cc:2180
 hmdcwiredata.cc:2181
 hmdcwiredata.cc:2182
 hmdcwiredata.cc:2183
 hmdcwiredata.cc:2184
 hmdcwiredata.cc:2185
 hmdcwiredata.cc:2186
 hmdcwiredata.cc:2187
 hmdcwiredata.cc:2188
 hmdcwiredata.cc:2189
 hmdcwiredata.cc:2190
 hmdcwiredata.cc:2191
 hmdcwiredata.cc:2192
 hmdcwiredata.cc:2193
 hmdcwiredata.cc:2194
 hmdcwiredata.cc:2195
 hmdcwiredata.cc:2196
 hmdcwiredata.cc:2197
 hmdcwiredata.cc:2198
 hmdcwiredata.cc:2199
 hmdcwiredata.cc:2200
 hmdcwiredata.cc:2201
 hmdcwiredata.cc:2202
 hmdcwiredata.cc:2203
 hmdcwiredata.cc:2204
 hmdcwiredata.cc:2205
 hmdcwiredata.cc:2206
 hmdcwiredata.cc:2207
 hmdcwiredata.cc:2208
 hmdcwiredata.cc:2209
 hmdcwiredata.cc:2210
 hmdcwiredata.cc:2211
 hmdcwiredata.cc:2212
 hmdcwiredata.cc:2213
 hmdcwiredata.cc:2214
 hmdcwiredata.cc:2215
 hmdcwiredata.cc:2216
 hmdcwiredata.cc:2217
 hmdcwiredata.cc:2218
 hmdcwiredata.cc:2219
 hmdcwiredata.cc:2220
 hmdcwiredata.cc:2221
 hmdcwiredata.cc:2222
 hmdcwiredata.cc:2223
 hmdcwiredata.cc:2224
 hmdcwiredata.cc:2225
 hmdcwiredata.cc:2226
 hmdcwiredata.cc:2227
 hmdcwiredata.cc:2228
 hmdcwiredata.cc:2229
 hmdcwiredata.cc:2230
 hmdcwiredata.cc:2231
 hmdcwiredata.cc:2232
 hmdcwiredata.cc:2233
 hmdcwiredata.cc:2234
 hmdcwiredata.cc:2235
 hmdcwiredata.cc:2236
 hmdcwiredata.cc:2237
 hmdcwiredata.cc:2238
 hmdcwiredata.cc:2239
 hmdcwiredata.cc:2240
 hmdcwiredata.cc:2241
 hmdcwiredata.cc:2242
 hmdcwiredata.cc:2243
 hmdcwiredata.cc:2244
 hmdcwiredata.cc:2245
 hmdcwiredata.cc:2246
 hmdcwiredata.cc:2247
 hmdcwiredata.cc:2248
 hmdcwiredata.cc:2249
 hmdcwiredata.cc:2250
 hmdcwiredata.cc:2251
 hmdcwiredata.cc:2252
 hmdcwiredata.cc:2253
 hmdcwiredata.cc:2254
 hmdcwiredata.cc:2255
 hmdcwiredata.cc:2256
 hmdcwiredata.cc:2257
 hmdcwiredata.cc:2258
 hmdcwiredata.cc:2259
 hmdcwiredata.cc:2260
 hmdcwiredata.cc:2261
 hmdcwiredata.cc:2262
 hmdcwiredata.cc:2263
 hmdcwiredata.cc:2264
 hmdcwiredata.cc:2265
 hmdcwiredata.cc:2266
 hmdcwiredata.cc:2267
 hmdcwiredata.cc:2268
 hmdcwiredata.cc:2269
 hmdcwiredata.cc:2270
 hmdcwiredata.cc:2271
 hmdcwiredata.cc:2272
 hmdcwiredata.cc:2273
 hmdcwiredata.cc:2274
 hmdcwiredata.cc:2275
 hmdcwiredata.cc:2276
 hmdcwiredata.cc:2277
 hmdcwiredata.cc:2278
 hmdcwiredata.cc:2279
 hmdcwiredata.cc:2280
 hmdcwiredata.cc:2281
 hmdcwiredata.cc:2282
 hmdcwiredata.cc:2283
 hmdcwiredata.cc:2284
 hmdcwiredata.cc:2285
 hmdcwiredata.cc:2286
 hmdcwiredata.cc:2287
 hmdcwiredata.cc:2288
 hmdcwiredata.cc:2289
 hmdcwiredata.cc:2290
 hmdcwiredata.cc:2291
 hmdcwiredata.cc:2292
 hmdcwiredata.cc:2293
 hmdcwiredata.cc:2294
 hmdcwiredata.cc:2295
 hmdcwiredata.cc:2296
 hmdcwiredata.cc:2297
 hmdcwiredata.cc:2298
 hmdcwiredata.cc:2299
 hmdcwiredata.cc:2300
 hmdcwiredata.cc:2301
 hmdcwiredata.cc:2302
 hmdcwiredata.cc:2303
 hmdcwiredata.cc:2304
 hmdcwiredata.cc:2305
 hmdcwiredata.cc:2306
 hmdcwiredata.cc:2307
 hmdcwiredata.cc:2308
 hmdcwiredata.cc:2309
 hmdcwiredata.cc:2310
 hmdcwiredata.cc:2311
 hmdcwiredata.cc:2312
 hmdcwiredata.cc:2313
 hmdcwiredata.cc:2314
 hmdcwiredata.cc:2315
 hmdcwiredata.cc:2316
 hmdcwiredata.cc:2317
 hmdcwiredata.cc:2318
 hmdcwiredata.cc:2319
 hmdcwiredata.cc:2320
 hmdcwiredata.cc:2321
 hmdcwiredata.cc:2322
 hmdcwiredata.cc:2323
 hmdcwiredata.cc:2324
 hmdcwiredata.cc:2325
 hmdcwiredata.cc:2326
 hmdcwiredata.cc:2327
 hmdcwiredata.cc:2328
 hmdcwiredata.cc:2329
 hmdcwiredata.cc:2330
 hmdcwiredata.cc:2331
 hmdcwiredata.cc:2332
 hmdcwiredata.cc:2333
 hmdcwiredata.cc:2334
 hmdcwiredata.cc:2335
 hmdcwiredata.cc:2336
 hmdcwiredata.cc:2337
 hmdcwiredata.cc:2338
 hmdcwiredata.cc:2339
 hmdcwiredata.cc:2340
 hmdcwiredata.cc:2341
 hmdcwiredata.cc:2342
 hmdcwiredata.cc:2343
 hmdcwiredata.cc:2344
 hmdcwiredata.cc:2345
 hmdcwiredata.cc:2346
 hmdcwiredata.cc:2347
 hmdcwiredata.cc:2348
 hmdcwiredata.cc:2349
 hmdcwiredata.cc:2350
 hmdcwiredata.cc:2351
 hmdcwiredata.cc:2352
 hmdcwiredata.cc:2353
 hmdcwiredata.cc:2354
 hmdcwiredata.cc:2355
 hmdcwiredata.cc:2356
 hmdcwiredata.cc:2357
 hmdcwiredata.cc:2358
 hmdcwiredata.cc:2359
 hmdcwiredata.cc:2360
 hmdcwiredata.cc:2361
 hmdcwiredata.cc:2362
 hmdcwiredata.cc:2363
 hmdcwiredata.cc:2364
 hmdcwiredata.cc:2365
 hmdcwiredata.cc:2366
 hmdcwiredata.cc:2367
 hmdcwiredata.cc:2368
 hmdcwiredata.cc:2369
 hmdcwiredata.cc:2370
 hmdcwiredata.cc:2371
 hmdcwiredata.cc:2372
 hmdcwiredata.cc:2373
 hmdcwiredata.cc:2374
 hmdcwiredata.cc:2375
 hmdcwiredata.cc:2376
 hmdcwiredata.cc:2377
 hmdcwiredata.cc:2378
 hmdcwiredata.cc:2379
 hmdcwiredata.cc:2380
 hmdcwiredata.cc:2381
 hmdcwiredata.cc:2382
 hmdcwiredata.cc:2383
 hmdcwiredata.cc:2384
 hmdcwiredata.cc:2385
 hmdcwiredata.cc:2386
 hmdcwiredata.cc:2387
 hmdcwiredata.cc:2388
 hmdcwiredata.cc:2389
 hmdcwiredata.cc:2390
 hmdcwiredata.cc:2391
 hmdcwiredata.cc:2392
 hmdcwiredata.cc:2393
 hmdcwiredata.cc:2394
 hmdcwiredata.cc:2395
 hmdcwiredata.cc:2396
 hmdcwiredata.cc:2397
 hmdcwiredata.cc:2398
 hmdcwiredata.cc:2399
 hmdcwiredata.cc:2400
 hmdcwiredata.cc:2401
 hmdcwiredata.cc:2402
 hmdcwiredata.cc:2403
 hmdcwiredata.cc:2404
 hmdcwiredata.cc:2405
 hmdcwiredata.cc:2406
 hmdcwiredata.cc:2407
 hmdcwiredata.cc:2408