ROOT logo
// $Id$
//**************************************************************************
//* This file is property of and copyright by the                          * 
//* ALICE Experiment at CERN, All rights reserved.                         *
//*                                                                        *
//* Primary Authors: Matthias Richter <Matthias.Richter@ift.uib.no>        *
//*                  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   AliHLTSystem.cxx
/// @author Matthias Richter
/// @date   
/// @brief  Implementation of HLT module management.
///

#include <cassert>
#include "AliHLTStdIncludes.h"
#include "AliHLTSystem.h"
#include "AliHLTComponentHandler.h"
#include "AliHLTComponent.h"
#include "AliHLTConfiguration.h"
#include "AliHLTConfigurationHandler.h"
#include "AliHLTOnlineConfiguration.h"
#include "AliHLTTask.h"
#include "AliHLTModuleAgent.h"
#include "AliHLTOfflineInterface.h"
#include "AliHLTDataSource.h"
#include "AliHLTOUT.h"
#include "AliHLTOUTHandler.h"
#include "AliHLTOUTTask.h"
#include "AliHLTControlTask.h"
#include "AliHLTDataBuffer.h"
#include "AliHLTMisc.h"
#include <TObjArray.h>
#include <TObjString.h>
#include <TStopwatch.h>
#include <TList.h>
//#include <TSystem.h>
#include <TROOT.h>
//#include <TInterpreter.h>

/** HLT default component libraries */
const char* AliHLTSystem::fgkHLTDefaultLibs[]= {
  "libAliHLTUtil.so", 
  "libAliHLTRCU.so", 
  "libAliHLTTPC.so", 
  //  "libAliHLTSample.so",
  "libAliHLTCalo.so",
  "libAliHLTEMCAL.so",
  "libAliHLTPHOS.so",
  "libAliHLTMUON.so",
  "libAliHLTTRD.so",
  "libAliHLTITS.so",
  "libAliHLTVZERO.so",
  "libAliHLTZDC.so",
  "libAliHLTGlobal.so",
  "libAliHLTTrigger.so",
  NULL
};

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

AliHLTSystem::AliHLTSystem(AliHLTComponentLogSeverity loglevel, const char* name,
			   AliHLTComponentHandler* pCompHandler,
			   AliHLTConfigurationHandler* pConfHandler
			   )
  : fpComponentHandler(pCompHandler==NULL?AliHLTComponentHandler::CreateHandler():pCompHandler)
  , fpConfigurationHandler(pConfHandler==NULL?AliHLTConfigurationHandler::CreateHandler():pConfHandler),
  fTaskList(),
  fState(0),
  fChains(),
  fStopwatches(new TObjArray),
  fEventCount(-1),
  fGoodEvents(-1),
  fpChainHandlers(NULL),
  fpEsdHandlers(NULL),
  fpProprietaryHandlers(NULL),
  fpHLTOUTTask(NULL),
  fpHLTOUT(NULL),
  fHLTOUTUse(0),
  fpControlTask(NULL),
  fName(name)
  , fECSParams()
  , fUseHLTOUTComponentTypeGlobal(true)
  , fDetMask(0)
{
  // see header file for class documentation
  // or
  // refer to README to build package
  // or
  // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt

  if (fgNofInstances++>0) {
    // July 2008: multiple instances are now allowed
    // AliHLTSystem is used in multiple instances for the kChain HLTOUT handler
    //HLTWarning("multiple instances of AliHLTSystem, you should not use more than one at a time");
  }
  SetGlobalLoggingLevel(loglevel);
  SetFrameworkLog(loglevel);
  if (fpComponentHandler) {
    AliHLTAnalysisEnvironment env;
    memset(&env, 0, sizeof(AliHLTAnalysisEnvironment));
    env.fStructSize=sizeof(AliHLTAnalysisEnvironment);
    env.fAllocMemoryFunc=AliHLTSystem::AllocMemory;
    env.fGetEventDoneDataFunc=AliHLTSystem::AllocEventDoneData;
    env.fLoggingFunc=NULL;
    fpComponentHandler->SetEnvironment(&env);
    InitAliLogFunc(fpComponentHandler);
    if (fgNofInstances==1) {
    fpComponentHandler->AnnounceVersion();
    }
  } else {
    HLTFatal("can not create Component Handler");
  }
  if (fpConfigurationHandler==NULL) {
    HLTFatal("can not create Configuration Handler");
  }
}

AliHLTSystem::~AliHLTSystem()
{
  // see header file for class documentation
  fgNofInstances--;
  CleanupHLTOUTHandlers();
  CleanTaskList();
  if (fpConfigurationHandler) {
    fpConfigurationHandler->Destroy();
  }
  fpConfigurationHandler=NULL;
  
  if (fpComponentHandler) {
    fpComponentHandler->Destroy();
  }
  fpComponentHandler=NULL;
  delete fStopwatches;

  // note: fpHLTOUTTask and fpControlTask are deleted by
  // CleanTaskList
}

int AliHLTSystem::fgNofInstances=0;

int AliHLTSystem::BuildTaskList(const char* id)
{
  // see header file for class documentation
  int iResult=0;
  if (id) {
    if (fpConfigurationHandler) {
      AliHLTConfiguration* pConf=fpConfigurationHandler->FindConfiguration(id);
      if (pConf) {
	iResult=BuildTaskList(pConf);
      } else {
	HLTError("unknown configuration \"%s\"", id);
	iResult=-EEXIST;
      }
    } else {
      iResult=-EFAULT;
    }
  } else {
    iResult=-EINVAL;
  }
  return iResult;
}

int AliHLTSystem::BuildTaskList(AliHLTConfiguration* pConf)
{
  // see header file for class documentation
  int iResult=0;
  if (pConf) {
    AliHLTTask* pTask=NULL;
    if ((pTask=FindTask(pConf->GetName()))!=NULL) {
      if (pTask->GetConf()!=pConf) {
	HLTError("configuration mismatch, there is already a task with configuration name \"%s\", but it is different. Most likely configuration %p is not registered properly", pConf->GetName(), pConf);
	iResult=-EEXIST;
      }
      // task for this configuration exists, terminate
      pTask=NULL;
    // check first if the configuration has all sources resolved, try to extract otherwise
    } else if (pConf->SourcesResolved()!=1 && pConf->ExtractSources(fpConfigurationHandler)!=1) {
	HLTError("configuration \"%s\" has unresolved sources, aborting ...", pConf->GetName());
	iResult=-ENOLINK;
    } else {
      pTask=new AliHLTTask(pConf);
      if (pTask==NULL) {
	iResult=-ENOMEM;
      } else {
	pTask->SetLocalLoggingLevel(GetLocalLoggingLevel());
      }
    }
    static int iterationLevel=0;
    if (pTask && iResult>=0) {
      // check for circular dependencies
      if ((iResult=pConf->FollowDependency(pConf->GetName()))>0) {
	HLTError("detected circular dependency for configuration \"%s\"", pTask->GetName());
	pTask->PrintDependencyTree(pTask->GetName(), 1/*use the configuration list*/);
	HLTError("aborted ...");
	iResult=-ELOOP;
      }
      if (iResult>=0) {
	// check whether all dependencies are already in the task list
	// create the missing ones
	// this step is an iterative process which calls this function again for the missing
	// configurations, in order to avoid the currently processed task to be created
	// again it is added to the list temporarily and removed afterwards
	// This is of high importance to preserve the order of the tasks. Furthermore, the
	// InsertTask method has to be used in order to set all the cross links right 
	fTaskList.Add(pTask);
	AliHLTConfiguration* pDep=pConf->GetFirstSource();
	while (pDep!=NULL && iResult>=0) {
	  HLTDebug("iteration %d: checking dependency %s (%p)", iterationLevel, pDep->GetName(), pDep);
	  if (FindTask(pDep->GetName())==NULL) {
	    HLTDebug("iteration %d: building task list for configuration %s (%p)", iterationLevel, pDep->GetName(), pDep);
	    iterationLevel++;
	    iResult=BuildTaskList(pDep);
	    iterationLevel--;
	  }
	  pDep=pConf->GetNextSource();
	}
	// remove the temporarily added task
	fTaskList.Remove(pTask);

	// insert the task and set the cross-links
	if (iResult>=0) {
	  HLTDebug("iteration %d: inserting task %s (%p)", iterationLevel, pTask->GetName(), pTask);
	  iResult=InsertTask(pTask);
	}
      } else {
	delete pTask;
	pTask=NULL;
      }
    }
  } else {
    iResult=-EINVAL;
  }
  return iResult;
}

int AliHLTSystem::CleanTaskList()
{
  // see header file for class documentation
  int iResult=0;
  fpHLTOUTTask=NULL;
  fpControlTask=NULL;
  TObjLink* lnk=NULL;
  while ((lnk=fTaskList.LastLink())!=NULL) {
    delete (lnk->GetObject());
    fTaskList.Remove(lnk);
  }

  return iResult;
}

int AliHLTSystem::InsertTask(AliHLTTask* pTask)
{
  // see header file for class documentation
  int iResult=0;
  if (fpControlTask==NULL) {
    fpControlTask=new AliHLTControlTask;
    if (!fpControlTask) return -ENOMEM;
    fTaskList.AddFirst(fpControlTask);
  }
  TObjLink *controlLnk=NULL;
  TObjLink *lnk = fTaskList.FirstLink();
  assert(!lnk || lnk->GetObject()==fpControlTask || fpControlTask==NULL);
  if (lnk && lnk->GetObject()==fpControlTask) {
    if (pTask->GetConf() && pTask->GetConf()->GetFirstSource()==NULL) {
      pTask->SetDependency(fpControlTask);
      fpControlTask->SetTarget(pTask);
    }
    controlLnk=lnk;
    lnk=lnk->Next();
  }
  if ((iResult=pTask->CheckDependencies())<=0)
    lnk=NULL;
  while (lnk && iResult>0) {
    AliHLTTask* pCurr = (AliHLTTask*)lnk->GetObject();
    //HLTDebug("checking  \"%s\"", pCurr->GetName());
    iResult=pTask->Depends(pCurr);
    if (iResult>0) {
      iResult=pTask->SetDependency(pCurr);
      pCurr->SetTarget(pTask);
      HLTDebug("set dependency  \"%s\" for configuration \"%s\"", pCurr->GetName(), pTask->GetName());
    }
    if (pCurr->Depends(pTask)) {
      // circular dependency
      HLTError("circular dependency: can not resolve dependencies for configuration \"%s\"", pTask->GetName());
      iResult=-ELOOP;
    } else if ((iResult=pTask->CheckDependencies())>0) {
      lnk = lnk->Next();
    }
  }
  if (iResult==0) {
      if (lnk) {
	fTaskList.AddAfter(lnk, pTask);
      } else if (controlLnk) {
	fTaskList.AddAfter(controlLnk, pTask);
      } else {
	fTaskList.AddFirst(pTask);
      }
      HLTDebug("task \"%s\" (%p) inserted (size %d)", pTask->GetName(), pTask, sizeof(AliHLTTask));
  } else if (iResult>0) {
    HLTError("can not resolve dependencies for configuration \"%s\" (%d unresolved)", pTask->GetName(), iResult);
    iResult=-ENOLINK;
  }
  return iResult;
}

AliHLTTask* AliHLTSystem::FindTask(const char* id)
{
  // see header file for class documentation
  AliHLTTask* pTask=NULL;
  if (id) {
    pTask=dynamic_cast<AliHLTTask*>(fTaskList.FindObject(id)); 
  }
  return pTask;
}

void AliHLTSystem::PrintTaskList()
{
  // see header file for class documentation
  HLTLogKeyword("task list");
  TObjLink *lnk = NULL;
  HLTMessage("Task List");
  lnk=fTaskList.FirstLink();
  while (lnk) {
    TObject* obj=lnk->GetObject();
    if (obj) {
      HLTMessage("  %s - status:", obj->GetName());
      AliHLTTask* pTask=(AliHLTTask*)obj;
      pTask->PrintStatus();
    } else {
    }
    lnk = lnk->Next();
  }
}

int AliHLTSystem::Run(Int_t iNofEvents, int bStop, AliHLTUInt64_t trgMask,
		      AliHLTUInt32_t timestamp, AliHLTUInt32_t eventtype,
		      AliHLTUInt32_t participatingDetectors)
{
  return Run(iNofEvents, bStop, AliHLTTriggerMask_t(trgMask), 
	     timestamp, eventtype, participatingDetectors);
}

int AliHLTSystem::Run(Int_t iNofEvents, int bStop, AliHLTTriggerMask_t trgMask,
		      AliHLTUInt32_t timestamp, AliHLTUInt32_t eventtype,
		      AliHLTUInt32_t participatingDetectors)
{
  // see header file for class documentation
  int iResult=0;
  int iCount=0;
  SetStatusFlags(kRunning);
  if (fEventCount>=0 || (iResult=InitTasks())>=0) {
    if (fEventCount>=0 || (iResult=StartTasks())>=0) {
      if (fEventCount==0) {
	InitBenchmarking(fStopwatches);
      } else {
	// Matthias Oct 11 2008 this is a bug
	// By resuming the stopwatches at this point, all continued counting, but the
	// starting and stopping is controlled by the AliHLTStopwatchGuard
	//ResumeBenchmarking(fStopwatches);    
      }
      for (int i=fEventCount; i<fEventCount+iNofEvents && iResult>=0; i++) {
	if (fpHLTOUTTask) {
	  if (iNofEvents>1 && i==fEventCount) {
	    HLTWarning("can not add more than one event to the HLTOUT, skipping all but last block");
	  }
	  // reset and prepare for new data
	  fpHLTOUTTask->Reset();
	}
	if (eventtype == 0) {
	  eventtype = gkAliEventTypeData;
	  participatingDetectors = 0x0;
	}
	if ((iResult=ProcessTasks(i, trgMask, timestamp, eventtype, participatingDetectors))>=0) {
	  fGoodEvents++;
	  iCount++;
	} else {
	  // TODO: define different running modes to either ignore errors in
	  // event processing or not
	  // currently ignored 
	  iResult=0;
	}
	AliHLTDataBuffer::SetGlobalEventCount(iCount);
      }
      fEventCount+=iNofEvents;
      if (bStop) StopTasks();
      else PauseBenchmarking(fStopwatches);
    }
    if (bStop) DeinitTasks();
  }
  if (iResult>=0) {
    iResult=iCount;
  } else  if (iResult==-126 /*ENOKEY*/) {
    iResult=0; // do not propagate the error
  }
  ClearStatusFlags(kRunning);
  AliHLTDataBuffer::PrintStatistics();
  return iResult;
}

int AliHLTSystem::InitTasks()
{
  // see header file for class documentation
  int iResult=0;
  TObjLink *lnk=fTaskList.FirstLink();

  if (lnk==NULL) {
    HLTInfo("Task list is empty, skipping HLT");
    return -126 /*ENOKEY*/;
  }
  while (lnk && iResult>=0) {
    TObject* obj=lnk->GetObject();
    if (obj) {
      AliHLTTask* pTask=(AliHLTTask*)obj;
      iResult=pTask->Init(NULL, fpComponentHandler);
//       ProcInfo_t ProcInfo;
//       gSystem->GetProcInfo(&ProcInfo);
//       HLTInfo("task %s initialized (%d), current memory usage %d %d", pTask->GetName(), iResult, ProcInfo.fMemResident, ProcInfo.fMemVirtual);
    } else {
    }
    lnk = lnk->Next();
  }
  if (iResult<0) {
    HLTError("can not initialize task list, error %d", iResult);
  }

  return iResult;
}

int AliHLTSystem::InitBenchmarking(TObjArray* pStopwatches)
{
  // see header file for class documentation
  int iResult=0;
  if (pStopwatches==NULL) return 0;

  for (int i=0; i<(int)AliHLTComponent::kSWTypeCount; i++) {
    TStopwatch* pStopwatch= new TStopwatch;
    if (pStopwatch) {
      pStopwatch->Reset();
      pStopwatches->AddAt(pStopwatch, i);
    } else {
      iResult=-ENOMEM;
      break;
    }
  }

  TObjLink *lnk=fTaskList.FirstLink();
  while (lnk && iResult>=0) {
    TObject* obj=lnk->GetObject();
    if (obj) {
      AliHLTTask* pTask=(AliHLTTask*)obj;
      AliHLTComponent* pComp=NULL;
      if (iResult>=0 && (pComp=pTask->GetComponent())!=NULL) {
	switch (pComp->GetComponentType()) {
	case AliHLTComponent::kProcessor:
	  pComp->SetStopwatches(pStopwatches);
	  break;
	case AliHLTComponent::kSource:
	  {
	    // this switch determines whether the time consumption of the
	    // AliHLTComponent base methods should be counted to the input
	    // stopwatch or base stopwatch.
	    //int inputBase=(int)AliHLTComponent::kSWBase;
	    int inputBase=(int)AliHLTComponent::kSWInput;
	    pComp->SetStopwatch(pStopwatches->At(inputBase), AliHLTComponent::kSWBase);
	    pComp->SetStopwatch(pStopwatches->At((int)AliHLTComponent::kSWInput), AliHLTComponent::kSWDA);
	  }
	  break;
	case AliHLTComponent::kSink:
	  {
	    // this switch determines whether the time consumption of the
	    // AliHLTComponent base methods should be counted to the output
	    // stopwatch or base stopwatch.
	    //int outputBase=(int)AliHLTComponent::kSWBase;
	    int outputBase=(int)AliHLTComponent::kSWOutput;
	    pComp->SetStopwatch(pStopwatches->At(outputBase), AliHLTComponent::kSWBase);
	    pComp->SetStopwatch(pStopwatches->At((int)AliHLTComponent::kSWOutput), AliHLTComponent::kSWDA);
	  }
	  break;
	default:
	  HLTWarning("unknown component type %d", (int)pComp->GetComponentType());
	}
      }
    } else {
    }
    lnk = lnk->Next();
  }
  return iResult;
}

int AliHLTSystem::PauseBenchmarking(TObjArray* pStopwatches) const
{
  // see header file for class documentation
  if (pStopwatches==NULL) return 0;

  for (int i=0; i<(int)AliHLTComponent::kSWTypeCount; i++) {
    if (!pStopwatches->At(i)) continue;
    TStopwatch* pSw=dynamic_cast<TStopwatch*>(pStopwatches->At(i));
    if (pSw) pSw->Stop();
  }
  return 0;
}

int AliHLTSystem::ResumeBenchmarking(TObjArray* pStopwatches) const
{
  // see header file for class documentation
  if (pStopwatches==NULL) return 0;

  for (int i=0; i<(int)AliHLTComponent::kSWTypeCount; i++) {
    if (!pStopwatches->At(i)) continue;
    TStopwatch* pSw=dynamic_cast<TStopwatch*>(pStopwatches->At(i));
    if (pSw) pSw->Continue();
  }
  return 0;
}

int AliHLTSystem::PrintBenchmarking(TObjArray* pStopwatches, int bClean) const
{
  // see header file for class documentation
  int iInitialized=1;
  if (pStopwatches==NULL) return 0;

  for (int i=0; i<(int)AliHLTComponent::kSWTypeCount; i++) {
    if (!dynamic_cast<TStopwatch*>(pStopwatches->At(i))) {
      iInitialized=0;
      break;
    }
  }

  if (iInitialized!=0) {
    HLTImportant("HLT statistics:\n"
	    "    base:              R:%.3fs C:%.3fs\n"
	    "    input:             R:%.3fs C:%.3fs\n"
	    "    output:            R:%.3fs C:%.3fs\n"
	    "    event processing : R:%.3fs C:%.3fs"
	    , dynamic_cast<TStopwatch*>(pStopwatches->At(AliHLTComponent::kSWBase))->RealTime()
	    , dynamic_cast<TStopwatch*>(pStopwatches->At(AliHLTComponent::kSWBase))->CpuTime()
	    , dynamic_cast<TStopwatch*>(pStopwatches->At(AliHLTComponent::kSWInput))->RealTime()
	    , dynamic_cast<TStopwatch*>(pStopwatches->At(AliHLTComponent::kSWInput))->CpuTime()
	    , dynamic_cast<TStopwatch*>(pStopwatches->At(AliHLTComponent::kSWOutput))->RealTime()
	    , dynamic_cast<TStopwatch*>(pStopwatches->At(AliHLTComponent::kSWOutput))->CpuTime()
	    , dynamic_cast<TStopwatch*>(pStopwatches->At(AliHLTComponent::kSWDA))->RealTime()
	    , dynamic_cast<TStopwatch*>(pStopwatches->At(AliHLTComponent::kSWDA))->CpuTime()
	    );
  }

  if (bClean) {
    for (int i=0; i<(int)AliHLTComponent::kSWTypeCount; i++) {
      TObject* pObj=pStopwatches->RemoveAt(i);
      if (pObj) delete pObj;
    }
  }
  return 0;
}

int AliHLTSystem::StartTasks()
{
  // see header file for class documentation
  int iResult=0;
  TObjLink *lnk=fTaskList.FirstLink();
  while (lnk && iResult>=0) {
    TObject* obj=lnk->GetObject();
    if (obj) {
      AliHLTTask* pTask=(AliHLTTask*)obj;
      iResult=pTask->StartRun();
//       ProcInfo_t ProcInfo;
//       gSystem->GetProcInfo(&ProcInfo);
//       HLTInfo("task %s started (%d), current memory usage %d %d", pTask->GetName(), iResult, ProcInfo.fMemResident, ProcInfo.fMemVirtual);
    } else {
    }
    lnk = lnk->Next();
  }
  if (iResult<0) {
    HLTError("can not start task list, error %d", iResult);
  } else {
    SetStatusFlags(kStarted);
    fEventCount=0;
    fGoodEvents=0;
    if ((iResult=SendControlEvent(kAliHLTDataTypeSOR))<0) {
      HLTError("can not send SOR event: error %d", iResult);
    }
  }
  return iResult;
}

int AliHLTSystem::ProcessTasks(Int_t eventNo, AliHLTTriggerMask_t trgMask,
	  AliHLTUInt32_t timestamp, AliHLTUInt32_t eventtype,
	  AliHLTUInt32_t participatingDetectors)
{
  // see header file for class documentation
  int iResult=0;
  HLTDebug("processing event no %d", eventNo);
  TObjLink *lnk=fTaskList.FirstLink();
  while (lnk) {
    TObject* obj=lnk->GetObject();
    if (obj) {
      AliHLTTask* pTask=(AliHLTTask*)obj;
      if (iResult>=0) {
      iResult=pTask->ProcessTask(eventNo, eventtype, trgMask, timestamp, participatingDetectors);
//       ProcInfo_t ProcInfo;
//       gSystem->GetProcInfo(&ProcInfo);
//       HLTInfo("task %s processed (%d), current memory usage %d %d", pTask->GetName(), iResult, ProcInfo.fMemResident, ProcInfo.fMemVirtual);
      } else {
	pTask->SubscribeSourcesAndSkip();
      }
    } else {
    }
    lnk = lnk->Next();
  }

  if (iResult>=0) {
    HLTImportant("Event %d successfully finished (%d)", eventNo, iResult);
    iResult=0;
  } else {
    HLTError("Processing of event %d failed (%d)", eventNo, iResult);
  }

  return iResult;
}

int AliHLTSystem::StopTasks()
{
  // see header file for class documentation
  int iResult=0;
  if ((iResult=SendControlEvent(kAliHLTDataTypeEOR))<0) {
    HLTError("can not send EOR event");
  }

  // cleanup blocks from the last event. This is a bit awkward. All output
  // blocks from the chains need to be stored in the HLTOUT task. Though,
  // we do not know, whether HLTOUT is going to be processed or not.
  if (fpHLTOUTTask)
    fpHLTOUTTask->Reset();

  TObjLink *lnk=fTaskList.FirstLink();
  while (lnk) {
    TObject* obj=lnk->GetObject();
    if (obj) {
      AliHLTTask* pTask=(AliHLTTask*)obj;
      int locResult=pTask->EndRun();
      if (iResult>=0 && locResult<0) iResult=locResult;
//       ProcInfo_t ProcInfo;
//       gSystem->GetProcInfo(&ProcInfo);
//       HLTInfo("task %s stopped (%d), current memory usage %d %d", pTask->GetName(), iResult, ProcInfo.fMemResident, ProcInfo.fMemVirtual);
    } else {
    }
    lnk = lnk->Next();
  }
  PrintBenchmarking(fStopwatches, 1 /*clean*/);
  if (fEventCount!=fGoodEvents) {
    HLTError("%d out of %d event(s) failed", fEventCount-fGoodEvents, fEventCount);
  }
  ClearStatusFlags(kStarted);
  return iResult;
}

int AliHLTSystem::SendControlEvent(AliHLTComponentDataType dt)
{
  // see header file for class documentation
  int iResult=0;

  AliHLTComponentBlockDataList controlBlocks;
  AliHLTComponentBlockData bd;

  // run decriptor block of type kAliHLTDataTypeSOR/kAliHLTDataTypeEOR 
  AliHLTComponent::FillBlockData(bd);
  AliHLTRunDesc runDesc;
  memset(&runDesc, 0, sizeof(AliHLTRunDesc));
  runDesc.fStructSize=sizeof(AliHLTRunDesc);
  runDesc.fRunNo=AliHLTMisc::Instance().GetCDBRunNo();
  bd.fPtr=&runDesc;
  bd.fSize=sizeof(AliHLTRunDesc);
  bd.fDataType=dt;
  bd.fSpecification=kAliHLTVoidDataSpec;
  controlBlocks.push_back(bd);

  // ECS parameter of type kAliHLTDataTypeECSParam
  if (fECSParams.IsNull())
    fECSParams="CTP_TRIGGER_CLASS=00:DUMMY-TRIGGER-ALL:00-01-02-03-04-05-06-07-08-09-10-11-12-13-14-15-16-17";
  AliHLTComponent::FillBlockData(bd);
  bd.fPtr=(void*)fECSParams.Data();
  bd.fSize=fECSParams.Length()+1;
  bd.fDataType=kAliHLTDataTypeECSParam;
  bd.fSpecification=kAliHLTVoidDataSpec;
  controlBlocks.push_back(bd);  

  AliHLTControlTask::AliHLTControlEventGuard g(fpControlTask, controlBlocks);
  HLTDebug("sending event %s, run descriptor %p", AliHLTComponent::DataType2Text(dt).c_str(), &runDesc);
  TObjLink *lnk=fTaskList.FirstLink();
  while (lnk && iResult>=0) {
    TObject* obj=lnk->GetObject();
    if (obj) {
      AliHLTTask* pTask=(AliHLTTask*)obj;
      AliHLTUInt32_t eventType=gkAliEventTypeUnknown;
      if (dt==kAliHLTDataTypeSOR) eventType=gkAliEventTypeStartOfRun;
      else if (dt==kAliHLTDataTypeEOR) eventType=gkAliEventTypeEndOfRun;
      else HLTWarning("unknown control event %s", AliHLTComponent::DataType2Text(dt).c_str());
      iResult=pTask->ProcessTask(-1, eventType, 0, 0);
    } else {
    }
    lnk = lnk->Next();
  }

  // control events are not supposed to go into the HLTOUT
  if (fpHLTOUTTask)
    fpHLTOUTTask->Reset();

  HLTDebug("event %s done (%d)", AliHLTComponent::DataType2Text(dt).c_str(), iResult);
  return iResult;
}

int AliHLTSystem::DeinitTasks()
{
  // see header file for class documentation
  int iResult=0;
  TObjLink *lnk=fTaskList.LastLink();
  while (lnk) {
    TObject* obj=lnk->GetObject();
    if (obj) {
      AliHLTTask* pTask=(AliHLTTask*)obj;
      int localRes=pTask->Deinit();
      if (iResult>=0) iResult=localRes;
//       ProcInfo_t ProcInfo;
//       gSystem->GetProcInfo(&ProcInfo);
//       HLTInfo("task %s cleaned (%d), current memory usage %d %d", pTask->GetName(), iResult, ProcInfo.fMemResident, ProcInfo.fMemVirtual);
    } else {
    }
    lnk = lnk->Prev();
  }
  fEventCount=-1;
  fGoodEvents=-1;

  return iResult;
}

int AliHLTSystem::CleanupHLTOUTHandlers()
{
  // see header file for class documentation
  if (fpChainHandlers) {
    AliHLTOUT::AliHLTOUTHandlerListEntryVector* pHandlers=reinterpret_cast<AliHLTOUT::AliHLTOUTHandlerListEntryVector*>(fpChainHandlers);
    fpChainHandlers=NULL;
    if (pHandlers) {
      AliHLTOUT::InvalidateBlocks(*pHandlers);
      AliHLTOUT::RemoveEmptyDuplicateHandlers(*pHandlers);
    }
    assert(pHandlers->size()==0);
    delete pHandlers;
  }

  if (fpEsdHandlers) {
    AliHLTOUT::AliHLTOUTHandlerListEntryVector* pHandlers=reinterpret_cast<AliHLTOUT::AliHLTOUTHandlerListEntryVector*>(fpEsdHandlers);
    fpEsdHandlers=NULL;
    if (pHandlers) {
      AliHLTOUT::InvalidateBlocks(*pHandlers);
      AliHLTOUT::RemoveEmptyDuplicateHandlers(*pHandlers);
    }
    assert(pHandlers->size()==0);
    delete pHandlers;
  }

  if (fpProprietaryHandlers) {
    AliHLTOUT::AliHLTOUTHandlerListEntryVector* pHandlers=reinterpret_cast<AliHLTOUT::AliHLTOUTHandlerListEntryVector*>(fpProprietaryHandlers);
    fpProprietaryHandlers=NULL;
    if (pHandlers) {
      AliHLTOUT::InvalidateBlocks(*pHandlers);
      AliHLTOUT::RemoveEmptyDuplicateHandlers(*pHandlers);
    }
    assert(pHandlers->size()==0);
    delete pHandlers;
  }
  return 0;
}

void* AliHLTSystem::AllocMemory( void* /*param*/, unsigned long size )
{
  // see header file for class documentation
  void* p=NULL;
  try {
    p=(void*)new char[size];
  }
  catch (...) {
    AliHLTLogging log;
    log.LoggingVarargs(kHLTLogError, "AliHLTSystem" , "AllocMemory" , __FILE__ , __LINE__ , "exeption during memory allocation" );
  }
  return p;
}

int AliHLTSystem::AllocEventDoneData( void* /*param*/, AliHLTEventID_t /*eventID*/, unsigned long size, AliHLTComponentEventDoneData** edd )
{
  // see header file for class documentation
  unsigned long blocksize=sizeof(AliHLTComponentEventDoneData)+size;
  void* block=AllocMemory(NULL, blocksize);
  if (!block) return -ENOMEM;
  memset(block, 0, blocksize);
  *edd=reinterpret_cast<AliHLTComponentEventDoneData*>(block);
  (*edd)->fStructSize=sizeof(AliHLTComponentEventDoneData);
  (*edd)->fDataSize=size;
  (*edd)->fData=reinterpret_cast<AliHLTUInt8_t*>(block)+sizeof(AliHLTComponentEventDoneData);
  
  return 0;
}

int AliHLTSystem::Reconstruct(int nofEvents, AliRunLoader* runLoader, 
			      AliRawReader* rawReader)
{
  // see header file for class documentation
  int iResult=0;
  if (runLoader || rawReader || nofEvents==0) {
    if (nofEvents>0) {HLTInfo("Run Loader %p, Raw Reader %p , %d event(s)", runLoader, rawReader, nofEvents);}
    if (CheckStatus(kReady)) {
      if (nofEvents==0) {
	// special case to close the reconstruction
	if (!CheckStatus(kError)) {
	StopTasks();
	DeinitTasks();
	CleanupHLTOUTHandlers();
	}
      } else {
      if ((iResult=AliHLTOfflineInterface::SetParamsToComponents(runLoader, rawReader))>=0) {
	AliHLTTriggerMask_t trgMask=0x1;
	AliHLTUInt32_t timestamp=kMaxUInt;
	AliHLTUInt32_t eventtype=0;
	if (runLoader==NULL) {
	  // this is a quick workaround for the case of simulation
	  // the trigger framework is still under development, secondly, AliHLTSimulation
	  // does not yet add the emulated ECS parameters, so no CTP trigger is known in the HLT
	  // AliHLTTask will initialize one dummy CTP trigger class with bit 0, that's why the
	  // default trigger mask is 0x1
	  trgMask=AliHLTMisc::Instance().GetTriggerMask(rawReader);

	  // get the timestamp and type of the event from the raw reader
	  // this is currently only meaningfull for reconstruction (runloader==NULL)
	  timestamp=AliHLTMisc::Instance().GetTimeStamp(rawReader);
	  eventtype=AliHLTMisc::Instance().GetEventType(rawReader);
	}
	// the system always remains started after event processing, a specific
	// call with nofEvents==0 is needed to execute the stop sequence
	if ((iResult=Run(nofEvents, 0, trgMask, timestamp, eventtype))<0) SetStatusFlags(kError);
      }
      }

      // add the current HLTOUT task to the collection
      if (fpHLTOUTTask) {
	AliHLTOUT* pTask=dynamic_cast<AliHLTOUT*>(fpHLTOUTTask);
	if (pTask && (iResult=pTask->Init())>=0) {
	  if (pTask->GetNofDataBlocks()>0) {
	    AliHLTOUT* pHLTOUT=RequestHLTOUT();
	    if (pHLTOUT) {
	      pHLTOUT->AddSubCollection(pTask);
	      ReleaseHLTOUT(pHLTOUT);
	    } else {
	      HLTWarning("no HLTOUT instance available, output blocks of the chain are ignored");
	    }
	  }
	} else {
	  HLTWarning("can not initialize HLTOUT sub collection %s for reconstruction chain (%d), data blocks are lost", pTask?fpHLTOUTTask->GetName():"nil", iResult);
	  iResult=0;
	}
      }
    } else {
      HLTError("wrong state %#x, required flags %#x", GetStatusFlags(), kReady);
    }
  } else {
    HLTError("missing RunLoader (%p)/RawReader (%p) instance", runLoader, rawReader);
    iResult=-EINVAL;
  }
  return iResult;
}

int AliHLTSystem::FillESD(int eventNo, AliRunLoader* runLoader, AliESDEvent* esd)
{
  // see header file for class documentation
  int iResult=0;
  if (runLoader || esd) {
    HLTInfo("Event %d: Run Loader %p, ESD %p", eventNo, runLoader, esd);
    iResult=AliHLTOfflineInterface::FillComponentESDs(eventNo, runLoader, esd);
  } else {
    HLTError("missing run loader/ESD instance(s)");
    iResult=-EINVAL;
  }
  return iResult;
}

int AliHLTSystem::ProcessHLTOUT(AliHLTOUT* pHLTOUT, AliESDEvent* esd)
{
  // see header file for class documentation
  int iResult=0;
  if (!pHLTOUT) return -EINVAL;
  HLTDebug("processing %d HLT data blocks", pHLTOUT->GetNofDataBlocks());

  //
  // process all kChain handlers first
  //
  if ((iResult=ProcessHLTOUTkChain(pHLTOUT))<0) {
    HLTWarning("Processing of kChain-type data blocks failed with error code %d", iResult);
    iResult=0;
  } 

  if (!fpEsdHandlers)
    fpEsdHandlers=new AliHLTOUT::AliHLTOUTHandlerListEntryVector;
  if (!fpProprietaryHandlers)
    fpProprietaryHandlers=new AliHLTOUT::AliHLTOUTHandlerListEntryVector;

  AliHLTOUT::AliHLTOUTHandlerListEntryVector* pEsdHandlers=reinterpret_cast<AliHLTOUT::AliHLTOUTHandlerListEntryVector*>(fpEsdHandlers);
  AliHLTOUT::AliHLTOUTHandlerListEntryVector* pProprietaryHandlers=reinterpret_cast<AliHLTOUT::AliHLTOUTHandlerListEntryVector*>(fpProprietaryHandlers);
  if (!pEsdHandlers || !pProprietaryHandlers) return -ENOMEM;

  // invalidate all blocks
  AliHLTOUT::InvalidateBlocks(*pEsdHandlers);
  AliHLTOUT::InvalidateBlocks(*pProprietaryHandlers);

  AliHLTComponentDataTypeList esdBlocks;

  for (iResult=pHLTOUT->SelectFirstDataBlock();
       iResult>=0;
       iResult=pHLTOUT->SelectNextDataBlock()) {
    AliHLTComponentDataType dt=kAliHLTVoidDataType;
    AliHLTUInt32_t spec=kAliHLTVoidDataSpec;
    pHLTOUT->GetDataBlockDescription(dt, spec);
    AliHLTOUTHandler* pHandler=pHLTOUT->GetHandler();
    AliHLTModuleAgent::AliHLTOUTHandlerType handlerType=pHLTOUT->GetDataBlockHandlerType();

    // default handling for ESD data blocks does not require an explicite handler
    if (!pHandler && (dt==kAliHLTDataTypeESDObject || dt==kAliHLTDataTypeESDTree)) {
      handlerType=AliHLTModuleAgent::kEsd;
    }
    const char* pMsg="invalid";
    switch (handlerType) {
    case AliHLTModuleAgent::kEsd:
      {
	if (pHandler) {
	  // schedule for later processing
	  pHLTOUT->InsertHandler(*pEsdHandlers, pHLTOUT->GetDataBlockHandlerDesc());
	} else {
	  AliHLTComponentDataTypeList::iterator element=esdBlocks.begin();
	  for (; element!=esdBlocks.end(); element++) {
	    if (*element==dt) {
	      HLTWarning("multiple ESDs of identical data type %s, please add appropriate handler to merge ESDs", AliHLTComponent::DataType2Text(dt).c_str());
	      break;
	    }
	  }
	  if (element==esdBlocks.end()) esdBlocks.push_back(dt);

	  // write directly
	  const AliHLTUInt8_t* pBuffer=NULL;
	  AliHLTUInt32_t size=0;
	  if (pHLTOUT->GetDataBuffer(pBuffer, size)>=0) {
	    pHLTOUT->WriteESD(pBuffer, size, dt, esd);
	    pHLTOUT->ReleaseDataBuffer(pBuffer);
	  }
	  pHLTOUT->MarkDataBlockProcessed();
	}
      }
      break;
    case AliHLTModuleAgent::kRawReader:
      // handled in the AliRawReaderHLT
      break;
    case AliHLTModuleAgent::kRawStream:
      HLTWarning("HLTOUT handler type 'kRawStream' not yet implemented: agent %s, data type %s, specification %#x",
		 pHLTOUT->GetAgent()?pHLTOUT->GetAgent()->GetModuleId():"<invalid>",
		 AliHLTComponent::DataType2Text(dt).c_str(), spec);
      break;
    case AliHLTModuleAgent::kChain:
      HLTWarning("HLTOUT handler type 'kChain' has already been processed: agent %s, data type %s, specification %#x\n"
		 "New block of this type added by the chain? Skipping data block ...",
		 pHLTOUT->GetAgent()?pHLTOUT->GetAgent()->GetModuleId():"<invalid>",
		 AliHLTComponent::DataType2Text(dt).c_str(), spec);
      break;
    case AliHLTModuleAgent::kProprietary:
      HLTDebug("processing proprietary data: agent %s, data type %s, specification %#x",
		 pHLTOUT->GetAgent()?pHLTOUT->GetAgent()->GetModuleId():"<invalid>",
		 AliHLTComponent::DataType2Text(dt).c_str(), spec);
      if (pHandler) {
	AliHLTOUT::AliHLTOUTLockGuard g(pHLTOUT);
	int res=pHandler->ProcessData(pHLTOUT);
	if (res<0) {
	  HLTWarning("processing proprietary data failed (%d): agent %s, data type %s, specification %#x",
		     res, pHLTOUT->GetAgent()?pHLTOUT->GetAgent()->GetModuleId():"<invalid>",
		     AliHLTComponent::DataType2Text(dt).c_str(), spec);
	}
      }
      break;
    case AliHLTModuleAgent::kUnknownOutput:
      pMsg="unknown";
      // fall trough intended
    default:
      HLTWarning("%s handler type: agent %s, data type %s, specification %#x, ... skipping data block",
		 pMsg, pHLTOUT->GetAgent()?pHLTOUT->GetAgent()->GetModuleId():"<invalid>",
		 AliHLTComponent::DataType2Text(dt).c_str(), spec);
    }
  }
  // TODO: the return value of SelectFirst/NextDataBlock must be
  // changed in order to avoid this check
  if (iResult==-ENOENT) iResult=0;

  AliHLTOUT::AliHLTOUTHandlerListEntryVector::iterator handler;

  // process and write all esd data blocks
  for (handler=pEsdHandlers->begin(); handler!=pEsdHandlers->end() && iResult>=0; handler++) {
    AliHLTOUT::AliHLTOUTSelectionGuard g(pHLTOUT, &(*handler));	    
    AliHLTOUTHandler* pHandler=*handler;
    const AliHLTUInt8_t* pBuffer=NULL;
    AliHLTUInt32_t size=0;
    pHandler->ProcessData(pHLTOUT);
    if ((size=pHandler->GetProcessedData(pBuffer))>0) {
      AliHLTModuleAgent::AliHLTOUTHandlerDesc desc=*handler;
      AliHLTComponentDataType dt=desc;
      pHLTOUT->WriteESD(pBuffer, size, dt, esd);
      pHandler->ReleaseProcessedData(pBuffer, size);
    }
    pHLTOUT->MarkDataBlocksProcessed(&(*handler));
  }

  // process all kProprietary data blocks
  for (handler=pProprietaryHandlers->begin(); handler!=pProprietaryHandlers->end() && iResult>=0; handler++) {
    AliHLTOUT::AliHLTOUTSelectionGuard g(pHLTOUT, &(*handler));	    
    AliHLTOUTHandler* pHandler=*handler;
    const AliHLTUInt8_t* pBuffer=NULL;
    AliHLTUInt32_t size=0;
    pHandler->ProcessData(pHLTOUT);
    if ((size=pHandler->GetProcessedData(pBuffer))>0) {
      HLTWarning("data produced by kProprietary handler ignored");
      pHandler->ReleaseProcessedData(pBuffer, size);
    }
    pHLTOUT->MarkDataBlocksProcessed(&(*handler));
  }

  // remove all empty handlers form the list (handlers which did not get a block this time)
  AliHLTOUT::RemoveEmptyDuplicateHandlers(*pEsdHandlers);
  AliHLTOUT::RemoveEmptyDuplicateHandlers(*pProprietaryHandlers);

  return iResult;
}

int AliHLTSystem::ProcessHLTOUTkChain(AliHLTOUT* pHLTOUT)
{
  // see header file for class documentation
  int iResult=0;
  if (!pHLTOUT) return -EINVAL;

  if (!fpChainHandlers)
    fpChainHandlers=new AliHLTOUT::AliHLTOUTHandlerListEntryVector;

  AliHLTOUT::AliHLTOUTHandlerListEntryVector* pChainHandlers=reinterpret_cast<AliHLTOUT::AliHLTOUTHandlerListEntryVector*>(fpChainHandlers);
  if (!pChainHandlers) return -ENOMEM;

  // invalidate all blocks
  AliHLTOUT::InvalidateBlocks(*pChainHandlers);

  // fill the list
  pHLTOUT->FillHandlerList(*pChainHandlers, AliHLTModuleAgent::kChain);

  // process all defined chain handlers
  AliHLTOUT::AliHLTOUTHandlerListEntryVector::iterator chainHandler;
  for (chainHandler=pChainHandlers->begin(); chainHandler!=pChainHandlers->end() && iResult>=0; chainHandler++) {
    if (chainHandler->IsEmpty()) continue;
    AliHLTOUT::AliHLTOUTSelectionGuard g(pHLTOUT, &(*chainHandler));	    
    AliHLTOUTHandler* pHandler=*chainHandler;
    const AliHLTUInt8_t* pBuffer=NULL;
    AliHLTUInt32_t size=0;
    pHandler->ProcessData(pHLTOUT);
    if ((size=pHandler->GetProcessedData(pBuffer))>0) {
      AliHLTModuleAgent::AliHLTOUTHandlerDesc desc=*chainHandler;
      //AliHLTComponentDataType dt=desc;

      pHandler->ReleaseProcessedData(pBuffer, size);
    }
    pHLTOUT->MarkDataBlocksProcessed(&(*chainHandler));
  }

  // remove all empty handlers form the list (handlers which did not get a block this time)
  AliHLTOUT::RemoveEmptyDuplicateHandlers(*pChainHandlers);

  return iResult;
}

int AliHLTSystem::LoadComponentLibraries(const char* libraries)
{
  // see header file for class documentation
  int iResult=0;
  if (libraries) {
    if (fpComponentHandler) {
      TString libs(libraries);
      TObjArray* pTokens=libs.Tokenize(" ");
      if (pTokens) {
	int iEntries=pTokens->GetEntriesFast();
	for (int i=0; i<iEntries && iResult>=0; i++) {
	  if (!pTokens->At(i)) continue;
	  iResult=fpComponentHandler->LoadLibrary(pTokens->At(i)->GetName());
	}
	delete pTokens;
      }
      if (iResult>=0) {
	SetStatusFlags(kLibrariesLoaded);
      } else {
	// lets see if we need this, probably not
	//fpComponentHandler->UnloadLibraries();
	ClearStatusFlags(kLibrariesLoaded);
      }
    } else {
      iResult=-EFAULT;
      HLTFatal("no component handler available");
    }
  } else {
    iResult=-EINVAL;
  }
  return iResult;
}

int AliHLTSystem::Configure(AliRunLoader* runloader)
{
  // see header file for class documentation
  return Configure(NULL, runloader);
}

int AliHLTSystem::Configure(AliRawReader* rawReader, AliRunLoader* runloader)
{
  // see header file for class documentation
  int iResult=0;
  if (CheckStatus(kRunning)) {
    HLTError("HLT system in running state, can not configure");
    return -EBUSY;
  }
  ClearStatusFlags(kTaskListCreated);
  if (CheckFilter(kHLTLogDebug))
    AliHLTModuleAgent::PrintStatus();
  if (CheckStatus(kConfigurationLoaded)==0) {
    iResult=LoadConfigurations(rawReader, runloader);
  } else {
    if (fChains.Length()==0) {
      HLTError("custom configuration(s) specified, but no configuration to run in local reconstruction, use \'chains=<chain,...>\' option");
      iResult=-ENOENT;
    }
  }
  if (iResult>=0) {
    SetStatusFlags(kConfigurationLoaded);
    if (CheckFilter(kHLTLogDebug))
      fpConfigurationHandler->PrintConfigurations();
    iResult=BuildTaskListsFromReconstructionChains(rawReader, runloader);
    if (iResult>=0) {
      SetStatusFlags(kTaskListCreated);
    }
  }
  if (iResult<0) SetStatusFlags(kError);
  
  return iResult;
}

int AliHLTSystem::ScanOptions(const char* options)
{
  // see header file for class documentation
  int iResult=0;
  if (options) {
    //AliHLTComponentHandler::TLibraryMode libMode=AliHLTComponentHandler::kDynamic;
    TString libs("");
    TString excludelibs("");
    TString alloptions(options);
    TObjArray* pTokens=alloptions.Tokenize(" ");
    if (pTokens) {
      int iEntries=pTokens->GetEntriesFast();
      for (int i=0; i<iEntries; i++) {
	if (!pTokens->At(i)) continue;
	TString token=pTokens->At(i)->GetName();
	if (token.Contains("loglevel=")) {
	  TString param=token.ReplaceAll("loglevel=", "");
	  if (param.IsDigit()) {
	    SetGlobalLoggingLevel((AliHLTComponentLogSeverity)param.Atoi());
	  } else if (param.BeginsWith("0x") &&
		     param.Replace(0,2,"",0).IsHex()) {
	    int severity=0;
	    sscanf(param.Data(),"%x", &severity);
	    SetGlobalLoggingLevel((AliHLTComponentLogSeverity)severity);
	  } else {
	    HLTWarning("wrong parameter for option \'loglevel=\', (hex) number expected");
	  }
	} else if (token.Contains("frameworklog=")) {
	  TString param=token.ReplaceAll("frameworklog=", "");
	  if (param.IsDigit()) {
	    SetFrameworkLog((AliHLTComponentLogSeverity)param.Atoi());
	  } else if (param.BeginsWith("0x") &&
		     param.Replace(0,2,"",0).IsHex()) {
	    int severity=0;
	    sscanf(param.Data(),"%x", &severity);
	    SetFrameworkLog((AliHLTComponentLogSeverity)severity);
	  } else {
	    HLTWarning("wrong parameter for option \'loglevel=\', (hex) number expected");
	  }
	} else if (token.Contains("alilog=off")) {
	  SwitchAliLog(0);
	} else if (token.Contains("config=") || token.Contains("run-online-config")) {
	  if (!CheckStatus(kConfigurationLoaded)) {
	    Int_t error=0;
	    AliHLTOnlineConfiguration* pConf = NULL;
	    if (token.Contains("run-online-config")) {
	      AliCDBEntry* pEntry=AliHLTMisc::Instance().LoadOCDBEntry("HLT/Calib/OnlineConfig");
	      if (pEntry) {
		TObject* pObject=AliHLTMisc::Instance().ExtractObject(pEntry);
		if (pObject && pObject->IsA() == AliHLTOnlineConfiguration::Class())
		  pConf = (AliHLTOnlineConfiguration*)pObject;
	      }
	    }
	    if (token.Contains("config=")) {
	      TString param=token.ReplaceAll("config=", "");
	      if (token.EndsWith(".xml", TString::kIgnoreCase)) {
		Int_t filesize = 0;
		pConf = new AliHLTOnlineConfiguration;
		filesize = pConf->LoadConfiguration(param.Data());
		if (filesize <= 0) {
		  HLTError("cannot load config \'%s\'", param.Data());
		  iResult=-EBADF;
		}
	      } else {
		gROOT->Macro(param.Data(), &error);
		if (error==0) {
		  SetStatusFlags(kConfigurationLoaded);
		} else {
		  HLTError("cannot execute macro \'%s\'", param.Data());
		  iResult=-EBADF;
		}
	      }
	    }
	    if (pConf) {
		error = pConf->Parse();
		if (error==0) {
		  fChains = pConf->GetDefaultChains();
		  libs = pConf->GetComponentLibraries();
		  libs += " ";
		  SetStatusFlags(kConfigurationLoaded);
		} else {
		  HLTError("cannot parse online configuration");
		  iResult=-EBADF;
		}
	    }
	    delete pConf; pConf=NULL;
	  } else {
	    HLTWarning("HLT options has both a config file and run-online-config set");
	  }
	} else if (token.Contains("chains=")) {
	  TString param=token.ReplaceAll("chains=", "");
	  fChains=param.ReplaceAll(",", " ");
	  if (fChains.IsNull()) fChains=" "; // disable all chains
	} else if (token.Contains("libmode=")) {
	  TString param=token.ReplaceAll("libmode=", "");
	  param.ReplaceAll(",", " ");
	  if (fpComponentHandler) {
	    if (param.CompareTo("static")==0) {
	      fpComponentHandler->SetLibraryMode(AliHLTComponentHandler::kStatic);
	    } else if (param.CompareTo("dynamic")==0) {
	      fpComponentHandler->SetLibraryMode(AliHLTComponentHandler::kDynamic);
	    } else {
	      HLTWarning("wrong argument for option \'libmode=\', use \'static\' or \'dynamic\'");
	    }
	  }
	} else if (token.BeginsWith("ECS=")) {
	  fECSParams=token.ReplaceAll("ECS=", "");
	} else if (token.BeginsWith("hltout-mode=")) {
	  // The actual parameter for argument 'hltout-mode' is treated in AliSimulation.
	  // For AliHLTSystem the occurrence with parameter 'split' signals the use of the
	  // separated HLTOUTComponents for digit and raw data. All others indicate
	  // HLTOUTComponent type 'global' where the data generation is steered from global
	  // flags
	  fUseHLTOUTComponentTypeGlobal=token.CompareTo("hltout-mode=split")!=0;
	} else if (token.BeginsWith("lib") && token.EndsWith(".so")) {
	  libs+=token;
	  libs+=" ";
	} else if (token.BeginsWith("!lib") && token.EndsWith(".so")) {
	  excludelibs+=token;
	  excludelibs+=" ";
	} else {
	  HLTWarning("unknown option \'%s\'", token.Data());
	}
      }
      delete pTokens;
    }

    if (iResult>=0) {
      if (libs.IsNull()) {
	const char** deflib=fgkHLTDefaultLibs;
	for (;*deflib; deflib++) {
	  if (excludelibs.Contains(*deflib)) continue;
	  libs+=*deflib;
	  libs+=" ";
	}
      }
      if ((!CheckStatus(AliHLTSystem::kLibrariesLoaded)) &&
	  (LoadComponentLibraries(libs.Data())<0)) {
	HLTError("error while loading HLT libraries");
	iResult=-EFAULT;
      }
    }
  }
  return iResult;
}

int AliHLTSystem::Reset(int bForce)
{
  // see header file for class documentation
  int iResult=0;
  if (!bForce && CheckStatus(kRunning)) {
    HLTError("HLT system in running state, can not configure");
    return -EBUSY;
  }
  CleanTaskList();
  ClearStatusFlags(~kUninitialized);
  return iResult;
}

int AliHLTSystem::LoadConfigurations(AliRawReader* rawReader, AliRunLoader* runloader)
{
  // see header file for class documentation
  if (CheckStatus(kRunning)) {
    HLTError("HLT system in running state, can not configure");
    return -EBUSY;
  }
  int iResult=0;
  AliHLTModuleAgent* pAgent=NULL;

  // first check for the required libraries and load those
  TString extralibs;
  for (pAgent=AliHLTModuleAgent::GetFirstAgent(); 
       pAgent && iResult>=0;
       pAgent=AliHLTModuleAgent::GetNextAgent()) {
    const char* deplibs=pAgent->GetRequiredComponentLibraries();
    if (deplibs) {
      HLTDebug("required libraries \'%s\' for agent %s (%p)", deplibs, pAgent->GetName(), pAgent);
      extralibs+=" ";
      extralibs+=deplibs;
    }
  }
  if (iResult>=0) {
    iResult=LoadComponentLibraries(extralibs.Data());
  }

  // in order to register the configurations in the correct sequence
  // all agents need to be ordered with respect to the required
  // libraries. Ordering relies on the naming convention
  // libAliHLT<Module>.so
  TList agents;
  for (pAgent=AliHLTModuleAgent::GetFirstAgent(); 
       pAgent && iResult>=0;
       pAgent=AliHLTModuleAgent::GetNextAgent()) {
    AliHLTModuleAgent* pPrevDep=NULL;
    TString dependencies=pAgent->GetRequiredComponentLibraries();
    TObjArray* pTokens=dependencies.Tokenize(" ");
    if (pTokens) {
      for (int n=0; n<pTokens->GetEntriesFast(); n++) {
	if (!pTokens->At(n)) continue;
	TString module=pTokens->At(n)->GetName();
	HLTDebug("  checking %s", module.Data());
	module.ReplaceAll("libAliHLT", "");
	module.ReplaceAll(".so", "");
	
	for (AliHLTModuleAgent* pCurrent=dynamic_cast<AliHLTModuleAgent*>(pPrevDep==NULL?agents.First():agents.After(pPrevDep));
	     pCurrent!=NULL; pCurrent=dynamic_cast<AliHLTModuleAgent*>(agents.After(pCurrent))) {
	  HLTDebug("    checking %s == %s", module.Data(), pCurrent->GetModuleId());

	  if (module.CompareTo(pCurrent->GetModuleId())==0) {
	    pPrevDep=pCurrent;
	    break;
	  }
	}
      }
      delete pTokens;
    }

    if (pPrevDep) {
      // insert right after the last dependency
      agents.AddAfter(pPrevDep, pAgent);
      HLTDebug("insert %s after %s", pAgent->GetModuleId(), pPrevDep->GetModuleId());
    } else {
      // insert at the beginning
      agents.AddFirst(pAgent);
      HLTDebug("insert %s at beginning", pAgent->GetModuleId());
    }
  }

  // now we load the configurations
  if (agents.GetEntries()) {
    TIter next(&agents);
    while ((pAgent = dynamic_cast<AliHLTModuleAgent*>(next()))) {
      if(fDetMask && !(fDetMask & pAgent->GetDetectorMask())) {
	HLTInfo("Skipping %s due to active detector mask.", pAgent->GetName());
      } else {
	HLTDebug("load configurations for agent %s (%p)", pAgent->GetName(), pAgent);
	pAgent->CreateConfigurations(fpConfigurationHandler, rawReader, runloader);
      }
    }
  }

  return iResult;
}

int AliHLTSystem::BuildTaskListsFromReconstructionChains(AliRawReader* rawReader, AliRunLoader* runloader)
{
  // see header file for class documentation
  if (CheckStatus(kRunning)) {
    HLTError("HLT system in running state, can not configure");
    return -EBUSY;
  }
  if (!CheckStatus(kConfigurationLoaded)) {
    HLTWarning("configurations not yet loaded");
    return 0;
  }

  if (!fpConfigurationHandler || !fpComponentHandler) return -EFAULT;

  int iResult=0;
  int bHaveOutput=0;

  // query chains
  TString chains;
  if (fChains.Length()>0) {
    chains=fChains;
    HLTImportant("custom reconstruction chain: %s", chains.Data());
  } else {
    for (AliHLTModuleAgent* pAgent=AliHLTModuleAgent::GetFirstAgent();
	 pAgent && iResult>=0;
	 pAgent=AliHLTModuleAgent::GetNextAgent()) {
      const char* agentchains=pAgent->GetReconstructionChains(rawReader, runloader);
      if (agentchains) {
	if (!chains.IsNull()) chains+=" ";
	chains+=agentchains;
	HLTInfo("reconstruction chains for agent %s (%p): %s", pAgent->GetName(), pAgent, agentchains);
      }
    }
  }

  // build task list for chains
  TObjArray* pTokens=chains.Tokenize(" ");
  if (pTokens) {
    int iEntries=pTokens->GetEntriesFast();
    for (int i=0; i<iEntries && iResult>=0; i++) {
      if (!pTokens->At(i)) continue;
      const char* pCID=pTokens->At(i)->GetName();
      AliHLTConfiguration* pConf=fpConfigurationHandler->FindConfiguration(pCID);
      if (pConf) {
	iResult=BuildTaskList(pConf);
	if (true) { // condition was deprecated but kept for sake of svn diff
	  // bHaveOutput variable has to be set for both running modes
	  // AliHLTSimulation and AliHLTReconstruction
	  TString cid=pConf->GetComponentID();
	  if (runloader!=NULL && cid.CompareTo("HLTOUT")==0) {
	    // remove from the input of a global HLTOUT configuration
	    chains.ReplaceAll(pCID, "");
	  } else if (bHaveOutput==0) {
	    // check whether this configuration produces data output
	    if ((bHaveOutput=fpComponentHandler->HasOutputData(cid.Data()))<0) {
	      bHaveOutput=0;
	      chains.ReplaceAll(pCID, "");
	    }
	  }
	}
      } else {
	HLTWarning("can not find configuration %s", pCID);
      }
    }
    delete pTokens;
  }

  // build HLTOUT for simulation
  if (iResult>=0 && runloader) {
    if (bHaveOutput) {
      // there are components in the chain which produce data which need to be
      // piped to an HLTOUT

      // add the SchemaEvolutionComponent which analyzes the ROOT objects in
      // the output stream
      if (fpComponentHandler->FindComponentIndex("ROOTSchemaEvolutionComponent")>=0 ||
	  fpComponentHandler->LoadLibrary("libAliHLTUtil.so")>=0) {
	fpConfigurationHandler->CreateConfiguration("_schemaevolution_", "ROOTSchemaEvolutionComponent", 
						     chains.Data(), "-file=HLT.StreamerInfo.root");
	iResult=BuildTaskList("_schemaevolution_");
      } else {
	HLTWarning("can not load libAliHLTUtil.so and ROOTSchemaEvolutionComponent");
      }

      // add the HLTOUT component
      if (fpComponentHandler->FindComponentIndex("HLTOUT")>=0 ||
	  fpComponentHandler->LoadLibrary("libHLTsim.so")>=0) {
	// for the default HLTOUTComponent type 'global' the data generation is steered
	// by global flags from AliSimulation. This allows for emulation of the old
	// AliHLTSimulation behavior where only one chain is run on either digits or
	// simulated raw data and the HLT digits and raw files have been generated
	// depending on the configuration
	const char* HLTOUTComponentId="HLTOUT";
	if (!fUseHLTOUTComponentTypeGlobal) {
	  // choose the type of output depending  on the availability of
	  // the raw reader
	  if (rawReader) HLTOUTComponentId="HLTOUTraw";
	  else HLTOUTComponentId="HLTOUTdigits";
	}
	fpConfigurationHandler->CreateConfiguration("_globalout_", HLTOUTComponentId, chains.Data(), NULL);
	iResult=BuildTaskList("_globalout_");
      } else {
	HLTError("can not load libHLTsim.so and HLTOUT component");
	iResult=-EFAULT;
      }
    }
  }

  // build HLTOUT task for reconstruction
  // Matthias 08.07.2008 the rawReader is never set when running embedded into
  // AliReconstruction. The system is configured during AliHLTReconstructor::Init
  // where the RawReader is not available. It is available in the first invocation
  // of Reconstruct.
  // 
  // That means that policy is slightly changed:
  // - if the run loader is available -> AliSimulation
  // - no run loader available -> AliReconstruction
  if (iResult>=0 && !runloader) {
    if (bHaveOutput) {
      // there are components in the chain which produce data which need to be
      // piped to an HLTOUT sub-collection
      if (!fpHLTOUTTask) {
	iResult=AddHLTOUTTask(chains.Data());
      }
    }
  }

  if (iResult>=0) SetStatusFlags(kTaskListCreated);

  return iResult;
}

int AliHLTSystem::AddHLTOUTTask(const char* hltoutchains)
{
  // see header file for class documentation
  int iResult=0;
  if (!hltoutchains || hltoutchains[0]==0) return 0;

  // check chains for output
  TString chains=hltoutchains;
  TObjArray* pTokens=chains.Tokenize(" ");
  if (pTokens) {
    int iEntries=pTokens->GetEntriesFast();
    for (int i=0; i<iEntries && iResult>=0; i++) {
      if (!pTokens->At(i)) continue;
      const char* token=pTokens->At(i)->GetName();
      AliHLTConfiguration* pConf=fpConfigurationHandler->FindConfiguration(token);
      if (pConf) {
	TString cid=pConf->GetComponentID();
	if (fpComponentHandler->HasOutputData(cid.Data())) {
	  continue;
	}
      } else {
	HLTWarning("can not find configuration %s", token);
      }
      // remove from the list of hltout chains
      chains.ReplaceAll(token, "");
    }
    delete pTokens;
  }

  // do not create the HLTOUT task if none of the chains have output
  if (chains.IsNull()) return 0;

  // indicate the task to be available
  iResult=1;

  if (fpHLTOUTTask) {
    if (strcmp(chains.Data(), fpHLTOUTTask->GetSourceChains())==0) {
      HLTWarning("HLTOUT task already added for chains \"%s\" %p", chains.Data(), fpHLTOUTTask);
    } else {
      HLTError("HLTOUT task already added for chains \"%s\" %p, ignoring new chains  \"%s\"",
	       fpHLTOUTTask->GetSourceChains(), fpHLTOUTTask, chains.Data());
    }
    return iResult;
  }

  fpHLTOUTTask=new AliHLTOUTTask(chains);
  if (fpHLTOUTTask) {
    if (fpHLTOUTTask->GetConf() && 
	(fpHLTOUTTask->GetConf()->SourcesResolved()>0 ||
	 fpHLTOUTTask->GetConf()->ExtractSources(fpConfigurationHandler)>0)) {
      iResult=InsertTask(fpHLTOUTTask);
    } else {
      HLTError("HLTOUT task (%s) sources not resolved", fpHLTOUTTask->GetName());
      iResult=-ENOENT;
    }

    if (iResult<0) {
      delete fpHLTOUTTask;
    }

  } else {
    iResult=-ENOMEM;
  }
  return iResult;
}

int AliHLTSystem::CheckStatus(int flag)
{
  // see header file for class documentation
  if (flag==kUninitialized && flag==fState) return 1;
  if ((fState&flag)==flag) return 1;
  return 0;
}

int AliHLTSystem::GetStatusFlags()
{
  // see header file for class documentation
  return fState;
}

int AliHLTSystem::SetStatusFlags(int flags)
{
  // see header file for class documentation
  fState|=flags;
  return fState;
}

int AliHLTSystem::ClearStatusFlags(int flags)
{
  // see header file for class documentation
  fState&=~flags;
  return fState;
}

AliHLTfctVoid AliHLTSystem::FindDynamicSymbol(const char* library, const char* symbol)
{
  // see header file for class documentation
  if (fpComponentHandler==NULL) return NULL;
  return fpComponentHandler->FindSymbol(library, symbol);
}

void AliHLTSystem::SetFrameworkLog(AliHLTComponentLogSeverity level) 
{
  // see header file for class documentation
  SetLocalLoggingLevel(level);
  if (fpComponentHandler) fpComponentHandler->SetLocalLoggingLevel(level);
  if (fpConfigurationHandler) fpConfigurationHandler->SetLocalLoggingLevel(level);
}

int AliHLTSystem::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);

  if (!fName.IsNull())
    AliHLTLogging::SetLogString(this, " (%p)", "%s_pfmt_: ", fName.Data());
  iResult=SendMessage(severity, originClass, originFunc, file, line, AliHLTLogging::BuildLogString(NULL, args, !fName.IsNull() /*append if non empty*/));
  va_end(args);

  return iResult;
}

int AliHLTSystem::InitHLTOUT(AliHLTOUT* instance)
{
  // Init the HLTOUT instance for the current event.
  // The instance can be used by other classes to get hold on the data
  // from HLTOUT.
  if (!instance) return -EINVAL;
  if (fpHLTOUT && fpHLTOUT!=instance) return -EBUSY;
  fpHLTOUT=instance;
  return 0;
}

int AliHLTSystem::InvalidateHLTOUT(AliHLTOUT** target)
{
  // Clear the HLTOUT instance.
  int iResult=0;
  if (fHLTOUTUse>0) {
    HLTWarning("HLTOUT instance still in use, potential problem due to invalid pointer ahead");
    fHLTOUTUse=0;
    iResult=-EBUSY;
  }
  if (target) *target=fpHLTOUT;
  fpHLTOUT=NULL;
  return iResult;
}

AliHLTOUT* AliHLTSystem::RequestHLTOUT()
{
  // Get the HLTOUT instance.
  // User method for processing classes. To be released after use.
  if (!fpHLTOUT) return NULL;
  fHLTOUTUse++;
  return fpHLTOUT;
}

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