ROOT logo
// $Id$

//**************************************************************************
//* This file is property of and copyright by the ALICE HLT Project        * 
//* ALICE Experiment at CERN, All rights reserved.                         *
//*                                                                        *
//* Primary Authors: Matthias Richter <Matthias.Richter@ift.uib.no>        *
//*                  Timm Steinbeck <timm@kip.uni-heidelberg.de>           *
//*                  for The ALICE HLT Project.                            *
//*                                                                        *
//* Permission to use, copy, modify and distribute this software and its   *
//* documentation strictly for non-commercial purposes is hereby granted   *
//* without fee, provided that the above copyright notice appears in all   *
//* copies and that both the copyright notice and this permission notice   *
//* appear in the supporting documentation. The authors make no claims     *
//* about the suitability of this software for any purpose. It is          *
//* provided "as is" without express or implied warranty.                  *
//**************************************************************************

//  @file   AliHLTComponent.cxx
//  @author Matthias Richter, Timm Steinbeck
//  @date   
//  @brief  Base class implementation for HLT components. */
//  @note   The class is both used in Online (PubSub) and Offline (AliRoot)
//          context


//#include "AliHLTStdIncludes.h"
#include "AliHLTComponent.h"
#include "AliHLTComponentHandler.h"
#include "AliHLTMessage.h"
#include "AliHLTCTPData.h"
#include "AliHLTErrorGuard.h"
#include "AliHLTCDHWrapper.h"
#include "TString.h"
#include "TMath.h"
#include "TObjArray.h"
#include "TObjectTable.h"
#include "TClass.h"
#include "TStopwatch.h"
#include "TFormula.h"
#include "TUUID.h"
#include "TMD5.h"
#include "TRandom3.h"
#include "AliHLTMemoryFile.h"
#include "AliHLTMisc.h"
#include <cassert>
#include <ctime>
#include <stdint.h>

/**
 * default compression level for ROOT objects
 */
#define ALIHLTCOMPONENT_DEFAULT_OBJECT_COMPRESSION 5
#define ALIHLTCOMPONENT_STATTIME_SCALER 1000000

/** ROOT macro for the implementation of ROOT specific class methods */
ClassImp(AliHLTComponent);

/** stopwatch macro using the stopwatch guard */
#define ALIHLTCOMPONENT_STOPWATCH(type) AliHLTStopwatchGuard swguard(fpStopwatches!=NULL?reinterpret_cast<TStopwatch*>(fpStopwatches->At((int)type)):NULL)
//#define ALIHLTCOMPONENT_STOPWATCH(type) 

/** stopwatch macro for operations of the base class */
#define ALIHLTCOMPONENT_BASE_STOPWATCH() ALIHLTCOMPONENT_STOPWATCH(kSWBase)
/** stopwatch macro for operations of the detector algorithm (DA) */
#define ALIHLTCOMPONENT_DA_STOPWATCH() ALIHLTCOMPONENT_STOPWATCH(kSWDA)

AliHLTComponent::AliHLTComponent()
  :
  fEnvironment(),
  fCurrentEvent(0),
  fEventCount(-1),
  fFailedEvents(0),
  fCurrentEventData(),
  fpInputBlocks(NULL),
  fCurrentInputBlock(-1),
  fSearchDataType(kAliHLTVoidDataType),
  fClassName(),
  fpInputObjects(NULL),
  fpOutputBuffer(NULL),
  fOutputBufferSize(0),
  fOutputBufferFilled(0),
  fOutputBlocks(),
  fpStopwatches(new TObjArray(kSWTypeCount)),
  fMemFiles(),
  fpRunDesc(NULL),
  fCDBSetRunNoFunc(NULL),
  fChainId(),
  fChainIdCrc(0),
  fpBenchmark(NULL),
  fFlags(0),
  fEventType(gkAliEventTypeUnknown),
  fComponentArgs(),
  fEventDoneData(NULL),
  fEventDoneDataSize(0),
  fCompressionLevel(ALIHLTCOMPONENT_DEFAULT_OBJECT_COMPRESSION)
  , fLastObjectSize(0)
  , fpCTPData(NULL)
  , fPushbackPeriod(0)
  , fLastPushBackTime(-1),
  fEventModulo(-1)
{
  // see header file for class documentation
  // or
  // refer to README to build package
  // or
  // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
  memset(&fEnvironment, 0, sizeof(AliHLTAnalysisEnvironment));
  if (fgpComponentHandler)
    fgpComponentHandler->ScheduleRegister(this);
  //SetLocalLoggingLevel(kHLTLogDefault);
}

AliHLTComponent::~AliHLTComponent()
{
  // see header file for function documentation
  if (fpBenchmark) delete fpBenchmark;
  fpBenchmark=NULL;

  CleanupInputObjects();
  if (fpStopwatches!=NULL) delete fpStopwatches;
  fpStopwatches=NULL;
  AliHLTMemoryFilePList::iterator element=fMemFiles.begin();
  while (element!=fMemFiles.end()) {
    if (*element) {
      if ((*element)->IsClosed()==0) {
	HLTWarning("memory file has not been closed, possible data loss or incomplete buffer");
	// close but do not flush as we dont know whether the buffer is still valid
	(*element)->CloseMemoryFile(0);
      }
      delete *element;
      *element=NULL;
    }
    element++;
  }
  if (fpRunDesc) {
    delete fpRunDesc;
    fpRunDesc=NULL;
  }
  if (fEventDoneData)
    delete [] reinterpret_cast<AliHLTUInt8_t*>( fEventDoneData );
  fEventDoneData=NULL;

  if (fpCTPData) {
    delete fpCTPData;
  }
  fpCTPData=NULL;
}

AliHLTComponentHandler* AliHLTComponent::fgpComponentHandler=NULL;

int AliHLTComponent::SetGlobalComponentHandler(AliHLTComponentHandler* pCH, int bOverwrite) 
{
  // see header file for function documentation
  int iResult=0;
  if (fgpComponentHandler==NULL || bOverwrite!=0)
    fgpComponentHandler=pCH;
  else
    iResult=-EPERM;
  return iResult;
}

int AliHLTComponent::UnsetGlobalComponentHandler() 
{
  // see header file for function documentation
  return SetGlobalComponentHandler(NULL,1);
}

int AliHLTComponent::SetComponentEnvironment(const AliHLTAnalysisEnvironment* comenv, void* environParam)
{
  // see header file for function documentation
  HLTLogKeyword(fChainId.c_str());
  int iResult=0;
  if (comenv) {
    memset(&fEnvironment, 0, sizeof(AliHLTAnalysisEnvironment));
    memcpy(&fEnvironment, comenv, comenv->fStructSize<sizeof(AliHLTAnalysisEnvironment)?comenv->fStructSize:sizeof(AliHLTAnalysisEnvironment));
    fEnvironment.fStructSize=sizeof(AliHLTAnalysisEnvironment);
    fEnvironment.fParam=environParam;
  }
  return iResult;
}

int AliHLTComponent::Init(const AliHLTAnalysisEnvironment* comenv, void* environParam, int argc, const char** argv )
{
  // see header file for function documentation
  HLTLogKeyword(fChainId.c_str());
  int iResult=0;
  if (comenv) {
    SetComponentEnvironment(comenv, environParam);
  }
  fPushbackPeriod=0;
  fLastPushBackTime=-1;

  fComponentArgs="";
  const char** pArguments=NULL;
  int iNofChildArgs=0;
  TString argument="";
  int bMissingParam=0;
  if (argc>0) {
    pArguments=new const char*[argc];
    if (pArguments) {
      for (int i=0; i<argc && iResult>=0; i++) {
	if (fComponentArgs.size()>0) fComponentArgs+=" ";
	fComponentArgs+=argv[i];
	argument=argv[i];
	if (argument.IsNull()) continue;

	// benchmark
	if (argument.CompareTo("-benchmark")==0) {

	  // -loglevel=
	} else if (argument.BeginsWith("-loglevel=")) {
	  TString parameter=argument.ReplaceAll("-loglevel=", "");
	  parameter.Remove(TString::kLeading, ' '); // remove all blanks
	  if (parameter.BeginsWith("0x") &&
	      parameter.Replace(0,2,"",0).IsHex()) {
	    unsigned int loglevel=kHLTLogNone;
	    sscanf(parameter.Data(),"%x", &loglevel);
	    SetLocalLoggingLevel((AliHLTComponentLogSeverity)loglevel);
	  } else {
	    HLTError("wrong parameter for argument %s, hex number expected", argument.Data());
	    iResult=-EINVAL;
	  }
	  // -object-compression=
	} else if (argument.BeginsWith("-object-compression=")) {
	  argument.ReplaceAll("-object-compression=", "");
	  if (argument.IsDigit()) {
	    fCompressionLevel=argument.Atoi();
	    if (fCompressionLevel<0 || fCompressionLevel>9) {
	      HLTWarning("invalid compression level %d, setting to default %d", fCompressionLevel, ALIHLTCOMPONENT_DEFAULT_OBJECT_COMPRESSION);
	      fCompressionLevel=ALIHLTCOMPONENT_DEFAULT_OBJECT_COMPRESSION;
	    }
	  } else {
	    HLTError("wrong parameter for argument -object-compression, number expected");
	  }
	  // -pushback-period=
	} else if (argument.BeginsWith("-pushback-period=")) {
	  argument.ReplaceAll("-pushback-period=", "");
	  if (argument.IsDigit()) {
	    fPushbackPeriod=argument.Atoi();
	  } else {
	    HLTError("wrong parameter for argument -pushback-period, number expected");
	  }
	  // -event-modulo
	} else if (argument.BeginsWith("-event-modulo=")) {
	  argument.ReplaceAll("-event-modulo=", "");
	  if (argument.IsDigit()) {
	    fEventModulo=argument.Atoi();
	    if (fEventModulo < 1)
	    {
	      fEventModulo = -1;
	      HLTError("number passed in -event-modulo must be a positive integer greater or equal to 1.");
	    }
	  } else {
	    HLTError("wrong parameter for argument -event-modulo, integer number expected");
	  }
	  // -disable-component-stat
	} else if (argument.CompareTo("-disable-component-stat")==0) {
	  fFlags|=kDisableComponentStat;
	} else {
	  pArguments[iNofChildArgs++]=argv[i];
	}
      }
    } else {
      iResult=-ENOMEM;
    }
  }
  if (bMissingParam) {
    HLTError("missing parameter for argument %s", argument.Data());
    iResult=-EINVAL;
  }
  if (iResult>=0) {
    iResult=CheckOCDBEntries();
  }
  if (iResult>=0) {
    iResult=DoInit(iNofChildArgs, pArguments);
  }
  if (iResult>=0) {
    fEventCount=0;

    // find out if the component wants to get the steering events
    // explicitly
    AliHLTComponentDataTypeList inputDt;
    GetInputDataTypes(inputDt);
    bool bRequireSteeringBlocks=false;
    for (AliHLTComponentDataTypeList::iterator dt=inputDt.begin();
	 dt!=inputDt.end() && !bRequireSteeringBlocks;
	 dt++) {
      bRequireSteeringBlocks|=MatchExactly(*dt,kAliHLTDataTypeSOR);
      bRequireSteeringBlocks|=MatchExactly(*dt,kAliHLTDataTypeRunType);
      bRequireSteeringBlocks|=MatchExactly(*dt,kAliHLTDataTypeEOR);
      bRequireSteeringBlocks|=MatchExactly(*dt,kAliHLTDataTypeDDL);
      bRequireSteeringBlocks|=MatchExactly(*dt,kAliHLTDataTypeComponentStatistics);
    }
    if (bRequireSteeringBlocks) fFlags|=kRequireSteeringBlocks;
  }
  if (pArguments) delete [] pArguments;

#if defined(HLT_COMPONENT_STATISTICS)
  // benchmarking stopwatch for the component statistics
  fpBenchmark=new TStopwatch;
#endif // HLT_COMPONENT_STATISTICS

  return iResult;
}

int AliHLTComponent::Deinit()
{
  // see header file for function documentation
  HLTLogKeyword(fChainId.c_str());
  int iResult=0;
  iResult=DoDeinit();
  if (fpRunDesc) {
    // TODO: the warning should be kept, but the condition is wrong since the
    // AliHLTRunDesc is set before the SOR event in the SetRunDescription
    // method. A couple of state flags should be defined but that is a bit more
    // work to do. For the moment disable the warning (2009-07-01)
    // 2009-09-08: now, the info is not cleared in the ProcessEvent, because it
    // might be needed by components during the event processing.
    //HLTWarning("did not receive EOR for run %d", fpRunDesc->fRunNo);
    AliHLTRunDesc* pRunDesc=fpRunDesc;
    fpRunDesc=NULL;
    delete pRunDesc;
  }
  if (fpCTPData) {
    delete fpCTPData;
  }
  fpCTPData=NULL;

  fEventCount=0;
  fFlags=0;
  return iResult;
}

int AliHLTComponent::InitCDB(const char* cdbPath, AliHLTComponentHandler* pHandler)
{
  // see header file for function documentation
  int iResult=0;
  HLTInfo("Using CDB: %s", cdbPath);
  if (pHandler) {
  // I have to think about separating the library handling from the
  // component handler. Requiring the component handler here is not
  // the cleanest solution.
  // We presume the library already to be loaded, which is the case
  // because it is loaded in the initialization of the logging functionality
  //
  // find the symbol
  AliHLTMiscInitCDB_t pFunc=(AliHLTMiscInitCDB_t)pHandler->FindSymbol(ALIHLTMISC_LIBRARY, ALIHLTMISC_INIT_CDB);
  if (pFunc) {
    TString path;
    if (cdbPath && cdbPath[0]!=0) {
      path=cdbPath;
      // very temporary fix, have to check for other formats
      if (!path.BeginsWith("local://")) {
	path="local://";
	path+=cdbPath;
      }
    }
    if ((iResult=(*pFunc)(path.Data()))>=0) {
      if (!(fCDBSetRunNoFunc=pHandler->FindSymbol(ALIHLTMISC_LIBRARY, ALIHLTMISC_SET_CDB_RUNNO))) {
	Message(NULL, kHLTLogWarning, "AliHLTComponent::InitCDB", "init CDB",
		"can not find function to set CDB run no");
      }
    }
  } else {
    Message(NULL, kHLTLogError, "AliHLTComponent::InitCDB", "init CDB",
	    "can not find initialization function");
    iResult=-ENOSYS;
  }
  } else {
    iResult=-EINVAL;
  }
  return iResult;
}

int AliHLTComponent::SetCDBRunNo(int runNo)
{
  // see header file for function documentation
  if (!fCDBSetRunNoFunc) return 0;
  return (*((AliHLTMiscSetCDBRunNo_t)fCDBSetRunNoFunc))(runNo);
}

int AliHLTComponent::SetRunDescription(const AliHLTRunDesc* desc, const char* /*runType*/)
{
  // see header file for function documentation
  if (!desc) return -EINVAL;
  if (desc->fStructSize!=sizeof(AliHLTRunDesc)) {
    HLTError("invalid size of RunDesc struct (%ul)", desc->fStructSize);
    return -EINVAL;
  }

  if (!fpRunDesc) {
    fpRunDesc=new AliHLTRunDesc;
    if (!fpRunDesc) return -ENOMEM;
    *fpRunDesc=kAliHLTVoidRunDesc;
  }

  if (fpRunDesc->fRunNo!=kAliHLTVoidRunNo && fpRunDesc->fRunNo!=desc->fRunNo) {
    HLTWarning("Run description has already been set");
  }
  *fpRunDesc=*desc;
  SetCDBRunNo(fpRunDesc->fRunNo);
  // TODO: we have to decide about the runType
  return 0;
}

int AliHLTComponent::SetComponentDescription(const char* desc)
{
  // see header file for function documentation
  int iResult=0;
  if (!desc) return 0;

  TString descriptor=desc;
  TObjArray* pTokens=descriptor.Tokenize(" ");
  if (pTokens) {
    for (int i=0; i<pTokens->GetEntriesFast() && iResult>=0; i++) {
      TString argument=pTokens->At(i++)->GetName();
      if (!argument || argument.IsNull()) continue;

      // chainid
      if (argument.BeginsWith("chainid")) {
	argument.ReplaceAll("chainid", "");
	if (argument.BeginsWith("=")) {
	  fChainId=argument.Replace(0,1,"");
	  fChainIdCrc=CalculateChecksum((const AliHLTUInt8_t*)fChainId.c_str(), fChainId.length());
	  HLTDebug("setting component description: chain id %s crc 0x%8x", fChainId.c_str(), fChainIdCrc);
	} else {
	  fChainId="";
	}
      } else {
	HLTWarning("unknown component description %s", argument.Data());
      }
    }
    delete pTokens;
  }
  
  return iResult;
}

int AliHLTComponent::ConfigureFromArgumentString(int argc, const char** argv)
{
  // Configure from an array of argument strings
  // Function supports individual arguments in the argv array and arguments
  // separated by blanks.
  //
  // Each argv entry can contain blanks, quotes and newlines. Newlines are interpreted
  // as blanks. Enclosing quotes deactivate blank as delimiter.
  // The separated arguments are stored in an array of strings, and the pointers to
  // those strings in an array of pointers. The latter is used in the custom argument
  // scan of the component.

  int iResult=0;
  vector<string> stringarray;   // array of argument copies
  // array of pointers to the argument copies
  // note: not necessarily in sync with the entries in stringarray
  // can contain any pointer to valid arguments in arbitrary sequence
  vector<const char*> ptrarray;

  TString argument="";
  int i=0;
  for (i=0; i<argc && iResult>=0; i++) {
    argument=argv[i];
    if (argument.IsWhitespace()) continue;

    // special handling for single component arguments ending with
    // a sequence of blanks. All characters until the first occurence
    // of a blank are removed. If the remainder contains only whitespaces
    // the argument is a single argument, just having whitespaces at the end.
    argument.Remove(0, argument.First(' '));
    if (argument.IsWhitespace()) {
      stringarray.push_back(argv[i]);
      continue;
    }

    // outer loop checks for enclosing quotes
    // extra blank to insert blank token before leading quotes, then
    // quoted arguments are always the even ones
    argument=" ";
    argument+=argv[i];
    // insert blank in consecutive quotes to correctly tokenize
    argument.ReplaceAll("''", "' '");
    // replace newlines by blanks
    argument.ReplaceAll("\n", " ");
    if (argument.IsNull()) continue;
    TObjArray* pTokensQuote=argument.Tokenize("'");
    if (pTokensQuote) {
      if (pTokensQuote->GetEntriesFast()>0) {
	for (int k=0; k<pTokensQuote->GetEntriesFast(); k++) {
	  argument=pTokensQuote->At(k)->GetName();
	  if (argument.IsWhitespace()) continue;
	  if (k%2) {
	    // every second entry is enclosed by quotes and thus
	    // one single argument
	    stringarray.push_back(argument.Data());
	  } else {
    TObjArray* pTokens=argument.Tokenize(" ");
    if (pTokens) {
      if (pTokens->GetEntriesFast()>0) {
	for (int n=0; n<pTokens->GetEntriesFast(); n++) {
	  TString data=pTokens->At(n)->GetName();
	  if (!data.IsNull() && !data.IsWhitespace()) {
	    stringarray.push_back(data.Data());
	  }
	}
      }
      delete pTokens;
    }
	  }
	}
      }
      delete pTokensQuote;
    }
  }

  // fill ptrarray; should be safe at this point
  // since stringarray isn't modified any further
  unsigned int idx;
  for(idx=0; idx<stringarray.size(); ++idx) {
    ptrarray.push_back(stringarray.at(idx).c_str());
  }

  for (i=0; (unsigned)i<ptrarray.size() && iResult>=0;) {
    int result=ScanConfigurationArgument(ptrarray.size()-i, &ptrarray[i]);
    if (result==0) {
      HLTWarning("unknown component argument %s", ptrarray[i]);
      i++;
    } else if (result>0) {
      i+=result;
    } else {
      iResult=result;
      if (iResult==-EINVAL) {
	HLTError("unknown argument %s", ptrarray[i]);
      } else if (iResult==-EPROTO) {
	HLTError("missing/wrong parameter for argument %s (%s)", ptrarray[i], (ptrarray.size()>(unsigned)i+1)?ptrarray[i+1]:"missing");
      } else {
	HLTError("scan of argument %s failed (%d)", ptrarray[i], iResult);
      }
    }
  }

  return iResult;
}

int AliHLTComponent::ConfigureFromCDBTObjString(const char* entries, const char* key)
{
  // load a list of OCDB objects and configure from the objects
  // can either be a TObjString or a TMap with a TObjString:TObjString key-value pair
  int iResult=0;
  TString arguments;
  TString confEntries=entries;
  TObjArray* pTokens=confEntries.Tokenize(" ");
  if (pTokens) {
    for (int n=0; n<pTokens->GetEntriesFast(); n++) {
      const char* path=pTokens->At(n)->GetName();
      const char* chainId=GetChainId();
      HLTInfo("configure from entry \"%s\"%s%s, chain id %s", path, key?" key ":"",key?key:"", (chainId!=NULL && chainId[0]!=0)?chainId:"<none>");
      TObject* pOCDBObject = LoadAndExtractOCDBObject(path, key);
      if (pOCDBObject) {
	TObjString* pString=dynamic_cast<TObjString*>(pOCDBObject);
	if (!pString) {
	  TMap* pMap=dynamic_cast<TMap*>(pOCDBObject);
	  if (pMap) {
	    // this is the case where no key has been specified and the OCDB
	    // object is a TMap, search for the default key
	    TObject* pObject=pMap->GetValue("default");
	    if (pObject && (pString=dynamic_cast<TObjString*>(pObject))!=NULL) {
	      HLTInfo("using default key of TMap of configuration object \"%s\"", path);
	    } else {
	      HLTError("no default key available in TMap of configuration object \"%s\"", path);
	      iResult=-ENOENT;
	      break;
	    }
	  }
	}

	if (pString) {
	  HLTInfo("received configuration object string: \'%s\'", pString->GetName());
	  arguments+=pString->GetName();
	  arguments+=" ";
	} else {
	  HLTError("configuration object \"%s\"%s%s has wrong type, required TObjString", path, key?" key ":"",key?key:"");
	  iResult=-EINVAL;
	}
      } else {
	HLTError("can not fetch object \"%s\" from OCDB", path);
	iResult=-ENOENT;
      }
    }
    delete pTokens;
  }
  if (iResult>=0 && !arguments.IsNull())  {
    const char* array=arguments.Data();
    iResult=ConfigureFromArgumentString(1, &array);
  }
  return iResult;
}

TObject* AliHLTComponent::LoadAndExtractOCDBObject(const char* path, const char* key) const
{
  // see header file for function documentation
  AliCDBEntry* pEntry=AliHLTMisc::Instance().LoadOCDBEntry(path, GetRunNo());
  if (!pEntry) return NULL;
  TObject* pObject=AliHLTMisc::Instance().ExtractObject(pEntry);
  TMap* pMap=dynamic_cast<TMap*>(pObject);
  if (pMap && key) {
    pObject=pMap->GetValue(key);
    if (!pObject) {
      pObject=pMap->GetValue("default");
      if (pObject) {
	HLTWarning("can not find object for key \"%s\" in TMap of configuration object \"%s\", using key \"default\"", key, path);
      }
    }
    if (!pObject) {
      HLTError("can not find object for key \"%s\" in TMap of configuration object \"%s\"", key, path);
      return NULL;
    }
  }
  return pObject;
}

int AliHLTComponent::DoInit( int /*argc*/, const char** /*argv*/)
{
  // default implementation, childs can overload
  HLTLogKeyword("dummy");
  return 0;
}

int AliHLTComponent::DoDeinit()
{
  // default implementation, childs can overload
  HLTLogKeyword("dummy");
  return 0;
}

int AliHLTComponent::Reconfigure(const char* /*cdbEntry*/, const char* /*chainId*/)
{
  // default implementation, childs can overload
  HLTLogKeyword("dummy");
  return 0;
}

int AliHLTComponent::ReadPreprocessorValues(const char* /*modules*/)
{
  // default implementation, childs can overload
  HLTLogKeyword("dummy");
  return 0;
}

int AliHLTComponent::ScanConfigurationArgument(int /*argc*/, const char** /*argv*/)
{
  // default implementation, childs can overload
  HLTLogKeyword("dummy");
  HLTWarning("The function needs to be implemented by the component");
  return 0;
}

int AliHLTComponent::StartOfRun()
{
  // default implementation, childs can overload
  HLTLogKeyword("dummy");
  return 0;
}

int AliHLTComponent::EndOfRun()
{
  // default implementation, childs can overload
  HLTLogKeyword("dummy");
  return 0;
}


int AliHLTComponent::GetOutputDataTypes(AliHLTComponentDataTypeList& /*tgtList*/)
{
  // default implementation, childs can overload
  HLTLogKeyword("dummy");
  return 0;
}

void AliHLTComponent::GetOCDBObjectDescription( TMap* const /*targetArray*/)
{
  // default implementation, childs can overload
  HLTLogKeyword("dummy");
}

int AliHLTComponent::CheckOCDBEntries(const TMap* const externList)
{
  // check the availability of the OCDB entry descriptions in the TMap
  //  key : complete OCDB path of the entry
  //  value : auxiliary object - short description
  // if the external map was not provided the function invokes
  // interface function GetOCDBObjectDescription() to retrieve the list.
  int iResult=0;
  if (externList) {
    iResult=AliHLTMisc::Instance().CheckOCDBEntries(externList);
  } else {
    TMap* pMap=new TMap;
    if (pMap) {
      pMap->SetOwnerKeyValue(kTRUE);
      GetOCDBObjectDescription(pMap);
      iResult=AliHLTMisc::Instance().CheckOCDBEntries(pMap);
      delete pMap;
      pMap=NULL;
    }
  }

  return iResult;
}

void AliHLTComponent::DataType2Text( const AliHLTComponentDataType& type, char output[kAliHLTComponentDataTypefIDsize+kAliHLTComponentDataTypefOriginSize+2] ) const
{
  // see header file for function documentation
  memset( output, 0, kAliHLTComponentDataTypefIDsize+kAliHLTComponentDataTypefOriginSize+2 );
  strncat( output, type.fOrigin, kAliHLTComponentDataTypefOriginSize );
  strncat( output, ":", 1 );
  strncat( output, type.fID, kAliHLTComponentDataTypefIDsize );
}

string AliHLTComponent::DataType2Text( const AliHLTComponentDataType& type, int mode)
{
  // see header file for function documentation
  string out("");

  // 'typeid' 'origin'
  // aligned to 8 and 4 chars respectively, blocks enclosed in quotes and
  // separated by blank e.g.
  // 'DDL_RAW ' 'TPC '
  if (mode==3) {
    int i=0;
    char tmp[8];
    out+="'";
    for (i=0; i<kAliHLTComponentDataTypefIDsize; i++) {
      unsigned char* puc=(unsigned char*)type.fID;
      if (puc[i]<32)
	sprintf(tmp, "\\%x", type.fID[i]);
      else
	sprintf(tmp, "%c", type.fID[i]);
      out+=tmp;
    }
    out+="' '";
    for (i=0; i<kAliHLTComponentDataTypefOriginSize; i++) {
      unsigned char* puc=(unsigned char*)type.fOrigin;
      if ((puc[i])<32)
	sprintf(tmp, "\\%x", type.fOrigin[i]);
      else
	sprintf(tmp, "%c", type.fOrigin[i]);
      out+=tmp;
    }
    out+="'";
    return out;
  }

  // origin typeid as numbers separated by colon e.g.
  // aligned to 8 and 4 chars respectively, all characters separated by
  // quotes, e.g.
  // '84'80'67'32':'68'68'76'95'82'65'87'32'
  if (mode==2) {
    int i=0;
    char tmp[8];
    for (i=0; i<kAliHLTComponentDataTypefOriginSize; i++) {
      sprintf(tmp, "'%d", type.fOrigin[i]);
      out+=tmp;
    }
    out+="':'";
    for (i=0; i<kAliHLTComponentDataTypefIDsize; i++) {
      sprintf(tmp, "%d'", type.fID[i]);
      out+=tmp;
    }
    return out;
  }

  // origin typeid separated by colon e.g.
  // aligned to 8 and 4 chars respectively, all characters separated by
  // quotes, e.g.
  // 'T'P'C' ':'D'D'L'_'R'A'W' '
  if (mode==1) {
    int i=0;
    char tmp[8];
    for (i=0; i<kAliHLTComponentDataTypefOriginSize; i++) {
      unsigned char* puc=(unsigned char*)type.fOrigin;
      if ((puc[i])<32)
	sprintf(tmp, "'\\%x", type.fOrigin[i]);
      else
	sprintf(tmp, "'%c", type.fOrigin[i]);
      out+=tmp;
    }
    out+="':'";
    for (i=0; i<kAliHLTComponentDataTypefIDsize; i++) {
      unsigned char* puc=(unsigned char*)type.fID;
      if (puc[i]<32)
	sprintf(tmp, "\\%x'", type.fID[i]);
      else
	sprintf(tmp, "%c'", type.fID[i]);
      out+=tmp;
    }
    return out;
  }

  // origin typeid
  // aligned to 8 and 4 chars respectively, separated by colon e.g.
  // TPC :DDL_RAW 
  if (type==kAliHLTVoidDataType) {
    out="VOID:VOID";
  } else {
    // some gymnastics in order to avoid a '0' which is part of either or both
    // ID and origin terminating the whole string. Unfortunately, string doesn't
    // stop appending at the '0' if the number of elements to append was 
    // explicitely specified
    string tmp("");
    tmp.append(type.fOrigin, kAliHLTComponentDataTypefOriginSize);
    out.append(tmp.c_str());
    out.append(":");
    tmp="";
    tmp.append(type.fID, kAliHLTComponentDataTypefIDsize);
    out.append(tmp.c_str());
  }
  return out;
}


void* AliHLTComponent::AllocMemory( unsigned long size ) 
{
  // see header file for function documentation
  if (fEnvironment.fAllocMemoryFunc)
    return (*fEnvironment.fAllocMemoryFunc)(fEnvironment.fParam, size );
  HLTFatal("no memory allocation handler registered");
  return NULL;
}

int AliHLTComponent::MakeOutputDataBlockList( const AliHLTComponentBlockDataList& blocks, AliHLTUInt32_t* blockCount,
					      AliHLTComponentBlockData** outputBlocks ) 
{
  // see header file for function documentation
    if ( blockCount==NULL || outputBlocks==NULL )
	return -EFAULT;
    AliHLTUInt32_t count = blocks.size();
    if ( !count )
	{
	*blockCount = 0;
	*outputBlocks = NULL;
	return 0;
	}
    *outputBlocks = reinterpret_cast<AliHLTComponentBlockData*>( AllocMemory( sizeof(AliHLTComponentBlockData)*count ) );
    if ( !*outputBlocks )
	return -ENOMEM;
    for ( unsigned long i = 0; i < count; i++ ) {
	(*outputBlocks)[i] = blocks[i];
	if (MatchExactly(blocks[i].fDataType, kAliHLTAnyDataType)) {
	  (*outputBlocks)[i].fDataType=GetOutputDataType();
	  /* data type was set to the output data type by the PubSub AliRoot
	     Wrapper component, if data type of the block was ********:****.
	     Now handled by the component base class in order to have same
	     behavior when running embedded in AliRoot
	  memset((*outputBlocks)[i].fDataType.fID, '*', kAliHLTComponentDataTypefIDsize);
	  memset((*outputBlocks)[i].fDataType.fOrigin, '*', kAliHLTComponentDataTypefOriginSize);
	  */
	}
    }
    *blockCount = count;
    return 0;

}

int AliHLTComponent::GetEventDoneData( unsigned long size, AliHLTComponentEventDoneData** edd ) const
{
  // see header file for function documentation
  if (fEnvironment.fGetEventDoneDataFunc)
    return (*fEnvironment.fGetEventDoneDataFunc)(fEnvironment.fParam, fCurrentEvent, size, edd );
  return -ENOSYS;
}

int AliHLTComponent::ReserveEventDoneData( unsigned long size )
{
  // see header file for function documentation
  int iResult=0;

  unsigned long capacity=fEventDoneDataSize;
  if (fEventDoneData) capacity-=sizeof(AliHLTComponentEventDoneData)+fEventDoneData->fDataSize;
  if (size>capacity) {
    unsigned long newSize=sizeof(AliHLTComponentEventDoneData)+size+(fEventDoneDataSize-capacity);
    AliHLTComponentEventDoneData* newEDD = reinterpret_cast<AliHLTComponentEventDoneData*>( new AliHLTUInt8_t[newSize] );
    if (!newEDD)
      return -ENOMEM;
    newEDD->fStructSize = sizeof(AliHLTComponentEventDoneData);
    newEDD->fDataSize = 0;
    newEDD->fData = reinterpret_cast<AliHLTUInt8_t*>(newEDD)+newEDD->fStructSize;
    if (fEventDoneData) {
      memcpy( newEDD->fData, fEventDoneData->fData, fEventDoneData->fDataSize );
      newEDD->fDataSize = fEventDoneData->fDataSize;
      delete [] reinterpret_cast<AliHLTUInt8_t*>( fEventDoneData );
    }
    fEventDoneData = newEDD;
    fEventDoneDataSize = newSize;
  }
  return iResult;

}

int AliHLTComponent::PushEventDoneData( AliHLTUInt32_t eddDataWord )
{
  // see header file for function documentation
  if (!fEventDoneData)
    return -ENOMEM;
  if (fEventDoneData->fDataSize+sizeof(AliHLTUInt32_t)>fEventDoneDataSize)
    return -ENOSPC;
  *reinterpret_cast<AliHLTUInt32_t*>((reinterpret_cast<AliHLTUInt8_t*>(fEventDoneData->fData)+fEventDoneData->fDataSize)) = eddDataWord;
  fEventDoneData->fDataSize += sizeof(AliHLTUInt32_t);
  return 0;
}

void AliHLTComponent::ReleaseEventDoneData()
{
   // see header file for function documentation
 if (fEventDoneData)
    delete [] reinterpret_cast<AliHLTUInt8_t*>( fEventDoneData );
  fEventDoneData = NULL;
  fEventDoneDataSize = 0;
}


int AliHLTComponent::FindMatchingDataTypes(AliHLTComponent* pConsumer, AliHLTComponentDataTypeList* tgtList) 
{
  // see header file for function documentation
  int iResult=0;
  if (pConsumer) {
    AliHLTComponentDataTypeList itypes;
    AliHLTComponentDataTypeList otypes;
    otypes.push_back(GetOutputDataType());
    if (MatchExactly(otypes[0],kAliHLTMultipleDataType)) {
      otypes.clear();
      int count=0;
      if ((count=GetOutputDataTypes(otypes))>0) {
      } else if (GetComponentType()!=kSink) {
	HLTWarning("component %s indicates multiple output data types but GetOutputDataTypes returns %d", GetComponentID(), count);
      }
    }
    pConsumer->GetInputDataTypes(itypes);
    AliHLTComponentDataTypeList::iterator otype=otypes.begin();
    for (;otype!=otypes.end();otype++) {
      //PrintDataTypeContent((*otype), "publisher \'%s\'");
      if ((*otype)==(kAliHLTAnyDataType|kAliHLTDataOriginPrivate)) {
	if (tgtList) tgtList->push_back(*otype);
	iResult++;
	continue;
      }
      
      AliHLTComponentDataTypeList::iterator itype=itypes.begin();
      for ( ; itype!=itypes.end() && (*itype)!=(*otype) ; itype++) {/* empty body */};
      //if (itype!=itypes.end()) PrintDataTypeContent(*itype, "consumer \'%s\'");
      if (itype!=itypes.end()) {
	if (tgtList) tgtList->push_back(*otype);
	iResult++;
      }
    }
  } else {
    iResult=-EINVAL;
  }
  return iResult;
}

void AliHLTComponent::PrintDataTypeContent(AliHLTComponentDataType& dt, const char* format)
{
  // see header file for function documentation
  const char* fmt="\'%s\'";
  if (format) fmt=format;
  AliHLTLogging::Message(NULL, kHLTLogNone, NULL , NULL, Form(fmt, (DataType2Text(dt)).c_str()));
  AliHLTLogging::Message(NULL, kHLTLogNone, NULL , NULL, 
			 Form("%x %x %x %x %x %x %x %x : %x %x %x %x", 
			      dt.fID[0],
			      dt.fID[1],
			      dt.fID[2],
			      dt.fID[3],
			      dt.fID[4],
			      dt.fID[5],
			      dt.fID[6],
			      dt.fID[7],
			      dt.fOrigin[0],
			      dt.fOrigin[1],
			      dt.fOrigin[2],
			      dt.fOrigin[3]));
}

void AliHLTComponent::FillBlockData( AliHLTComponentBlockData& blockData )
{
  // see header file for function documentation
  blockData.fStructSize = sizeof(blockData);
  FillShmData( blockData.fShmKey );
  blockData.fOffset = ~(AliHLTUInt32_t)0;
  blockData.fPtr = NULL;
  blockData.fSize = 0;
  FillDataType( blockData.fDataType );
  blockData.fSpecification = kAliHLTVoidDataSpec;
}

void AliHLTComponent::FillShmData( AliHLTComponentShmData& shmData )
{
  // see header file for function documentation
  shmData.fStructSize = sizeof(shmData);
  shmData.fShmType = gkAliHLTComponentInvalidShmType;
  shmData.fShmID = gkAliHLTComponentInvalidShmID;
}

void AliHLTComponent::FillDataType( AliHLTComponentDataType& dataType )
{
  // see header file for function documentation
  dataType=kAliHLTAnyDataType;
}

void AliHLTComponent::CopyDataType(AliHLTComponentDataType& tgtdt, const AliHLTComponentDataType& srcdt) 
{
  // see header file for function documentation
  memcpy(&tgtdt.fID[0], &srcdt.fID[0], kAliHLTComponentDataTypefIDsize);
  memcpy(&tgtdt.fOrigin[0], &srcdt.fOrigin[0], kAliHLTComponentDataTypefOriginSize);
}

void AliHLTComponent::SetDataType(AliHLTComponentDataType& tgtdt, const char* id, const char* origin) 
{
  // see header file for function documentation
  tgtdt.fStructSize=sizeof(AliHLTComponentDataType);
  if (id) {
    memset(&tgtdt.fID[0], 0, kAliHLTComponentDataTypefIDsize);
    strncpy(&tgtdt.fID[0], id, strlen(id)<(size_t)kAliHLTComponentDataTypefIDsize?strlen(id):kAliHLTComponentDataTypefIDsize);
  }
  if (origin) {
    memset(&tgtdt.fOrigin[0], 0, kAliHLTComponentDataTypefOriginSize);
    strncpy(&tgtdt.fOrigin[0], origin, strlen(origin)<(size_t)kAliHLTComponentDataTypefOriginSize?strlen(origin):kAliHLTComponentDataTypefOriginSize);
  }
}

void AliHLTComponent::SetDataType(AliHLTComponentDataType& dt, AliHLTUInt64_t id, AliHLTUInt32_t origin)
{
  // see header file for function documentation
  dt.fStructSize=sizeof(AliHLTComponentDataType);
  assert(kAliHLTComponentDataTypefIDsize==sizeof(id));
  assert(kAliHLTComponentDataTypefOriginSize==sizeof(origin));
  memcpy(&dt.fID, &id, kAliHLTComponentDataTypefIDsize);
  memcpy(&dt.fOrigin, &origin, kAliHLTComponentDataTypefOriginSize);
}

void AliHLTComponent::FillEventData(AliHLTComponentEventData& evtData)
{
  // see header file for function documentation
  memset(&evtData, 0, sizeof(AliHLTComponentEventData));
  evtData.fStructSize=sizeof(AliHLTComponentEventData);
  evtData.fEventID=kAliHLTVoidEventID;
  evtData.fEventCreation_s = kMaxUInt;
}

void AliHLTComponent::PrintComponentDataTypeInfo(const AliHLTComponentDataType& dt) 
{
  // see header file for function documentation
  TString msg;
  msg.Form("AliHLTComponentDataType(%d): ID=\"", dt.fStructSize);
  for ( int i = 0; i < kAliHLTComponentDataTypefIDsize; i++ ) {
   if (dt.fID[i]!=0) msg+=dt.fID[i];
   else msg+="\\0";
  }
  msg+="\" Origin=\"";
  for ( int i = 0; i < kAliHLTComponentDataTypefOriginSize; i++ ) {
   if (dt.fOrigin[i]!=0) msg+=dt.fOrigin[i];
   else msg+="\\0";
  }
  msg+="\"";
  AliHLTLogging::Message(NULL, kHLTLogNone, NULL , NULL, msg.Data());
}

int AliHLTComponent::GetEventCount() const
{
  // see header file for function documentation
  return fEventCount;
}

int AliHLTComponent::IncrementEventCounter()
{
  // see header file for function documentation
  if (fEventCount>=0) fEventCount++;
  return fEventCount;
}

int AliHLTComponent::GetNumberOfInputBlocks() const
{
  // see header file for function documentation
  if (fpInputBlocks!=NULL) {
    return fCurrentEventData.fBlockCnt;
  }
  return 0;
}

AliHLTEventID_t AliHLTComponent::GetEventId() const
{
  // see header file for function documentation
  if (fpInputBlocks!=NULL) {
    return fCurrentEventData.fEventID;
  }
  return 0;
}

const TObject* AliHLTComponent::GetFirstInputObject(const AliHLTComponentDataType& dt,
						    const char* classname,
						    int bForce)
{
  // see header file for function documentation
  ALIHLTCOMPONENT_BASE_STOPWATCH();
  fSearchDataType=dt;
  if (classname) fClassName=classname;
  else fClassName.clear();
  int idx=FindInputBlock(fSearchDataType, 0, 1);
  TObject* pObj=NULL;
  if (idx>=0) {
    HLTDebug("found block %d when searching for data type %s", idx, DataType2Text(dt).c_str());
    if ((pObj=GetInputObject(idx, fClassName.c_str(), bForce))!=NULL) {
      fCurrentInputBlock=idx;
    } else {
    }
  }
  return pObj;
}

const TObject* AliHLTComponent::GetFirstInputObject(const char* dtID, 
						    const char* dtOrigin,
						    const char* classname,
						    int         bForce)
{
  // see header file for function documentation
  ALIHLTCOMPONENT_BASE_STOPWATCH();
  AliHLTComponentDataType dt;
  SetDataType(dt, dtID, dtOrigin);
  return GetFirstInputObject(dt, classname, bForce);
}

const TObject* AliHLTComponent::GetNextInputObject(int bForce)
{
  // see header file for function documentation
  ALIHLTCOMPONENT_BASE_STOPWATCH();
  int idx=FindInputBlock(fSearchDataType, fCurrentInputBlock+1, 1);
  //HLTDebug("found block %d when searching for data type %s", idx, DataType2Text(fSearchDataType).c_str());
  TObject* pObj=NULL;
  if (idx>=0) {
    if ((pObj=GetInputObject(idx, fClassName.c_str(), bForce))!=NULL) {
      fCurrentInputBlock=idx;
    }
  }
  return pObj;
}

int AliHLTComponent::FindInputBlock(const AliHLTComponentDataType& dt, int startIdx, int bObject) const
{
  // see header file for function documentation
  int iResult=-ENOENT;
  if (fpInputBlocks!=NULL) {
    int idx=startIdx<0?0:startIdx;
    for ( ; (UInt_t)idx<fCurrentEventData.fBlockCnt && iResult==-ENOENT; idx++) {
      if (dt!=fpInputBlocks[idx].fDataType) continue;

      if (bObject!=0) {
	if (fpInputBlocks[idx].fPtr==NULL) continue;
	AliHLTUInt32_t firstWord=*((AliHLTUInt32_t*)fpInputBlocks[idx].fPtr);
	if (firstWord!=fpInputBlocks[idx].fSize-sizeof(AliHLTUInt32_t)) continue;
      }
      iResult=idx;
    }
  }
  return iResult;
}

TObject* AliHLTComponent::CreateInputObject(int idx, int bForce)
{
  // see header file for function documentation
  TObject* pObj=NULL;
  if (fpInputBlocks!=NULL) {
    if ((UInt_t)idx<fCurrentEventData.fBlockCnt) {
      if (fpInputBlocks[idx].fPtr) {
	AliHLTUInt32_t firstWord=*((AliHLTUInt32_t*)fpInputBlocks[idx].fPtr);
	if (firstWord==fpInputBlocks[idx].fSize-sizeof(AliHLTUInt32_t)) {
	  HLTDebug("create object from block %d size %d", idx, fpInputBlocks[idx].fSize);
	  AliHLTMessage msg(fpInputBlocks[idx].fPtr, fpInputBlocks[idx].fSize);
	  TClass* objclass=msg.GetClass();
	  pObj=msg.ReadObject(objclass);
	  if (pObj && objclass) {
	    HLTDebug("object %p type %s created", pObj, objclass->GetName());
	  } else {
	  }
	  //} else {
       	} else if (bForce!=0) {
	  HLTError("size mismatch: block size %d, indicated %d", fpInputBlocks[idx].fSize, firstWord+sizeof(AliHLTUInt32_t));
	}
      } else {
	HLTFatal("block descriptor empty");
      }
    } else {
      HLTError("index %d out of range %d", idx, fCurrentEventData.fBlockCnt);
    }
  } else {
    HLTError("no input blocks available");
  }
  
  return pObj;
}

TObject* AliHLTComponent::GetInputObject(int idx, const char* /*classname*/, int bForce)
{
  // see header file for function documentation
  if (fpInputObjects==NULL) {
    fpInputObjects=new TObjArray(fCurrentEventData.fBlockCnt);
  }
  TObject* pObj=NULL;
  if (fpInputObjects) {
    pObj=fpInputObjects->At(idx);
    if (pObj==NULL) {
      pObj=CreateInputObject(idx, bForce);
      if (pObj) {
	fpInputObjects->AddAt(pObj, idx);
      }
    }
  } else {
    HLTFatal("memory allocation failed: TObjArray of size %d", fCurrentEventData.fBlockCnt);
  }
  return pObj;
}

int AliHLTComponent::CleanupInputObjects()
{
  // see header file for function documentation
  if (!fpInputObjects) return 0;
  TObjArray* array=fpInputObjects;
  fpInputObjects=NULL;
  for (int i=0; i<array->GetEntriesFast(); i++) {
    TObject* pObj=array->At(i);
    // grrr, garbage collection strikes back: When read via AliHLTMessage
    // (CreateInputObject), and written to a TFile afterwards, the
    // TFile::Close calls ROOOT's garbage collection. No clue why the
    // object ended up in the key list and needs to be deleted
    //
    // Matthias 09.11.2008 follow up
    // This approach doesn't actually work in all cases: the object table
    // can be switched off globally, the flag needs to be checked here as
    // well in order to avoid memory leaks.
    // This means we have to find another solution for the problem if it
    // pops up again.
    if (pObj &&
	(!TObject::GetObjectStat() || gObjectTable->PtrIsValid(pObj))) {
      delete pObj;
    }
  }
  delete array;
  return 0;
}

AliHLTComponentDataType AliHLTComponent::GetDataType(const TObject* pObject)
{
  // see header file for function documentation
  ALIHLTCOMPONENT_BASE_STOPWATCH();
  AliHLTComponentDataType dt=kAliHLTVoidDataType;
  int idx=fCurrentInputBlock;
  if (pObject) {
    if (fpInputObjects==NULL || (idx=fpInputObjects->IndexOf(pObject))>=0) {
    } else {
      HLTError("unknown object %p", pObject);
    }
  }
  if (idx>=0) {
    if ((UInt_t)idx<fCurrentEventData.fBlockCnt) {
      dt=fpInputBlocks[idx].fDataType;
    } else {
      HLTFatal("severe internal error, index out of range");
    }
  }
  return dt;
}

AliHLTUInt32_t AliHLTComponent::GetSpecification(const TObject* pObject)
{
  // see header file for function documentation
  ALIHLTCOMPONENT_BASE_STOPWATCH();
  AliHLTUInt32_t iSpec=kAliHLTVoidDataSpec;
  int idx=fCurrentInputBlock;
  if (pObject) {
    if (fpInputObjects==NULL || (idx=fpInputObjects->IndexOf(pObject))>=0) {
    } else {
      HLTError("unknown object %p", pObject);
    }
  }
  if (idx>=0) {
    if ((UInt_t)idx<fCurrentEventData.fBlockCnt) {
      iSpec=fpInputBlocks[idx].fSpecification;
    } else {
      HLTFatal("severe internal error, index out of range");
    }
  }
  return iSpec;
}

int AliHLTComponent::Forward(const TObject* pObject)
{
  // see header file for function documentation
  int iResult=0;
  int idx=fCurrentInputBlock;
  if (pObject) {
    if (fpInputObjects==NULL || (idx=fpInputObjects->IndexOf(pObject))>=0) {
    } else {
      HLTError("unknown object %p", pObject);
      iResult=-ENOENT;
    }
  }
  if (idx>=0) {
    fOutputBlocks.push_back(fpInputBlocks[idx]);
  }
  return iResult;
}

int AliHLTComponent::Forward(const AliHLTComponentBlockData* pBlock)
{
  // see header file for function documentation
  int iResult=0;
  int idx=fCurrentInputBlock;
  if (pBlock) {
    if ((idx=FindInputBlock(pBlock))>=0) {
    } else {
      HLTError("unknown Block %p", pBlock);
      iResult=-ENOENT;      
    }
  }
  if (idx>=0) {
    // check for fpInputBlocks pointer done in FindInputBlock
    fOutputBlocks.push_back(fpInputBlocks[idx]);
  }
  return iResult;
}

const AliHLTComponentBlockData* AliHLTComponent::GetFirstInputBlock(const AliHLTComponentDataType& dt)
{
  // see header file for function documentation
  ALIHLTCOMPONENT_BASE_STOPWATCH();
  fSearchDataType=dt;
  fClassName.clear();
  int idx=FindInputBlock(fSearchDataType, 0);
  const AliHLTComponentBlockData* pBlock=NULL;
  if (idx>=0) {
    // check for fpInputBlocks pointer done in FindInputBlock
    pBlock=&fpInputBlocks[idx];
    fCurrentInputBlock=idx;
  }
  return pBlock;
}

const AliHLTComponentBlockData* AliHLTComponent::GetFirstInputBlock(const char* dtID, 
								    const char* dtOrigin)
{
  // see header file for function documentation
  ALIHLTCOMPONENT_BASE_STOPWATCH();
  AliHLTComponentDataType dt;
  SetDataType(dt, dtID, dtOrigin);
  return GetFirstInputBlock(dt);
}

const AliHLTComponentBlockData* AliHLTComponent::GetInputBlock(int index) const
{
  // see header file for function documentation
  ALIHLTCOMPONENT_BASE_STOPWATCH();
  assert( 0 <= index and index < (int)fCurrentEventData.fBlockCnt );
  return &fpInputBlocks[index];
}

const AliHLTComponentBlockData* AliHLTComponent::GetNextInputBlock()
{
  // see header file for function documentation
  ALIHLTCOMPONENT_BASE_STOPWATCH();
  int idx=FindInputBlock(fSearchDataType, fCurrentInputBlock+1);
  const AliHLTComponentBlockData* pBlock=NULL;
  if (idx>=0) {
    // check for fpInputBlocks pointer done in FindInputBlock
    pBlock=&fpInputBlocks[idx];
    fCurrentInputBlock=idx;
  }
  return pBlock;
}

int AliHLTComponent::FindInputBlock(const AliHLTComponentBlockData* pBlock) const
{
  // see header file for function documentation
  int iResult=-ENOENT;
  if (fpInputBlocks!=NULL) {
    if (pBlock) {
      if (pBlock>=fpInputBlocks && pBlock<fpInputBlocks+fCurrentEventData.fBlockCnt) {
	iResult=(int)(pBlock-fpInputBlocks);
      }
    } else {
      iResult=-EINVAL;
    }
  }
  return iResult;
}

AliHLTUInt32_t AliHLTComponent::GetSpecification(const AliHLTComponentBlockData* pBlock)
{
  // see header file for function documentation
  ALIHLTCOMPONENT_BASE_STOPWATCH();
  AliHLTUInt32_t iSpec=kAliHLTVoidDataSpec;
  int idx=fCurrentInputBlock;
  if (pBlock) {
    if (fpInputObjects==NULL || (idx=FindInputBlock(pBlock))>=0) {
    } else {
      HLTError("unknown Block %p", pBlock);
    }
  }
  if (idx>=0) {
    // check for fpInputBlocks pointer done in FindInputBlock
    iSpec=fpInputBlocks[idx].fSpecification;
  }
  return iSpec;
}

int AliHLTComponent::PushBack(const TObject* pObject, const AliHLTComponentDataType& dt, AliHLTUInt32_t spec, 
			      void* pHeader, int headerSize)
{
  // see header file for function documentation
  ALIHLTCOMPONENT_BASE_STOPWATCH();
  int iResult=0;
  fLastObjectSize=0;
  if (fPushbackPeriod>0) {
    // suppress the output
    TDatime time;
    if (fLastPushBackTime<0 || (int)time.Get()-fLastPushBackTime<fPushbackPeriod) return 0;
  }
  if (pObject) {
    AliHLTMessage msg(kMESS_OBJECT);
    msg.SetCompressionLevel(fCompressionLevel);
    msg.WriteObject(pObject);
    Int_t iMsgLength=msg.Length();
    if (iMsgLength>0) {
      // Matthias Sep 2008
      // NOTE: AliHLTMessage does implement it's own SetLength method
      // which is not architecture independent. The original SetLength
      // stores the size always in network byte order.
      // I'm trying to remember the rational for that, might be that
      // it was just some lack of knowledge. Want to change this, but
      // has to be done carefullt to be backward compatible.
      msg.SetLength(); // sets the length to the first (reserved) word

      // does nothing if the level is 0
      msg.Compress();

      char *mbuf = msg.Buffer();
      if (msg.CompBuffer()) {
	msg.SetLength(); // set once more to have to byte order
	mbuf = msg.CompBuffer();
	iMsgLength = msg.CompLength();
      }
      assert(mbuf!=NULL);
      iResult=InsertOutputBlock(mbuf, iMsgLength, dt, spec, pHeader, headerSize);
      if (iResult>=0) {
	HLTDebug("object %s (%p) size %d compression %d inserted to output", pObject->ClassName(), pObject, iMsgLength, msg.GetCompressionLevel());
      }
      fLastObjectSize=iMsgLength;
    } else {
      HLTError("object serialization failed for object %p", pObject);
      iResult=-ENOMSG;
    }
  } else {
    iResult=-EINVAL;
  }
  return iResult;
}

int AliHLTComponent::PushBack(const TObject* pObject, const char* dtID, const char* dtOrigin, AliHLTUInt32_t spec,
			      void* pHeader, int headerSize)
{
  // see header file for function documentation
  ALIHLTCOMPONENT_BASE_STOPWATCH();
  AliHLTComponentDataType dt;
  SetDataType(dt, dtID, dtOrigin);
  return PushBack(pObject, dt, spec, pHeader, headerSize);
}

int AliHLTComponent::PushBack(const void* pBuffer, int iSize, const AliHLTComponentDataType& dt, AliHLTUInt32_t spec,
			      const void* pHeader, int headerSize)
{
  // see header file for function documentation
  ALIHLTCOMPONENT_BASE_STOPWATCH();
  if (fPushbackPeriod>0) {
    // suppress the output
    TDatime time;
    if (fLastPushBackTime<0 || (int)time.Get()-fLastPushBackTime<fPushbackPeriod) return 0;
  }

  return InsertOutputBlock(pBuffer, iSize, dt, spec, pHeader, headerSize);
}

int AliHLTComponent::PushBack(const void* pBuffer, int iSize, const char* dtID, const char* dtOrigin, AliHLTUInt32_t spec,
			      const void* pHeader, int headerSize)
{
  // see header file for function documentation
  ALIHLTCOMPONENT_BASE_STOPWATCH();
  AliHLTComponentDataType dt;
  SetDataType(dt, dtID, dtOrigin);
  return PushBack(pBuffer, iSize, dt, spec, pHeader, headerSize);
}

int AliHLTComponent::InsertOutputBlock(const void* pBuffer, int iBufferSize, const AliHLTComponentDataType& dt, AliHLTUInt32_t spec,
				       const void* pHeader, int iHeaderSize)
{
  // see header file for function documentation
  int iResult=0;
  int iBlkSize = iBufferSize + iHeaderSize;

  if ((pBuffer!=NULL && iBufferSize>0) || (pHeader!=NULL && iHeaderSize>0)) {
    if (fpOutputBuffer && iBlkSize<=(int)(fOutputBufferSize-fOutputBufferFilled)) {
      AliHLTUInt8_t* pTgt=fpOutputBuffer+fOutputBufferFilled;

      // copy header if provided but skip if the header is the target location
      // in that case it has already been copied
      if (pHeader!=NULL && pHeader!=pTgt) {
	memcpy(pTgt, pHeader, iHeaderSize);
      }

      pTgt += (AliHLTUInt8_t) iHeaderSize;

      // copy buffer if provided but skip if buffer is the target location
      // in that case it has already been copied
      if (pBuffer!=NULL && pBuffer!=pTgt) {
	memcpy(pTgt, pBuffer, iBufferSize);
	
	//AliHLTUInt32_t firstWord=*((AliHLTUInt32_t*)pBuffer);	
	//HLTDebug("copy %d bytes from %p to output buffer %p, first word %#x", iBufferSize, pBuffer, pTgt, firstWord);
      }
      //HLTDebug("buffer inserted to output: size %d data type %s spec %#x", iBlkSize, DataType2Text(dt).c_str(), spec);
    } else {
      if (fpOutputBuffer) {
	HLTError("too little space in output buffer: %d of %d, required %d", fOutputBufferSize-fOutputBufferFilled, fOutputBufferSize, iBlkSize);
      } else {
	HLTError("output buffer not available");
      }
      iResult=-ENOSPC;
    }
  }
  if (iResult>=0) {
    AliHLTComponentBlockData bd;
    FillBlockData( bd );
    bd.fOffset        = fOutputBufferFilled;
    bd.fSize          = iBlkSize;
    bd.fDataType      = dt;
    bd.fSpecification = spec;
    fOutputBlocks.push_back( bd );
    fOutputBufferFilled+=bd.fSize;
  }

  return iResult;
}

int AliHLTComponent::EstimateObjectSize(const TObject* pObject) const
{
  // see header file for function documentation
  if (!pObject) return 0;

  AliHLTMessage msg(kMESS_OBJECT);
  msg.WriteObject(pObject);
  return msg.Length();  
}

AliHLTMemoryFile* AliHLTComponent::CreateMemoryFile(int capacity, const char* dtID,
						    const char* dtOrigin,
						    AliHLTUInt32_t spec)
{
  // see header file for function documentation
  ALIHLTCOMPONENT_BASE_STOPWATCH();
  AliHLTComponentDataType dt;
  SetDataType(dt, dtID, dtOrigin);
  return CreateMemoryFile(capacity, dt, spec);
}

AliHLTMemoryFile* AliHLTComponent::CreateMemoryFile(int capacity,
						    const AliHLTComponentDataType& dt,
						    AliHLTUInt32_t spec)
{
  // see header file for function documentation
  ALIHLTCOMPONENT_BASE_STOPWATCH();
  AliHLTMemoryFile* pFile=NULL;
  if (capacity>=0 && static_cast<unsigned int>(capacity)<=fOutputBufferSize-fOutputBufferFilled){
    AliHLTUInt8_t* pTgt=fpOutputBuffer+fOutputBufferFilled;
    pFile=new AliHLTMemoryFile((char*)pTgt, capacity);
    if (pFile) {
      unsigned int nofBlocks=fOutputBlocks.size();
      if (nofBlocks+1>fMemFiles.size()) {
	fMemFiles.resize(nofBlocks+1, NULL);
      }
      if (nofBlocks<fMemFiles.size()) {
	fMemFiles[nofBlocks]=pFile;
	AliHLTComponentBlockData bd;
	FillBlockData( bd );
	bd.fOffset        = fOutputBufferFilled;
	bd.fSize          = capacity;
	bd.fDataType      = dt;
	bd.fSpecification = spec;
	fOutputBufferFilled+=bd.fSize;
	fOutputBlocks.push_back( bd );
      } else {
	HLTError("can not allocate/grow object array");
	pFile->CloseMemoryFile(0);
	delete pFile;
	pFile=NULL;
      }
    }
  } else {
    HLTError("can not create memory file of size %d (%d available)", capacity, fOutputBufferSize-fOutputBufferFilled);
  }
  return pFile;
}

AliHLTMemoryFile* AliHLTComponent::CreateMemoryFile(const char* dtID,
						    const char* dtOrigin,
						    AliHLTUInt32_t spec,
						    float capacity)
{
  // see header file for function documentation
  ALIHLTCOMPONENT_BASE_STOPWATCH();
  AliHLTComponentDataType dt;
  SetDataType(dt, dtID, dtOrigin);
  int size=fOutputBufferSize-fOutputBufferFilled;
  if (capacity<0 || capacity>1.0) {
    HLTError("invalid parameter: capacity %f", capacity);
    return NULL;
  }
  size=(int)(size*capacity);
  return CreateMemoryFile(size, dt, spec);
}

AliHLTMemoryFile* AliHLTComponent::CreateMemoryFile(const AliHLTComponentDataType& dt,
						    AliHLTUInt32_t spec,
						    float capacity)
{
  // see header file for function documentation
  ALIHLTCOMPONENT_BASE_STOPWATCH();
  int size=fOutputBufferSize-fOutputBufferFilled;
  if (capacity<0 || capacity>1.0) {
    HLTError("invalid parameter: capacity %f", capacity);
    return NULL;
  }
  size=(int)(size*capacity);
  return CreateMemoryFile(size, dt, spec);
}

int AliHLTComponent::Write(AliHLTMemoryFile* pFile, const TObject* pObject,
			   const char* key, int option)
{
  // see header file for function documentation
  int iResult=0;
  if (pFile && pObject) {
    pFile->cd();
    iResult=pObject->Write(key, option);
    if (iResult>0) {
      // success
    } else {
      iResult=-pFile->GetErrno();
      if (iResult==-ENOSPC) {
	HLTError("error writing memory file, buffer too small");
      }
    }
  } else {
    iResult=-EINVAL;
  }
  return iResult;
}

int AliHLTComponent::CloseMemoryFile(AliHLTMemoryFile* pFile)
{
  // see header file for function documentation
  int iResult=0;
  if (pFile) {
    AliHLTMemoryFilePList::iterator element=fMemFiles.begin();
    int i=0;
    while (element!=fMemFiles.end() && iResult>=0) {
      if (*element && *element==pFile) {
	iResult=pFile->CloseMemoryFile();
	
	// sync memory files and descriptors
	if (iResult>=0) {
	  fOutputBlocks[i].fSize=(*element)->GetSize()+(*element)->GetHeaderSize();
	}
	delete *element;
	*element=NULL;
	return iResult;
      }
      element++; i++;
    }
    HLTError("can not find memory file %p", pFile);
    iResult=-ENOENT;
  } else {
    iResult=-EINVAL;
  }
  return iResult;
}

int AliHLTComponent::CreateEventDoneData(AliHLTComponentEventDoneData edd)
{
  // see header file for function documentation
  int iResult=0;

  AliHLTComponentEventDoneData* newEDD = NULL;
  
  unsigned long newSize=edd.fDataSize;
  if (fEventDoneData)
    newSize += fEventDoneData->fDataSize;

  if (newSize>fEventDoneDataSize) {
    newEDD = reinterpret_cast<AliHLTComponentEventDoneData*>( new AliHLTUInt8_t[ sizeof(AliHLTComponentEventDoneData)+newSize ] );
    if (!newEDD)
      return -ENOMEM;
    newEDD->fStructSize = sizeof(AliHLTComponentEventDoneData);
    newEDD->fDataSize = newSize;
    newEDD->fData = reinterpret_cast<AliHLTUInt8_t*>(newEDD)+newEDD->fStructSize;
    unsigned long long offset = 0;
    if (fEventDoneData) {
      memcpy( newEDD->fData, fEventDoneData->fData, fEventDoneData->fDataSize );
      offset += fEventDoneData->fDataSize;
    }
    memcpy( reinterpret_cast<AliHLTUInt8_t*>(newEDD->fData)+offset, edd.fData, edd.fDataSize );
    if (fEventDoneData)
      delete [] reinterpret_cast<AliHLTUInt8_t*>( fEventDoneData );
    fEventDoneData = newEDD;
    fEventDoneDataSize = newSize;
  }
  else if (fEventDoneData) {
    memcpy( reinterpret_cast<AliHLTUInt8_t*>(fEventDoneData->fData)+fEventDoneData->fDataSize, edd.fData, edd.fDataSize );
    fEventDoneData->fDataSize += edd.fDataSize;
  }
  else {
    HLTError("internal mismatch, fEventDoneData=%d but buffer is NULL", fEventDoneDataSize);
    iResult=-EFAULT;
  }
  return iResult;
}

namespace
{
  // helper function for std:sort, implements an operator<
  bool SortComponentStatisticsById(const AliHLTComponentStatistics& a, const AliHLTComponentStatistics& b)
  {
    return a.fId<b.fId;
  }

  // helper function for std:sort
  bool SortComponentStatisticsDescendingByLevel(const AliHLTComponentStatistics& a, const AliHLTComponentStatistics& b)
  {
    return a.fId>b.fId;
  }

  // helper class to define operator== between AliHLTComponentStatistics and AliHLTComponentStatistics.fId
  class AliHLTComponentStatisticsId {
  public:
    AliHLTComponentStatisticsId(AliHLTUInt32_t id) : fId(id) {}
    AliHLTComponentStatisticsId(const AliHLTComponentStatisticsId& src) : fId(src.fId) {}
    AliHLTComponentStatisticsId& operator=(const AliHLTComponentStatisticsId& src) {
      if (this==&src) return *this;
      fId=src.fId; return *this;
    }
    bool operator==(const AliHLTComponentStatistics& a) const {return a.fId==fId;}
  private:
    AliHLTComponentStatisticsId();
    AliHLTUInt32_t fId;
  };

  // operator for std::find of AliHLTComponentStatistics by id
  bool operator==(const AliHLTComponentStatistics& a, const AliHLTComponentStatisticsId& b)
  {
    return b==a;
  }

  bool AliHLTComponentStatisticsCompareIds(const AliHLTComponentStatistics& a, const AliHLTComponentStatistics& b)
  {
    return a.fId==b.fId;
  }

  // helper class to define operator== between AliHLTComponentBlockData and AliHLTComponentBlockData.fSpecification
  class AliHLTComponentBlockDataSpecification {
  public:
    AliHLTComponentBlockDataSpecification(AliHLTUInt32_t specification) : fSpecification(specification) {}
    AliHLTComponentBlockDataSpecification(const AliHLTComponentBlockDataSpecification& src) : fSpecification(src.fSpecification) {}
    AliHLTComponentBlockDataSpecification& operator=(const AliHLTComponentBlockDataSpecification& src) {
      if (this==&src) return *this;
      fSpecification=src.fSpecification; return *this;
    }
    bool operator==(const AliHLTComponentBlockData& bd) const {return bd.fSpecification==fSpecification;}
  private:
    AliHLTComponentBlockDataSpecification();
    AliHLTUInt32_t fSpecification;
  };

  // operator for std::find of AliHLTComponentBlockData by specification
  bool operator==(const AliHLTComponentBlockData& bd, const AliHLTComponentBlockDataSpecification& spec)
  {
    return spec==bd;
  }

  // operator for std::find
  bool operator==(const AliHLTComponentBlockData& a, const AliHLTComponentBlockData& b)
  {
    if (!MatchExactly(a.fDataType,b.fDataType)) return false;
    return a.fSpecification==b.fSpecification;
  }

} // end of namespace

int AliHLTComponent::ProcessEvent( const AliHLTComponentEventData& evtData,
				   const AliHLTComponentBlockData* blocks, 
				   AliHLTComponentTriggerData& trigData,
				   AliHLTUInt8_t* outputPtr, 
				   AliHLTUInt32_t& size,
				   AliHLTUInt32_t& outputBlockCnt, 
				   AliHLTComponentBlockData*& outputBlocks,
				   AliHLTComponentEventDoneData*& edd )
{
  // see header file for function documentation
  HLTLogKeyword(fChainId.c_str());
  ALIHLTCOMPONENT_BASE_STOPWATCH();
  int iResult=0;
  fCurrentEvent=evtData.fEventID;
  fCurrentEventData=evtData;
  fpInputBlocks=blocks;
  fCurrentInputBlock=-1;
  fSearchDataType=kAliHLTAnyDataType;
  fpOutputBuffer=outputPtr;
  fOutputBufferSize=size;
  fOutputBufferFilled=0;
  fOutputBlocks.clear();
  outputBlockCnt=0;
  outputBlocks=NULL;

  AliHLTComponentBlockDataList forwardedBlocks;

  // optional component statistics
  AliHLTComponentStatisticsList compStats;
  bool bAddComponentTableEntry=false;
  vector<AliHLTUInt32_t> parentComponentTables;
  int processingLevel=-1;
#if defined(HLT_COMPONENT_STATISTICS)
  if ((fFlags&kDisableComponentStat)==0) {
    AliHLTComponentStatistics outputStat;
    memset(&outputStat, 0, sizeof(AliHLTComponentStatistics));
    outputStat.fStructSize=sizeof(AliHLTComponentStatistics);
    outputStat.fId=fChainIdCrc;
    if (fpBenchmark) {
      fpBenchmark->Stop();
      outputStat.fComponentCycleTime=(AliHLTUInt32_t)(fpBenchmark->RealTime()*ALIHLTCOMPONENT_STATTIME_SCALER);
      fpBenchmark->Reset();
      fpBenchmark->Start();
    }
    compStats.push_back(outputStat);
  }
#endif // HLT_COMPONENT_STATISTICS

  // data processing is skipped
  // -  if there are only steering events in the block list.
  //    For the sake of data source components data processing
  //    is not skipped if there is no block list at all or if it
  //    just contains the eventType block
  // - always skipped if the event is of type
  //   - gkAliEventTypeConfiguration
  //   - gkAliEventTypeReadPreprocessor
  const unsigned int skipModeDefault=0x1;
  const unsigned int skipModeForce=0x2;
  unsigned int bSkipDataProcessing=skipModeDefault;

  // find special events
  if (fpInputBlocks && evtData.fBlockCnt>0) {
    // first look for all special events and execute in the appropriate
    // sequence afterwords
    int indexComConfEvent=-1;
    int indexUpdtDCSEvent=-1;
    int indexSOREvent=-1;
    int indexEOREvent=-1;
    int indexECSParamBlock=-1;
    for (unsigned int i=0; i<evtData.fBlockCnt && iResult>=0; i++) {
      if (fpInputBlocks[i].fDataType==kAliHLTDataTypeSOR) {
	indexSOREvent=i;
	// the AliHLTCalibrationProcessor relies on the SOR and EOR events
	bSkipDataProcessing&=~skipModeDefault;
      } else if (fpInputBlocks[i].fDataType==kAliHLTDataTypeRunType) {
	// run type string
	// handling is not clear yet
	if (fpInputBlocks[i].fPtr) {
	  HLTDebug("got run type \"%s\"\n", fpInputBlocks[i].fPtr);
	}
      } else if (fpInputBlocks[i].fDataType==kAliHLTDataTypeEOR) {
	indexEOREvent=i;
	// the calibration processor relies on the SOR and EOR events
	bSkipDataProcessing&=~skipModeDefault;
      } else if (fpInputBlocks[i].fDataType==kAliHLTDataTypeDDL) {
	// DDL list
	// this event is most likely deprecated
      } else if (fpInputBlocks[i].fDataType==kAliHLTDataTypeComConf) {
	indexComConfEvent=i;
      } else if (fpInputBlocks[i].fDataType==kAliHLTDataTypeUpdtDCS) {
	indexUpdtDCSEvent=i;
      } else if (fpInputBlocks[i].fDataType==kAliHLTDataTypeEvent) {
	fEventType=fpInputBlocks[i].fSpecification;
	if (fEventType != gkAliEventTypeConfiguration and
	    fEventType != gkAliEventTypeReadPreprocessor
	   )
	{
	  // We can actually get the event type from the CDH if it is valid.
	  // Otherwise just use the specification of the input block.
	  AliHLTCDHWrapper cdh;
	  if (ExtractTriggerData(trigData, NULL, NULL, &cdh, NULL) == 0)
	  {
	    fEventType = ExtractEventTypeFromCDH(&cdh);
	  }
	}

	// skip always in case of gkAliEventTypeConfiguration
	if (fpInputBlocks[i].fSpecification==gkAliEventTypeConfiguration) bSkipDataProcessing|=skipModeForce;

	// skip always in case of gkAliEventTypeReadPreprocessor
	if (fpInputBlocks[i].fSpecification==gkAliEventTypeReadPreprocessor) bSkipDataProcessing|=skipModeForce;

	// never skip if the event type block is the only block
	if (evtData.fBlockCnt==1) bSkipDataProcessing&=~skipModeDefault;

      } else if (fpInputBlocks[i].fDataType==kAliHLTDataTypeComponentStatistics) {
	if (compStats.size()>0) {
	  AliHLTUInt8_t* pData=reinterpret_cast<AliHLTUInt8_t*>(fpInputBlocks[i].fPtr);
	  for (AliHLTUInt32_t offset=0;
	       offset+sizeof(AliHLTComponentStatistics)<=fpInputBlocks[i].fSize;
	       offset+=sizeof(AliHLTComponentStatistics)) {
	    AliHLTComponentStatistics* pStat=reinterpret_cast<AliHLTComponentStatistics*>(pData+offset);
	    if (pStat && compStats[0].fLevel<=pStat->fLevel) {
	      compStats[0].fLevel=pStat->fLevel+1;
	    }
	    if (find(compStats.begin(), compStats.end(), AliHLTComponentStatisticsId(pStat->fId))==compStats.end()) {
	      compStats.push_back(*pStat);
	    }
	  }
	}
      } else if (fpInputBlocks[i].fDataType==kAliHLTDataTypeComponentTable) {
	AliHLTComponentBlockDataList::iterator element=forwardedBlocks.begin();
	while ((element=find(element, forwardedBlocks.end(), AliHLTComponentBlockDataSpecification(fpInputBlocks[i].fSpecification)))!=forwardedBlocks.end()) {
	  if (element->fDataType==fpInputBlocks[i].fDataType) break;
	  // TODO: think about some more checks inclusing also the actual data buffers
	  // this has to handle multiplicity>1 in the online system, where all components
	  // send the information on SOR, because this event is broadcasted
	}
	if (element==forwardedBlocks.end()) {
	  forwardedBlocks.push_back(fpInputBlocks[i]);
	}
	parentComponentTables.push_back(fpInputBlocks[i].fSpecification);
	if (fpInputBlocks[i].fSize>=sizeof(AliHLTComponentTableEntry)) {
	  const AliHLTComponentTableEntry* entry=reinterpret_cast<AliHLTComponentTableEntry*>(fpInputBlocks[i].fPtr);
	  if (entry->fStructSize==sizeof(AliHLTComponentTableEntry)) {
	    if (processingLevel<0 || processingLevel<=(int)entry->fLevel) 
	      processingLevel=entry->fLevel+1;
	  }
	}
      } else if (fpInputBlocks[i].fDataType==kAliHLTDataTypeECSParam) {
	indexECSParamBlock=i;
      } else {
	// the processing function is called if there is at least one
	// non-steering data block. Steering blocks are not filtered out
	// for sake of performance 
	bSkipDataProcessing&=~skipModeDefault;
	if (compStats.size()>0) {
	  compStats[0].fInputBlockCount++;
	  compStats[0].fTotalInputSize+=fpInputBlocks[i].fSize;
	}
      }
    }

    if (indexSOREvent>=0) {
      // start of run
      bAddComponentTableEntry=true;
      compStats.clear();   // no component statistics for SOR
      if (fpRunDesc==NULL) {
	fpRunDesc=new AliHLTRunDesc;
	if (fpRunDesc) *fpRunDesc=kAliHLTVoidRunDesc;
      }
      if (fpRunDesc) {
	AliHLTRunDesc rundesc;
	if ((iResult=CopyStruct(&rundesc, sizeof(AliHLTRunDesc), indexSOREvent, "AliHLTRunDesc", "SOR"))>0) {
	  if (fpRunDesc->fRunNo==kAliHLTVoidRunNo) {
	    *fpRunDesc=rundesc;
	    HLTDebug("set run decriptor, run no %d", fpRunDesc->fRunNo);
	    SetCDBRunNo(fpRunDesc->fRunNo);
	  } else if (fpRunDesc->fRunNo!=rundesc.fRunNo) {
	    HLTWarning("already set run properties run no %d, ignoring SOR with run no %d", fpRunDesc->fRunNo, rundesc.fRunNo);
	  }
	}
      } else {
	iResult=-ENOMEM;
      }

      if (indexECSParamBlock>=0) {
	if (fpInputBlocks[indexECSParamBlock].fSize>0) {
	  const char* param=reinterpret_cast<const char*>(fpInputBlocks[indexECSParamBlock].fPtr);
	  TString paramString;
	  if (param[fpInputBlocks[indexECSParamBlock].fSize-1]!=0) {
	    HLTWarning("ECS parameter string not terminated");
	    paramString.Insert(0, param, fpInputBlocks[indexECSParamBlock].fSize);
	    paramString+="";
	  } else {
	    paramString=param;
	  }
	  ScanECSParam(paramString.Data());
	} else {
	  HLTWarning("empty ECS parameter received");
	}
      } else {
	// TODO: later on we might throw a warning here since the CTP trigger classes
	// should be mandatory
      }
    }
    if (indexEOREvent>=0) {
      fLastPushBackTime=0; // always send at EOR
      bAddComponentTableEntry=true;
      compStats.clear();   // no component statistics for EOR
      if (fpRunDesc!=NULL) {
	if (fpRunDesc) {
	  AliHLTRunDesc rundesc;
	  if ((iResult=CopyStruct(&rundesc, sizeof(AliHLTRunDesc), indexEOREvent, "AliHLTRunDesc", "SOR"))>0) {
	    if (fpRunDesc->fRunNo!=rundesc.fRunNo) {
	      HLTWarning("run no mismatch: SOR %d, EOR %d", fpRunDesc->fRunNo, rundesc.fRunNo);
	    } else {
	      HLTDebug("EOR run no %d", fpRunDesc->fRunNo);
	    }
	  }
	  // we do not unload the fpRunDesc struct here in order to have the run information
	  // available during the event processing
	  // https://savannah.cern.ch/bugs/?39711
	  // the info will be cleared in DeInit
	}
      } else {
	HLTWarning("did not receive SOR, ignoring EOR");
      }
    }
    if (fEventType==gkAliEventTypeConfiguration) {
      if (indexComConfEvent>=0) {
      TString cdbEntry;
      if (indexComConfEvent>=0 && fpInputBlocks[indexComConfEvent].fPtr!=NULL && fpInputBlocks[indexComConfEvent].fSize>0) {
	cdbEntry.Append(reinterpret_cast<const char*>(fpInputBlocks[indexComConfEvent].fPtr), fpInputBlocks[indexComConfEvent].fSize);
      }
      HLTDebug("received component configuration command: entry %s", cdbEntry.IsNull()?"none":cdbEntry.Data());
      int tmpResult=Reconfigure(cdbEntry[0]==0?NULL:cdbEntry.Data(), fChainId.c_str());
      if (tmpResult<0) {
	HLTWarning("reconfiguration of component %p (%s) failed with error code %d", this, GetComponentID(), tmpResult);
      }
      } else {
	ALIHLTERRORGUARD(1, "incomplete Configure event, missing parameter data block");
      }
    }
    if (fEventType==gkAliEventTypeReadPreprocessor) {
      if (indexUpdtDCSEvent>=0) {
      TString modules;
      if (fpInputBlocks[indexUpdtDCSEvent].fPtr!=NULL && fpInputBlocks[indexUpdtDCSEvent].fSize>0) {
	modules.Append(reinterpret_cast<const char*>(fpInputBlocks[indexUpdtDCSEvent].fPtr), fpInputBlocks[indexUpdtDCSEvent].fSize);
      }
      HLTDebug("received preprocessor update command: detectors %s", modules.IsNull()?"ALL":modules.Data());
      int tmpResult=ReadPreprocessorValues(modules[0]==0?"ALL":modules.Data());
      if (tmpResult<0) {
	HLTWarning("preprocessor update of component %p (%s) failed with error code %d", this, GetComponentID(), tmpResult);
      }
      } else {
	ALIHLTERRORGUARD(1, "incomplete ReadPreprocessor event, missing parameter data block");
      }
    }
  } else {
    // processing function needs to be called if there are no input data
    // blocks in order to make data source components working.
    bSkipDataProcessing&=~skipModeDefault;
  }

  // data processing is not skipped if the component explicitly asks
  // for the private blocks
  if ((fFlags&kRequireSteeringBlocks)!=0) bSkipDataProcessing=0;

  // data processing is not skipped for data sources
  if (GetComponentType()==AliHLTComponent::kSource) bSkipDataProcessing=0;

  if (fpCTPData) {
    // set the active triggers for this event
    fpCTPData->SetTriggers(trigData);
    // increment CTP trigger counters if available
    if (IsDataEvent()) fpCTPData->Increment(trigData);
  }
  
  // Check if the event processing should be skipped because of the
  // down scaling from the event modulo argument. Using a prime number
  // as pre divisor to pseudo-randomise the event number to get a more
  // uniform distribution.
  if (fEventModulo > 1)
  {
    bSkipDataProcessing |= ( ((AliHLTUInt64_t(fCurrentEvent) / AliHLTUInt64_t(4789)) % AliHLTUInt64_t(fEventModulo)) != 0 );
  }

  AliHLTComponentBlockDataList blockData;
  if (iResult>=0 && !bSkipDataProcessing)
  { // dont delete, sets the scope for the stopwatch guard
    // do not use ALIHLTCOMPONENT_DA_STOPWATCH(); macro
    // in order to avoid 'shadowed variable' warning
    AliHLTStopwatchGuard swguard2(fpStopwatches!=NULL?reinterpret_cast<TStopwatch*>(fpStopwatches->At((int)kSWDA)):NULL);
    AliHLTMisc::AliOnlineGuard onlineGuard;
    iResult=DoProcessing(evtData, blocks, trigData, outputPtr, size, blockData, edd);
  } // end of the scope of the stopwatch guard
  if (iResult>=0 && !bSkipDataProcessing) {
    if (fOutputBlocks.size()>0) {
      // High Level interface

      //HLTDebug("got %d block(s) via high level interface", fOutputBlocks.size());      
      // sync memory files and descriptors
      AliHLTMemoryFilePList::iterator element=fMemFiles.begin();
      int i=0;
      while (element!=fMemFiles.end() && iResult>=0) {
	if (*element) {
	  if ((*element)->IsClosed()==0) {
	    HLTWarning("memory file has not been closed, force flush");
	    iResult=CloseMemoryFile(*element);
	  }
	}
	element++; i++;
      }

      if (iResult>=0) {
	// create the descriptor list
	if (blockData.size()>0) {
	  HLTError("low level and high interface must not be mixed; use PushBack methods to insert data blocks");
	  iResult=-EFAULT;
	} else {
	  if (compStats.size()>0 && IsDataEvent()) {
	    int offset=AddComponentStatistics(fOutputBlocks, fpOutputBuffer, fOutputBufferSize, fOutputBufferFilled, compStats);
	    if (offset>0) fOutputBufferFilled+=offset;
	  }
	  if (bAddComponentTableEntry) {
	    int offset=AddComponentTableEntry(fOutputBlocks, fpOutputBuffer, fOutputBufferSize, fOutputBufferFilled, parentComponentTables, processingLevel);
	    if (offset>0) size+=offset;
	  }
	  if (forwardedBlocks.size()>0) {
	    fOutputBlocks.insert(fOutputBlocks.end(), forwardedBlocks.begin(), forwardedBlocks.end());
	  }
	  iResult=MakeOutputDataBlockList(fOutputBlocks, &outputBlockCnt, &outputBlocks);
	  size=fOutputBufferFilled;
	}
      }
    } else {
      // Low Level interface
      if (blockData.empty() && size!=0) {
	// set the size to zero because there is no announced data
	//HLTWarning("no output blocks added by component but output buffer filled %d of %d", size, fOutputBufferSize);
	size=0;
      }

      if (compStats.size()>0) {
	int offset=AddComponentStatistics(blockData, fpOutputBuffer, fOutputBufferSize, size, compStats);
	if (offset>0) size+=offset;
      }
      if (bAddComponentTableEntry) {
	int offset=AddComponentTableEntry(blockData, fpOutputBuffer, fOutputBufferSize, size, parentComponentTables, processingLevel);
	if (offset>0) size+=offset;
      }
      if (forwardedBlocks.size()>0) {
	blockData.insert(blockData.end(), forwardedBlocks.begin(), forwardedBlocks.end());
      }
      iResult=MakeOutputDataBlockList(blockData, &outputBlockCnt, &outputBlocks);
    }
    if (iResult<0) {
      HLTFatal("component %s (%p): can not convert output block descriptor list", GetComponentID(), this);
    }
  }
  if (iResult<0 || bSkipDataProcessing) {
    outputBlockCnt=0;
    outputBlocks=NULL;
  }
  CleanupInputObjects();
  if (iResult>=0 && IsDataEvent()) {
    IncrementEventCounter();
  }
  if (outputBlockCnt==0) {
    // no output blocks, set size to 0
    size=0;
  }

  // reset the internal EventData struct
  FillEventData(fCurrentEventData);

  // reset the active triggers
  if (fpCTPData) fpCTPData->SetTriggers(0);

  // set the time for the pushback period
  if (fPushbackPeriod>0) {
    // suppress the output
    TDatime time;
    if (fLastPushBackTime<0) {
      // choose a random offset at beginning to equalize traffic for multiple instances
      // of the component
      gRandom->SetSeed(fChainIdCrc);
      fLastPushBackTime=time.Get();
      fLastPushBackTime-=gRandom->Integer(fPushbackPeriod);
    } else if ((int)time.Get()-fLastPushBackTime>=fPushbackPeriod) {
      fLastPushBackTime=time.Get();
    }
  }

  return iResult;
}

int  AliHLTComponent::AddComponentStatistics(AliHLTComponentBlockDataList& blocks, 
					     AliHLTUInt8_t* buffer,
					     AliHLTUInt32_t bufferSize,
					     AliHLTUInt32_t offset,
					     AliHLTComponentStatisticsList& stats) const
{
  // see header file for function documentation
  int iResult=0;
  if ((fFlags&kDisableComponentStat)!=0) return 0;
#if defined(HLT_COMPONENT_STATISTICS)
  if (stats.size()==0) return -ENOENT;
  // check if there is space for at least one entry
  if (offset+sizeof(AliHLTComponentStatistics)>bufferSize) return 0;
  stats[0].fTotalOutputSize=offset;
  stats[0].fOutputBlockCount=blocks.size();
  if (fpBenchmark) {
    fpBenchmark->Stop();
    stats[0].fTime=(AliHLTUInt32_t)(fpBenchmark->RealTime()*ALIHLTCOMPONENT_STATTIME_SCALER);
    stats[0].fCTime=(AliHLTUInt32_t)(fpBenchmark->CpuTime()*ALIHLTCOMPONENT_STATTIME_SCALER);
    fpBenchmark->Continue();
  }

  sort(stats.begin(), stats.end(), SortComponentStatisticsDescendingByLevel);

  // shrink the number of entries if the buffer is too small
  if (offset+stats.size()*sizeof(AliHLTComponentStatistics)>bufferSize) {
    unsigned originalSize=stats.size();
    AliHLTUInt32_t removedLevel=0;
    do {
      // remove all entries of the level of the last entry
      removedLevel=stats.back().fLevel;
      AliHLTComponentStatisticsList::iterator element=stats.begin();
      element++;
      while (element!=stats.end()) {
	if (element->fLevel<=removedLevel) {
	  element=stats.erase(element);
	} else {
	  element++;
	}
      }
    } while (stats.size()>1 && 
	     (offset+stats.size()*sizeof(AliHLTComponentStatistics)>bufferSize));
    HLTWarning("too little space in output buffer to add block of %d statistics entries (size %d), available %d, removed %d entries",
	       originalSize, sizeof(AliHLTComponentStatistics), bufferSize-offset, originalSize-stats.size());
  } else {
    HLTDebug("adding block of %d statistics entries", stats.size());
  }
  assert(stats.size()>0);
  if (stats.size()==0) return 0;

  if (offset+stats.size()*sizeof(AliHLTComponentStatistics)<=bufferSize) {
    AliHLTComponentBlockData bd;
    FillBlockData( bd );
    bd.fOffset        = offset;
    bd.fSize          = stats.size()*sizeof(AliHLTComponentStatistics);
    bd.fDataType      = kAliHLTDataTypeComponentStatistics;
    bd.fSpecification = fChainIdCrc;
    memcpy(buffer+offset, &(stats[0]), bd.fSize);
    blocks.push_back(bd);
    iResult=bd.fSize;
  }
#else
  if (blocks.size() && buffer && bufferSize && offset && stats.size()) {
    // get rid of warning
  }
#endif // HLT_COMPONENT_STATISTICS
  return iResult;
}

int  AliHLTComponent::AddComponentTableEntry(AliHLTComponentBlockDataList& blocks, 
					     AliHLTUInt8_t* buffer,
					     AliHLTUInt32_t bufferSize,
					     AliHLTUInt32_t offset,
					     const vector<AliHLTUInt32_t>& parents,
					     int processingLevel) const
{
  // see header file for function documentation
  int iResult=0;
  if ((fFlags&kDisableComponentStat)!=0) return 0;
#if defined(HLT_COMPONENT_STATISTICS)
  // the payload consists of the AliHLTComponentTableEntry struct,
  // followed by a an array of 32bit crc chain ids and the component
  // description string
  unsigned int payloadSize=sizeof(AliHLTComponentTableEntry);
  payloadSize+=parents.size()*sizeof(AliHLTUInt32_t);

  // the component description has the following format:
  // chain-id{component-id:arguments}
  const char* componentId=const_cast<AliHLTComponent*>(this)->GetComponentID();
  unsigned int descriptionSize=fChainId.size()+1;
  descriptionSize+=2; // the '{}' around the component id
  descriptionSize+=strlen(componentId);
  descriptionSize+=1; // the ':' between component id and arguments
  descriptionSize+=fComponentArgs.size();

  payloadSize+=descriptionSize;
  if (buffer && (offset+payloadSize<=bufferSize)) {
    AliHLTUInt8_t* pTgt=buffer+offset;
    memset(pTgt, 0, payloadSize);

    // write entry
    AliHLTComponentTableEntry* pEntry=reinterpret_cast<AliHLTComponentTableEntry*>(pTgt);
    pEntry->fStructSize=sizeof(AliHLTComponentTableEntry);
    pEntry->fLevel=processingLevel>=0?processingLevel:0;
    pEntry->fNofParents=parents.size();
    pEntry->fSizeDescription=descriptionSize;
    pTgt=pEntry->fBuffer;

    // write array of parents
    if (parents.size()>0) {
      unsigned int copy=parents.size()*sizeof(vector<AliHLTUInt32_t>::value_type);
      memcpy(pTgt, &parents[0], parents.size()*sizeof(vector<AliHLTUInt32_t>::value_type));
      pTgt+=copy;
    }

    // write component description
    memcpy(pTgt, fChainId.c_str(), fChainId.size());
    pTgt+=fChainId.size();
    *pTgt++='{';
    memcpy(pTgt, componentId, strlen(componentId));
    pTgt+=strlen(componentId);
    *pTgt++=':';
    memcpy(pTgt, fComponentArgs.c_str(), fComponentArgs.size());
    pTgt+=fComponentArgs.size();
    *pTgt++='}';
    *pTgt++=0;

    AliHLTComponentBlockData bd;
    FillBlockData( bd );
    bd.fOffset        = offset;
    bd.fSize          = payloadSize;
    bd.fDataType      = kAliHLTDataTypeComponentTable;
    bd.fSpecification = fChainIdCrc;
    blocks.push_back(bd);
    iResult=bd.fSize;
  }
#else
  if (blocks.size() && buffer && bufferSize && offset && parents.size() && processingLevel) {
    // get rid of warning
  }
#endif // HLT_COMPONENT_STATISTICS
  return iResult;
}

AliHLTComponent::AliHLTStopwatchGuard::AliHLTStopwatchGuard()
  :
  fpStopwatch(NULL),
  fpPrec(NULL)
{
  // standard constructor (not for use)
}

AliHLTComponent::AliHLTStopwatchGuard::AliHLTStopwatchGuard(TStopwatch* pStopwatch)
  :
  fpStopwatch(pStopwatch),
  fpPrec(NULL)
{
  // constructor

  // check for already existing guard
  if (fgpCurrent) fpPrec=fgpCurrent;
  fgpCurrent=this;

  // stop the preceeding guard if it controls a different stopwatch
  int bStart=1;
  if (fpPrec && fpPrec!=this) bStart=fpPrec->Hold(fpStopwatch);

  // start the stopwatch if the current guard controls a different one
  if (fpStopwatch && bStart==1) fpStopwatch->Start(kFALSE);
}

AliHLTComponent::AliHLTStopwatchGuard::AliHLTStopwatchGuard(const AliHLTStopwatchGuard&)
  :
  fpStopwatch(NULL),
  fpPrec(NULL)
{
  //
  // copy constructor not for use
  //
}

AliHLTComponent::AliHLTStopwatchGuard& AliHLTComponent::AliHLTStopwatchGuard::operator=(const AliHLTStopwatchGuard& other)
{
  //
  // assignment operator not for use
  //
  if (this==&other) return *this;
  fpStopwatch=NULL;
  fpPrec=NULL;
  return *this;
}

AliHLTComponent::AliHLTStopwatchGuard* AliHLTComponent::AliHLTStopwatchGuard::fgpCurrent=NULL;

AliHLTComponent::AliHLTStopwatchGuard::~AliHLTStopwatchGuard()
{
  // destructor

  // resume the preceeding guard if it controls a different stopwatch
  int bStop=1;
  if (fpPrec && fpPrec!=this) bStop=fpPrec->Resume(fpStopwatch);

  // stop the stopwatch if the current guard controls a different one
  if (fpStopwatch && bStop==1) fpStopwatch->Stop();

  // resume to the preceeding guard
  fgpCurrent=fpPrec;
}

int AliHLTComponent::AliHLTStopwatchGuard::Hold(const TStopwatch* pSucc)
{
  // see header file for function documentation
  if (fpStopwatch!=NULL && fpStopwatch!=pSucc) fpStopwatch->Stop();
  return fpStopwatch!=pSucc?1:0;
}

int AliHLTComponent::AliHLTStopwatchGuard::Resume(const TStopwatch* pSucc)
{
  // see header file for function documentation
  if (fpStopwatch!=NULL && fpStopwatch!=pSucc) fpStopwatch->Start(kFALSE);
  return fpStopwatch!=pSucc?1:0;
}

int AliHLTComponent::SetStopwatch(TObject* pSW, AliHLTStopwatchType type) 
{
  // see header file for function documentation
  int iResult=0;
  if (pSW!=NULL && type<kSWTypeCount) {
    if (fpStopwatches) {
      TObject* pObj=fpStopwatches->At((int)type);
      if (pSW==NULL        // explicit reset
	  || pObj==NULL) { // explicit set
	fpStopwatches->AddAt(pSW, (int)type);
      } else if (pObj!=pSW) {
	HLTWarning("stopwatch %d already set, reset first", (int)type);
	iResult=-EBUSY;
      }
    }
  } else {
    iResult=-EINVAL;
  }
  return iResult;
}

int AliHLTComponent::SetStopwatches(TObjArray* pStopwatches)
{
  // see header file for function documentation
  if (pStopwatches==NULL) return -EINVAL;

  int iResult=0;
  for (int i=0 ; i<(int)kSWTypeCount && pStopwatches->GetEntriesFast(); i++)
    SetStopwatch(pStopwatches->At(i), (AliHLTStopwatchType)i);
  return iResult;
}

AliHLTUInt32_t AliHLTComponent::GetRunNo() const
{
  // see header file for function documentation

  // 2010-02-11 OCDB is now the reliable source for the run number, it is
  // initialized either by aliroot or the external interface depending
  // on the environment. It turned out that the rundescriptor is not set
  // in the aliroot mode, resulting in an invalid run number. However this
  // did not cause problems until now. OCDB initialization has been revised
  // already in 10/2009. This was a remnant.
  // Have to check whether we get rid of the rundescriptor at some point.
  if (fpRunDesc==NULL) return AliHLTMisc::Instance().GetCDBRunNo();
  if (fpRunDesc->fRunNo!=(unsigned)AliHLTMisc::Instance().GetCDBRunNo()) {
    HLTWarning("run number mismatch: ocdb %d   run descriptor %d", AliHLTMisc::Instance().GetCDBRunNo(), fpRunDesc->fRunNo);
  }
  return fpRunDesc->fRunNo;
}

AliHLTUInt32_t AliHLTComponent::GetRunType() const
{
  // see header file for function documentation
  if (fpRunDesc==NULL) return kAliHLTVoidRunType;
  return fpRunDesc->fRunType;
}


AliHLTUInt32_t    AliHLTComponent::GetTimeStamp() const
{
  // see header file for function documentation
  if (fCurrentEventData.fEventCreation_s < kMaxUInt ) { 
    return  fCurrentEventData.fEventCreation_s;
  }
  // using the actual UTC if the time stamp was not set by the framework
  return static_cast<AliHLTUInt32_t>(time(NULL));
}

AliHLTUInt32_t    AliHLTComponent::GetPeriodNumber() const
{
  // see header file for function documentation
  return (GetEventId()>>36)&0xfffffff;
}

AliHLTUInt32_t    AliHLTComponent::GetOrbitNumber() const
{
  // see header file for function documentation
  return (GetEventId()>>12)&0xffffff;
}

AliHLTUInt16_t    AliHLTComponent::GetBunchCrossNumber() const
{
  // see header file for function documentation
  return GetEventId()&0xfff;
}

bool AliHLTComponent::IsDataEvent(AliHLTUInt32_t* pTgt) const
{
  // see header file for function documentation
  if (pTgt) *pTgt=fEventType;
  return (fEventType==gkAliEventTypeData ||
	  fEventType==gkAliEventTypeDataReplay);
}

int AliHLTComponent::CopyStruct(void* pStruct, unsigned int iStructSize, unsigned int iBlockNo,
				const char* structname, const char* eventname)
{
  // see header file for function documentation
  int iResult=0;
  if (pStruct!=NULL && iStructSize>sizeof(AliHLTUInt32_t)) {
    if (fpInputBlocks!=NULL && iBlockNo<fCurrentEventData.fBlockCnt) {
      AliHLTUInt32_t* pTgt=(AliHLTUInt32_t*)pStruct;
      if (fpInputBlocks[iBlockNo].fPtr && fpInputBlocks[iBlockNo].fSize) {
	AliHLTUInt32_t copy=*((AliHLTUInt32_t*)fpInputBlocks[iBlockNo].fPtr);
	if (fpInputBlocks[iBlockNo].fSize!=copy) {
	  HLTWarning("%s event: mismatch of block size (%d) and structure size (%d)", eventname, fpInputBlocks[iBlockNo].fSize, copy);
	  if (copy>fpInputBlocks[iBlockNo].fSize) copy=fpInputBlocks[iBlockNo].fSize;
	}
	if (copy!=iStructSize) {
	  HLTWarning("%s event: mismatch in %s version (data type version %d)", eventname, structname, ALIHLT_DATA_TYPES_VERSION);
	  if (copy>iStructSize) {
	    copy=iStructSize;
	  } else {
	    memset(pTgt, 0, iStructSize);
	  }
	}
	memcpy(pTgt, fpInputBlocks[iBlockNo].fPtr, copy);
	*pTgt=iStructSize;
	iResult=copy;
      } else {
	HLTWarning("%s event: missing data block", eventname);
      }
    } else {
      iResult=-ENODATA;
    }
  } else {
    HLTError("invalid struct");
    iResult=-EINVAL;
  }
  return iResult;
}

AliHLTUInt32_t AliHLTComponent::CalculateChecksum(const AliHLTUInt8_t* buffer, int size)
{
  // see header file for function documentation
  AliHLTUInt32_t  remainder = 0; 
  const AliHLTUInt8_t crcwidth=(8*sizeof(AliHLTUInt32_t));
  const AliHLTUInt32_t topbit=1 << (crcwidth-1);
  const AliHLTUInt32_t polynomial=0xD8;  /* 11011 followed by 0's */

  // code from
  // http://www.netrino.com/Embedded-Systems/How-To/CRC-Calculation-C-Code

  /*
   * Perform modulo-2 division, a byte at a time.
   */
  for (int byte = 0; byte < size; ++byte)
    {
      /*
       * Bring the next byte into the remainder.
       */
      remainder ^= (buffer[byte] << (crcwidth - 8));

      /*
       * Perform modulo-2 division, a bit at a time.
       */
      for (uint8_t bit = 8; bit > 0; --bit)
        {
	  /*
	   * Try to divide the current data bit.
	   */
	  if (remainder & topbit)
            {
	      remainder = (remainder << 1) ^ polynomial;
            }
	  else
            {
	      remainder = (remainder << 1);
            }
        }
    }

  /*
   * The final remainder is the CRC result.
   */
  return (remainder);
}

int AliHLTComponent::ExtractComponentTableEntry(const AliHLTUInt8_t* pBuffer, AliHLTUInt32_t size,
						string& retChainId, string& retCompId, string& retCompArgs,
						vector<AliHLTUInt32_t>& parents, int& level)
{
  // see header file for function documentation
  retChainId.clear();
  retCompId.clear();
  retCompArgs.clear();
  parents.clear();
  level=-1;
  if (!pBuffer || size==0) return 0;

  const AliHLTComponentTableEntry* pEntry=reinterpret_cast<const AliHLTComponentTableEntry*>(pBuffer);
  if (size<8/* the initial size of the structure*/ ||
      pEntry==NULL || pEntry->fStructSize<8) return -ENOMSG;

  if (pEntry->fStructSize!=sizeof(AliHLTComponentTableEntry)) return -EBADF;
  level=pEntry->fLevel;
  const AliHLTUInt32_t* pParents=reinterpret_cast<const AliHLTUInt32_t*>(pEntry->fBuffer);
  const AliHLTUInt8_t* pEnd=pBuffer+size;

  if (pParents+pEntry->fNofParents>=reinterpret_cast<const AliHLTUInt32_t*>(pEnd)) return -ENODEV;
  for (unsigned int i=0; i<pEntry->fNofParents; i++, pParents++) {
    parents.push_back(*pParents);
  }

  const char* pDescription=reinterpret_cast<const char*>(pParents);
  if (pDescription+pEntry->fSizeDescription>=reinterpret_cast<const char*>(pEnd) ||
      *(pDescription+pEntry->fSizeDescription)!=0) {
    return -EBADF;
  }

  TString descriptor=reinterpret_cast<const char*>(pDescription);
  TString chainId;
  TString compId;
  TString compArgs;
  TObjArray* pTokens=descriptor.Tokenize("{");
  if (pTokens) {
    int n=0;
    if (pTokens->GetEntriesFast()>n) {
      retChainId=pTokens->At(n++)->GetName();
    }
    if (pTokens->GetEntriesFast()>n) {
      compId=pTokens->At(n++)->GetName();
    }
    delete pTokens;
  }
  if (!compId.IsNull() && (pTokens=compId.Tokenize(":"))!=NULL) {
    int n=0;
    if (pTokens->GetEntriesFast()>n) {
      compId=pTokens->At(n++)->GetName();
    }
    if (pTokens->GetEntriesFast()>n) {
      compArgs=pTokens->At(n++)->GetName();
    }
    delete pTokens;
  }
  compId.ReplaceAll("}", "");
  compArgs.ReplaceAll("}", "");

  retCompId=compId;
  retCompArgs=compArgs;

  if (retChainId.size()==0) return -ENODATA;

  return 1;
}

int AliHLTComponent::ExtractTriggerData(
    const AliHLTComponentTriggerData& trigData,
    const AliHLTUInt8_t (**attributes)[gkAliHLTBlockDAttributeCount],
    AliHLTUInt64_t* status,
    AliHLTCDHWrapper* const cdh,
    AliHLTReadoutList* readoutlist,
    bool printErrors
  )
{
  // see header file for function documentation
  
  // Check that the trigger data structure is the correct size.
  if (trigData.fStructSize != sizeof(AliHLTComponentTriggerData))
  {
    if (printErrors)
    {
      AliHLTLogging log;
      log.LoggingVarargs(kHLTLogError, Class_Name(), FUNCTIONNAME(), __FILE__, __LINE__,
          "Invalid trigger structure size: %d but expected %d.", trigData.fStructSize, sizeof(AliHLTComponentTriggerData)
        );
    }
    return -ENOENT;
  }
  
  // Get the size of the AliHLTEventTriggerData structure without the readout list part.
  // The way we do this here should also handle memory alignment correctly.
  AliHLTEventTriggerData* dummy = NULL;
  size_t sizeWithoutReadout = (char*)(&dummy->fReadoutList) - (char*)(dummy);
  
  // Check that the trigger data pointer points to data of a size we can handle.
  // Either it is the size of AliHLTEventTriggerData or the size of the old
  // version of AliHLTEventTriggerData using AliHLTEventDDLV0.
  if (trigData.fDataSize != sizeof(AliHLTEventTriggerData) and
      trigData.fDataSize != sizeWithoutReadout + sizeof(AliHLTEventDDLV0)
     )
  {
    if (printErrors)
    {
      AliHLTLogging log;
      log.LoggingVarargs(kHLTLogError, Class_Name(), FUNCTIONNAME(), __FILE__, __LINE__,
          "Invalid trigger data size: %d but expected %d.", trigData.fDataSize, sizeof(AliHLTEventTriggerData)
        );
    }
    return -EBADF;
  }
  
  AliHLTEventTriggerData* evtData = reinterpret_cast<AliHLTEventTriggerData*>(trigData.fData);
  assert(evtData != NULL);
  
  // Check that the CDH has the right number of words.
  if (cdh != NULL and evtData->fCommonHeaderWordCnt != gkAliHLTCommonHeaderCount)
  {
    if (printErrors)
    {
      AliHLTLogging log;
      log.LoggingVarargs(kHLTLogError, Class_Name(), FUNCTIONNAME(), __FILE__, __LINE__,
          "Common Data Header (CDH) has wrong number of data words: %d but expected %d",
          evtData->fCommonHeaderWordCnt, gkAliHLTCommonHeaderCount
        );
    }
    return -EBADMSG;
  }
  
  // Check that the readout list has the correct count of words. i.e. something we can handle,
  if (readoutlist != NULL and
      evtData->fReadoutList.fCount != (unsigned)gkAliHLTDDLListSizeV0 and
      evtData->fReadoutList.fCount != (unsigned)gkAliHLTDDLListSizeV1
     )
  {
    if (printErrors)
    {
      AliHLTLogging log;
      log.LoggingVarargs(kHLTLogError, Class_Name(), FUNCTIONNAME(), __FILE__, __LINE__,
          "Readout list structure has wrong number of data words: %d but expected %d",
          evtData->fReadoutList.fCount, gkAliHLTDDLListSize
        );
    }
    return -EPROTO;
  }
  
  if (attributes != NULL)
  {
    *attributes = &evtData->fAttributes;
  }
  if (status != NULL)
  {
    *status = evtData->fHLTStatus;
  }
  if (cdh != NULL)
  {
    *cdh = &(evtData->fCommonHeader[0]);
  }
  if (readoutlist != NULL)
  {
    *readoutlist = AliHLTReadoutList(evtData->fReadoutList);
  }
  return 0;
}

AliHLTUInt32_t AliHLTComponent::ExtractEventTypeFromCDH(const AliHLTCDHWrapper* const cdh)
{
  // see header file for function documentation
  UChar_t l1msg = cdh->GetL1TriggerMessage();
  if ((l1msg & 0x1) == 0x0) return gkAliEventTypeData;
  // The L2SwC bit must be one if we got here, i.e. l1msg & 0x1 == 0x1.
  if (((l1msg >> 2) & 0xF) == 0xE) return gkAliEventTypeStartOfRun;
  if (((l1msg >> 2) & 0xF) == 0xF) return gkAliEventTypeEndOfRun;
  // Check the C1T bit to see if this is a calibration event,
  // if not then it must be some other software trigger event.
  if (((l1msg >> 6) & 0x1) == 0x1) return gkAliEventTypeCalibration;
  return gkAliEventTypeSoftware;
}

int AliHLTComponent::LoggingVarargs(AliHLTComponentLogSeverity severity, 
				    const char* originClass, const char* originFunc,
				    const char* file, int line, ... ) const
{
  // see header file for function documentation
  int iResult=0;

  va_list args;
  va_start(args, line);

  // logging function needs to be const in order to be called from const member functions
  // without problems. But at this point we face the problem with virtual members which
  // are not necessarily const.
  AliHLTComponent* nonconst=const_cast<AliHLTComponent*>(this);
  AliHLTLogging::SetLogString(this, ", %p", "%s (%s_pfmt_): ", 
			      fChainId[0]!=0?fChainId.c_str():nonconst->GetComponentID(),
			      nonconst->GetComponentID());
  iResult=SendMessage(severity, originClass, originFunc, file, line, AliHLTLogging::BuildLogString(NULL, args, true /*append*/));
  va_end(args);

  return iResult;
}

TUUID AliHLTComponent::GenerateGUID()
{
  // Generates a globally unique identifier.

  // Start by creating a new UUID. We cannot use the one automatically generated
  // by ROOT because the algorithm used will not guarantee unique IDs when generating
  // these UUIDs at a high rate in parallel.
  TUUID uuid;
  // We then use the generated UUID to form part of the random number seeds which
  // will be used to generate a proper random UUID. For good measure we use a MD5
  // hash also. Note that we want to use the TUUID class because it will combine the
  // host address information into the UUID. Using gSystem->GetHostByName() apparently
  // can cause problems on Windows machines with a firewall, because it always tries
  // to contact a DNS. The TUUID class handles this case appropriately.
  union
  {
    UChar_t buf[16];
    UShort_t word[8];
    UInt_t dword[4];
  };
  uuid.GetUUID(buf);
  TMD5 md5;
  md5.Update(buf, sizeof(buf));
  TMD5 md52 = md5;
  md5.Final(buf);
  dword[0] += gSystem->GetUid();
  dword[1] += gSystem->GetGid();
  dword[2] += gSystem->GetPid();
  for (int i = 0; i < 4; ++i)
  {
    gRandom->SetSeed(dword[i]);
    dword[i] = gRandom->Integer(0xFFFFFFFF);
  }
  md52.Update(buf, sizeof(buf));
  md52.Final(buf);
  // To keep to the standard we need to set the version and reserved bits.
  word[3] = (word[3] & 0x0FFF) | 0x4000;
  buf[8] = (buf[8] & 0x3F) | 0x80;

  // Create the name of the new class and file.
  char uuidstr[64];
  sprintf(uuidstr, "%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x",
    dword[0], word[2], word[3], buf[8], buf[9], buf[10], buf[11], buf[12], buf[13], buf[14], buf[15]
  );

  uuid.SetUUID(uuidstr);
  return uuid;
}

int AliHLTComponent::ScanECSParam(const char* ecsParam)
{
  // see header file for function documentation

  // format of the parameter string from ECS
  // <command>;<parameterkey>=<parametervalue>;<parameterkey>=<parametervalue>;...
  // search for a subset of the parameterkeys
  //   RUN_TYPE=
  //   RUN_NUMBER=
  //   HLT_IN_DDL_LIST=
  //   CTP_TRIGGER_CLASS=
  //   DATA_FORMAT_VERSION=
  //   BEAM_TYPE=
  //   HLT_OUT_DDL_LIST=
  //   HLT_TRIGGER_CODE=
  //   DETECTOR_LIST=
  //   HLT_MODE=
  // The command apears not to be sent by the online framework
  int iResult=0;
  TString string=ecsParam;
  TObjArray* parameter=string.Tokenize(";");
  if (parameter) {
    for (int i=0; i<parameter->GetEntriesFast(); i++) {
      TString entry=parameter->At(i)->GetName();
      HLTDebug("scanning ECS entry: %s", entry.Data());
      TObjArray* entryParams=entry.Tokenize("=");
      if (entryParams) {
	if (entryParams->GetEntriesFast()>1) {
	  if ((((TObjString*)entryParams->At(0))->GetString()).CompareTo("CTP_TRIGGER_CLASS")==0) {
	    int result=InitCTPTriggerClasses(entryParams->At(1)->GetName());
	    if (iResult>=0 && result<0) iResult=result;
	  } else {
	    // TODO: scan the other parameters
	    // e.g. consistency check of run number
	  }
	}
	delete entryParams;
      }
    }
    delete parameter;
  }

  return iResult;
}

int AliHLTComponent::SetupCTPData()
{
  // see header file for function documentation
  if (fpCTPData) delete fpCTPData;
  fpCTPData=new AliHLTCTPData;
  if (!fpCTPData) return -ENOMEM;
  return 0;
}

int AliHLTComponent::InitCTPTriggerClasses(const char* ctpString)
{
  // see header file for function documentation
  if (!fpCTPData) return 0; // silently accept as the component has to announce that it want's the CTP info
  return fpCTPData->InitCTPTriggerClasses(ctpString);
}

bool AliHLTComponent::EvaluateCTPTriggerClass(const char* expression, AliHLTComponentTriggerData& trigData) const
{
  // see header file for function documentation
  if (!fpCTPData) {
    static bool bWarningThrown=false;
    if (!bWarningThrown) HLTError("Trigger classes not initialized, use SetupCTPData from DoInit()");
    bWarningThrown=true;
    return false;
  }

  return fpCTPData->EvaluateCTPTriggerClass(expression, trigData);
}

int AliHLTComponent::CheckCTPTrigger(const char* name) const
{
  // see header file for function documentation
  if (!fpCTPData) {
    static bool bWarningThrown=false;
    if (!bWarningThrown) HLTError("Trigger classes not initialized, use SetupCTPData from DoInit()");
    bWarningThrown=true;
    return false;
  }

  return fpCTPData->CheckTrigger(name);
}

Double_t AliHLTComponent::GetBz()
{
  // Returns Bz.
  return AliHLTMisc::Instance().GetBz();
}

Double_t AliHLTComponent::GetBz(const Double_t *r)
{
  // Returns Bz (kG) at the point "r" .
  return AliHLTMisc::Instance().GetBz(r);
}

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