ROOT logo
//*-- AUTHOR : J.Kempter
//*-- Modified :

//_HADES_CLASS_DESCRIPTION 
///////////////////////////////////////////////////////////////////////////////
//
// HMdcOffset
//
// Defines the offset  parameter for MDC calibration. Uses HMdcCalParRaw container
// as  input/output for calibration data
//
///////////////////////////////////////////////////////////////////////////////
using namespace std;
#include <math.h>
#include <stdlib.h>
#include <fstream> 
#include <iomanip> 
#include <iostream> 

#include "TF1.h"
#include "TH1.h"
#include "TH2.h"
#include "TStopwatch.h"
#include "TDirectory.h"
#include "TNtuple.h"
#include "TMath.h"
#include "TSystem.h"
#include "TLatex.h"

#include "heventheader.h"
#include "hmdcoffset.h"
#include "hmdcdef.h"
#include "hmdctrackddef.h"
#include "hmdcsizescells.h"
#include "hmdcraw.h"
#include "hmdcclus.h"
#include "hdebug.h"
#include "hades.h"
#include "hiterator.h"
#include "hruntimedb.h"
#include "hspectrometer.h"
#include "hmdcdetector.h"
#include "hdetector.h"
#include "hevent.h"
#include "hcategory.h"
#include "hlocation.h"
#include "hmdccal1.h"
#include "hmdclookupgeom.h"
#include "hmdclookupraw.h"
#include "hmdccalparraw.h"
#include "hstart2hit.h"
#include "hstartdef.h"
#include "hmdctimecut.h"
#include "htool.h"

ClassImp(HMdcOffset)

const Int_t HMdcOffset::nbin        = 2048;
const Int_t HMdcOffset::nbinp1      = HMdcOffset::nbin+1;
const Int_t HMdcOffset::nbinm1      = HMdcOffset::nbin-1;
const Int_t HMdcOffset::nSubEvents  = (6*192)*3;


HMdcOffset::HMdcOffset(void)
{
    setDefault();
    initVariables();
    //initMemory();
}

HMdcOffset::HMdcOffset(const Text_t* name,const Text_t* title) : HReconstructor(name,title)
{
    setDefault();
    initVariables();
    //initMemory();
}
HMdcOffset::~HMdcOffset(void)
{
    // Destructor.
    if (iter)            { delete iter; }
    if (iter_start)      { delete iter_start; }
    if (iter_clus)       { delete iter_clus; }
    if (fNameAsciiOffset){ delete fNameAsciiOffset; }
    if (fNameRootOffset) { delete fNameRootOffset;  }
    if (hreverse)        { delete[] hreverse; }
    iter       = NULL;
    iter_start = NULL;
    iter_clus  = NULL;

}
void HMdcOffset::initVariables()
{
    // pointer to iterators and categories
    rawCat       = 0;
    hitStartCat  = 0;
    clusCat      = 0;
    iter         = 0;
    iter_start   = 0;
    iter_clus    = 0;
    locraw.set(4,0,0,0,0);

    // switch options
    isPulserFile      = kFALSE;
    noStart           = kFALSE;
    useTimeCuts       = kTRUE;
    useClusters       = kTRUE;
    useWireOffset     = kTRUE;
    useTof            = kFALSE;
    debug             = kFALSE;
    fillHistsOnly     = kFALSE;
    readHists         = kFALSE;
    perMBO            = kFALSE;
    perMBOafterSingle = kFALSE;
    filterwindow1     = 50.;
    filterwindow2     =  5.;
    filenumber        = 0;

    // pointers to fileds and hists
    hreverse     = (MyField*) new MyField;
    hint         = 0;
    hinv         = 0;

    // container pointers
    calparraw    = 0;
    lookupgeom   = 0;
    timecut      = 0;
    sizescells   = 0;

    // constants
    signalspeed  = 0.004; // [ns/mm]

    // varables in finalize
    validRange   = 1000.;
    meanhOffset  = 0;
    myoffset     = 0;
    myerror      = 0;

    // counters
    eventcounter = 0;
    skipcounter  = 0;
    nSkipEvents  = 0;
    nStep        = 1000;

    // output file names
    fNameAsciiOffset  = 0;
    fNameRootOffset   = 0;
    ferrorlog         = 0;
    offsetTuple       = 0;
    offsetPulserTuple = 0;

    // fit variables
    yequalzero        = 0;
    crosspointX       = 0;
    fitpar0           = 0;
    fitpar0error      = 0;
    fitpar1           = 0;
    fitpar1error      = 0;

    fitparNoise0      = 0;
    fitparNoise0error = 0;
    fitparNoise1      = 0;
    fitparNoise1error = 0;
    totalsigma        = 0;

    fitGaussMean      = 0;
    fitGaussSigma     = 0;

    useCuts = kFALSE;
    for(Int_t i=0;i<4;i++){
           cutT1L[i]=-2000;
	   cutT1R[i]=2000;
	   cutT12[i]=0;
    }

}
void HMdcOffset::setDefault()
{
    // Sets the the default values for the fits.
    setNoise     (100, 50);
    setThreshold (0.15, 0.5);
    setRangeGauss(50);
    setCleanThreshold(0);
    setFitNoise(kTRUE);
}

void HMdcOffset::setOutputAscii(const Char_t *c)
{
    // Sets ascii output of HMdcOffset for debugging output.
    if (fNameAsciiOffset) { delete fNameAsciiOffset; }
    fNameAsciiOffset = new Char_t[strlen(c) + 1];
    strcpy(fNameAsciiOffset, c);
}

void HMdcOffset::setOutputRoot(const Char_t *c)
{
    // Sets rootfile output of HMdcOffset where all created histograms were written.
    //
    if (fNameRootOffset) { delete fNameRootOffset; }
    fNameRootOffset = new Char_t[strlen(c) + 1];
    strcpy(fNameRootOffset, c);
}
void HMdcOffset::setUseTof(TString filename)
{
    // Retrieves TF1's for min tof substraction from root file
    // and switches the usesage of tof substraction kTRUE.
    if (filename.CompareTo("") == 0)
    {   // check for empty string
	useTof = kFALSE;
	Warning("setUseTof()","Empty String received for inputfile name of tof parameters!");
        exit(1);
    }
    else
    {   // if string is not empty
	TFile* inp = new TFile(filename,"READ");
	if(inp == 0)
	{   // if file does not exist
	    Warning("setUseTof()","Input file not existent!");
	    exit(1);
	}
	else
	{   // if file exists
	    cout<<"HMdcOffset::setUseTof(): Reading from "<<filename.Data()<<endl;
	    Char_t fitname[300];
	    for(Int_t mdc = 0; mdc < 4; mdc ++){
		for(Int_t lay = 0; lay < 6; lay ++){
		    sprintf(fitname,"fit[%i][%i]",mdc,lay);
                    toffunc[mdc][lay] = (TF1*)inp->Get(fitname);
		    if(toffunc[mdc][lay] == 0)
		    {   // if fit object has not been found in file
			Warning("setUseTof()","Error in reading input file!");
                        exit(1);
		    }
		}
	    }
	    useTof = kTRUE;
	}
    }
}
void HMdcOffset::setReadHists(TString filename,Bool_t print)
{
    // Retrieves TH1's for each channel from hinv histogram
    // and switches the usesage of tof substraction kTRUE.
    if (filename.CompareTo("") == 0)
    {   // check for empty string
	readHists = kFALSE;
	Warning("setReadHists()","Empty String received for Hist inputfile !");
        exit(1);
    }
    else
    {   // if string is not empty
	if(gSystem->AccessPathName(filename.Data()))
	{   // if file does not exist
	    Warning("setReadHists()","Input file : %s not existent! Skipping!",filename.Data());
	}
	else
	{   // if file exists
	    filenumber ++;
	    Info("setReadHists()"," Reading from %3i : %s ",filenumber,filename.Data());
            HSpectrometer* spec = gHades->getSetup();
	    if(!spec){

		Error("setReadHists()","HSpectrometer not defined!");
                exit(1);

		
	    }
	    HDetector* mdc = spec->getDetector("Mdc");
	    if(mdc == NULL){

		Error("setReadHists()","HMdcDetector not defined!");
		exit(1);
	    }

	    TFile* inp = new TFile(filename,"READ");

	    for(Int_t s = 0; s < 6; s ++)
	    {  //loop over sectors
		if(print) { cout<<"Sector "<<s<<endl; }
		for(Int_t mo = 0; mo < 4; mo ++)
		{  //loop over modules
		    if(!mdc->getModule(s,mo)){ continue; }
		    if(print) { cout<<"    Module "<<mo<<endl; }
		    for(Int_t mb = 0; mb < 16; mb ++)
		    {  //loop over layer
			for(Int_t t = 0; t < 96; t ++) {  //loop over cells
			    MyHist* h = (MyHist*)inp->Get(Form("sector %i/module %i/mbo %02i/hinv/hinv[%i][%i][%02i][%02i]",s,mo,mb,s,mo,mb,t));
			    if(h){
				Int_t val = 0;
				for(Int_t i = 0; i < 2048; i ++){
				    if(!perMBO){
					val = (Int_t)h->GetBinContent(i + 1);
					(*hreverse)[s][mo][mb][t][i] += val;
				    }
				    else {
					val = (Int_t)h->GetBinContent(i + 1);
					for(Int_t t1 = 0; t1 < 96; t1 ++){
                                            (*hreverse)[s][mo][mb][t1][i] += val;
					}
				    }
				}
                                delete h;
			    }else{
                               break; // next MB...etc
			    }
			} //end tdc
		    } // end mbo
		} // end module
	    } // end sector

	    readHists = kTRUE;
	    inp->Close();
            delete inp;
	}
    }
}
void HMdcOffset::printStatus()
{
    printf("**************** HMdcOffset ***********************\n");
    printf("* ACTUAL SETTINGS                                 *\n");
    if(useTimeCuts)
    {
	printf("*    TIME CUTS are used                           *\n");
    }
    if(!useTimeCuts)
    {
	printf("*    NO TIME CUTS are used                        *\n");
    }
    if(useClusters)
    {
	printf("*    TIMES FILLED FROM CLUSTERS                   *\n");
    }
    if(!useClusters)
    {
	printf("*    TIMES FILLED FROM RAW                        *\n");
    }
    if(useWireOffset && useClusters)
    {
	printf("*    TIME OF SIGNAL ON WIRE SUBTRACTED            *\n");
    }
    if(!useWireOffset)
    {
	printf("*    TIME OF SIGNAL ON WIRE NOT SUBTRACTED        *\n");
    }
    if(useTof)
    {
	printf("*    MINIMUM TOF WILL BE SUBSTRACTED              *\n");
    }
    if(!useTof)
    {
	printf("*    MINIMUM TOF WILL NOT BE SUBSTRACTED          *\n");
    }
    if(isPulserFile)
    {
	printf("*    Mode set to PULSER FILE                      *\n");
    }
    if(!isPulserFile)
    {
	printf("*    Mode set to REAL DATA FILE                   *\n");
    }

    if(!noStart)
    {
	printf("*    START TIMES are used                         *\n");
    }
    if(noStart)
    {
	printf("*    NO START TIMES are used                      *\n");
    }
    if(readHists)
    {
	printf("*    DATA WILL BE READ FROM HISTOGRAMS            *\n");
    }
    if(!readHists)
    {
	printf("*    DATA WILL BE READ FROM HLDFILES              *\n");
    }
    if(fillHistsOnly)
    {
	printf("*    ONLY HISTOGRAMS WILL BE FILLED (BATCH mode)  *\n");
    }
    if(!fillHistsOnly)
    {
	printf("*    HISTOGRAMS/NTUPLES FILLED IN ONE SHOT        *\n");
    }
    if(perMBO)
    {
	printf("*    HISTOGRAMS WILL BE FILLED PER MBO            *\n");
    }
    if(perMBOafterSingle)
    {
	printf("*    HISTOGRAMS WILL BE FILLED PER MBO AFTER CH   *\n");
    }
    if(!perMBOafterSingle && !perMBO)
    {
	printf("*    HISTOGRAMS FILLED FOR SINGLE TDC CHANNEL     *\n");
    }
    printf("*    SIGNALSPEED = %5.3f [ns/mm]                 *\n"   ,signalspeed);
    printf("*    VALID OFFSET RANGE = %5.1f                  *\n"   ,validRange);
    printf("*    NOISE OFFSET = %4i                          *\n"   ,offsetfitNoise);
    printf("*    NOISE WIDTH  = %4i                          *\n"   ,widthfitNoise);
    printf("*    MIN Threshold   = %1.2f MAX Threshold = %1.2f  *\n",minfitthreshold,maxfitthreshold);
    printf("*    Range GAUSS FIT = %4i                       *\n"   ,rangeGauss);
    printf("**************** HMdcOffset ***********************\n");
}
Bool_t HMdcOffset::init(void)
{
    //  Inits HMdcOffset and the needed HMdcCalParRaw, if this container does not exists
    if(!readHists)
    {
	if(!noStart)
	{
	    hitStartCat = gHades->getCurrentEvent()->getCategory(catStart2Hit);       //????
	    if (!hitStartCat)
	    {
		Error("init()","NO START HIT CATEGORY IN INPUT!");
		return kFALSE;
	    } else { iter_start = (HIterator *)hitStartCat->MakeIterator("native"); }
	}
	if(useClusters)
	{
	    clusCat = gHades->getCurrentEvent()->getCategory(catMdcClus);       //????
	    if (!clusCat)
	    {
		Error("init()","NO CLUS CATEGORY IN INPUT!");
		return kFALSE;
	    } else { iter_clus = (HIterator *)clusCat->MakeIterator("native"); }

	    if(useWireOffset)
	    {
		sizescells = HMdcSizesCells::getExObject();
		if(!sizescells)
		{
		    Error("init()","NO HMDCSIZESCELLS CONTAINER IN INPUT!");
		    return kFALSE;
		}
	    }
	}
	rawCat = gHades->getCurrentEvent()->getCategory(catMdcRaw);
	if (!rawCat)
	{
	    Error("init()","NO MDC RAW CATEGORY IN INPUT!");
	    return kFALSE;
	} else { iter = (HIterator *)rawCat->MakeIterator(); }

	if(useTimeCuts){
	    timecut     = (HMdcTimeCut*)   gHades->getRuntimeDb()->getContainer("MdcTimeCut");
	} else {
	    timecut = NULL;
	}
    }

    calparraw  = (HMdcCalParRaw*) gHades->getRuntimeDb()->getContainer("MdcCalParRaw");
    lookupgeom = (HMdcLookupGeom*)gHades->getRuntimeDb()->getContainer("MdcLookupGeom");
    lookupraw  = (HMdcLookupRaw*) gHades->getRuntimeDb()->getContainer("MdcLookupRaw");

    fActive      = kTRUE;
    eventcounter = 0;
    skipcounter  = 0;
    printStatus();
    return kTRUE;
}

Bool_t HMdcOffset::reinit(void)
{
    //
    cout<<"skipcount "<<skipcounter<<endl;
    skipcounter = 0;
    fActive     = kTRUE;
    return kTRUE;
}



void HMdcOffset::createHist(TFile* file,Int_t s, Int_t m, Int_t l, Int_t c, Bool_t read)
{
    // Histograms for inverted Time1 and integrated Time1 per Tdc-Channel are created
    // in a subdirectory structure.
    static Char_t title[50], tmp[30];

    sprintf(title,"%s%i%s%i%s%i%s%i","Sector ",s,"  Module ",m,"  Mbo ", l,"  Tdc ", c);
    file->TDirectory::Cd("hinv");
    sprintf(tmp, "%s%i%s%i%s%02i%s%02i%s", "hinv[",s,"][",m,"][",l,"][",c,"]");
    if(read) { hinv = (MyHist*) gDirectory->Get(tmp); }
    else     { hinv = new MyHist(tmp, title, nbin,-nbin + 0.5,0.5); } //inverted hist.
    file->TDirectory::Cd("../hint");
    sprintf(tmp, "%s%i%s%i%s%02i%s%02i%s", "hint[",s,"][",m,"][",l,"][",c,"]");
    if(read) { hint = (MyHist*) gDirectory->Get(tmp); }
    else     { hint = new MyHist(tmp, title, nbin,-nbin + 0.5,0.5); } // integrated hist.
    file->TDirectory::Cd("..");
}
void HMdcOffset::createHist_2D(Int_t s, Int_t m, Bool_t read)
{
    // Histograms for inverted Time1 and integrated Time1 per Tdc-Channel are created
    // in a subdirectory structure.
    static Char_t title[50], tmp[30];
    for(Int_t mb = 0; mb < 16; mb ++)
    {
	sprintf(title,"%s%i%s%i%s%i","Sector ",s,"  Module ",m,"  Mbo ", mb);
	sprintf(tmp, "%s%i%s%i%s%02i%s", "htime1_mbo[",s,"][",m,"][",mb,"]");
	if(read) {
	    htime1_mbo[mb] = (TH2F*) gDirectory->Get(tmp);
	    htime1_mbo[mb]->SetName(Form("%s_perMBO",tmp));
	    htime1_mbo[mb]->Reset();
	} else { htime1_mbo[mb] = new TH2F(tmp, title,700,-200,500,96,1,97); } //hist time vers tdc.
    }
    for(Int_t lay = 0; lay < 6; lay ++)
    {
	sprintf(title,"%s%i%s%i%s%i","Sector ",s,"  Module ",m,"  Lay ", lay);
	sprintf(tmp, "%s%i%s%i%s%02i%s", "htime1_lay[",s,"][",m,"][",lay,"]");
	if(read) {
	    htime1_lay[lay] = (TH2F*) gDirectory->Get(tmp);
            htime1_lay[lay]->SetName(Form("%s_perMBO",tmp));
	    htime1_lay[lay]->Reset();
	} else { htime1_lay[lay] = new TH2F(tmp, title,700,-200,500,210,1,211); } //hist time vers tdc.

	sprintf(title,"%s%i%s%i%s%i","Sector ",s,"  Module ",m,"  Lay ", lay);
	sprintf(tmp, "%s%i%s%i%s%02i%s", "htime1_lay_inv_norm[",s,"][",m,"][",lay,"]");

	if(read) {
	    htime1_lay_inv_norm[lay] = (TH2F*) gDirectory->Get(tmp);
            htime1_lay_inv_norm[lay]->SetName(Form("%s_perMBO",tmp));
            htime1_lay_inv_norm[lay]->Reset();
	} else { htime1_lay_inv_norm[lay] = new TH2F(tmp, title,700,-200,500,210,1,211); } //hist time vers tdc.

	sprintf(title,"%s%i%s%i%s%i","Sector ",s,"  Module ",m,"  Lay ", lay);
	sprintf(tmp, "%s%i%s%i%s%02i%s", "htime1_lay_int[",s,"][",m,"][",lay,"]");

	if(read) {
	    htime1_lay_int[lay] = (TH2F*) gDirectory->Get(tmp);
	    htime1_lay_int[lay]->SetName(Form("%s_perMBO",tmp));
            htime1_lay_int[lay]->Reset();
	} else { htime1_lay_int[lay] = new TH2F(tmp, title,700,-200,500,210,1,211); } //hist time vers tdc.

	sprintf(title,"%s%i%s%i%s%i","Sector ",s,"  Module ",m,"  Lay ", lay);
	sprintf(tmp, "%s%i%s%i%s%02i%s", "htime1_lay_int_norm[",s,"][",m,"][",lay,"]");
	if(read) {
	    htime1_lay_int_norm[lay] = (TH2F*) gDirectory->Get(tmp);
	    htime1_lay_int_norm[lay]->SetName(Form("%s_perMBO",tmp));
            htime1_lay_int_norm[lay]->Reset();
	} else { htime1_lay_int_norm[lay] = new TH2F(tmp, title,700,-200,500,210,1,211); } //hist time vers tdc.
    }

}
void HMdcOffset::deleteHist()
{
    // Created histograms are deleted
    delete hinv;
    delete hint;
}
void HMdcOffset::deleteHist_2D()
{
    // Created histograms are deleted
    for(Int_t mb = 0; mb < 16; mb ++)
    {
	delete htime1_mbo[mb];
        htime1_mbo[mb] = 0;
    }
    for(Int_t lay = 0; lay < 6; lay ++)
    {
	delete htime1_lay         [lay];
	delete htime1_lay_inv_norm[lay];
	delete htime1_lay_int     [lay];
	delete htime1_lay_int_norm[lay];
	htime1_lay         [lay] = 0;
	htime1_lay_inv_norm[lay] = 0;
	htime1_lay_int     [lay] = 0;
	htime1_lay_int_norm[lay] = 0;
    }



}

void HMdcOffset::fillHist(Int_t s, Int_t m, Int_t l, Int_t c)
{
    // Histograms for inverted Time1 and integrated Time1 per Tdc-Channel are filled

    hint->SetBinContent(1,(Double_t)(*hreverse)[s][m][l][c][0]);
    hinv->SetBinContent(1,(Double_t)(*hreverse)[s][m][l][c][0]);

    for(Int_t k = 2; k < nbinp1; k ++)
    {
	if(((Double_t)(*hreverse)[s][m][l][c][k - 1]) > cleanThreshold ){
	    hinv->SetBinContent(k,(Double_t)(*hreverse)[s][m][l][c][k - 1]);
	}
	hint->SetBinContent(k,(hint->GetBinContent(k - 1)+hinv->GetBinContent(k)));
    }
    integral[s][m][l][c] = (Int_t)hint->GetBinContent(nbin - 2);
}
void HMdcOffset::fillHist_2D(Int_t s, Int_t m, Int_t l, Int_t c)
{
    // Histograms for Time1 vers Tdc-Channel and cell are filled
    HMdcLookupChan& chan = (*lookupgeom)[s][m][l][c];
    Int_t layer          = chan.getNLayer();
    Int_t cell           = chan.getNCell();
    Int_t myoffbin       = (Int_t)(2048 - offsets[s][m][l][c]); // convert offset x to offset bin
    Float_t temp;





    for(Int_t k = 1; k < nbinp1; k ++) // loop over all bins of hinv  (x from -2048 to 0)
    {
	if(k - myoffbin < 500 && k - myoffbin > - 200) // check if bin in range
	{
	    Int_t mybin = 200 + k - myoffbin;

	    temp = htime1_mbo[l]->GetCellContent(mybin,c + 1);
	    htime1_mbo       [l]->SetCellContent(mybin,c + 1   ,hinv->GetBinContent(k) + temp);

	    temp = htime1_lay         [layer]->GetCellContent(mybin,cell + 1);
	    htime1_lay                [layer]->SetCellContent(mybin,cell + 1,hinv->GetBinContent(k) + temp);

	    temp = htime1_lay_int     [layer]->GetCellContent(mybin,cell + 1);
	    htime1_lay_int            [layer]->SetCellContent(mybin,cell + 1,hint->GetBinContent(k) + temp);

	    temp = htime1_lay_inv_norm[layer]->GetCellContent(mybin,cell + 1);
	    htime1_lay_inv_norm       [layer]->SetCellContent(mybin,cell + 1,hinv->GetBinContent(k) + temp);

	    temp = htime1_lay_int_norm[layer]->GetCellContent(mybin,cell + 1);
	    htime1_lay_int_norm       [layer]->SetCellContent(mybin,cell + 1,hint->GetBinContent(k) +temp);

	}
    }

    Float_t max_inv = hinv->GetMaximum();
    Float_t max_int = hint->GetMaximum();

    for(Int_t k = 1; k < nbinp1; k ++) // loop over all bins of hinv  (x from -2048 to 0)
    {
	if(max_inv != 0)
	{
	    temp = htime1_lay_inv_norm[layer]->GetCellContent(k,cell + 1);
	    htime1_lay_inv_norm       [layer]->SetCellContent(k,cell + 1,temp / max_inv);
	}
	if(max_int != 0)
	{
	    temp = htime1_lay_int_norm[layer]->GetCellContent(k,cell + 1);
	    htime1_lay_int_norm       [layer]->SetCellContent(k,cell + 1,temp / max_int);
	}
    }
}

Int_t HMdcOffset::fitHist(Int_t s, Int_t m, Int_t l, Int_t c)
{
    // The offset is calculated from two linear fits. Some pictures of the fitted histograms
    // can be found on Begin_Html <a href="http://www-hades.gsi.de/docs/mdc/mdcana/#calibration">MDC calibration page</a>End_Html .
    // The first linear fit (red) is done to find the rising edge of the integrated spectra.
    // The second linear fit (blue) is done to substract the noise.
    // The ranges for both fits can be set through the functions setNoise()(x-range) for the
    // second fit (default values: 100,50) and setThreshold()(y-range) for the first fit
    // (default values :0.15,0.50). The y-range is calculated by the percentage of the maximum
    // height of the spectra.
    // The offset ist calculated from the intersection point of both linear fits.
    // The sigma of the offset is calculated from the sigmas of the two linear fits.
    //
    // If the analyzed file is a pulser file for external calibration a gaussian fit is done.
    // To set this fit the function setPulserFile() has to be used in the macro. The range of
    // the fit is set through the function setRangeGauss()(default value: 50) around the maximum.
    // The mean and sigma of the fit is written to the ascii debugging output.
    // The hist is checked for multiple peaks.The peaks which have been found are written to an array.

    fitGaussMean      = 0;
    fitGaussSigma     = 0;
    fitpar0           = 0;
    fitpar0error      = 0;
    fitpar1           = 0;
    fitpar1error      = 0;
    fitparNoise0      = 0;
    fitparNoise1      = 0;
    fitparNoise0error = 0;
    fitparNoise1error = 0;
    totalsigma        = 0;
    yequalzero        = 0;
    crosspointX       = 0;
    //-----------------------------------------------------------
    // if hist is empty do nothing
    if(hint->Integral() == 0 )
    {   
	if(debug){ cout<<s<<" "<<m<<" "<<l<<" "<<c<<" skip: Integral==0 "<<endl; }
	yequalzero  = 1;
	crosspointX = 1;
	return 1;

    }
    //-----------------------------------------------------------

    //-----------------------------------------------------------
    // Check for overflows. In case of an overflow bins
    // might be negative
    if(hint->GetMinimum() < 0)
    {
        cout<<" "<<endl;
	cout<<"WARNING: IN HINT "<<s<<" "<<m<<" "<<l<<" "<<c<<" NEGATIV VALUES DETECTED!"<<endl;
        cout<<" "<<endl;
	fprintf(ferrorlog,"%i %i %i %2i %s\n",s,m,l,c,"fit: in hint negative values detected!");
    }
    //-----------------------------------------------------------


    //-----------------------------------------------------------
    // finding upper fitting range for signal fit
    Int_t   xmaxfitbin = nbinm1;

    Float_t yminfit    = minfitthreshold * hint->GetBinContent(nbinm1 - 1);     // setting y thresholds for fitting
    Float_t ymaxfit    = maxfitthreshold * hint->GetBinContent(nbinm1 - 1);     // relative to maximum y-value
    while (hint->GetBinContent(-- xmaxfitbin) > ymaxfit && xmaxfitbin);         // find to ymaxfit corresponding bin
    //-----------------------------------------------------------

    //-----------------------------------------------------------
    // if no match for the upper fit range has been found in
    // the desired Y range
    if (!xmaxfitbin)
    {
	if(debug){ cout<<s<<" "<<m<<" "<<l<<" "<<c<<" skip: xmaxfitbin=0, integral "<<hint->Integral()<<endl; }
	yequalzero  = 1;
	crosspointX = 1;
	return 1;
    }
    //-----------------------------------------------------------

    //-----------------------------------------------------------
    // finding lower fitting range for signal fit
    Int_t xminfitbin = xmaxfitbin;
    while (hint->GetBinContent(-- xminfitbin) > yminfit && xminfitbin); // find to yminfit corresponding bin
    //-----------------------------------------------------------

    //-----------------------------------------------------------
    // if no match for the lower fit range has been found in
    // the desired Y range
    if (!xminfitbin)
    {
	if(debug){ cout<<s<<" "<<m<<" "<<l<<" "<<c<<" skip: xminfitbin=0, integral "<<hint->Integral()<<endl; }
	yequalzero  = 2;
	crosspointX = 2;
	return 2;
    }
    //-----------------------------------------------------------

    //-----------------------------------------------------------
    // if fit range is just 1 bin the fit will give an error message.
    // this is just to suppress the error message.
    if(xmaxfitbin-xminfitbin == 1)
    {   // fit range is just 1 bin!
	if(debug){ cout<<s<<" "<<m<<" "<<l<<" "<<c<<" skip: fit range 1 bin, integral "<<hint->Integral()<<endl; }
	yequalzero  = 2;
	crosspointX = 2;
	return 2;

    }
    //-----------------------------------------------------------

    //-----------------------------------------------------------
    // create pol1 fit function in desired range and fit the hist.
    TF1 *f = new TF1("fitsignal","pol1",hint->GetBinCenter(xminfitbin),hint->GetBinCenter(xmaxfitbin)); // call fit function poynom 1.order in x-range
    hint->Fit("fitsignal","RNQ");
    fitpar0      = 0;
    fitpar0error = 0;
    fitpar1      = 0;
    fitpar1error = 0;
    fitpar0      = f->GetParameter(0);  // get fitparameters
    fitpar0error = f->GetParError (0);
    fitpar1      = f->GetParameter(1);  //(f1->GetParameter(1)<0.000001)?-1:(f1->GetParameter(1));
    fitpar1error = f->GetParError (1);  // y=fitpar[1]* x +  fitpar[0]
    //-----------------------------------------------------------
    

    //-----------------------------------------------------------
    // if result of fit is nan or inf.
    if(TMath::Finite(f->GetParameter(0)) == 0 ||
       TMath::Finite(f->GetParameter(1)) == 0
      )
    {   // bullshit !!
	if(debug){
	    cout<<s<<" "<<m<<" "<<l<<" "<<c<<" skip: fit result strange, integral "
		<<hint->Integral()
		<<" xminbin "<<xminfitbin
		<<" xmaxbin "<<xmaxfitbin
		<<" fitpar0 "<<f->GetParameter(0)
		<<" fitpar1 "<<f->GetParameter(1)
		<<endl;
	}
	yequalzero  = 3;
	crosspointX = 3;
	delete f;
	return 3;
    }
    //-----------------------------------------------------------


    //-----------------------------------------------------------
    // remove fit function
    delete f;
    //-----------------------------------------------------------

    //-----------------------------------------------------------
    // if fitpar1 is 0 we can not do anything usefull
    if (fitpar1 == 0)
    {
	if(debug) {
	    cout<<s<<" "<<m<<" "<<l<<" "<<c<<" skip: fitpar1==0 , integral "
		<<hint->Integral()
		<<" xminbin "<<xminfitbin
		<<" xmaxbin "<<xmaxfitbin
		<<" fitpar0 "<<fitpar0
		<<" fitpar1 "<<fitpar1
		<<endl;
	}
	yequalzero  = 3;
	crosspointX = 3;
	return 3;
    }
    //-----------------------------------------------------------

    //-----------------------------------------------------------
    // calculate cross point of fit with x-axis
    // and check for good range
    yequalzero =  0;
    yequalzero = -fitpar0 / fitpar1;

    if (-yequalzero < (offsetfitNoise + widthfitNoise) || -yequalzero > nbin)
    {
	if(debug){
	    cout<<s<<" "<<m<<" "<<l<<" "<<c<<" skip: yequalzero out of range, integral "
		<<hint->Integral()
		<<" -yequalzero "<<-yequalzero
		<<" xminbin "    <<xminfitbin
		<<" xmaxbin "    <<xmaxfitbin
		<<" fitpar0 "    <<fitpar0
		<<" fitpar1 "    <<fitpar1
		<<endl;
	}
	crosspointX = 4;
	return 4;
    }
    //-----------------------------------------------------------

    //-----------------------------------------------------------
    // check weather the range for the noise fit contains any
    // counts. This is just to suppress error messages from the
    // fit. If the is no signal yequalzero will be taken as offset.
    if(hint->Integral(hint->FindBin(yequalzero - (offsetfitNoise + widthfitNoise)),
		      hint->FindBin(yequalzero - offsetfitNoise)) < 10    ||
       !fitNoise
      )
    {  // almost no counts in range of fit!

	if(debug){
	    cout<<s<<" "<<m<<" "<<l<<" "<<c<<" skip: no counts in noise region , integral "
		<<hint->Integral()
		<<" -yequalzero "<<-yequalzero
		<<" minbinNoise "<<hint->FindBin(yequalzero - (offsetfitNoise + widthfitNoise))
		<<" maxbinNoise "<<hint->FindBin(yequalzero - offsetfitNoise)
		<<endl;
	}
	crosspointX       = -yequalzero;
	fitparNoise0      =  0;
	fitparNoise1      =  0;
	fitparNoise0error =  0;
	fitparNoise1error =  0;
    }
    else
    {
	//-----------------------------------------------------------
	// create pol1 fit function for the noise fit in
        // the desired range and fit the hist
	f = new TF1("fitnoise","pol1",
		    yequalzero - (offsetfitNoise + widthfitNoise),
		    yequalzero - offsetfitNoise);
	hint->Fit("fitnoise","RNQ");
	fitparNoise0      = 0;
	fitparNoise1      = 0;
	fitparNoise0error = 0;
	fitparNoise1error = 0;
	fitparNoise0      = f->GetParameter(0); // get fitparameters
	fitparNoise1      = f->GetParameter(1);
	fitparNoise0error = f->GetParError (0); // get fitparameters
	fitparNoise1error = f->GetParError (1);
	//-----------------------------------------------------------

	//-----------------------------------------------------------
	// if result of fit is nan or inf.
        // if so yequalzero is taken as offset
	if(TMath::Finite(f->GetParameter(0)) == 0 ||
	   TMath::Finite(f->GetParameter(1)) == 0
	  )
	{   // bullshit !!
	    if(debug){
		cout<<s<<" "<<m<<" "<<l<<" "<<c<<" skip: noise fit result strange , integral "
	             <<hint->Integral()
		     <<" -yequalzero " <<-yequalzero
		     <<" minbinNoise " <<hint->FindBin(yequalzero - (offsetfitNoise + widthfitNoise))
		     <<" maxbinNoise " <<hint->FindBin(yequalzero - offsetfitNoise)
		     <<" fitparNoise0 "<<f->GetParameter(0)
		     <<" fitparNoise1 "<<f->GetParameter(1)
		    <<endl;
	    }
	    crosspointX       = -yequalzero;
	    fitparNoise0      =  0;
	    fitparNoise1      =  0;
	    fitparNoise0error =  0;
	    fitparNoise1error =  0;
       }

	//-----------------------------------------------------------
	// if fitpar1==fitparNoise1 we can not calculate
        // any cross point. if so yequalzero is taken as offset
	if (fitpar1 == fitparNoise1)
	{
	    if(debug){
		cout<<s<<" "<<m<<" "<<l<<" "<<c<<" skip: no intersection for fit functions , integral "
	             <<hint->Integral()
		     <<" -yequalzero " <<-yequalzero
		     <<" minbinNoise " <<hint->FindBin(yequalzero - (offsetfitNoise + widthfitNoise))
		     <<" maxbinNoise " <<hint->FindBin(yequalzero - offsetfitNoise)
                     <<" fitpar0     " <<fitpar0
                     <<" fitpar1     " <<fitpar1
                     <<" fitparNoise0 "<<f->GetParameter(0)
		     <<" fitparNoise1 "<<f->GetParameter(1)
		    <<endl;
	    }
	    crosspointX       = -yequalzero;
	    fitparNoise0      =  0;
	    fitparNoise1      =  0;
	    fitparNoise0error =  0;
	    fitparNoise1error =  0;
	}

	
	//-----------------------------------------------------------
	// finally calculate cross point between noise and signal
	// fit to define the offset
	crosspointX = -(fitparNoise0 - fitpar0)/(fitpar1 - fitparNoise1);
	//-----------------------------------------------------------

	//-----------------------------------------------------------
	// check if value is ok and in meaningfull range
	if (TMath::Finite(crosspointX) == 0 || crosspointX < 0 || crosspointX > nbinm1)
	{
	    if(debug){
		cout<<s<<" "<<m<<" "<<l<<" "<<c<<" skip: crospointX out of range or strange , integral "
		    <<hint->Integral()
		    <<" -yequalzero " <<-yequalzero
		    <<" crosspaintX " <<crosspointX
		    <<" xminbin "     <<xminfitbin
		    <<" xmaxbin "     <<xmaxfitbin
		    <<" minbinNoise " <<hint->FindBin(yequalzero - (offsetfitNoise + widthfitNoise))
		    <<" maxbinNoise " <<hint->FindBin(yequalzero - offsetfitNoise)
		    <<" fitpar0     " <<fitpar0
		    <<" fitpar1     " <<fitpar1
		    <<" fitparNoise0 "<<f->GetParameter(0)
		    <<" fitparNoise1 "<<f->GetParameter(1)
		    <<endl;
	    }
	    crosspointX       = -yequalzero;
	    fitparNoise0      =  0;
	    fitparNoise1      =  0;
	    fitparNoise0error =  0;
	    fitparNoise1error =  0;
	}
 	//-----------------------------------------------------------

	//-----------------------------------------------------------
	// remove fit function
	delete f;
	//-----------------------------------------------------------
    }

    //-----------------------------------------------------------
    // calculating total sigma of the found offset
    totalsigma = (Float_t)sqrt(  (pow( fitparNoise0error    ,2) / pow( fitparNoise1-fitpar1 ,2))
			       + (pow( fitpar0error         ,2) / pow( fitparNoise1-fitpar1 ,2))
			       + (pow( fitparNoise0-fitpar0 ,2) * pow( fitpar1error         ,2) / pow( fitparNoise1 - fitpar1 ,4))
			       + (pow( fitparNoise0-fitpar0 ,2) * pow( fitparNoise1error    ,2) / pow( fitparNoise1 - fitpar1 ,4))
			      );
    //-----------------------------------------------------------

    // check if fitpars are meaningful
    if(fitpar1      < 100000  && fitpar1 > -100000) { fitslope1[s][m][l][c] = fitpar1; }
    else                                            { fitslope1[s][m][l][c] = 0; }
    if(fitparNoise1 < 100000  && fitpar1 > -100000) { fitslope2[s][m][l][c] = fitparNoise1; }
    else                                            { fitslope2[s][m][l][c] = 0; }

    if(useTof){
	// (2048 - traw1 * slope) + starttime - wireoff - tof;
	HMdcLookupChan& chan = (*lookupgeom)[s][m][l][c];
	Int_t lay            = chan.getNLayer();
	Int_t cell           = chan.getNCell();
	Float_t tof          = toffunc[m][lay]->Eval(cell);
	crosspointX += tof;
	yequalzero  -= tof;
    }

    if (!isPulserFile) { return 0; }


    // If there are more than 1 peak only the most prominant is fitted
    Float_t localmax = (2048 - (hinv->GetMaximumBin()));
    f = new TF1("f3","gaus",-localmax - rangeGauss, -crosspointX + rangeGauss);

    hinv->Fit("f3","RNQ");
    fitGaussMean  = f->GetParameter(1);  //mean
    fitGaussSigma = f->GetParameter(2);  //sigma

    findMultiplePeaks(s,m,l,c);

    delete f;

    // FIXME: Error handling for gauss fit ???

    return 0;
}
void HMdcOffset::findMultiplePeaks(Int_t s,Int_t m,Int_t l,Int_t c)
{
    for(Int_t j = 0;j < 2047;j ++){ htime1temp->SetBinContent(j,hinv->GetBinContent(j)); } // copy hinv to temp hist

    htime1temp->Smooth(10);// make it smooth

    Char_t address    [50];
    Float_t binlowold [5];
    Float_t binhighold[5];
    Float_t binlow    [5];
    Float_t binhigh   [5];
    Int_t binmax      [5];

    Float_t max      = 0;
    Float_t min      = 0;
    Float_t threshold= 0.05;

    for(Int_t j=0;j<5;j++)// reset helper arrays
    {
	binlowold [j] = 0;
	binhighold[j] = 0;
	binlow    [j] = 0;
	binhigh   [j] = 0;
	binmax    [j] = 0;
    }
    max         = min = 0;
    max         = htime1temp->GetMaximum(); // get max height
    min         = threshold * max;
    Int_t count = 0;
    for(Int_t bin = 0; bin < 2047; bin ++)
    {
	if(count < 5)
	{
	    binlow [count] = htime1temp->GetBinContent(bin);
	    binhigh[count] = htime1temp->GetBinContent(bin + 1);

	    if(bin > 40 && binlow[count] > 20                    && // skip the first 40 tdc bins and take into account only if > 20 counts
	       fabs(binhigh      [count]-binlow   [count]) > 1   &&
	           (binhighold   [count]-binlowold[count]  > 0)  &&
	           (binhigh      [count]-binlow   [count]  < 0) ) // if zero was crossed
	    {
		binmax[count] = bin;
		count ++;
	    }
	    if(count < 5)
	    {
		binlowold [count] = binlow [count];
		binhighold[count] = binhigh[count];
	    } else { cout<<"MORE THAN 5 PEAKS!"<<endl; }
	}
    }
    if(count > 1)
    {
        cout<<" "<<endl;
	cout<<"sector "<<s<<" module "<<m<<" mbo "<<l<<" tdc "<<c<<endl;
	for(Int_t i = 0; i < count; i ++)
	{
	    if(i < 5)
	    {
		cout<<"peak found: "<<i + 1
		    <<" bin="       <<binmax        [i]
		    <<" ,x="        <<(2048 - binmax[i])
		    <<" max="       <<binlow        [i]
		    <<endl;
                sprintf(address,"%i %i %i %2i",s,m,l,c);
		fprintf(ferrorlog,"%s %i %s %4i %s %4i %s %8.0f\n",address,i + 1,"multiple peaks: bin=",binmax[i]," ,x=",(2048 - binmax[i])," max=",binlow[i]);
	    } else { cout<<"MORE THAN 5 PEAKS!"<<endl; }
	}
	cout<<" "<<endl;
    }

    for(Int_t j = 0; j < 5; j ++)// coppy to global array
    {
	if(binmax[j] > 0){ offsetpulser[s][m][l][c][j] = (2048 - binmax[j]); }
	else             { offsetpulser[s][m][l][c][j] = 0; }
    }
}
void HMdcOffset::writeAscii(ofstream &fout, Int_t s, Int_t m, Int_t l, Int_t c)
{
    // The adresses of the channel(sector,module,mbo,tdc),offset, two fitparameters for the
    // two linear fits, the sigma of the offset ,offset and the integral(number of entries for this channel)
    // are written to the ascii debugging output.In the case of an pulser file (external calibration)
    // the mean and the sigma of the gaussian fit are also written to the output.
    if (isPulserFile)
    {
	fout
            << setw(3)  << s                 << " "
            << setw(4)  << m                 << " "
            << setw(4)  << l                 << " "
            << setw(5)  << c                 << " "
	    << setw(10) << -yequalzero       << " "
            << setw(10) << yequalzero        << " "
	    << setw(10) << crosspointX       << " "
            << setw(15) << -fitGaussMean     << " "
            << setw(15) << fitGaussSigma     << " "
            << setw(15) << fitpar0           << " "
            << setw(15) << fitpar1           << " "
            << setw(15) << fitparNoise0      << " "
            << setw(15) << fitparNoise1      << " "
            << setw(15) << totalsigma        << " "
            << setw(10) << integral[s][m][l][c]

            << endl;
    }
    else
    {
        fout
            << setw(3)  << s                  << " "
            << setw(4)  << m                  << " "
            << setw(4)  << l                  << " "
            << setw(5)  << c                  << " "
	    << setw(10) << -yequalzero        << " "
	    << setw(10) << crosspointX        << " "
            << setw(15) << fitpar0            << " "
            << setw(15) << fitpar1            << " "
            << setw(15) << fitparNoise0       << " "
            << setw(15) << fitparNoise1       << " "
            << setw(15) << totalsigma         << " "
            << setw(10) << integral[s][m][l][c]
	    << endl;
    }
}

void HMdcOffset::writeHist(TFile* file)
{
    // All created histograms are written to a rootfile.
    // The file is structured for sector,module,mbo.
    
    file->TDirectory::Cd("hinv");
    hinv->Write();
    file->TDirectory::Cd("../hint");
    hint->Write();
    file->TDirectory::Cd("..");
}
void HMdcOffset::writeHist_2D(Int_t s,Int_t m)
{
    TLatex* tex;


    // All created histograms are written to a rootfile.
    for(Int_t mb = 0; mb < 16; mb ++)
    {
	HMdcLookupMoth& moth = (*lookupgeom)[s][m][mb];
	for(Int_t i = 0; i < moth.getSize(); i ++){
	    HMdcLookupChan& t = (*lookupgeom)[s][m][mb][i];
	    Int_t l           = t.getNLayer();
	    Int_t c           = t.getNCell();
	    tex = new TLatex(-150,i+1,Form("s%i m%i l%i c%i",s,m,l,c));
	    tex->SetTextSize(0.02);
	    htime1_mbo[mb]->GetListOfFunctions()->Add(tex);
	}
	htime1_mbo[mb]->SetEntries(1);
        htime1_mbo[mb]->SetOption("colz");
        htime1_mbo[mb]->Write();
    }

    for(Int_t lay = 0;lay < 6; lay ++)
    {
	HMdcLookupLayer& layer = (*lookupraw)[s][m][lay];
	for(Int_t i=0;i<layer.getSize();i++){
	    HMdcLookupCell& cell = (*lookupraw)[s][m][lay][i];
	    Int_t t  = cell.getNChan();
	    Int_t mb = cell.getNMoth();

	    tex = new TLatex(-150,i+1,Form("s%i m%i mb%i t%i",s,m,mb,t));
	    tex->SetTextSize(0.02);
	    htime1_lay[lay]         ->GetListOfFunctions()->Add(tex);
	    htime1_lay_inv_norm[lay]->GetListOfFunctions()->Add(tex);
	    htime1_lay_int     [lay]->GetListOfFunctions()->Add(tex);
	    htime1_lay_int_norm[lay]->GetListOfFunctions()->Add(tex);
	}

	htime1_lay         [lay]->SetEntries(1);
        htime1_lay         [lay]->SetOption("colz");
        htime1_lay         [lay]->Write();

	htime1_lay_inv_norm[lay]->SetEntries(1);
        htime1_lay_inv_norm[lay]->SetOption("colz");
        htime1_lay_inv_norm[lay]->Write();

	htime1_lay_int     [lay]->SetEntries(1);
        htime1_lay_int     [lay]->SetOption("colz");
        htime1_lay_int     [lay]->Write();

	htime1_lay_int_norm[lay]->SetEntries(1);
        htime1_lay_int_norm[lay]->SetOption("colz");
        htime1_lay_int_norm[lay]->Write();
    }
}

ofstream *HMdcOffset::openAsciiFile()
{
    // Opens the ascii debugging output and writes the headerline.
    ofstream *fout = NULL;
    if (fNameAsciiOffset) { fout = new ofstream(fNameAsciiOffset, ios::out); }
    if (fout)
    {            // changed *fout
        if (isPulserFile)
        {
            *fout //<< "Layer     Cell      crosspoint" << endl;
                << setw(3)  << "s"              << " "
                << setw(4)  << "mo"             << " "
                << setw(4)  << "mb"             << " "
                << setw(5)  << "t"              << " "
		<< setw(10) << "yequalzero"     << " "
		<< setw(10) << "Offset"         << " "
                << setw(15) << "GaussMean"      << " "
                << setw(15) << "GaussSigma"     << " "
                << setw(15) << "fitpar0"        << " "
                << setw(15) << "fitpar1"        << " "
                << setw(15) << "fitparNoise0"   << " "
                << setw(15) << "fitparNoise1"   << " "
                << setw(15) << "totalsigma"     << " "
                << setw(10) << "Integral"       << " "<< endl;
          *fout << setw(14) << "[MdcCalParRaw]" <<endl;
        }
        else
        {
            *fout //<< "Layer     Cell      crosspoint" << endl;
                << setw(3)  << "s"              << " "
                << setw(4)  << "mo"             << " "
                << setw(4)  << "mb"             << " "
                << setw(5)  << "t"              << " "
		<< setw(10) << "yequalzero"     << " "
		<< setw(10) << "Offset"         << " "
                << setw(15) << "fitpar0"        << " "
                << setw(15) << "fitpar1"        << " "
                << setw(15) << "fitparNoise0"   << " "
                << setw(15) << "fitparNoise1"   << " "
                << setw(15) << "totalsigma"     << " "
                << setw(10) << "Integral"       << " "<< endl;
          *fout << setw(14) << "[MdcCalParRaw]" <<endl;
	}
    }
    return fout;
}
void HMdcOffset::fillNTuples(Int_t s,Int_t mo,Int_t mb,Int_t t)
{
    // fill NTuples for offsets and multiple peaks
    HMdcLookupChan& chan = (*lookupgeom)[s][mo][mb][t];
    offsetTuple->Fill(s,mo,mb,t,
		      chan.getNLayer(),
		      chan.getNCell(),
		      (*calparraw)[s][mo][mb][t].getSlope(),
		      (*calparraw)[s][mo][mb][t].getSlopeErr(),
		      offsets     [s][mo][mb][t],
		      offsetErr   [s][mo][mb][t],
		      integral    [s][mo][mb][t],
		      offset1     [s][mo][mb][t],
		      fitslope1   [s][mo][mb][t],
		      fitslope2   [s][mo][mb][t]);

    offsetPulserTuple->Fill(s,mo,mb,t,
			    chan.getNLayer(),
			    chan.getNCell(),
			    offsets     [s][mo][mb][t],
			    offsetErr   [s][mo][mb][t],
			    integral    [s][mo][mb][t],
			    offsetpulser[s][mo][mb][t][0],
			    offsetpulser[s][mo][mb][t][1],
			    offsetpulser[s][mo][mb][t][2],
			    offsetpulser[s][mo][mb][t][3],
			    offsetpulser[s][mo][mb][t][4]);

}
void HMdcOffset::fillArrays(TH1F *hOffset, Int_t s,Int_t mo,Int_t mb,Int_t t)
{
    if(!isPulserFile)
    {
	hOffset->Fill(crosspointX);
	offsets  [s][mo][mb][t] = crosspointX;
	offsetErr[s][mo][mb][t] = totalsigma;
	offset1  [s][mo][mb][t] = -yequalzero;
    }
    else
    {
	hOffset->Fill(fitGaussMean);
	offsets  [s][mo][mb][t] = -fitGaussMean;
	offsetErr[s][mo][mb][t] =  fitGaussSigma;
	offset1  [s][mo][mb][t] = -yequalzero;
    }
}
void HMdcOffset::fillCalParRaw(TH1F *hOffsetcorr, Int_t s,Int_t mo,Int_t mb,Int_t t)
{
    // fills CalParRaw with offsets, offseterrors and Methods
    // Checks if offset is in valid range arround mean value of offsets.
    // If it is out of range the value is replaced by the mean value.
    // Not connected channels are marked with -7.
    myoffset = offsets  [s][mo][mb][t];
    myerror  = offsetErr[s][mo][mb][t];
    HMdcLookupChan& chan   = (*lookupgeom)[s][mo][mb][t];
    Int_t connected        = 0;
    connected              = chan.getNCell();
    if(!myoffset){ myoffset = 0;}

    if(myoffset >= 0)   // all offsets where no error showed up
    {
	if((myoffset < meanhOffset-validRange) ||
	   (myoffset > meanhOffset+validRange))
	{   // if offset out of alowed range replace it by mean

	    (*calparraw)[s][mo][mb][t].setOffset(meanhOffset);
	    (*calparraw)[s][mo][mb][t].setOffsetMethod(0);
	    (*calparraw)[s][mo][mb][t].setOffsetErr(100);
	    offsets     [s][mo][mb][t] = meanhOffset;

	    hOffsetcorr->Fill(meanhOffset);
	}
	else  // if offsets in allowed range and no error flag
	{
	    hOffsetcorr->Fill(myoffset);
	    (*calparraw)[s][mo][mb][t].setOffset(myoffset);
	    (*calparraw)[s][mo][mb][t].setOffsetMethod(2);
	    if(myerror > 99) // if some nonsense value shows up in Err
	    {
		(*calparraw)[s][mo][mb][t].setOffsetErr(100);
		offsetErr   [s][mo][mb][t] = 100;
	    }
	    else // if Err gives nomal values
	    {
		(*calparraw)[s][mo][mb][t].setOffsetErr(myerror);
	    }
	}
    }
    else
    {  // if offsets contain error flags
	if(connected == -1) // if no wire is connected
	{
	    (*calparraw)[s][mo][mb][t].setOffset(-7);
	    offsets     [s][mo][mb][t] = -7;
	    hOffsetcorr->Fill(-7);
	}
	else // if wire is connected but error showed up
	{
	    (*calparraw)[s][mo][mb][t].setOffset(myoffset);
	    hOffsetcorr->Fill(myoffset);
	}
	(*calparraw)[s][mo][mb][t].setOffsetMethod(2);
	(*calparraw)[s][mo][mb][t].setOffsetErr(100);
	offsetErr   [s][mo][mb][t] = 100;
    }
}

Bool_t HMdcOffset::finalize(void)
{
    // This function is called after the execute function is finished. At this point
    // the arrays for the drift-time are filled. Froms this arrays the histograms for
    // the drift-time and the integrated drift-time are filled. The fits for the calcutation
    // of the offsets are done and the offsets and the sigma of the offsets are
    // calculated .All histograms are written to a rootfile output and the information
    // of the fits to an ascii debugging output. The offset and the sigma of the offset
    // are filled into the container (HMdcCalParRaw) for the calibration parameters.
    // To characterize the method of calculation of the offsets the function setOffsetMethod()
    // of HMdcCalParRaw is used. As default value for the method 2 is used for  automatic
    // calibration. If no calibration is done this value is set to 0.
    cout << "From HMdcOffset::finalize" << endl;

    // Start Stop Watch
    TStopwatch timer;
    timer.Start();

    // open Root file for writing
    htime1temp = new MyHist("time1temp","time1temp", nbin,-nbin+0.5,0.5); //temp time1 hist.

    TFile *file       = NULL;
    offsetTuple       = NULL;
    offsetPulserTuple = NULL;
    ofstream *fout    = NULL;
    ferrorlog         = fopen("offset_error_log.txt","w"); // open file for log of errors/warnings

    if( fNameRootOffset )
    {
	TH1F *hOffset     = 0;
        TH1F *hOffsetcorr = 0;

	file = new TFile(fNameRootOffset,"RECREATE");
	file->cd();

	if(!fillHistsOnly)
	{
	    offsetTuple       = new TNtuple("offset"    ,"offset"    ,"s:m:mb:tdc:lay:cell:slope:slopeErr:off:offErr:integral:off1:fit1slope:fit2slope");
	    offsetPulserTuple = new TNtuple("multipeaks","multipeaks","s:m:mb:tdc:lay:cell:off:offErr:integral:p1:p2:p3:p4:p5");

	    hOffset     = new TH1F("Offset", "Offset", 512, 0, 2048);
	    hOffsetcorr = new TH1F("Offsetcorr", "Offsetcorr", 512, 0, 2048);


	    // open ascii file for writing
	    if (fNameAsciiOffset) { fout = openAsciiFile(); }
	}


	Int_t err   = -3;
	meanhOffset =  0;

	initArrays();

	HDetector *mdcDet = gHades->getSetup()->getDetector("Mdc");
	if (!mdcDet){
	    cout << "Error in HMdcOffset::finalize: Mdc-Detector setup (gHades->getSetup()->getDetector(\"Mdc\")) missing." << endl;
	}
	else
	{

	    for(Int_t s = 0; s < 6; s ++)
	    {  //loop over sectors
		cout<<"Sector "<<s<<endl;
		TDirectory* dirSec = NULL;
		if (file) { dirSec = Mkdir(file, "sector", s); }
		for(Int_t mo = 0; mo < 4; mo ++)
		{  //loop over modules
		    cout<<"Module "<<mo<<endl;
		    if (!mdcDet->getModule(s, mo)) { continue; }
		    TDirectory*   dirMod = NULL;
		    if (dirSec) { dirMod = Mkdir(dirSec, "module", mo); }
		    if( !fillHistsOnly ) { createHist_2D(s,mo); }
		    Int_t nMb = (*calparraw)[s][mo].getSize();
		    for(Int_t mb = 0; mb < nMb; mb ++)
		    {  //loop over layer
			TDirectory* dirMbo = NULL;
			if (dirMod)
			{
			    dirMbo = Mkdir(dirMod, "mbo", mb, 2);
			    dirMbo->mkdir("hinv");
			    dirMbo->mkdir("hint");
			}
			Int_t nTdc = (*calparraw)[s][mo][mb].getSize();
			for(Int_t t = 0; t < nTdc; t ++)
			{  //loop over cells
			    createHist(file, s, mo, mb, t);
			    fillHist  (s, mo, mb, t);
			    
			    if( !fillHistsOnly )
			    {
				if ((err = fitHist(s, mo, mb, t))) { crosspointX = fitpar1 = -err; }
				fillArrays (hOffset,s,mo,mb,t);
				fillHist_2D(s,mo,mb,t);
			    }
			    if (file){ writeHist (file); }
			    if (fNameAsciiOffset && !fillHistsOnly ){ writeAscii(*fout, s, mo, mb, t); }
			    deleteHist();
			}
			if (dirMbo){ dirMbo->TDirectory::Cd(".."); }
			cout << "." << flush;
		    }
		    if( !fillHistsOnly )
		    {
			writeHist_2D(s,mo);
			deleteHist_2D();
		    }
		    cout<<" "<<endl;
		    if (dirMod){ dirMod->TDirectory::Cd(".."); }
		}
		cout<<" "<<endl;
		if (dirSec){ dirSec->TDirectory::Cd(".."); }
	    }
	    cout << endl;
	}

        //----------------------------------------------------
	// calculate offsets per MBO from single
	// offsets . A 2 step filtering of outliers
	// is applied to reduce influence of noisy and low
	// stat channels
	if(perMBOafterSingle && !fillHistsOnly)
	{
            cout<<"Fill per MBO after Single"<<endl;
            Float_t offtemp[96];
	    for(Int_t s = 0; s < 6; s ++){
		for(Int_t mo = 0; mo < 4; mo ++){
		    for(Int_t mb = 0; mb < 16; mb ++){

			Int_t count = 0;
			memset(offtemp,0,sizeof(Float_t) * 96);

			//----------------------------------------------------
                        // calculate first mean offset of mbo
			for(Int_t t = 0; t < 96; t ++){
			    Float_t off = offsets[s][mo][mb][t];
			    if(off > 0){ // filter invalid offsets
                                offtemp[count] = off;
				count++;
			    }
			}

			Float_t mean      = TMath::Mean(count,offtemp);
			//----------------------------------------------------

			//----------------------------------------------------
			// now filter in large in arround mean to throw out
                        // outliers. Caclulate truncated mean (10% highest/lowest cut)
			memset(offtemp,0,sizeof(Float_t) * 96);
                        count = 0;
			for(Int_t t = 0; t < 96; t ++){
			    Float_t off = offsets[s][mo][mb][t];
			    if(off > 0 && fabs(off - mean) < filterwindow1){ // filter invalid offsets arround mean
				offtemp[count] = off;
				count++;
			    }
			}
			if(count > 0){
			    mean = HTool::truncatedMean(count,offtemp,0.1);
			}
			//----------------------------------------------------

			//----------------------------------------------------
			// now filter arround narrow window arround
                        // improved mean and calulate final mean
			memset(offtemp,0,sizeof(Float_t) * 96);
                        count = 0;
			for(Int_t t = 0; t < 96; t ++){
			    Float_t off = offsets[s][mo][mb][t];
			    if(off > 0 && fabs(off - mean) < filterwindow2){ // filter invalid offsets arround trunc mean
				offtemp[count] = off;
				count++;
			    }
			}

                        mean = TMath::Mean(count,offtemp);
			for(Int_t t = 0; t < 96; t ++){
                            Float_t off = offsets[s][mo][mb][t];
			    if(off > 0) { offsets[s][mo][mb][t] = mean; }   // keep negative or 0
			}
			//----------------------------------------------------
		    }
		}
	    }



	    for(Int_t s = 0; s < 6; s ++)
	    {  //loop over sectors

		cout<<"Sector "<<s<<endl;
		for(Int_t mo = 0; mo < 4; mo ++)
		{  //loop over modules
		    if (!mdcDet->getModule(s, mo)) { continue; }
		    file->cd();
		    file->TDirectory::Cd(Form("sector %i/module %i",s,mo));
		    cout<<"Module "<<mo<<endl;

		    createHist_2D(s,mo,kTRUE);

		    Int_t nMb = (*calparraw)[s][mo].getSize();
		    for(Int_t mb = 0; mb < nMb; mb ++)
		    {  //loop over layer

			Int_t nTdc = (*calparraw)[s][mo][mb].getSize();

			file->cd();
			file->cd(Form("sector %i/module %i/mbo %02i",s,mo,mb));

			for(Int_t t = 0; t < nTdc; t ++)
			{  //loop over cells
			    createHist(file, s, mo, mb, t, kTRUE);
			    fillHist_2D(s,mo,mb,t);
			    deleteHist();
			}
			cout << "." << flush;
		    }
		    file->cd();
		    file->TDirectory::Cd(Form("sector %i/module %i",s,mo));
		    writeHist_2D(s,mo);
		    deleteHist_2D();
		    cout<<" "<<endl;
		}
		cout<<" "<<endl;
	    }
	    cout << endl;
	    file->cd();
	}

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

	if( !fillHistsOnly )
	{
	    // write offsets to calparraw
	    myoffset    = 0;
	    myerror     = 0;
	    meanhOffset = (Float_t)((Int_t)(hOffset->GetMean()));

	    for(Int_t s = 0; s < 6; s ++)
	    {  //loop over sectors
		for(Int_t mo = 0; mo < 4; mo ++)
		{  //loop over modules
		    if (!mdcDet->getModule(s, mo)){ continue; }
		    Int_t nMb = (*calparraw)[s][mo].getSize();
		    for(Int_t mb = 0; mb < nMb; mb++)
		    {  //loop over layer
			Int_t nTdc = (*calparraw)[s][mo][mb].getSize();
			for(Int_t t = 0; t < nTdc; t ++)
			{  //loop over cells
			    fillCalParRaw(hOffsetcorr,s,mo,mb,t);
			    fillNTuples(s,mo,mb,t);
			}
		    }
		}
	    }


	    hOffset          ->Write();
	    hOffsetcorr      ->Write();
	    offsetTuple      ->Write();
	    offsetPulserTuple->Write();

	    delete hOffset;
	    delete hOffsetcorr;



	    //------------------------------------------------------------------
	    // Fill some control hists for mean/rms per mbo, good channels per mbo
            // and rms of deviation from truncated mean per mbo
	    const Char_t* mdcs[4]      = {"MDCI","MDCII","MDCIII","MDCIV"};


	    TCanvas* result2 = new TCanvas("mean_values"         ,"mean values"        ,1000,800);
	    TCanvas* result3 = new TCanvas("rms_offsets"         ,"rms offsets"        ,1000,800);
	    TCanvas* result4 = new TCanvas("good_channels"       ,"good channels"      ,1000,800);
	    TCanvas* result5 = new TCanvas("deviation_offsets"   ,"deviation_offsets"  ,1000,800);


	    TH2F* hmean     = new TH2F("hmean"      ,"mean offset per MB"         ,24,0,24,16  ,0,16);
	    TH2F* hrms      = new TH2F("hrms"       ,"rms offset per MB"          ,24,0,24,16  ,0,16);
	    TH2F* hcts      = new TH2F("hcts"       ,"good channels per MB"       ,24,0,24,16  ,0,16);
	    TH2F* hdev      = new TH2F("hdev"       ,"deviation from mean per MB" ,24,0,24,16  ,0,16);

	    for(Int_t s = 0; s < 6; s++){
		for(Int_t m = 0; m < 4; m++){
		    hmean      ->GetXaxis()->SetBinLabel(m*6+s+1,Form("%s%i",mdcs[m],s));
		    hrms       ->GetXaxis()->SetBinLabel(m*6+s+1,Form("%s%i",mdcs[m],s));
		    hcts       ->GetXaxis()->SetBinLabel(m*6+s+1,Form("%s%i",mdcs[m],s));
		    hdev       ->GetXaxis()->SetBinLabel(m*6+s+1,Form("%s%i",mdcs[m],s));
		}
	    }
	    hmean      ->GetXaxis()->LabelsOption("v");
	    hrms       ->GetXaxis()->LabelsOption("v");
	    hcts       ->GetXaxis()->LabelsOption("v");
	    hdev       ->GetXaxis()->LabelsOption("v");

	    hmean      ->SetYTitle("mbo number");
	    hrms       ->SetYTitle("mbo number");
	    hcts       ->SetYTitle("mbo number");
	    hdev       ->SetYTitle("mbo number");

	    // temporary working histograms
	    TH1F* htmprms = new TH1F("htmprms","htmprms",2000,    0,2000);
	    TH1F* htmpdev = new TH1F("htmpdev","htmpdev",4000,-2000,2000);

	    Float_t offsetMB[96];
	    Float_t offsetWindow = 5.;  // window arround truncated mean for second iteration
	    Float_t trunc        = 0.1; // fraction of lowest/highest values to truncate for the mean calulation


	    for(Int_t s = 0; s < 6; s++){
		for(Int_t m = 0; m < 4; m++){
		    for(Int_t mb = 0; mb < 16; mb++){

			Int_t    ctall         = 0;
			Int_t    ctsuppressed  = 0;
			Float_t  sum           = 0;
			Float_t  off           = 0;
			Float_t  mean          = 0;
			Double_t truncMean     = 0;
			htmprms->Reset();
			htmpdev->Reset();

			memset(&offsetMB[0],0,96 * sizeof(Float_t)); // reset array to 0

			//-------------------------------------------------
			// fill temporary array of offset values
			// to calulate the truncated mean of offset per MB
			for(Int_t t = 0; t < 96; t++){
			    off = offsets[s][m][mb][t];

			    if(off <= 0) { continue; }

			    htmprms->Fill(off);
			    offsetMB[t] = off;
			    ctall ++;
			}

			HTool::sort(96,offsetMB,0,kTRUE,kTRUE);  // sort the array descending , overwrite
			truncMean = HTool::truncatedMean(ctall,offsetMB, trunc, kTRUE, kFALSE); // 10% , descending, do not overwrite

			//-------------------------------------------------
			// filter arround the truncated mean and
			// calculate the improved mean
			for(Int_t t = 0; t < 96; t++){
			    off = offsets[s][m][mb][t];
			    if(off <= 0) { continue; }
			    if(fabs(off - truncMean) > offsetWindow) { continue; }

			    sum += off;
			    ctsuppressed ++;
			}

			if(ctsuppressed != 0){
			    // second iteration of mean
			    mean = sum / ctsuppressed;
			} else { mean = truncMean; }
			//-------------------------------------------------

			//-------------------------------------------------
			// calulate the deviation of each channel
			// from the mean of the MB .
			for(Int_t t = 0; t < 96; t++){
			    off = offsets[s][m][mb][t];
			    if(off <= 0) { continue; }
			    htmpdev->Fill(off - mean);
			}
			//-------------------------------------------------


			//-------------------------------------------------
			// fill results
			if(ctsuppressed != 0){
			    hdev ->Fill(m * 6 + s,mb,htmpdev->GetRMS());
			    hmean->Fill(m * 6 + s,mb,mean);
			    hrms ->Fill(m * 6 + s,mb,htmprms->GetRMS());
			    hcts ->Fill(m * 6 + s,mb,ctall);
			}
			//-------------------------------------------------

		    }
		}
	    }


	    //-------------------------------------------------
	    // draw results

	    result2->cd();
	    HTool::roundHist(hmean,0);
	    hmean->DrawCopy("colz text");

	    result3->cd();
	    HTool::roundHist(hrms,1);
	    hrms->DrawCopy("colz text");

	    result4->cd();
	    hcts->DrawCopy("colz text");

	    result5->cd();
	    HTool::roundHist(hdev,1);
	    hdev->DrawCopy("colz text");

	    delete htmprms ;
	    delete htmpdev ;

	    file->cd();

            result2->Write();
            result3->Write();
            result4->Write();
            result5->Write();
	    //------------------------------------------------------------------

	}

	// stop watch
	cout << "Time of cell loop (offset calculation time):" << endl;
	timer.Print();
	timer.Stop();

	// close root file
	file->Save();
	file->Close();
	delete file;

	if (fNameAsciiOffset && !fillHistsOnly )
	{ // close ascii file
	    fout->close();
	    delete fout;
	}
	else
	{
	    cout<<"WARNING: NO ASCII OUTPUT SET, NO FILE WRITTEN TO DISK!"<<endl;
            fprintf(ferrorlog,"%s\n","WARNING: NO ASCII OUTPUT SET, NO FILE WRITTEN TO DISK!");
	}
    }
    else
    {
	cout<<"WARNING: NO ROOT OUTPUT SET, NO FILE WRITTEN TO DISK!"<<endl;
        fprintf(ferrorlog,"%s\n","WARNING: NO ROOT OUTPUT SET, NO FILE WRITTEN TO DISK!");
    }
    
    fclose(ferrorlog);
    return kTRUE;
}

TDirectory *HMdcOffset::Mkdir(TDirectory *dirOld,const Char_t *c, Int_t i, Int_t p)    //! Makes new Dir, changes to Dir, returns pointer to new Dir
{
    // Function to create subdirectories
    static Char_t sDir[255];// = new Char_t[strlen(c)+3];
    static Char_t sFmt[10];
    sprintf(sFmt, "%%s %%0%1ii", p);
    sprintf(sDir, sFmt, c, i);
    TDirectory *dirNew = dirOld->mkdir(sDir);
    dirOld->cd(sDir);
    //  free (sDir);
    return dirNew;
}

Float_t HMdcOffset::getstarttime(){
    // Need some work for multiple hists in start detector
    // Better select multiplicity 1 in start.
    static Int_t ntimes0         = 0;
    static Int_t ntimesGreater1  = 0;

    Int_t i             =  0;
    Int_t startmod      = -1;
    HStart2Hit* starthit =  0;
    Float_t starttime   =  0;
    iter_start->Reset();
    while ((starthit = (HStart2Hit *)iter_start->Next()) != 0) {
	startmod = starthit->getModule();
	if(startmod == 0)
	{
	    i ++;
	    if(starthit->getFlag()){ starttime = -starthit->getTime(); }  // changed
	}
    }

    if(i==0) ntimes0++;
    if(i>1 ) ntimesGreater1++;

    //if(i != 1){ Error("getstarttime(int)","Multiplicity in Start > 1 or 0"); }

    if(gHades->getEventCounter()%1000==0){
	Info("getstarttime()","Start time summary for 1000 events : %i == 0, %i > 1 hit multiplicity",ntimes0,ntimesGreater1);
    }
    if(TMath::Finite(starttime) == 0){ starttime = 0; }
    if(TMath::Abs(starttime) > 100)  { starttime = 0; }

    return starttime;
}

Int_t HMdcOffset::execute()
{
    Int_t result = 0;
    if(readHists)     { return 0; } // nothing to fill
    if(useClusters)   { result = executeClus(); }
    else              { result = executeRaw();  }
    return result;
}
Int_t HMdcOffset::executeClus()
{
    // Fired cells are take from the list of Cells inside one HMdcClus.
    // Raw data of Time1  multiplied by the slope of the channel taken from the
    // container of the calibration parameters are filled into the array for the
    // drift-time . This array contains 2048 (corresponding to the resulution of
    // the tdc chip) entries for each tdc channel.
    static HMdcRaw *raw   = NULL;
    static HMdcClus *clus = NULL;

    Float_t testTime1     = 0;
    Float_t testTime2     = 0;

    Double_t wireoff      = 0.;
    Float_t starttime     = 0;

    Double_t xp1,yp1,zp1,xp2,yp2,zp2,signalpath;
    Int_t s, mo, mb, t;
    Int_t l,c;

    iter_clus->Reset();
    if(skipcounter > nSkipEvents)
    {
	if(!noStart) // Start Time is used
	{
	    starttime = getstarttime();
	}
	while ((clus = (HMdcClus*)iter_clus->Next()))
	{
	    s = mo = mb = t = -99;
	    l = c = -99;
	    xp1 = clus->getX();
	    yp1 = clus->getY();
	    zp1 = clus->getZ();
	    xp2 = clus->getXTarg();
	    yp2 = clus->getYTarg();
	    zp2 = clus->getZTarg();

	    s           = clus->getSec();
	    locraw[0]   = s;

	    Int_t ioseg = clus->getIOSeg();
	    //Int_t mod  = clus->getMod();


	    for(Int_t lay = 0; lay < 12; lay ++)
	    {  // loop over layers
		//---------------finding module-----------
		//if(mod < 0)
		//{ 	// combined clusters
		    if(ioseg == 0){
			(lay < 6)? locraw[1] = 0 : locraw[1] = 1;
		    } else if(ioseg == 1){
			(lay < 6)? locraw[1] = 2 : locraw[1] = 3;
		    }
		//}
		//else
		//{  // chamber clusters
		  //  locraw[1] = mod;
		//}
		mo = locraw[1];
		//---------------finding layer------------
		(lay < 6)? l = lay : l = lay - 6;
		//----------------------------------------

		Int_t nCells = clus->getNCells(lay);
		for(Int_t cell = 0; cell < nCells; cell ++)
		{  // loop over cells in layer
		    c = clus->getCell(lay,cell);

		    HMdcLookupCell& mycell = (*lookupraw)[s][mo][l][c];
		    mb        = mycell.getNMoth();
		    t         = mycell.getNChan();
		    locraw[2] = mb;
		    locraw[3] = t;

		    raw       = (HMdcRaw*)rawCat->getObject(locraw);
		    if(raw)
		    {
			if(useWireOffset)
			{
			    signalpath = (*sizescells)[s][mo][l].getSignPath(xp1,yp1,zp1,xp2,yp2,zp2,c);
			    if(signalpath > 0) { wireoff = signalpath*signalspeed; }
			    else               { wireoff = 0.; }
			}

			Float_t slope = ((*calparraw)[s][mo][mb][t].getSlope()) ;
			Float_t t1    = raw->getTime(1);
			Float_t t2    = raw->getTime(2);
			Int_t bin     =  (Int_t)(2048 - (t1 * slope + starttime - wireoff));

			if( slope != 0) {
			    testTime1 = t1 - (starttime/slope);
			    testTime2 = t2 - (starttime/slope);
			} else {
			    testTime1 = t1;
			    testTime2 = t2;
			}

			if(useTimeCuts)  // if Time Cuts and Start Time
			{
			    if(testTimeCuts(s,mo,testTime1,testTime2))
			    {
				// we have to use Float_ts here

				if(!perMBO) {
				    (*hreverse)[s][mo][mb][t][bin] ++;
				} else {
				    for(Int_t ti = 0; ti < 96; ti ++){
					(*hreverse)[s][mo][mb][ti][bin] ++;
				    }
				}
			    }
			} else {   // No Time Cuts and Start Time
			    if(!perMBO) {
				(*hreverse)[s][mo][mb][t][bin] ++;
			    } else {
				for(Int_t ti = 0; ti < 96; ti ++){
				    (*hreverse)[s][mo][mb][ti][bin] ++;
				}
			    }
			}
		    } else { Error("executeClus()","Error: NULL pointer for HMdcRaw retrieved!!"); }
		}
	    }
	}
	if(eventcounter % nStep == 0){ cout<<eventcounter<<" events analyzed"<<endl; }
    }
    skipcounter  ++;
    eventcounter ++;
    return 0;
}
Int_t HMdcOffset::executeRaw()
{
    // Raw data of Time1  multiplied by the slope of the channel taken from the
    // container of the calibration parameters are filled into the array for the
    // drift-time . This array contains 2048 (corresponding to the resulution of
    // the tdc chip) entries for each tdc channel.
    static HMdcRaw *raw = NULL;
    Float_t testTime1   = 0;
    Float_t testTime2   = 0;
    Float_t starttime   = 0.;

    Int_t s, mo, mb, t;

    iter->Reset();
    if(skipcounter > nSkipEvents)
    {
	if(!noStart) // Start Time is used
	{
	    starttime = getstarttime();
	}
	while ((raw = (HMdcRaw*)iter->Next()))
	{
	    s = mo = mb = t = -99;
	    raw->getAddress(s, mo, mb, t);

	    Float_t slope = ((*calparraw)[s][mo][mb][t].getSlope()) ;
	    Float_t t1    = raw->getTime(1);
	    Float_t t2    = raw->getTime(2);
	    Int_t bin     =  (Int_t)(2048 - (t1 * slope + starttime));

	    if(slope != 0) {
		testTime1 = t1-(starttime/slope);
		testTime2 = t2-(starttime/slope);
	    } else {
		testTime1 = t1;
		testTime2 = t2;
	    }

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