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   AliHLTOUT.cxx
/// @author Matthias Richter
/// @date   
/// @brief  The control class for HLTOUT data.
///

#include <cerrno>
#include <cassert>
#include "AliHLTOUT.h"
#include "AliHLTMessage.h"
#include "AliHLTMisc.h"
#include "TSystem.h"
#include "TClass.h"
#include "TROOT.h"
#include <sstream>
#include <iomanip>

using std::cout;

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

AliHLTOUT::AliHLTOUT()
  :
  fSearchDataType(kAliHLTVoidDataType),
  fSearchSpecification(kAliHLTVoidDataSpec),
  fSearchHandlerType(AliHLTModuleAgent::kUnknownOutput),
  fFlags(kSkipProcessed),
  fBlockDescList(),
  fCurrent(0),
  fpBuffer(NULL),
  fDataHandlers(),
  fbVerbose(false),
  fLog()
  , fpDataObject(NULL)
  , fpObjectBuffer(NULL)
  , fObjectBufferSize(0)
  , fCurrentEventId(kAliHLTVoidEventID)
{
  // constructor
  // 
  // The control class for HLTOUT data
  // see header file for class documentation
  // author Matthias Richter
}

AliHLTOUT::~AliHLTOUT()
{
  // destructor
  if (CheckStatusFlag(kIsSubCollection)) {
    fLog.LoggingVarargs(kHLTLogWarning, "AliHLTOUT", "~AliHLTOUT" , __FILE__ , __LINE__ , "severe internal error: collection has not been released, potential crash due to invalid pointer");
  }

  if (fpDataObject) {
    fLog.LoggingVarargs(kHLTLogWarning, "AliHLTOUT", "GetDataObject" , __FILE__ , __LINE__ , "data object has not been released, potential memory leak");
  }
  fpDataObject=NULL;
}
AliHLTOUT* AliHLTOUT::fgGlobalInstance=NULL;

int AliHLTOUT::Init()
{
  // see header file for class documentation
  int iResult=0;

  // ignore if already initialized
  if (fBlockDescList.size()>0) {
    return 0;
  }

  SetStatusFlag(kCollecting);
  if ((iResult=GenerateIndex())>=0) {
    if ((iResult=InitHandlers())>=0) {
    }
  }
  ClearStatusFlag(kCollecting);
  return iResult;
}

int AliHLTOUT::GetNofDataBlocks()
{
  // get number of data blocks
  return fBlockDescList.size();
}

int AliHLTOUT::SelectFirstDataBlock(AliHLTComponentDataType dt, AliHLTUInt32_t spec,
				    AliHLTModuleAgent::AliHLTOUTHandlerType handlerType,
				    bool skipProcessed)
{
  // select the first data block according to data type, specification and
  // handler type
  fCurrent=0;
  fSearchDataType=dt;
  fSearchSpecification=spec;
  fSearchHandlerType=handlerType;
  if (skipProcessed) SetStatusFlag(kSkipProcessed);
  else ClearStatusFlag(kSkipProcessed);
  return FindAndSelectDataBlock();
}

int AliHLTOUT::SelectNextDataBlock()
{
  // select next data block according to selection criteria specified
  // for SelectFirstDataBlock
  if (fCurrent>=fBlockDescList.size()) return -ENOENT;
  fCurrent++;
  return FindAndSelectDataBlock();
}

int AliHLTOUT::FindAndSelectDataBlock()
{
  // Select data block according to data type and specification, internal function
  // invoked by SelectFirstDataBlock/SelectNextDataBlock
  if (CheckStatusFlag(kLocked)) return -EPERM;
  int iResult=-ENOENT;
  while (fCurrent<fBlockDescList.size() && iResult==-ENOENT) {
    if (fBlockDescList[fCurrent]==fSearchDataType &&
	(fSearchSpecification==kAliHLTVoidDataSpec || fBlockDescList[fCurrent]==fSearchSpecification) &&
	(fSearchHandlerType==AliHLTModuleAgent::kUnknownOutput || FindHandlerDesc(fCurrent)==fSearchHandlerType) &&
	(!CheckStatusFlag(kBlockSelection) || fBlockDescList[fCurrent].IsSelected()) &&
	(!CheckStatusFlag(kSkipProcessed) || !fBlockDescList[fCurrent].IsProcessed())) {
      iResult=fBlockDescList[fCurrent].GetIndex();
      // TODO: check the byte order on the current system and the byte order of the
      // data block, print warning when mismatch and user did not check
      //AliHLTOUTByteOrder blockBO=CheckByteOrder();
      CheckByteOrder();
      /*
	if (blockBO!=fByteOrder) {
	SetStatusFlag(kByteOrderWarning);

	}
       */
      ClearStatusFlag(kByteOrderChecked);

      // TODO: check the alignment on the current system and the alignment of the
      // data block, print warning when mismatch and user did not check
      ClearStatusFlag(kAlignmentChecked);

      break;
    }
    fCurrent++;
  }
  return iResult;
}

int AliHLTOUT::GetDataBlockDescription(AliHLTComponentDataType& dt, AliHLTUInt32_t& spec)
{
  // fill data type and specification
  int iResult=-ENOENT;
  if (fCurrent<fBlockDescList.size()) {
    iResult=0;
    dt=fBlockDescList[fCurrent];
    spec=fBlockDescList[fCurrent];
  }
  return iResult;
}

const AliHLTOUT::AliHLTOUTHandlerListEntry& AliHLTOUT::GetDataBlockHandlerDesc()
{
  // Get handler descriptor of the selected data block.
  return FindHandlerDesc(fCurrent);
}

AliHLTModuleAgent::AliHLTOUTHandlerType AliHLTOUT::GetDataBlockHandlerType()
{
  // Get handler type of the selected data block.
  AliHLTModuleAgent::AliHLTOUTHandlerDesc desc=FindHandlerDesc(fCurrent);
  AliHLTModuleAgent::AliHLTOUTHandlerType type=desc;
  return type;
}

AliHLTUInt32_t AliHLTOUT::GetDataBlockIndex()
{
  // Get the index of the current data block.
  if (fCurrent>=fBlockDescList.size()) return AliHLTOUTInvalidIndex;
  return fBlockDescList[fCurrent].GetIndex();
}

int AliHLTOUT::GetDataBuffer(AliHLTComponentBlockData& desc)
{
  // fill block data descriptor and select the current data buffer
  // buffer has to be released using ReleaseDataBuffer
  int iResult=-ENOENT;
  if (fCurrent<fBlockDescList.size()) {
    AliHLTComponent::FillBlockData(desc);
    if ((iResult=fBlockDescList[fCurrent].GetDataBuffer(fpBuffer, desc.fSize))>=0) {
      desc.fPtr=const_cast<void*>(reinterpret_cast<const void*>(fpBuffer));
      desc.fDataType=fBlockDescList[fCurrent];
      desc.fSpecification=fBlockDescList[fCurrent];
    }
  }
  return iResult;
}

int AliHLTOUT::GetDataBuffer(const AliHLTUInt8_t* &pBuffer, AliHLTUInt32_t& size)
{
  // select and return the current data buffer
  // buffer has to be released using ReleaseDataBuffer
  int iResult=-ENOENT;
  pBuffer=NULL;
  size=0;
  if (fCurrent<fBlockDescList.size()) {
    if ((iResult=fBlockDescList[fCurrent].GetDataBuffer(fpBuffer, size))>=0) {
      pBuffer=fpBuffer;
    }
  }
  return iResult;  
}

int AliHLTOUT::ReleaseDataBuffer(const AliHLTUInt8_t* pBuffer)
{
  // release data buffer, previously returned by GetDataBuffer
  int iResult=0;
  if (pBuffer==fpBuffer) {
    fpBuffer=NULL;
  } else {
    fLog.LoggingVarargs(kHLTLogWarning, "AliHLTOUT", "ReleaseDataBuffer" , __FILE__ , __LINE__ , "buffer %p does not match the provided one %p", pBuffer, fpBuffer);
  }
  return iResult;  
}

AliHLTModuleAgent* AliHLTOUT::GetAgent()
{
  // get module agent of the selected data block
  AliHLTModuleAgent* pAgent=NULL;
  pAgent=FindHandlerDesc(fCurrent);
  return pAgent;
}

AliHLTOUTHandler* AliHLTOUT::GetHandler()
{
  // get HLTOUT handler of the selected data block
  AliHLTOUTHandler* pHandler=NULL;
  pHandler=FindHandlerDesc(fCurrent);
  return pHandler;
}

int AliHLTOUT::WriteESD(const AliHLTUInt8_t* /*pBuffer*/, AliHLTUInt32_t /*size*/, AliHLTComponentDataType /*dt*/, AliESDEvent* /*tgtesd*/) const
{
  // default function, child must overload
  fLog.LoggingVarargs(kHLTLogWarning, "AliHLTOUT", "WriteESD" , __FILE__ , __LINE__ , "method not implemented in base class");
  return -ENOSYS;
}

int AliHLTOUT::AddBlockDescriptor(const AliHLTOUTBlockDescriptor desc)
{
  // add new block descriptor
  if (!CheckStatusFlag(kCollecting)) return -EPERM;
  int iResult=0;
  fBlockDescList.push_back(desc);
  return iResult;  
}

AliHLTOUT::AliHLTOUTByteOrder AliHLTOUT::CheckByteOrder()
{
  // check the byte order of the current data block
  // NOTE: this functionality has not been tested and development was hardly finished
  if (fCurrent<fBlockDescList.size()) {
    SetStatusFlag(kByteOrderChecked);
    AliHLTOUT::AliHLTOUTByteOrder order=CheckBlockByteOrder(fBlockDescList[fCurrent].GetIndex());
    return order;
  }
  return kInvalidByteOrder;
}

int AliHLTOUT::CheckAlignment(AliHLTOUT::AliHLTOUTDataType type)
{
  // check alignment of the current data block
  // NOTE: this functionality has not been tested and development was hardly finished
  if (fCurrent<fBlockDescList.size()) {
    SetStatusFlag(kAlignmentChecked);
    int alignment=CheckBlockAlignment(fBlockDescList[fCurrent].GetIndex(), type);
    return alignment;
  }
  return -ENOENT;
}

int AliHLTOUT::InitHandlers()
{
  // init handlers for all registered blocks
  int iResult=0;
  AliHLTOUTIndexList remnants;
  int iCount=0;
  for (int havedata=SelectFirstDataBlock(kAliHLTAnyDataType, kAliHLTVoidDataSpec); havedata>=0; havedata=SelectNextDataBlock()) {
    iCount++;
    remnants.push_back(GetDataBlockIndex());
    AliHLTComponentDataType dt=kAliHLTVoidDataType;
    AliHLTUInt32_t spec=kAliHLTVoidDataSpec;
    if (GetDataBlockDescription(dt, spec)<0) break;
    bool bHaveHandler=false;
    for (AliHLTModuleAgent* pAgent=AliHLTModuleAgent::GetFirstAgent(); pAgent && iResult>=0; pAgent=AliHLTModuleAgent::GetNextAgent()) {
      AliHLTModuleAgent::AliHLTOUTHandlerDesc handlerDesc;
      if (pAgent->GetHandlerDescription(dt, spec, handlerDesc)>0) {
	AliHLTOUTHandlerListEntry entry(pAgent->GetOutputHandler(dt, spec), handlerDesc, pAgent, GetDataBlockIndex());
	InsertHandler(fDataHandlers, entry);
	remnants.pop_back();
	bHaveHandler=true;
	if (fbVerbose) {
	  stringstream sout;
	  sout << "adding handler for block " << AliHLTComponent::DataType2Text(dt).c_str()
	       << " 0x" << setfill('0') << setw(8) << hex << spec;
	  cout << sout.str() << endl;
	}
	break;
      }
    }
    if (!bHaveHandler && (dt==kAliHLTDataTypeESDObject || dt==kAliHLTDataTypeESDTree)) {
      // ESDs are handled by the framework
      remnants.pop_back();
    }
  }

  // warning if some of the data blocks are not selected by the kAliHLTAnyDataType
  // criterion
  if (GetNofDataBlocks()>iCount) {
    fLog.LoggingVarargs(kHLTLogWarning, "AliHLTOUT", "InitHandlers" , __FILE__ , __LINE__ , "incomplete data type in %d out of %d data block(s)", GetNofDataBlocks()-iCount, GetNofDataBlocks());
  }

  // warning if handler not found
  if (remnants.size()>0) {
    fLog.LoggingVarargs(kHLTLogWarning, "AliHLTOUT", "InitHandlers" , __FILE__ , __LINE__ , "no handlers found for %d data blocks out of %d", remnants.size(), iCount);
    AliHLTOUTBlockDescriptorVector::iterator block=fBlockDescList.begin();
    for (AliHLTOUTIndexList::iterator element=remnants.begin();
	 element!=remnants.end() && block!=fBlockDescList.end();
	 element++) {
      for (int trials=0; trials<2; trials++) {
	do {
	  // we start searching the index from the current position in the block list
	  if ((*block).GetIndex()==*element) break;
	} while ((++block)!=fBlockDescList.end());
	if (block==fBlockDescList.end()) {
	  // rewind and try again
	  block=fBlockDescList.begin();
	}
      }
      assert(block!=fBlockDescList.end());
    }
  }

  if (fbVerbose) Print();

  return iResult;
}

int AliHLTOUT::InsertHandler(AliHLTOUTHandlerListEntryVector& list, const AliHLTOUTHandlerListEntry &entry)
{
  // insert handler into list, called from child implementations
  int iResult=0;
  AliHLTOUTHandlerListEntryVector::iterator element=list.begin();
  for (; element!=list.end();
	 element++) {
    if (entry==(*element)) break;
  }
  if (element==list.end()) {
    list.push_back(entry);
  } else {
    element->AddIndex(const_cast<AliHLTOUTHandlerListEntry&>(entry));
  }
  return iResult;
}

int AliHLTOUT::FillHandlerList(AliHLTOUTHandlerListEntryVector& list, AliHLTModuleAgent::AliHLTOUTHandlerType handlerType)
{
  // fill a list according to specified handler type
  int iResult=0;
  for (iResult=SelectFirstDataBlock(kAliHLTAnyDataType, kAliHLTVoidDataSpec, handlerType);
       iResult>=0;
       iResult=SelectNextDataBlock()) {
    AliHLTComponentDataType dt=kAliHLTVoidDataType;
    AliHLTUInt32_t spec=kAliHLTVoidDataSpec;
    GetDataBlockDescription(dt, spec);
    AliHLTOUTHandler* pHandler=GetHandler();
    if (!pHandler) {
      fLog.LoggingVarargs(kHLTLogWarning, "AliHLTOUT", "FillHandlerList" , __FILE__ , __LINE__ , 
			 "missing HLTOUT handler for block of type kChain: agent %s, data type %s, specification %#x, ... skipping data block",
			 GetAgent()?GetAgent()->GetModuleId():"invalid",
			 AliHLTComponent::DataType2Text(dt).c_str(), spec);
    } else {
      InsertHandler(list, GetDataBlockHandlerDesc());
    }
  }
  // TODO: the return value of SelectFirst/NextDataBlock must be
  // changed in order to avoid this check
  if (iResult==-ENOENT) iResult=0;

  return iResult;
}

int AliHLTOUT::RemoveEmptyDuplicateHandlers(AliHLTOUTHandlerListEntryVector& list)
{
  // remove empty handlers from list
  int iResult=0;
  AliHLTOUTHandlerListEntryVector::iterator element=list.begin();
  while (element!=list.end()) {
    if (element->IsEmpty()) {
      AliHLTOUTHandler* pHandler=*element;
      AliHLTModuleAgent* pAgent=*element;
      AliHLTModuleAgent::AliHLTOUTHandlerDesc desc=*element;
      if (FindHandler(list, desc)>=0) {
	element=list.erase(element);
	if (pAgent) {
	  pAgent->DeleteOutputHandler(pHandler);
	}
	// we are already at the next element
	continue;
      }
    }
    element++;
  }
  return iResult;
}

int AliHLTOUT::FindHandler(AliHLTOUTHandlerListEntryVector& list, const AliHLTModuleAgent::AliHLTOUTHandlerDesc desc)
{
  // find handler according to descriptor
  for (int i=0; i<(int)list.size(); i++) {
    if (list[i]==desc) return i;
  }
  return -ENOENT;
}

int AliHLTOUT::InvalidateBlocks(AliHLTOUTHandlerListEntryVector& list)
{
  // invalidate all handlers in a list
  for (AliHLTOUTHandlerListEntryVector::iterator element=list.begin();
	 element!=list.end();
	 element++) {
    element->InvalidateBlocks();
  }
  return 0;
}

const AliHLTOUT::AliHLTOUTHandlerListEntry& AliHLTOUT::FindHandlerDesc(AliHLTUInt32_t blockIndex)
{
  // get handler description
  if (blockIndex<fBlockDescList.size()) {
    return fBlockDescList[blockIndex].GetHandlerDesc();
  }
  return const_cast<AliHLTOUT::AliHLTOUTHandlerListEntry&>(AliHLTOUT::AliHLTOUTHandlerListEntry::VoidHandlerListEntry());
}

AliHLTOUT::AliHLTOUTHandlerListEntry::AliHLTOUTHandlerListEntry()
  :
  fpHandler(NULL),
  fpHandlerDesc(NULL),
  fpAgent(NULL),
  fBlocks()
{
  // default constructor
}

AliHLTOUT::AliHLTOUTHandlerListEntry::AliHLTOUTHandlerListEntry(AliHLTOUTHandler* pHandler, 
								AliHLTModuleAgent::AliHLTOUTHandlerDesc& handlerDesc,
								AliHLTModuleAgent* pAgent,
								AliHLTUInt32_t index)
  :
  fpHandler(pHandler),
  fpHandlerDesc(new AliHLTModuleAgent::AliHLTOUTHandlerDesc),
  fpAgent(pAgent),
  fBlocks()
{
  // constructor
  *fpHandlerDesc=handlerDesc;
  fBlocks.push_back(index);
}

AliHLTOUT::AliHLTOUTHandlerListEntry::AliHLTOUTHandlerListEntry(const AliHLTOUTHandlerListEntry& src)
  :
  fpHandler(src.fpHandler),
  fpHandlerDesc(new AliHLTModuleAgent::AliHLTOUTHandlerDesc),
  fpAgent(src.fpAgent),
  fBlocks()
{
  // copy constructor
  *fpHandlerDesc=*src.fpHandlerDesc;
  fBlocks.assign(src.fBlocks.begin(), src.fBlocks.end());
}

AliHLTOUT::AliHLTOUTHandlerListEntry::~AliHLTOUTHandlerListEntry()
{
  // destructor
  if (fpHandlerDesc) delete fpHandlerDesc;
  fpHandlerDesc=NULL;
}

AliHLTOUT::AliHLTOUTHandlerListEntry& AliHLTOUT::AliHLTOUTHandlerListEntry::operator=(const AliHLTOUTHandlerListEntry& src)
{
  // assignment operator
  if (this==&src) return *this;  
  fpHandler=src.fpHandler;
  if (src.fpHandlerDesc)
    *fpHandlerDesc=*src.fpHandlerDesc;
  fpAgent=src.fpAgent;
  fBlocks.assign(src.fBlocks.begin(), src.fBlocks.end());
  return *this;
}

AliHLTUInt32_t AliHLTOUT::AliHLTOUTHandlerListEntry::operator[](int i) const
{
  // access operator
  return (int)fBlocks.size()>i?fBlocks[i]:AliHLTOUTInvalidIndex;
}

bool AliHLTOUT::AliHLTOUTHandlerListEntry::operator==(const AliHLTOUTHandlerListEntry& entry) const
{
  // comparison operator
  if (entry.fpHandler!=fpHandler || fpHandler==NULL) return false;
  assert(entry.fpAgent==fpAgent);
  if (entry.fpAgent!=fpAgent) return false;
  return true;
}

bool AliHLTOUT::AliHLTOUTHandlerListEntry::operator==(const AliHLTModuleAgent::AliHLTOUTHandlerType handlerType) const
{
  // comparison operator
  if (!fpHandlerDesc) return false;
  return *fpHandlerDesc==handlerType;
}

bool AliHLTOUT::AliHLTOUTHandlerListEntry::operator==(const AliHLTModuleAgent::AliHLTOUTHandlerDesc desc) const
{
  // comparison operator
  if (!fpHandlerDesc) return false;
  return *fpHandlerDesc==desc;
}

void AliHLTOUT::AliHLTOUTHandlerListEntry::AddIndex(const AliHLTOUT::AliHLTOUTHandlerListEntry &desc)
{
  // add block index, a handler can serve multiple blocks
  AliHLTOUTIndexList::const_iterator element;
  for (element=desc.fBlocks.begin(); element!=desc.fBlocks.end(); element++) {
    AddIndex(*element);
  }  
}

void AliHLTOUT::AliHLTOUTHandlerListEntry::AddIndex(AliHLTUInt32_t index)
{
  // add block index, a handler can serve multiple blocks
  fBlocks.push_back(index);
}

bool AliHLTOUT::AliHLTOUTHandlerListEntry::HasIndex(AliHLTUInt32_t index) const
{
  // check if handler serves the specified block
  AliHLTOUTIndexList::iterator element;
  for (unsigned int i=0; i<fBlocks.size(); i++) {
    if (fBlocks[i]==index) return true;
  }
  return false;
}

const AliHLTOUT::AliHLTOUTHandlerListEntry AliHLTOUT::AliHLTOUTHandlerListEntry::fgkVoidHandlerListEntry;

AliHLTUInt64_t AliHLTOUT::ByteSwap64(AliHLTUInt64_t src)
{
  // swap a 64 bit number
  return ((src & 0xFFULL) << 56) | 
    ((src & 0xFF00ULL) << 40) | 
    ((src & 0xFF0000ULL) << 24) | 
    ((src & 0xFF000000ULL) << 8) | 
    ((src & 0xFF00000000ULL) >> 8) | 
    ((src & 0xFF0000000000ULL) >> 24) | 
    ((src & 0xFF000000000000ULL) >>  40) | 
    ((src & 0xFF00000000000000ULL) >> 56);
}

AliHLTUInt32_t AliHLTOUT::ByteSwap32(AliHLTUInt32_t src)
{
  // swap a 32 bit number
  return ((src & 0xFFULL) << 24) | 
    ((src & 0xFF00ULL) << 8) | 
    ((src & 0xFF0000ULL) >> 8) | 
    ((src & 0xFF000000ULL) >> 24);
}

AliHLTOUT* AliHLTOUT::New(AliRawReader* pRawReader)
{
  // transparently create HLTOUT implementation for AliRawReader
  AliHLTOUT* instance=AliHLTMisc::LoadInstance((AliHLTOUT*)0, "AliHLTOUTRawReader", "libHLTrec.so");
  if (instance) {
    instance->SetParam(pRawReader);
  }
  return instance;
}

AliHLTOUT* AliHLTOUT::New(TTree* pDigitTree, int event)
{
  // transparently create HLTOUT implementation for digit tree
  AliHLTOUT* instance=AliHLTMisc::LoadInstance((AliHLTOUT*)0, "AliHLTOUTDigitReader", "libHLTrec.so");
  if (instance) {
    instance->SetParam(pDigitTree, event);
  }
  return instance;
}

AliHLTOUT* AliHLTOUT::New(const char* filename, int event)
{
  // transparently create HLTOUT implementation for raw file
  AliHLTOUT* instance=AliHLTMisc::LoadInstance((AliHLTOUT*)0, "AliHLTOUTDigitReader", "libHLTrec.so");
  if (instance) {
    instance->SetParam(filename, event);
  }
  return instance;
}

void AliHLTOUT::Delete(AliHLTOUT* pInstance)
{
  // delete the HLTOUT instance
  // check if the library is still there in order to have the
  // destructor available

  if (!pInstance) return;
  if (pInstance==fgGlobalInstance) return;

  TClass* pCl1=TClass::GetClass("AliHLTOUTRawReader");
  TClass* pCl2=TClass::GetClass("AliHLTOUTDigitReader");
  if (!pCl1 && !pCl2) {
    AliHLTLogging log;
    log.Logging(kHLTLogError, "AliHLTOUT::Delete", "HLTOUT handling", "potential memory leak: libHLTrec library not available, skipping destruction %p", pInstance);    
    return;
  }

  delete pInstance;  
}

void AliHLTOUT::SetParam(AliRawReader* /*pRawReader*/)
{
  // see header file for class documentation
  // default implementation, we should never get here
  // this function can only be called from the class itsself and
  // is intended to be used with the New functions. If we get into
  // the default implementation there is a class mismatch.
  assert(0);
  fLog.LoggingVarargs(kHLTLogFatal, "AliHLTOUT", "SetParam" , __FILE__ , __LINE__ , "severe internal error: class mismatch");
}

void AliHLTOUT::SetParam(TTree* /*pDigitTree*/, int /*event*/)
{
  // see header file for class documentation
  // default implementation, we should never get here
  // this function can only be called from the class itsself and
  // is intended to be used with the New functions. If we get into
  // the default implementation there is a class mismatch.
  assert(0);
  fLog.LoggingVarargs(kHLTLogFatal, "AliHLTOUT", "SetParam" , __FILE__ , __LINE__ , "severe internal error: class mismatch");
}

void AliHLTOUT::SetParam(const char* /*filename*/, int /*event*/)
{
  // see header file for class documentation
  // default implementation, we should never get here
  // this function can only be called from the class itsself and
  // is intended to be used with the New functions. If we get into
  // the default implementation there is a class mismatch.
  assert(0);
  fLog.LoggingVarargs(kHLTLogFatal, "AliHLTOUT", "SetParam" , __FILE__ , __LINE__ , "severe internal error: class mismatch");
}

int AliHLTOUT::SelectDataBlock()
{
  // mark the current data block for processing
  int iResult=0;
  if (fCurrent>=fBlockDescList.size()) return 0;
  fBlockDescList[fCurrent].Select(true);
  EnableBlockSelection();
  return iResult;
}

int AliHLTOUT::SelectDataBlocks(const AliHLTOUTHandlerListEntry* pHandlerEntry)
{
  // mark all data blocks served by specified handler for processing
  int iResult=0;
  if (!pHandlerEntry) return 0;

  AliHLTModuleAgent* pAgent=*pHandlerEntry;
  AliHLTLogging log;
  log.Logging(kHLTLogDebug, "AliHLTOUT::SelectDataBlocks", "HLTOUT handling", "selecting blocks for handler %s", pAgent->GetModuleId());
  AliHLTOUTBlockDescriptorVector::iterator element;
  for (AliHLTOUTBlockDescriptorVector::iterator block=fBlockDescList.begin();
       block!=fBlockDescList.end();
       block++) {
    if (block->GetHandlerDesc()==*pHandlerEntry && pHandlerEntry->HasIndex(block->GetIndex())) {
      block->Select(true);
      log.Logging(kHLTLogDebug, "AliHLTOUT::SelectDataBlocks", "HLTOUT handling", "   select block %s", AliHLTComponent::DataType2Text(*block).c_str());
    } else {
      log.Logging(kHLTLogDebug, "AliHLTOUT::SelectDataBlocks", "HLTOUT handling", "   skip block %s", AliHLTComponent::DataType2Text(*block).c_str());
      block->Select(false);
    }
  }
  EnableBlockSelection();

  // Matthias 2009-07-03 bugfix: the fCurrent position was not reset at that
  // place. Also I think the data type and specification must be set in order
  // to make SelectFirst/NextDataBlock working on the selected collection
  // of data blocks
  AliHLTModuleAgent::AliHLTOUTHandlerDesc pHandlerDesc=*pHandlerEntry; 
  fSearchDataType=pHandlerDesc;
  fSearchSpecification=kAliHLTVoidDataSpec;
  fSearchHandlerType=pHandlerDesc;
  fCurrent=0;
  
  return iResult;
}

int AliHLTOUT::EnableBlockSelection()
{
  // enable block selection, in this mode only the blocks marked for
  // processing can be accessed
  SetStatusFlag(kBlockSelection);
  return 0;
}

int AliHLTOUT::DisableBlockSelection()
{
  // disable block selection
  ClearStatusFlag(kBlockSelection);
  return 0;
}

int AliHLTOUT::ResetBlockSelection()
{
  // reset the 'selected' flag for all blocks
  for (AliHLTOUTBlockDescriptorVector::iterator block=fBlockDescList.begin();
       block!=fBlockDescList.end();
       block++) {
    block->Select(false);
  }
  return 0;
}

int AliHLTOUT::MarkDataBlockProcessed()
{
  // mark the current data block as 'processed'
  int iResult=0;
  if (fCurrent>=fBlockDescList.size()) return 0;
  fBlockDescList[fCurrent].MarkProcessed();
  return iResult;
}

int AliHLTOUT::MarkDataBlocksProcessed(const AliHLTOUTHandlerListEntry* pHandlerDesc)
{
  // mark all data blocks served by handler as processed
  int iResult=0;
  if (!pHandlerDesc) return 0;

  AliHLTOUTBlockDescriptorVector::iterator element;
  for (AliHLTOUTBlockDescriptorVector::iterator block=fBlockDescList.begin();
       block!=fBlockDescList.end();
       block++) {
    if (block->GetHandlerDesc()==*pHandlerDesc && pHandlerDesc->HasIndex(block->GetIndex()))
      block->MarkProcessed();
  }
  
  return iResult;
}

int AliHLTOUT::AddSubCollection(AliHLTOUT* pCollection)
{
  // add a sub-collection to the HLTOUT instance
  // all blocks of the sub-collection are accessed transparently through the master instance
  int iResult=0;
  if (!pCollection) return 0;

  SetStatusFlag(kCollecting);  
  int index=-1;
  for (index=pCollection->SelectFirstDataBlock();
       index>=0;
       index=pCollection->SelectNextDataBlock()) {
    AliHLTComponentDataType dt=kAliHLTVoidDataType;
    AliHLTUInt32_t spec=kAliHLTVoidDataSpec;
    pCollection->GetDataBlockDescription(dt, spec);  
    AliHLTOUTBlockDescriptor desc(dt, spec, index, pCollection);
    AddBlockDescriptor(desc);
    iResult++;
  }
  if (iResult>0) {
    if (CheckStatusFlag(kIsSubCollection)) {
      fLog.LoggingVarargs(kHLTLogWarning, "AliHLTOUT", "AddSubCollection" , __FILE__ , __LINE__ , "HLTOUT object %p has already been added as sub-collection", pCollection);
    } else {
      pCollection->SetStatusFlag(kIsSubCollection);
    }
  }
  ClearStatusFlag(kCollecting);  

  return iResult;
}

int AliHLTOUT::ReleaseSubCollection(AliHLTOUT* pCollection)
{
  // release a sub-collection
  int iResult=0;
  if (!pCollection) return 0;

  AliHLTOUTBlockDescriptorVector::iterator block=fBlockDescList.begin();
  while (block!=fBlockDescList.end()) {
    if ((*block)==pCollection) {
      block=fBlockDescList.erase(block);
      continue;
    }
    block++;
  }
  pCollection->ClearStatusFlag(kIsSubCollection);

  return iResult;
}

int AliHLTOUT::Reset()
{
  // reset HLTOUT instance
  // clears all blocks and handler descriptions
  int iResult=0;
  AliHLTOUTPVector subCollections;
  AliHLTOUTBlockDescriptorVector::iterator block=fBlockDescList.begin();
  while (block!=fBlockDescList.end()) {
    if (!((*block)==this)) {
      AliHLTOUTPVector::iterator collection=subCollections.begin();
      for (; collection!=subCollections.end(); collection++)
	if((*block)==*collection) break;
      if (collection==subCollections.end())
	subCollections.push_back(block->GetCollection());
    }
    block=fBlockDescList.erase(block);
  }

  for (AliHLTOUTPVector::iterator collection=subCollections.begin(); 
       collection!=subCollections.end(); collection++) {
    (*collection)->Reset();
    (*collection)->ClearStatusFlag(kIsSubCollection);
  }

  ResetInput();
  fCurrentEventId=kAliHLTVoidEventID;

  return iResult;
}

int AliHLTOUT::ResetInput()
{
  // default implementation, nothing to do
  return 0;
}

const AliHLTOUT::AliHLTOUTHandlerListEntry& AliHLTOUT::AliHLTOUTBlockDescriptor::GetHandlerDesc()
{
  // see header file for class documentation
  if (fpCollection) {
    AliHLTOUTHandlerListEntryVector::iterator element=fpCollection->fDataHandlers.begin();
    while (element!=fpCollection->fDataHandlers.end()) {
      if (element->HasIndex(GetIndex())) {
	return *element;
      }
      element++;
    }
  }
  return const_cast<AliHLTOUT::AliHLTOUTHandlerListEntry&>(AliHLTOUT::AliHLTOUTHandlerListEntry::VoidHandlerListEntry());
}

TObject* AliHLTOUT::GetDataObject()
{
  // check if the current block encodes a ROOT object and expand it
  if (fpDataObject) {
    fLog.LoggingVarargs(kHLTLogWarning, "AliHLTOUT", "GetDataObject" , __FILE__ , __LINE__ , "data object has not been released, potential memory leak");
    ReleaseDataBuffer(fpObjectBuffer);
  }
  fpObjectBuffer=NULL;
  fObjectBufferSize=0;
  fpDataObject=NULL;

  if (GetDataBuffer(fpObjectBuffer, fObjectBufferSize)>=0) {
    fpDataObject=AliHLTMessage::Extract(fpObjectBuffer, fObjectBufferSize);
  } else {
    fLog.LoggingVarargs(kHLTLogError, "AliHLTOUT", "GetDataObject" , __FILE__ , __LINE__ , "can not fetch data buffer");    
  }

  return fpDataObject;
}

int AliHLTOUT::ReleaseDataObject(TObject* pObject)
{
  // release a ROOT object previously expanded from the currentr data block
  if (!pObject) return -EINVAL;
  if (pObject!=fpDataObject) {
    fLog.LoggingVarargs(kHLTLogError, "AliHLTOUT", "GetDataObject" , __FILE__ , __LINE__ , "attempt to release wrong data object %p, expected %p", pObject, fpDataObject);
    return -EINVAL;
  }

  delete fpDataObject;
  fpDataObject=NULL;
  ReleaseDataBuffer(fpObjectBuffer);
  fpObjectBuffer=NULL;
  fObjectBufferSize=0;

  return 0;
}

void AliHLTOUT::SetEventId(AliHLTUInt64_t id)
{
  // set event id
  if (fCurrentEventId!=kAliHLTVoidEventID && fCurrentEventId!=id) {
    fLog.LoggingVarargs(kHLTLogWarning, "AliHLTOUT", "SetEventId" , __FILE__ , __LINE__ , "event id was already set to 0x%llx, setting now to 0x%llx", fCurrentEventId, id);
  }
  fCurrentEventId=id;
}

void AliHLTOUT::Print(const char* option) const
{
  // print info
  {
    for (AliHLTOUTBlockDescriptorVector::const_iterator  i=fBlockDescList.begin();
	 i!=fBlockDescList.end(); i++)
      i->Print(option);
  }
  {
    for (AliHLTOUTHandlerListEntryVector::const_iterator  i=fDataHandlers.begin();
	 i!=fDataHandlers.end(); i++)
      i->Print(option);
  }
}

void AliHLTOUT::AliHLTOUTBlockDescriptor::Print(const char* /*option*/) const
{
  // print info
  stringstream sout;
  sout << "AliHLTOUTBlockDescriptor index 0x" << setfill('0') << setw(8) << hex << right << fIndex 
       << ":   " << AliHLTComponent::DataType2Text(fDataType).c_str()
       << "  0x" << setfill('0') << setw(8) << hex << fSpecification
       << "  processed " << dec << fProcessed;
  cout << sout.str() << endl;
}

void AliHLTOUT::AliHLTOUTHandlerListEntry::Print(const char* /*option*/) const
{
  // print info
  stringstream sout;
  AliHLTModuleAgent::AliHLTOUTHandlerType type=AliHLTModuleAgent::kUnknownOutput;
  AliHLTComponentDataType dt=kAliHLTVoidDataType;
  if (this->fpHandlerDesc) {
    type=*(this->fpHandlerDesc);
    dt=*(this->fpHandlerDesc);
  }
  const char* stype="";
  switch(type) {
  case AliHLTModuleAgent::kEsd: stype="ESD"; break;
  case AliHLTModuleAgent::kRawReader: stype="RawReader"; break;
  case AliHLTModuleAgent::kRawStream: stype="RawStream"; break;
  case AliHLTModuleAgent::kChain: stype="Chain"; break;
  case AliHLTModuleAgent::kProprietary: stype="Proprietary"; break;
  default: stype="unknown";
  }
  sout << "HLTOUT handler: "
       << "  " << type << " (" << stype << ")"
       << "  " << AliHLTComponent::DataType2Text(dt).c_str();
  cout << sout.str() << endl;
}
 AliHLTOUT.cxx:1
 AliHLTOUT.cxx:2
 AliHLTOUT.cxx:3
 AliHLTOUT.cxx:4
 AliHLTOUT.cxx:5
 AliHLTOUT.cxx:6
 AliHLTOUT.cxx:7
 AliHLTOUT.cxx:8
 AliHLTOUT.cxx:9
 AliHLTOUT.cxx:10
 AliHLTOUT.cxx:11
 AliHLTOUT.cxx:12
 AliHLTOUT.cxx:13
 AliHLTOUT.cxx:14
 AliHLTOUT.cxx:15
 AliHLTOUT.cxx:16
 AliHLTOUT.cxx:17
 AliHLTOUT.cxx:18
 AliHLTOUT.cxx:19
 AliHLTOUT.cxx:20
 AliHLTOUT.cxx:21
 AliHLTOUT.cxx:22
 AliHLTOUT.cxx:23
 AliHLTOUT.cxx:24
 AliHLTOUT.cxx:25
 AliHLTOUT.cxx:26
 AliHLTOUT.cxx:27
 AliHLTOUT.cxx:28
 AliHLTOUT.cxx:29
 AliHLTOUT.cxx:30
 AliHLTOUT.cxx:31
 AliHLTOUT.cxx:32
 AliHLTOUT.cxx:33
 AliHLTOUT.cxx:34
 AliHLTOUT.cxx:35
 AliHLTOUT.cxx:36
 AliHLTOUT.cxx:37
 AliHLTOUT.cxx:38
 AliHLTOUT.cxx:39
 AliHLTOUT.cxx:40
 AliHLTOUT.cxx:41
 AliHLTOUT.cxx:42
 AliHLTOUT.cxx:43
 AliHLTOUT.cxx:44
 AliHLTOUT.cxx:45
 AliHLTOUT.cxx:46
 AliHLTOUT.cxx:47
 AliHLTOUT.cxx:48
 AliHLTOUT.cxx:49
 AliHLTOUT.cxx:50
 AliHLTOUT.cxx:51
 AliHLTOUT.cxx:52
 AliHLTOUT.cxx:53
 AliHLTOUT.cxx:54
 AliHLTOUT.cxx:55
 AliHLTOUT.cxx:56
 AliHLTOUT.cxx:57
 AliHLTOUT.cxx:58
 AliHLTOUT.cxx:59
 AliHLTOUT.cxx:60
 AliHLTOUT.cxx:61
 AliHLTOUT.cxx:62
 AliHLTOUT.cxx:63
 AliHLTOUT.cxx:64
 AliHLTOUT.cxx:65
 AliHLTOUT.cxx:66
 AliHLTOUT.cxx:67
 AliHLTOUT.cxx:68
 AliHLTOUT.cxx:69
 AliHLTOUT.cxx:70
 AliHLTOUT.cxx:71
 AliHLTOUT.cxx:72
 AliHLTOUT.cxx:73
 AliHLTOUT.cxx:74
 AliHLTOUT.cxx:75
 AliHLTOUT.cxx:76
 AliHLTOUT.cxx:77
 AliHLTOUT.cxx:78
 AliHLTOUT.cxx:79
 AliHLTOUT.cxx:80
 AliHLTOUT.cxx:81
 AliHLTOUT.cxx:82
 AliHLTOUT.cxx:83
 AliHLTOUT.cxx:84
 AliHLTOUT.cxx:85
 AliHLTOUT.cxx:86
 AliHLTOUT.cxx:87
 AliHLTOUT.cxx:88
 AliHLTOUT.cxx:89
 AliHLTOUT.cxx:90
 AliHLTOUT.cxx:91
 AliHLTOUT.cxx:92
 AliHLTOUT.cxx:93
 AliHLTOUT.cxx:94
 AliHLTOUT.cxx:95
 AliHLTOUT.cxx:96
 AliHLTOUT.cxx:97
 AliHLTOUT.cxx:98
 AliHLTOUT.cxx:99
 AliHLTOUT.cxx:100
 AliHLTOUT.cxx:101
 AliHLTOUT.cxx:102
 AliHLTOUT.cxx:103
 AliHLTOUT.cxx:104
 AliHLTOUT.cxx:105
 AliHLTOUT.cxx:106
 AliHLTOUT.cxx:107
 AliHLTOUT.cxx:108
 AliHLTOUT.cxx:109
 AliHLTOUT.cxx:110
 AliHLTOUT.cxx:111
 AliHLTOUT.cxx:112
 AliHLTOUT.cxx:113
 AliHLTOUT.cxx:114
 AliHLTOUT.cxx:115
 AliHLTOUT.cxx:116
 AliHLTOUT.cxx:117
 AliHLTOUT.cxx:118
 AliHLTOUT.cxx:119
 AliHLTOUT.cxx:120
 AliHLTOUT.cxx:121
 AliHLTOUT.cxx:122
 AliHLTOUT.cxx:123
 AliHLTOUT.cxx:124
 AliHLTOUT.cxx:125
 AliHLTOUT.cxx:126
 AliHLTOUT.cxx:127
 AliHLTOUT.cxx:128
 AliHLTOUT.cxx:129
 AliHLTOUT.cxx:130
 AliHLTOUT.cxx:131
 AliHLTOUT.cxx:132
 AliHLTOUT.cxx:133
 AliHLTOUT.cxx:134
 AliHLTOUT.cxx:135
 AliHLTOUT.cxx:136
 AliHLTOUT.cxx:137
 AliHLTOUT.cxx:138
 AliHLTOUT.cxx:139
 AliHLTOUT.cxx:140
 AliHLTOUT.cxx:141
 AliHLTOUT.cxx:142
 AliHLTOUT.cxx:143
 AliHLTOUT.cxx:144
 AliHLTOUT.cxx:145
 AliHLTOUT.cxx:146
 AliHLTOUT.cxx:147
 AliHLTOUT.cxx:148
 AliHLTOUT.cxx:149
 AliHLTOUT.cxx:150
 AliHLTOUT.cxx:151
 AliHLTOUT.cxx:152
 AliHLTOUT.cxx:153
 AliHLTOUT.cxx:154
 AliHLTOUT.cxx:155
 AliHLTOUT.cxx:156
 AliHLTOUT.cxx:157
 AliHLTOUT.cxx:158
 AliHLTOUT.cxx:159
 AliHLTOUT.cxx:160
 AliHLTOUT.cxx:161
 AliHLTOUT.cxx:162
 AliHLTOUT.cxx:163
 AliHLTOUT.cxx:164
 AliHLTOUT.cxx:165
 AliHLTOUT.cxx:166
 AliHLTOUT.cxx:167
 AliHLTOUT.cxx:168
 AliHLTOUT.cxx:169
 AliHLTOUT.cxx:170
 AliHLTOUT.cxx:171
 AliHLTOUT.cxx:172
 AliHLTOUT.cxx:173
 AliHLTOUT.cxx:174
 AliHLTOUT.cxx:175
 AliHLTOUT.cxx:176
 AliHLTOUT.cxx:177
 AliHLTOUT.cxx:178
 AliHLTOUT.cxx:179
 AliHLTOUT.cxx:180
 AliHLTOUT.cxx:181
 AliHLTOUT.cxx:182
 AliHLTOUT.cxx:183
 AliHLTOUT.cxx:184
 AliHLTOUT.cxx:185
 AliHLTOUT.cxx:186
 AliHLTOUT.cxx:187
 AliHLTOUT.cxx:188
 AliHLTOUT.cxx:189
 AliHLTOUT.cxx:190
 AliHLTOUT.cxx:191
 AliHLTOUT.cxx:192
 AliHLTOUT.cxx:193
 AliHLTOUT.cxx:194
 AliHLTOUT.cxx:195
 AliHLTOUT.cxx:196
 AliHLTOUT.cxx:197
 AliHLTOUT.cxx:198
 AliHLTOUT.cxx:199
 AliHLTOUT.cxx:200
 AliHLTOUT.cxx:201
 AliHLTOUT.cxx:202
 AliHLTOUT.cxx:203
 AliHLTOUT.cxx:204
 AliHLTOUT.cxx:205
 AliHLTOUT.cxx:206
 AliHLTOUT.cxx:207
 AliHLTOUT.cxx:208
 AliHLTOUT.cxx:209
 AliHLTOUT.cxx:210
 AliHLTOUT.cxx:211
 AliHLTOUT.cxx:212
 AliHLTOUT.cxx:213
 AliHLTOUT.cxx:214
 AliHLTOUT.cxx:215
 AliHLTOUT.cxx:216
 AliHLTOUT.cxx:217
 AliHLTOUT.cxx:218
 AliHLTOUT.cxx:219
 AliHLTOUT.cxx:220
 AliHLTOUT.cxx:221
 AliHLTOUT.cxx:222
 AliHLTOUT.cxx:223
 AliHLTOUT.cxx:224
 AliHLTOUT.cxx:225
 AliHLTOUT.cxx:226
 AliHLTOUT.cxx:227
 AliHLTOUT.cxx:228
 AliHLTOUT.cxx:229
 AliHLTOUT.cxx:230
 AliHLTOUT.cxx:231
 AliHLTOUT.cxx:232
 AliHLTOUT.cxx:233
 AliHLTOUT.cxx:234
 AliHLTOUT.cxx:235
 AliHLTOUT.cxx:236
 AliHLTOUT.cxx:237
 AliHLTOUT.cxx:238
 AliHLTOUT.cxx:239
 AliHLTOUT.cxx:240
 AliHLTOUT.cxx:241
 AliHLTOUT.cxx:242
 AliHLTOUT.cxx:243
 AliHLTOUT.cxx:244
 AliHLTOUT.cxx:245
 AliHLTOUT.cxx:246
 AliHLTOUT.cxx:247
 AliHLTOUT.cxx:248
 AliHLTOUT.cxx:249
 AliHLTOUT.cxx:250
 AliHLTOUT.cxx:251
 AliHLTOUT.cxx:252
 AliHLTOUT.cxx:253
 AliHLTOUT.cxx:254
 AliHLTOUT.cxx:255
 AliHLTOUT.cxx:256
 AliHLTOUT.cxx:257
 AliHLTOUT.cxx:258
 AliHLTOUT.cxx:259
 AliHLTOUT.cxx:260
 AliHLTOUT.cxx:261
 AliHLTOUT.cxx:262
 AliHLTOUT.cxx:263
 AliHLTOUT.cxx:264
 AliHLTOUT.cxx:265
 AliHLTOUT.cxx:266
 AliHLTOUT.cxx:267
 AliHLTOUT.cxx:268
 AliHLTOUT.cxx:269
 AliHLTOUT.cxx:270
 AliHLTOUT.cxx:271
 AliHLTOUT.cxx:272
 AliHLTOUT.cxx:273
 AliHLTOUT.cxx:274
 AliHLTOUT.cxx:275
 AliHLTOUT.cxx:276
 AliHLTOUT.cxx:277
 AliHLTOUT.cxx:278
 AliHLTOUT.cxx:279
 AliHLTOUT.cxx:280
 AliHLTOUT.cxx:281
 AliHLTOUT.cxx:282
 AliHLTOUT.cxx:283
 AliHLTOUT.cxx:284
 AliHLTOUT.cxx:285
 AliHLTOUT.cxx:286
 AliHLTOUT.cxx:287
 AliHLTOUT.cxx:288
 AliHLTOUT.cxx:289
 AliHLTOUT.cxx:290
 AliHLTOUT.cxx:291
 AliHLTOUT.cxx:292
 AliHLTOUT.cxx:293
 AliHLTOUT.cxx:294
 AliHLTOUT.cxx:295
 AliHLTOUT.cxx:296
 AliHLTOUT.cxx:297
 AliHLTOUT.cxx:298
 AliHLTOUT.cxx:299
 AliHLTOUT.cxx:300
 AliHLTOUT.cxx:301
 AliHLTOUT.cxx:302
 AliHLTOUT.cxx:303
 AliHLTOUT.cxx:304
 AliHLTOUT.cxx:305
 AliHLTOUT.cxx:306
 AliHLTOUT.cxx:307
 AliHLTOUT.cxx:308
 AliHLTOUT.cxx:309
 AliHLTOUT.cxx:310
 AliHLTOUT.cxx:311
 AliHLTOUT.cxx:312
 AliHLTOUT.cxx:313
 AliHLTOUT.cxx:314
 AliHLTOUT.cxx:315
 AliHLTOUT.cxx:316
 AliHLTOUT.cxx:317
 AliHLTOUT.cxx:318
 AliHLTOUT.cxx:319
 AliHLTOUT.cxx:320
 AliHLTOUT.cxx:321
 AliHLTOUT.cxx:322
 AliHLTOUT.cxx:323
 AliHLTOUT.cxx:324
 AliHLTOUT.cxx:325
 AliHLTOUT.cxx:326
 AliHLTOUT.cxx:327
 AliHLTOUT.cxx:328
 AliHLTOUT.cxx:329
 AliHLTOUT.cxx:330
 AliHLTOUT.cxx:331
 AliHLTOUT.cxx:332
 AliHLTOUT.cxx:333
 AliHLTOUT.cxx:334
 AliHLTOUT.cxx:335
 AliHLTOUT.cxx:336
 AliHLTOUT.cxx:337
 AliHLTOUT.cxx:338
 AliHLTOUT.cxx:339
 AliHLTOUT.cxx:340
 AliHLTOUT.cxx:341
 AliHLTOUT.cxx:342
 AliHLTOUT.cxx:343
 AliHLTOUT.cxx:344
 AliHLTOUT.cxx:345
 AliHLTOUT.cxx:346
 AliHLTOUT.cxx:347
 AliHLTOUT.cxx:348
 AliHLTOUT.cxx:349
 AliHLTOUT.cxx:350
 AliHLTOUT.cxx:351
 AliHLTOUT.cxx:352
 AliHLTOUT.cxx:353
 AliHLTOUT.cxx:354
 AliHLTOUT.cxx:355
 AliHLTOUT.cxx:356
 AliHLTOUT.cxx:357
 AliHLTOUT.cxx:358
 AliHLTOUT.cxx:359
 AliHLTOUT.cxx:360
 AliHLTOUT.cxx:361
 AliHLTOUT.cxx:362
 AliHLTOUT.cxx:363
 AliHLTOUT.cxx:364
 AliHLTOUT.cxx:365
 AliHLTOUT.cxx:366
 AliHLTOUT.cxx:367
 AliHLTOUT.cxx:368
 AliHLTOUT.cxx:369
 AliHLTOUT.cxx:370
 AliHLTOUT.cxx:371
 AliHLTOUT.cxx:372
 AliHLTOUT.cxx:373
 AliHLTOUT.cxx:374
 AliHLTOUT.cxx:375
 AliHLTOUT.cxx:376
 AliHLTOUT.cxx:377
 AliHLTOUT.cxx:378
 AliHLTOUT.cxx:379
 AliHLTOUT.cxx:380
 AliHLTOUT.cxx:381
 AliHLTOUT.cxx:382
 AliHLTOUT.cxx:383
 AliHLTOUT.cxx:384
 AliHLTOUT.cxx:385
 AliHLTOUT.cxx:386
 AliHLTOUT.cxx:387
 AliHLTOUT.cxx:388
 AliHLTOUT.cxx:389
 AliHLTOUT.cxx:390
 AliHLTOUT.cxx:391
 AliHLTOUT.cxx:392
 AliHLTOUT.cxx:393
 AliHLTOUT.cxx:394
 AliHLTOUT.cxx:395
 AliHLTOUT.cxx:396
 AliHLTOUT.cxx:397
 AliHLTOUT.cxx:398
 AliHLTOUT.cxx:399
 AliHLTOUT.cxx:400
 AliHLTOUT.cxx:401
 AliHLTOUT.cxx:402
 AliHLTOUT.cxx:403
 AliHLTOUT.cxx:404
 AliHLTOUT.cxx:405
 AliHLTOUT.cxx:406
 AliHLTOUT.cxx:407
 AliHLTOUT.cxx:408
 AliHLTOUT.cxx:409
 AliHLTOUT.cxx:410
 AliHLTOUT.cxx:411
 AliHLTOUT.cxx:412
 AliHLTOUT.cxx:413
 AliHLTOUT.cxx:414
 AliHLTOUT.cxx:415
 AliHLTOUT.cxx:416
 AliHLTOUT.cxx:417
 AliHLTOUT.cxx:418
 AliHLTOUT.cxx:419
 AliHLTOUT.cxx:420
 AliHLTOUT.cxx:421
 AliHLTOUT.cxx:422
 AliHLTOUT.cxx:423
 AliHLTOUT.cxx:424
 AliHLTOUT.cxx:425
 AliHLTOUT.cxx:426
 AliHLTOUT.cxx:427
 AliHLTOUT.cxx:428
 AliHLTOUT.cxx:429
 AliHLTOUT.cxx:430
 AliHLTOUT.cxx:431
 AliHLTOUT.cxx:432
 AliHLTOUT.cxx:433
 AliHLTOUT.cxx:434
 AliHLTOUT.cxx:435
 AliHLTOUT.cxx:436
 AliHLTOUT.cxx:437
 AliHLTOUT.cxx:438
 AliHLTOUT.cxx:439
 AliHLTOUT.cxx:440
 AliHLTOUT.cxx:441
 AliHLTOUT.cxx:442
 AliHLTOUT.cxx:443
 AliHLTOUT.cxx:444
 AliHLTOUT.cxx:445
 AliHLTOUT.cxx:446
 AliHLTOUT.cxx:447
 AliHLTOUT.cxx:448
 AliHLTOUT.cxx:449
 AliHLTOUT.cxx:450
 AliHLTOUT.cxx:451
 AliHLTOUT.cxx:452
 AliHLTOUT.cxx:453
 AliHLTOUT.cxx:454
 AliHLTOUT.cxx:455
 AliHLTOUT.cxx:456
 AliHLTOUT.cxx:457
 AliHLTOUT.cxx:458
 AliHLTOUT.cxx:459
 AliHLTOUT.cxx:460
 AliHLTOUT.cxx:461
 AliHLTOUT.cxx:462
 AliHLTOUT.cxx:463
 AliHLTOUT.cxx:464
 AliHLTOUT.cxx:465
 AliHLTOUT.cxx:466
 AliHLTOUT.cxx:467
 AliHLTOUT.cxx:468
 AliHLTOUT.cxx:469
 AliHLTOUT.cxx:470
 AliHLTOUT.cxx:471
 AliHLTOUT.cxx:472
 AliHLTOUT.cxx:473
 AliHLTOUT.cxx:474
 AliHLTOUT.cxx:475
 AliHLTOUT.cxx:476
 AliHLTOUT.cxx:477
 AliHLTOUT.cxx:478
 AliHLTOUT.cxx:479
 AliHLTOUT.cxx:480
 AliHLTOUT.cxx:481
 AliHLTOUT.cxx:482
 AliHLTOUT.cxx:483
 AliHLTOUT.cxx:484
 AliHLTOUT.cxx:485
 AliHLTOUT.cxx:486
 AliHLTOUT.cxx:487
 AliHLTOUT.cxx:488
 AliHLTOUT.cxx:489
 AliHLTOUT.cxx:490
 AliHLTOUT.cxx:491
 AliHLTOUT.cxx:492
 AliHLTOUT.cxx:493
 AliHLTOUT.cxx:494
 AliHLTOUT.cxx:495
 AliHLTOUT.cxx:496
 AliHLTOUT.cxx:497
 AliHLTOUT.cxx:498
 AliHLTOUT.cxx:499
 AliHLTOUT.cxx:500
 AliHLTOUT.cxx:501
 AliHLTOUT.cxx:502
 AliHLTOUT.cxx:503
 AliHLTOUT.cxx:504
 AliHLTOUT.cxx:505
 AliHLTOUT.cxx:506
 AliHLTOUT.cxx:507
 AliHLTOUT.cxx:508
 AliHLTOUT.cxx:509
 AliHLTOUT.cxx:510
 AliHLTOUT.cxx:511
 AliHLTOUT.cxx:512
 AliHLTOUT.cxx:513
 AliHLTOUT.cxx:514
 AliHLTOUT.cxx:515
 AliHLTOUT.cxx:516
 AliHLTOUT.cxx:517
 AliHLTOUT.cxx:518
 AliHLTOUT.cxx:519
 AliHLTOUT.cxx:520
 AliHLTOUT.cxx:521
 AliHLTOUT.cxx:522
 AliHLTOUT.cxx:523
 AliHLTOUT.cxx:524
 AliHLTOUT.cxx:525
 AliHLTOUT.cxx:526
 AliHLTOUT.cxx:527
 AliHLTOUT.cxx:528
 AliHLTOUT.cxx:529
 AliHLTOUT.cxx:530
 AliHLTOUT.cxx:531
 AliHLTOUT.cxx:532
 AliHLTOUT.cxx:533
 AliHLTOUT.cxx:534
 AliHLTOUT.cxx:535
 AliHLTOUT.cxx:536
 AliHLTOUT.cxx:537
 AliHLTOUT.cxx:538
 AliHLTOUT.cxx:539
 AliHLTOUT.cxx:540
 AliHLTOUT.cxx:541
 AliHLTOUT.cxx:542
 AliHLTOUT.cxx:543
 AliHLTOUT.cxx:544
 AliHLTOUT.cxx:545
 AliHLTOUT.cxx:546
 AliHLTOUT.cxx:547
 AliHLTOUT.cxx:548
 AliHLTOUT.cxx:549
 AliHLTOUT.cxx:550
 AliHLTOUT.cxx:551
 AliHLTOUT.cxx:552
 AliHLTOUT.cxx:553
 AliHLTOUT.cxx:554
 AliHLTOUT.cxx:555
 AliHLTOUT.cxx:556
 AliHLTOUT.cxx:557
 AliHLTOUT.cxx:558
 AliHLTOUT.cxx:559
 AliHLTOUT.cxx:560
 AliHLTOUT.cxx:561
 AliHLTOUT.cxx:562
 AliHLTOUT.cxx:563
 AliHLTOUT.cxx:564
 AliHLTOUT.cxx:565
 AliHLTOUT.cxx:566
 AliHLTOUT.cxx:567
 AliHLTOUT.cxx:568
 AliHLTOUT.cxx:569
 AliHLTOUT.cxx:570
 AliHLTOUT.cxx:571
 AliHLTOUT.cxx:572
 AliHLTOUT.cxx:573
 AliHLTOUT.cxx:574
 AliHLTOUT.cxx:575
 AliHLTOUT.cxx:576
 AliHLTOUT.cxx:577
 AliHLTOUT.cxx:578
 AliHLTOUT.cxx:579
 AliHLTOUT.cxx:580
 AliHLTOUT.cxx:581
 AliHLTOUT.cxx:582
 AliHLTOUT.cxx:583
 AliHLTOUT.cxx:584
 AliHLTOUT.cxx:585
 AliHLTOUT.cxx:586
 AliHLTOUT.cxx:587
 AliHLTOUT.cxx:588
 AliHLTOUT.cxx:589
 AliHLTOUT.cxx:590
 AliHLTOUT.cxx:591
 AliHLTOUT.cxx:592
 AliHLTOUT.cxx:593
 AliHLTOUT.cxx:594
 AliHLTOUT.cxx:595
 AliHLTOUT.cxx:596
 AliHLTOUT.cxx:597
 AliHLTOUT.cxx:598
 AliHLTOUT.cxx:599
 AliHLTOUT.cxx:600
 AliHLTOUT.cxx:601
 AliHLTOUT.cxx:602
 AliHLTOUT.cxx:603
 AliHLTOUT.cxx:604
 AliHLTOUT.cxx:605
 AliHLTOUT.cxx:606
 AliHLTOUT.cxx:607
 AliHLTOUT.cxx:608
 AliHLTOUT.cxx:609
 AliHLTOUT.cxx:610
 AliHLTOUT.cxx:611
 AliHLTOUT.cxx:612
 AliHLTOUT.cxx:613
 AliHLTOUT.cxx:614
 AliHLTOUT.cxx:615
 AliHLTOUT.cxx:616
 AliHLTOUT.cxx:617
 AliHLTOUT.cxx:618
 AliHLTOUT.cxx:619
 AliHLTOUT.cxx:620
 AliHLTOUT.cxx:621
 AliHLTOUT.cxx:622
 AliHLTOUT.cxx:623
 AliHLTOUT.cxx:624
 AliHLTOUT.cxx:625
 AliHLTOUT.cxx:626
 AliHLTOUT.cxx:627
 AliHLTOUT.cxx:628
 AliHLTOUT.cxx:629
 AliHLTOUT.cxx:630
 AliHLTOUT.cxx:631
 AliHLTOUT.cxx:632
 AliHLTOUT.cxx:633
 AliHLTOUT.cxx:634
 AliHLTOUT.cxx:635
 AliHLTOUT.cxx:636
 AliHLTOUT.cxx:637
 AliHLTOUT.cxx:638
 AliHLTOUT.cxx:639
 AliHLTOUT.cxx:640
 AliHLTOUT.cxx:641
 AliHLTOUT.cxx:642
 AliHLTOUT.cxx:643
 AliHLTOUT.cxx:644
 AliHLTOUT.cxx:645
 AliHLTOUT.cxx:646
 AliHLTOUT.cxx:647
 AliHLTOUT.cxx:648
 AliHLTOUT.cxx:649
 AliHLTOUT.cxx:650
 AliHLTOUT.cxx:651
 AliHLTOUT.cxx:652
 AliHLTOUT.cxx:653
 AliHLTOUT.cxx:654
 AliHLTOUT.cxx:655
 AliHLTOUT.cxx:656
 AliHLTOUT.cxx:657
 AliHLTOUT.cxx:658
 AliHLTOUT.cxx:659
 AliHLTOUT.cxx:660
 AliHLTOUT.cxx:661
 AliHLTOUT.cxx:662
 AliHLTOUT.cxx:663
 AliHLTOUT.cxx:664
 AliHLTOUT.cxx:665
 AliHLTOUT.cxx:666
 AliHLTOUT.cxx:667
 AliHLTOUT.cxx:668
 AliHLTOUT.cxx:669
 AliHLTOUT.cxx:670
 AliHLTOUT.cxx:671
 AliHLTOUT.cxx:672
 AliHLTOUT.cxx:673
 AliHLTOUT.cxx:674
 AliHLTOUT.cxx:675
 AliHLTOUT.cxx:676
 AliHLTOUT.cxx:677
 AliHLTOUT.cxx:678
 AliHLTOUT.cxx:679
 AliHLTOUT.cxx:680
 AliHLTOUT.cxx:681
 AliHLTOUT.cxx:682
 AliHLTOUT.cxx:683
 AliHLTOUT.cxx:684
 AliHLTOUT.cxx:685
 AliHLTOUT.cxx:686
 AliHLTOUT.cxx:687
 AliHLTOUT.cxx:688
 AliHLTOUT.cxx:689
 AliHLTOUT.cxx:690
 AliHLTOUT.cxx:691
 AliHLTOUT.cxx:692
 AliHLTOUT.cxx:693
 AliHLTOUT.cxx:694
 AliHLTOUT.cxx:695
 AliHLTOUT.cxx:696
 AliHLTOUT.cxx:697
 AliHLTOUT.cxx:698
 AliHLTOUT.cxx:699
 AliHLTOUT.cxx:700
 AliHLTOUT.cxx:701
 AliHLTOUT.cxx:702
 AliHLTOUT.cxx:703
 AliHLTOUT.cxx:704
 AliHLTOUT.cxx:705
 AliHLTOUT.cxx:706
 AliHLTOUT.cxx:707
 AliHLTOUT.cxx:708
 AliHLTOUT.cxx:709
 AliHLTOUT.cxx:710
 AliHLTOUT.cxx:711
 AliHLTOUT.cxx:712
 AliHLTOUT.cxx:713
 AliHLTOUT.cxx:714
 AliHLTOUT.cxx:715
 AliHLTOUT.cxx:716
 AliHLTOUT.cxx:717
 AliHLTOUT.cxx:718
 AliHLTOUT.cxx:719
 AliHLTOUT.cxx:720
 AliHLTOUT.cxx:721
 AliHLTOUT.cxx:722
 AliHLTOUT.cxx:723
 AliHLTOUT.cxx:724
 AliHLTOUT.cxx:725
 AliHLTOUT.cxx:726
 AliHLTOUT.cxx:727
 AliHLTOUT.cxx:728
 AliHLTOUT.cxx:729
 AliHLTOUT.cxx:730
 AliHLTOUT.cxx:731
 AliHLTOUT.cxx:732
 AliHLTOUT.cxx:733
 AliHLTOUT.cxx:734
 AliHLTOUT.cxx:735
 AliHLTOUT.cxx:736
 AliHLTOUT.cxx:737
 AliHLTOUT.cxx:738
 AliHLTOUT.cxx:739
 AliHLTOUT.cxx:740
 AliHLTOUT.cxx:741
 AliHLTOUT.cxx:742
 AliHLTOUT.cxx:743
 AliHLTOUT.cxx:744
 AliHLTOUT.cxx:745
 AliHLTOUT.cxx:746
 AliHLTOUT.cxx:747
 AliHLTOUT.cxx:748
 AliHLTOUT.cxx:749
 AliHLTOUT.cxx:750
 AliHLTOUT.cxx:751
 AliHLTOUT.cxx:752
 AliHLTOUT.cxx:753
 AliHLTOUT.cxx:754
 AliHLTOUT.cxx:755
 AliHLTOUT.cxx:756
 AliHLTOUT.cxx:757
 AliHLTOUT.cxx:758
 AliHLTOUT.cxx:759
 AliHLTOUT.cxx:760
 AliHLTOUT.cxx:761
 AliHLTOUT.cxx:762
 AliHLTOUT.cxx:763
 AliHLTOUT.cxx:764
 AliHLTOUT.cxx:765
 AliHLTOUT.cxx:766
 AliHLTOUT.cxx:767
 AliHLTOUT.cxx:768
 AliHLTOUT.cxx:769
 AliHLTOUT.cxx:770
 AliHLTOUT.cxx:771
 AliHLTOUT.cxx:772
 AliHLTOUT.cxx:773
 AliHLTOUT.cxx:774
 AliHLTOUT.cxx:775
 AliHLTOUT.cxx:776
 AliHLTOUT.cxx:777
 AliHLTOUT.cxx:778
 AliHLTOUT.cxx:779
 AliHLTOUT.cxx:780
 AliHLTOUT.cxx:781
 AliHLTOUT.cxx:782
 AliHLTOUT.cxx:783
 AliHLTOUT.cxx:784
 AliHLTOUT.cxx:785
 AliHLTOUT.cxx:786
 AliHLTOUT.cxx:787
 AliHLTOUT.cxx:788
 AliHLTOUT.cxx:789
 AliHLTOUT.cxx:790
 AliHLTOUT.cxx:791
 AliHLTOUT.cxx:792
 AliHLTOUT.cxx:793
 AliHLTOUT.cxx:794
 AliHLTOUT.cxx:795
 AliHLTOUT.cxx:796
 AliHLTOUT.cxx:797
 AliHLTOUT.cxx:798
 AliHLTOUT.cxx:799
 AliHLTOUT.cxx:800
 AliHLTOUT.cxx:801
 AliHLTOUT.cxx:802
 AliHLTOUT.cxx:803
 AliHLTOUT.cxx:804
 AliHLTOUT.cxx:805
 AliHLTOUT.cxx:806
 AliHLTOUT.cxx:807
 AliHLTOUT.cxx:808
 AliHLTOUT.cxx:809
 AliHLTOUT.cxx:810
 AliHLTOUT.cxx:811
 AliHLTOUT.cxx:812
 AliHLTOUT.cxx:813
 AliHLTOUT.cxx:814
 AliHLTOUT.cxx:815
 AliHLTOUT.cxx:816
 AliHLTOUT.cxx:817
 AliHLTOUT.cxx:818
 AliHLTOUT.cxx:819
 AliHLTOUT.cxx:820
 AliHLTOUT.cxx:821
 AliHLTOUT.cxx:822
 AliHLTOUT.cxx:823
 AliHLTOUT.cxx:824
 AliHLTOUT.cxx:825
 AliHLTOUT.cxx:826
 AliHLTOUT.cxx:827
 AliHLTOUT.cxx:828
 AliHLTOUT.cxx:829
 AliHLTOUT.cxx:830
 AliHLTOUT.cxx:831
 AliHLTOUT.cxx:832
 AliHLTOUT.cxx:833
 AliHLTOUT.cxx:834
 AliHLTOUT.cxx:835
 AliHLTOUT.cxx:836
 AliHLTOUT.cxx:837
 AliHLTOUT.cxx:838
 AliHLTOUT.cxx:839
 AliHLTOUT.cxx:840
 AliHLTOUT.cxx:841
 AliHLTOUT.cxx:842
 AliHLTOUT.cxx:843
 AliHLTOUT.cxx:844
 AliHLTOUT.cxx:845
 AliHLTOUT.cxx:846
 AliHLTOUT.cxx:847
 AliHLTOUT.cxx:848
 AliHLTOUT.cxx:849
 AliHLTOUT.cxx:850
 AliHLTOUT.cxx:851
 AliHLTOUT.cxx:852
 AliHLTOUT.cxx:853
 AliHLTOUT.cxx:854
 AliHLTOUT.cxx:855
 AliHLTOUT.cxx:856
 AliHLTOUT.cxx:857
 AliHLTOUT.cxx:858
 AliHLTOUT.cxx:859
 AliHLTOUT.cxx:860
 AliHLTOUT.cxx:861
 AliHLTOUT.cxx:862
 AliHLTOUT.cxx:863
 AliHLTOUT.cxx:864
 AliHLTOUT.cxx:865
 AliHLTOUT.cxx:866
 AliHLTOUT.cxx:867
 AliHLTOUT.cxx:868
 AliHLTOUT.cxx:869
 AliHLTOUT.cxx:870
 AliHLTOUT.cxx:871
 AliHLTOUT.cxx:872
 AliHLTOUT.cxx:873
 AliHLTOUT.cxx:874
 AliHLTOUT.cxx:875
 AliHLTOUT.cxx:876
 AliHLTOUT.cxx:877
 AliHLTOUT.cxx:878
 AliHLTOUT.cxx:879
 AliHLTOUT.cxx:880
 AliHLTOUT.cxx:881
 AliHLTOUT.cxx:882
 AliHLTOUT.cxx:883
 AliHLTOUT.cxx:884
 AliHLTOUT.cxx:885
 AliHLTOUT.cxx:886
 AliHLTOUT.cxx:887
 AliHLTOUT.cxx:888
 AliHLTOUT.cxx:889
 AliHLTOUT.cxx:890
 AliHLTOUT.cxx:891
 AliHLTOUT.cxx:892
 AliHLTOUT.cxx:893
 AliHLTOUT.cxx:894
 AliHLTOUT.cxx:895
 AliHLTOUT.cxx:896
 AliHLTOUT.cxx:897
 AliHLTOUT.cxx:898
 AliHLTOUT.cxx:899
 AliHLTOUT.cxx:900
 AliHLTOUT.cxx:901
 AliHLTOUT.cxx:902
 AliHLTOUT.cxx:903
 AliHLTOUT.cxx:904
 AliHLTOUT.cxx:905
 AliHLTOUT.cxx:906
 AliHLTOUT.cxx:907
 AliHLTOUT.cxx:908
 AliHLTOUT.cxx:909
 AliHLTOUT.cxx:910
 AliHLTOUT.cxx:911
 AliHLTOUT.cxx:912
 AliHLTOUT.cxx:913
 AliHLTOUT.cxx:914
 AliHLTOUT.cxx:915
 AliHLTOUT.cxx:916
 AliHLTOUT.cxx:917
 AliHLTOUT.cxx:918
 AliHLTOUT.cxx:919
 AliHLTOUT.cxx:920
 AliHLTOUT.cxx:921
 AliHLTOUT.cxx:922
 AliHLTOUT.cxx:923
 AliHLTOUT.cxx:924
 AliHLTOUT.cxx:925
 AliHLTOUT.cxx:926
 AliHLTOUT.cxx:927
 AliHLTOUT.cxx:928
 AliHLTOUT.cxx:929
 AliHLTOUT.cxx:930
 AliHLTOUT.cxx:931
 AliHLTOUT.cxx:932
 AliHLTOUT.cxx:933
 AliHLTOUT.cxx:934
 AliHLTOUT.cxx:935
 AliHLTOUT.cxx:936
 AliHLTOUT.cxx:937
 AliHLTOUT.cxx:938
 AliHLTOUT.cxx:939
 AliHLTOUT.cxx:940
 AliHLTOUT.cxx:941
 AliHLTOUT.cxx:942
 AliHLTOUT.cxx:943
 AliHLTOUT.cxx:944
 AliHLTOUT.cxx:945
 AliHLTOUT.cxx:946
 AliHLTOUT.cxx:947
 AliHLTOUT.cxx:948
 AliHLTOUT.cxx:949
 AliHLTOUT.cxx:950
 AliHLTOUT.cxx:951
 AliHLTOUT.cxx:952
 AliHLTOUT.cxx:953
 AliHLTOUT.cxx:954
 AliHLTOUT.cxx:955
 AliHLTOUT.cxx:956
 AliHLTOUT.cxx:957
 AliHLTOUT.cxx:958
 AliHLTOUT.cxx:959
 AliHLTOUT.cxx:960
 AliHLTOUT.cxx:961
 AliHLTOUT.cxx:962
 AliHLTOUT.cxx:963
 AliHLTOUT.cxx:964
 AliHLTOUT.cxx:965
 AliHLTOUT.cxx:966
 AliHLTOUT.cxx:967
 AliHLTOUT.cxx:968
 AliHLTOUT.cxx:969
 AliHLTOUT.cxx:970
 AliHLTOUT.cxx:971
 AliHLTOUT.cxx:972