/data3/calcul/jacquem/working_dir/Micromegas/micromegasFrameWork/src/parser/MicrorocLabviewReader.cpp

Go to the documentation of this file.

/* @version $Revision: 1338 $ * @modifiedby $Author: jacquem $ * @lastmodified $Date: 2011-10-07 11:03:14 +0200 (Fri, 07 Oct 2011) $ */

////////////////////////////////////////////////////////////////////////
// MICROMEGAS
//
//       EVENT RECONSTRUCTION SOFTWARE FOR MICROROC BOARDS
//
////////////////////////////////////////////////////////////////////////

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>

#include "parser/MicrorocSCReader.hh"
#include "parser/MicrorocLabviewReader.hh"
#include "parser/AcquisitionParser.hh"

#include "event/Event.hh"

#include "geometry/Chamber.hh"
#include "geometry/Board.hh"
#include "geometry/Dif.hh"
#include "geometry/MicrorocChip.hh"
#include "geometry/Detector.hh"

#include "tools/Toolbox.hh"
#include "tools/SteerDesc.hh"
#include "tools/Log.hh"
#include "tools/MicroException.hh"

#include <iostream>
#include <iomanip>

using namespace std;

////////////////////////////////////////////////////////////////////////
MicrorocLabviewReader::MicrorocLabviewReader(Run& aRun, FILE *aFile, ui32 lastEventId) : MicrorocReader(aRun, aFile, lastEventId), nbChipPerLine(0), analogDataActivate(false)
{
  FILE_LOG(logDEBUG1) << "--MicrorocLabviewReader constructor()"<< endl;
  FILE_LOG(logDEBUG) << "cwMixrorocLabview ReaderDifReader Constructeur  crc adr[" <<  crc << "]" << endl;
  
  for ( ui16 line = 0 ; line < NBLINE ; line++)
  {
    analogDataActivatedLine[line] = false;
  } 

  reset();

}

//--------------- Destructeur -------------//
MicrorocLabviewReader::~MicrorocLabviewReader()
{
  FILE_LOG(logDEBUG1)<< "----MicrorocLabviewReader destructor"<< endl;
}

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

int MicrorocLabviewReader::getScData() {
  unsigned int data;
  display(+1);
  FILE_LOG(logDEBUG) << " Slow Control data header B1 found" << endl;


  int scHRNumber = 24;

  difId=1; // in case of dataFormat = 7 Difid is not in data file
        ui16 dataFormat = run.getDataFormat();
  if ( dataFormat == 11 || dataFormat == 12)
  {

      nbChipPerLine = 12;  //DEBUG
      bool findA1 = false;
      difId = getData(1);
                  display(+1);
      FILE_LOG(logDEBUG) << "--- difId[" << difId << "] config ---" << endl;

                        Dif& dif = run.getDetector().getDifById(difId);
      FILE_LOG(logINFO) << "-------- dif Id[0x" << hex << dif.getId() << "]" << endl;
                        dif.setDifFirmware(getData(2));
                        display(+2);
      FILE_LOG(logINFO) << "-------- difFirmware[0x" << hex << dif.getDifFirmware() << "]" << endl;

                        dif.setDifConfig (getData(1));
                        display(+1);
      FILE_LOG(logINFO) << "-------- difConfig[0x" << hex <<  dif.getDifConfig() << "]" << endl;

                        dif.setAsicType(getData(1));
                        display(+1);
      FILE_LOG(logINFO) << "-------- asicType[0x" << dif.getAsicType() << "]" << endl;
      if ( dif.getAsicType() == 4 ) 
      {
        FILE_LOG(logINFO) << "------------------ [ Microroc ]" << endl;
      }
      dif.setConfigured(true);
    
      if ( dataFormat == 12 )
      {
      // Test next Byte to decode analigic informations
        int foo = getData(1);
        if ( foo != 0x0 )
        {
          analogDataActivate = true;
          ui16 bitshift = 0x1;
          for ( ui16 line = 0 ; line < NBLINE; line++)
          {
            analogDataActivatedLine[line] = foo & bitshift; 
            bitshift = bitshift * 2;
            FILE_LOG(logDEBUG) << "line [" << line << "] analog activation["<< analogDataActivatedLine[line] <<"]" << endl; 
          }
          FILE_LOG(logINFO) << "-------- analog data enable. Mask to enable line [0x"  <<hex << foo <<"]" << endl; 
        }
        else 
        { 
          analogDataActivate = false; 
          FILE_LOG(logINFO) << "-------- analogData disable" << endl; 
        }
      }

                        dif.setAsu1Id(getData(1));
      FILE_LOG(logINFO) << "-------- ASU 1 Id[0x" << hex << dif.getAsu1Id() << "]" << endl;
                        display(+1);

      // Consistency verification beetween geometry base on XML file and data send by Labview
      // In XML when a dif contains 2 ASU, we considere the first one a the left one ( close to DIF ) with row = 0 
      // se second ASU is on right ( far away from Dif ) with row = 1
      // From Labview data, ASU1Id is always on left ( close to the Dif )

      ui16 boardColToCheck = 0;
      if ( dif.getAsu1Id() != 0)
      {
        if ( dif.getBoardByCol(boardColToCheck).getId() !=  dif.getAsu1Id() )
        {
          FILE_LOG(logINFO) << "Error data say ASU id =  "<<  dif.getAsu1Id() << " for ASU close to DIF ( left side ) while XML say ASU id = " << dif.getBoardByCol(boardColToCheck).getId() << endl;
          FILE_LOG(logINFO) << "Please consider modifying XML file" << endl;
          exit(-1);
        }
        boardColToCheck++;
      }


                        dif.setAsu2Id (getData(1));
      FILE_LOG(logINFO) << "-------- ASU 2 Id[0x" <<hex << dif.getAsu2Id() << "]" << endl;
                        display(+1);
      if (  dif.getAsu2Id() != 0)
      {
        if ( dif.getBoardByCol(boardColToCheck).getId() !=  dif.getAsu2Id() )
        {
          FILE_LOG(logINFO) << "Error data say ASU id =  "<<  dif.getAsu2Id() << " for ASU far away to DIF ( right side ) while XML say ASU id = " << dif.getBoardByCol(boardColToCheck).getId() << endl;
          FILE_LOG(logINFO) << "Please consider modifying XML file" << endl;
          exit(-1);
        }
      }
      scHRNumber = getData(1);
      FILE_LOG(logINFO) << "-------- Nombre de chip en Slow control[0x" << hex << scHRNumber << "]" << endl;
    
      // set all chip to byppassed = True.
      // then each chip prensent in Slow control will by set to bypassed = False 
      dif.setChipByPassed(true);
      for ( int nbChip = 0 ; (nbChip < scHRNumber) & findA1 == false   ; nbChip++)
      {
        const unsigned char *buf = initGetBits(74, false);
        vector<int> sc;
        for ( ui16 i = 0; i < 74 ; i++)
        {
          int foo = getBits(8);
          sc.push_back(foo);
        }
        finishGetBits();
        MicrorocSCReader scReader(run,sc,difId);
        scReader.parseSC(difId);


          
      } // end for nbChip
          if ( ! findA1) {
              unsigned char *buf = initGetBits(1, false);
              if ( !buf)
              {
                FILE_LOG(logERROR) << "  malloc error while getting SC buffer" << endl;
                exit ( -1);
              }
              // Verify A1 Header
              int foo = getBits(8);
              finishGetBits();

              FILE_LOG(logDEBUG) << "Header[" <<hex <<  foo <<"]" << endl;
              if ( foo != 0xa1)
              {
                  FILE_LOG(logERROR) << "  Header A1 not found" << endl;
                  exit (-1);
              }
              FILE_LOG(logDEBUG1) << "Header A1 found" << endl;
              
          }
    
    } //end if format == 11 OR 12

    return(1);
} // MicrorocLabviewReader.getScData

//-------------------------------------------------------------------
// read analog acq  data
int MicrorocLabviewReader::getAnalogData(Event& event) {
  FILE_LOG(logDEBUG) << " global header C0 found" << endl;
  this->setComputeCrcFlag(true);
  crc->compute(0xC0); 

  ui16 nbchannel  = 64;
  ui16 nbLine = 4;
  ui16 nbBitsPerLine = this->nbChipPerLine * nbchannel * 16;
  Dif& dif = run.getDetector().getDifById(difId);
  ui16 nbChipByBoard = dif.getBoards().begin()->second->getNbColumns();
  ui16 nbBoard =  dif.getBoards().size();
  FILE_LOG(logDEBUG) << "nbBoard[" << nbBoard << "]" <<endl;
  FILE_LOG(logDEBUG) << "nbChipByBoard[" << nbChipByBoard << "]" <<endl;

  this->analogData.clear();
  bool firstLine=true;
  for ( ui16 line = 0; line < nbLine  ; line++)
  {
    if (  analogDataActivatedLine[line] == true )
    {  
      FILE_LOG(logDEBUG) << " New Line[" << line << "]" <<  endl;
      if ( !firstLine  )
      {
        int foo = getData(1);  // read 8 bits
        FILE_LOG(logDEBUG) << " foo C0["<< hex <<  foo << "]" << endl;
        if ( foo != 0xC0 )
        {
          FILE_LOG(logERROR) << "C0 header not found[0x" << hex << foo << "]" << endl;
          exit(-1);
        }
      }
      if( firstLine == true) { firstLine = false; }
  
      for ( i32 col = nbBoard * nbChipByBoard -1  ; col >= 0; col--) 
      {
        FILE_LOG(logDEBUG)<< hex << "col index[0x" << col << "]board col["<< col/nbChipByBoard << "] line["<< line <<"], col["<< col%nbChipByBoard <<"] "<<endl;
        Chip& chip = dif.getChipByRowCol(col/nbChipByBoard, line,col%nbChipByBoard);
        FILE_LOG(logDEBUG) << "------------chipId["<< chip.getId() << "] chip bypassed[" << chip.getBypassed() << "]"  <<endl;
        if( chip.getBypassed() == false )
        {
          map<ui16,ui16> channelsValues;
          for ( ui16 channel = 0 ; channel < nbchannel ;channel++) 
          {
            int foo = getData(2); 
            //this->analogData[line][col][channel] = foo; 
            channelsValues[channel] = foo;
            FILE_LOG(logDEBUG) << "chipId["<< chip.getId() <<"] analogData line["<< line <<"], col number["<< col << "] , channel[" << channel << "= " << hex <<foo << dec << endl;
          }
          this->analogData[chip.getId()] = channelsValues;
        }
      }
      
      // Get D0
      int foo = getData(1); 
      if ( foo != 0xD0 )
      {
        FILE_LOG(logERROR) << "D0 header not found[0x" << hex << foo << "]" << endl;
        exit(-1);
      }
    }
    else
    {
      FILE_LOG(logDEBUG) << " line[ " <<  line +1<< "] is disable  ( starting number at  1 )" << endl;
    }
  }


  this->setComputeCrcFlag(false);
  unsigned short CRC_check = getData(2);
  if ( CRC_check != crc->getCrc() )
  {
    FILE_LOG(logERROR) << endl << " CRC Error event Id: " << lastEventId <<  endl;
    FILE_LOG(logERROR) << hex << " Compute CRC[" << crc->getCrc() << "]" <<  endl;
    FILE_LOG(logERROR) << hex << " Received CRC[" << CRC_check << "]" <<  endl;
    event.setCrcIsCorrect(false);
  }
  else
  {
    event.setCrcIsCorrect(true);
  }

  return 0;
  }
//-------------------------------------------------------------------
// read acq  data
int MicrorocLabviewReader::getAcqData(Event& event) {
  ui32 nbanalogHit = 0;
  unsigned int nbHits = 0;

  display(+1);
  FILE_LOG(logDEBUG) << " global header B0 found" << endl;


  this->setComputeCrcFlag(true);
  //FILE_LOG(logDEBUG) << "MicrorocLabviewReader crc adr[" <<  crc << "]" << endl;
   FILE_LOG(logDEBUG) << "crc->compute(0xB0)[ "<< crc <<"]"   << endl;

  crc->compute(0xB0); 
  
  

  // reset the data for the block
//  bcId_AbsOrg = -1;
  bcId_Abs = 0; // max. 48 bits
  bcId_Dif = 0;
  // the following data is repeated one time for each Dif which has sent data
  difId = getData(1); 
  
  difTriggerCounter = getData(4);
  usbBusyTrigger = getData(4);  // trigger counter version >= 4
  globalTriggerCounter = getData(4);
  ui64 bcIdHigh = getData(2);
  ui64 bcIdLow = getData(4);
  bcId_Abs = (bcIdHigh << 32) + bcIdLow;
  FILE_LOG(logDEBUG1) << "bcId_Abs[" <<bcId_Abs <<  endl;
  bcId_Dif = getData(3);

  bcId_AbsOrg =  getbcIdAbsOrg(difId, bcId_Abs);
 
  ui16 lineInfo =  getData(1);
  ui16 nbLine   = (lineInfo & 0xF0 ) >> 4;
  ui16 usedLine = lineInfo & 0x0F; //bit 3 (4eme ligne,)  bit 2 (3eme ligne)  bit 1 (2eme ligne)  bit 0 (1ere ligne)
  
  
  display();

  // the bcTime in milliseconds
  i64 bcTime = ((bcId_Abs - bcId_AbsOrg) * bcPeriod) / 1000;
  // the reading time in milliseconds
  i64 readTime = globalTime + bcTime;

  FILE_LOG(logDEBUG)   << "  START EVENT ------------- time " << readTime << " ms" << endl;
  FILE_LOG(logDEBUG)   << "    bc time               " << bcTime << " ms" << endl;
  FILE_LOG(logDEBUG)   << "    DIF Id                0x" << hex << (int)difId << dec << endl;
  FILE_LOG(logDEBUG)   << "    DIF trigger counter   " << difTriggerCounter << endl;
  FILE_LOG(logDEBUG)   << "    USB Busy trigger counter   " << usbBusyTrigger << endl;
  FILE_LOG(logDEBUG)   << "    total trigger counter " << globalTriggerCounter << endl;
  FILE_LOG(logDEBUG)   << "    absolute bcId         " << bcId_Abs - bcId_AbsOrg << endl;
  FILE_LOG(logDEBUG)   << "    nb line          " << dec <<nbLine << endl;
  FILE_LOG(logDEBUG)   << "    used line        " << hex << usedLine << dec <<endl;
        event.setDifTriggerCounter(difTriggerCounter);
        event.setGlobalTriggerCounter(globalTriggerCounter);


  Detector &detector = run.getDetector();

  if ( analogDataActivate )//&& orderInChipMemory == 0 )
  {
    for ( map<ui16,map<ui16,ui16> >::iterator iterAnal = analogData.begin(); iterAnal!= analogData.end(); iterAnal++)
    {
       map<ui16,ui16>& byChip = iterAnal->second;
       ui16 chipId = iterAnal->first;
      // When analog is anable, all channel of all chip enable for analogic respond
      for ( std::map<ui16,ui16>::iterator iterChip = byChip.begin(); iterChip != byChip.end();iterChip++)
      {
        ui16 analogValue =  iterChip->second;
        ui16 channelId = iterChip->first;

        nbHits += newHit(event, detector, 0, analogValue,channelId , chipId, difId);
        nbanalogHit++;
      }
    }
  }
  // end of global header

  bool difFound = false;
  { const ChamberMap_t &chambers = detector.getChambers();
    for (ChamberMap_t::const_iterator it = chambers.begin(); it != chambers.end(); ++it) {
      try {
        Chamber& chamber = *(it->second);
        const BoardMap_t& boards = chamber.getBoardsByDifId(difId);
      }
      catch (...) {
        // any error case - try next chamber
        continue;
      }

      // the DIF has been found in a chamber. Process all data and continue
      difFound = true;
      break;
    } // for
    if (!difFound) {
      FILE_LOG(logERROR) << "    No dif found with Id 0x" << hex << difId << dec << endl;
    }
  }

  for (bool finish = false; !finish; ) {
    int delimiter = 0;

    display();
    for (; delimiter != 0xA0 && delimiter != 0xB4; ) {
      // seek for first data frame header (0xB4)
      delimiter = getData(1);
      if (fileError == EOF) {
        delimiter = 0;
        break;
      }
      if (delimiter == 0xA3)
        FILE_LOG(logERROR) << "    frame trailer A3 found -- should not" << endl;
    }
    if (delimiter == 0x00) {
      FILE_LOG(logERROR) << "  end of file -- should not" << endl;
      break;
    }
    if (delimiter == 0xA0) {
       FILE_LOG(logDEBUG) << "    frame trailer A0 found" << endl;
      this->setComputeCrcFlag(false);
      unsigned short CRC_check = getData(2);
      FILE_LOG(logDEBUG) << hex << " Compute CRC[" << crc->getCrc() << "]" <<  endl;
      FILE_LOG(logDEBUG) << hex << " Received CRC[" << CRC_check << "]" <<  endl;
      if ( CRC_check != crc->getCrc() )
      {
        FILE_LOG(logERROR) << endl << " CRC Error for event id " <<  lastEventId << endl;
        event.setCrcIsCorrect(false);
//        exit(-1);
      }
      else
      {
        event.setCrcIsCorrect(true);
      }


      display(-1);
      FILE_LOG(logDEBUG) << " global trailer A0 found" << endl;
      break;
    }
    display(+1);
    FILE_LOG(logDEBUG) << "   frame header B4 found" << endl;


    int chipId = -1;
    ui16 orderInChipMemory = 0;
    for (; ; )  // Read in chip memory for different BCId_HIT. 
    {
      chipId = getData(1);
      FILE_LOG(logDEBUG) << "8 bits read[" << chipId << "] [0x"  << hex << chipId << "]" << dec << endl;
      
      if (fileError == EOF) {
        finish = true;
        FILE_LOG(logINFO) << "    end of file found -- should not" << endl;
        break;
      }
      if (chipId == 0x00) {
        // dummy null bytes
        continue;
      }
      else if (chipId == 0xA3) {
        display(-1);
        FILE_LOG(logDEBUG) << "   frame trailer A3 found" << endl;
        break;
      }
      else if (chipId == 0xA0) {
        finish = true;
        display(-1);
        FILE_LOG(logERROR) << "    global trailer A0 found -- should not" << endl;
        int CRC_check = getData(1);
        break;
      }
      else if (chipId == 0xC3) {
        display(-1);
        FILE_LOG(logERROR) << "    frame trailer C3 found - error occured during data transfer" << endl;
        break;
      }

      // bcId from hardroc chip is counted as Gray code
      bcId_Hit = grayToBinary(getData(3));
      // event time in milliseconds
      eventTime = readTime + (((bcId_Dif - bcId_Hit) * bcPeriod) / 1000);

      orderInChipMemory++;
      // not on first line and bcId OK : get and check data
      if (difFound) 
      {
        FILE_LOG(logDEBUG) << "      chip Id               0x" << hex << (int)chipId << dec << endl;
        FILE_LOG(logDEBUG) << "      bcId Microroc          " << hex << (int)bcId_Hit << endl;
        FILE_LOG(logDEBUG) << "      event time            " << eventTime << endl;

        for (int chNum = 48; chNum >= 0; chNum -= 16)  // read data ( 128) for different channel Id with same BCID_HIT
        {
          unsigned int data4 = getData(4); // lit 4 bytes => 8 char => 16 canaux
          for (int index = 0; index < 16; index++) 
          {
              // sur les 16 canaux, recupere les donnees canal par canal
            int trigger = (data4 >> ((15 - index) * 2)) & 0x03; // 2 bits
            // store new event data if any
            if (trigger)  // on elimine tous les hits dans la valeur est 0 
            {
//        cout << " analogDataActivate[" <<analogDataActivate << "]  orderInChipMemory]" << orderInChipMemory <<  "]"  << endl;
                 if ( analogDataActivate && orderInChipMemory == 1 )
                 {
 //                 cout << " New Hit with ana;log value" <<endl;
                  i16 analogValue = analogData[chipId][index + chNum];
                  nbHits += newHit(event, detector, trigger, analogValue, index + chNum, chipId, difId,orderInChipMemory);
                 }
                 else
                 {
                  nbHits += newHit(event, detector, trigger, 0, index + chNum, chipId, difId,orderInChipMemory);
                 }
              
                //digital[index+chNum]=trigger;
                FILE_LOG(logDEBUG) << "digital chipId[" << chipId << "] channelNum["<< index+chNum <<"]= " << trigger << endl;
            }
          } // for (index)
        } // End digital data. for (chNum)
      }
    display();
    } // for(;;)

  } // for (;;)
  display(-1);

 // CREATE EVENT for current Run
      
// if ( nbHits > 0 )
// {
  event.setTimeStamp(globalTime + ((bcId_AbsOrg /1000000 * bcPeriod) )  );  // globalTime -> millisecond and bcId_AbsOrg * bcPeriod -> nano second
  event.setId(++lastEventId);
  FILE_LOG(logDEBUG) << "  STORE EVENT " << lastEventId << ", " << nbHits << " hits" << endl;
// }
// else
// {
//  FILE_LOG(logDEBUG) << "  EMPTY EVENT " << lastEventId << ", " << nbHits << " hits" << endl;
// }


  if (SkippedBcId) {
    FILE_LOG(logWARNING) << "    skipped " << SkippedBcId << " data because of bad bcId" << endl;
    SkippedBcId = 0;
  }

  return(nbHits);
} // MicrorocLabviewReader.getAcqData

//-------------------------------------------------------------------
// LOOP over the data Files, returns after each event
//      called for every dif found in the data file.
int MicrorocLabviewReader::getNextEvent(Event& event) {
  // Start data reconstruction
  Level(0);

        ui16 dataFormat = run.getDataFormat();

  if (dataFormat == 0) {
    // first read of the file
    bcIdDifAbsOrgMap.clear();
    // read file header
    dataFormat = getData(1);
    FILE_LOG(logINFO) << " labview data format[" << hex << dataFormat << "] "<< endl;
    if ( dataFormat == 0x10  ) { dataFormat = 0xa; }
                run.setDataFormat(dataFormat);


    if (fileError == EOF) {
      FILE_LOG(logERROR) << "parsing file[" << inputFile << "]  - error " << errno << ":" << strerror(errno) << endl;
      reset();
      return(LAST_FILE_EVENT);
    }
    display(+1);
    FILE_LOG(logINFO) << "  Microroc LABVIEW DATA FORMAT  : " << dataFormat << endl;

    if (! ( dataFormat == 11  ||  dataFormat == 12)  ){
      // unknown format
      FILE_LOG(logERROR) << " Microroc LABVIEW data format  " << dataFormat << " is not implemented" << endl;
      reset();
      return(LAST_FILE_EVENT);
    }

        if ( dataFormat == 11 ||  dataFormat == 12 )
        {
                run.setDaqSoftware( getData(1));
                display(+1);
                FILE_LOG(logINFO) << "  DAQ software version  : " << run.getDaqSoftware() << endl;

                run.setCccFirmware(getData(1));
                display(+1);
        FILE_LOG(logINFO) << "  ccc firware  : " << run.getCccFirmware() << endl;
        }

    globalTime = getData(4)    ; // labview time is second since 1 janv 1970 and globalTime milli second
    FILE_LOG(logDEBUG) << "globalTime in second:["  << hex << globalTime << "]" <<  endl;
    globalTime *= 1000;
    FILE_LOG(logDEBUG1) << "globalTime in millisecond:[" << globalTime << "]" <<  endl;
    FILE_LOG(logDEBUG1) << "  Global timestamp(hex) [" << hex << globalTime << "]" << endl;
    


    if (fileError == EOF) {
      FILE_LOG(logDEBUG) << "  END OF DATA FILE" << endl;
      reset();
      return(LAST_FILE_EVENT);
    }
    //FILE_LOG(logDEBUG) << run.getDetector() << endl;
    display(-1);
    return NEW_CONFIG;
  }


  // loops until a non-empty event has been found
  //for (unsigned int nbHits = 0; !nbHits; ) {
        bool eventFound = false;
        while (! eventFound)
                {
        // look for a global data header and process corresponding data
        unsigned int globalHeader = getData(1);
        if (fileError == EOF) {
           FILE_LOG(logDEBUG) << "  END OF DATA FILE" << endl;
          reset();
          return(LAST_FILE_EVENT);
        }
        FILE_LOG(logDEBUG) << "globalHeader:["<< hex  << globalHeader << "]" << endl;
        if (globalHeader == 0xB1) {
          // slow control data
          getScData();
        }
        else if (globalHeader == 0xC0) {
          // acquisition data
          getAnalogData(event);
        }
        else if (globalHeader == 0xB0) {
          // acquisition data
          getAcqData(event);
                      eventFound = true;
        }
        else {
          display();
         FILE_LOG(logERROR) << "  parsing file error. global header error : " << hex << globalHeader << dec << endl;
        }
        }
  //} // for (nbHits)

  return EVENT_CORRECT;
}

---