Esempio n. 1
0
SWIGEXPORT jint JNICALL Java_org_scilab_modules_graphic_1objects_DataLoaderJNI_getDataSize(JNIEnv *jenv, jclass jcls, jint jarg1) {
  jint jresult = 0 ;
  int arg1 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  arg1 = (int)jarg1; 
  result = (int)getDataSize(arg1);
  jresult = (jint)result; 
  return jresult;
}
Esempio n. 2
0
uint8_t *TR::X86DataSnippet::emitSnippetBody()
   {
   uint8_t *cursor = cg()->getBinaryBufferCursor();

   // align to 16 bytes
   if (getDataSize() % 16 == 0)
      {
      cursor = (uint8_t*)(((intptrj_t)(cursor + 15)) & ((-1)<<4));
      }

   getSnippetLabel()->setCodeLocation(cursor);

   memcpy(cursor, getRawData(), getDataSize());

   addMetaDataForCodeAddress(cursor);


   cursor += getDataSize();

   return cursor;
   }
Esempio n. 3
0
TextTable *
makeTextTable (TextTableData *ttd) {
  TextTable *table = malloc(sizeof(*table));

  if (table) {
    table->header.fields = getTextTableHeader(ttd);
    table->size = getDataSize(ttd->area);
    resetDataArea(ttd->area);
  }

  return table;
}
bool TypedValue::isPlausibleInstanceOf(const TypeSignature type) const {
  TypeID type_id = getTypeID();
  if (type_id != type.id) {
    return false;
  }

  if (isNull()) {
    return type.nullable;
  }

  switch (type_id) {
    case kInt:
    case kLong:
    case kFloat:
    case kDouble:
    case kDatetime:
    case kDatetimeInterval:
    case kYearMonthInterval:
      return true;
    case kChar: {
      size_t data_size = getDataSize();
      if (data_size == type.length) {
        return true;
      } else if (data_size < type.length) {
        // If the data is shorter than the max size for a CHAR type, make sure
        // it is null-terminated.
        return (memchr(value_union_.out_of_line_data, '\0', data_size) != nullptr);
      } else {
        return false;
      }
    }
    case kVarChar:
      return getDataSize() <= (type.length + 1);
    default: {
      size_t data_size = getDataSize();
      return (data_size <= type.length);
    }
  }
}
Esempio n. 5
0
void Sound::play(int flag) {
	Audio::SoundHandle *handle = getHandle();

	if (g_fp->_mixer->isSoundHandleActive(*handle))
		return;

	byte *soundData = loadData();
	Common::MemoryReadStream *dataStream = new Common::MemoryReadStream(soundData, getDataSize());
	Audio::RewindableAudioStream *wav = Audio::makeWAVStream(dataStream, DisposeAfterUse::YES);
	Audio::AudioStream *audioStream = new Audio::LoopingAudioStream(wav, (flag == 1) ? 0 : 1);

	g_fp->_mixer->playStream(Audio::Mixer::kSFXSoundType, handle, audioStream);
}
//! (internal)
void StringData::initJumpTable()const{
	std::vector<size_t> jumpTable;
	size_t codePointCursor = 0;
	const size_t numBytes = getDataSize();
	for(size_t byteCursor = 0; byteCursor<numBytes;
			byteCursor += getUTF8CodePointLength(data->s.c_str()+byteCursor) ){

		if( (codePointCursor%JUMP_TABLE_STEP_SIZE)==0 && byteCursor>0) // skip the initial 0
			jumpTable.emplace_back(byteCursor);

		++codePointCursor;
	}
	data->numCodePoints = codePointCursor;

	if(codePointCursor == getDataSize()){
		data->dataType = Data::ASCII;
	}else{
		data->dataType = Data::UNICODE_WITH_JUMTABLE;
		if(!jumpTable.empty())
			data->jumpTable.reset(new std::vector<size_t>(std::move(jumpTable)));
	}
}
BOOL LLImageTGA::decodeTruecolorRle8( LLImageRaw* raw_image )
{
	llassert( getComponents() == 1 );

	U8* dst = raw_image->getData();
	U8* src = getData() + mDataOffset;

	U8* last_src = src + getDataSize();
	U8* last_dst = dst + getHeight() * getWidth() - 1;
	
	while( dst <= last_dst )
	{
		// Read RLE block header

		if (src >= last_src)
			return FALSE;

		U8 block_header_byte = *src;
		src++;

		U8 block_pixel_count = (block_header_byte & 0x7F) + 1;
		if( block_header_byte & 0x80 )
		{
			if (src >= last_src)
				return FALSE;
			
			// Encoded (duplicate-pixel) block
			memset( dst, *src, block_pixel_count );
			dst += block_pixel_count;
			src++;
		}
		else 
		{
			// Unencoded block
			do
			{
				if (src >= last_src)
					return FALSE;
				
				*dst = *src;
				dst++;
				src++;
				block_pixel_count--;
			}
			while( block_pixel_count > 0 );
		}
	}

	return TRUE;
}
Esempio n. 8
0
/**
 * @return The size of the domain to be created.
 */
size_t FitMD::getDomainSize() const {
  setParameters();
  if (!m_IMDWorkspace)
    throw std::runtime_error("FitMD: workspace wasn't defined");
  auto iterator = m_IMDWorkspace->createIterator();
  size_t n = iterator->getDataSize();
  delete iterator;
  if (m_count != 0) {
    if (m_startIndex + m_count > n)
      throw std::range_error("FitMD: index is out of range");
    n = m_count;
  }
  return n;
}
Esempio n. 9
0
BOOL LLImageBMP::decode(LLImageRaw* raw_image, F32 decode_time)
{
	llassert_always(raw_image);
	
	resetLastError();

	// Check to make sure that this instance has been initialized with data
	U8* mdata = getData();
	if (!mdata || (0 == getDataSize()))
	{
		setLastError("llimagebmp trying to decode an image with no data!");
		return FALSE;
	}
	
	raw_image->resize(getWidth(), getHeight(), 3);

	U8* src = mdata + mBitmapOffset;
	U8* dst = raw_image->getData();

	BOOL success = FALSE;

	switch( mBitsPerPixel )
	{
	case 8:
		if( mColorPaletteColors >= 256 )
		{
			success = decodeColorTable8( dst, src );
		}
		break;
	
	case 16:
		success = decodeColorMask16( dst, src );
		break;
	
	case 24:
		success = decodeTruecolor24( dst, src );
		break;

	case 32:
		success = decodeColorMask32( dst, src );
		break;
	}

	if( success && mOriginAtTop )
	{
		raw_image->verticalFlip();
	}

	return success;
}
Esempio n. 10
0
void LLImageRaw::setDataAndSize(U8 *data, S32 width, S32 height, S8 components) 
{ 
	if(data == getData())
	{
		return ;
	}

	deleteData();

	LLImageBase::setSize(width, height, components) ;
	LLImageBase::setDataAndSize(data, width * height * components) ;
	
	sGlobalRawMemory += getDataSize();
}
    /**
     * Удаляет все найденые ключи, тоесть ищет их командой keys и удаляет каждый найденый ключь.
     * @param key
     * @return Вернёт -1 или количество удалёных ключей
     * @todo Реализовать более быстрый способ работы
     */
    int SimpleRedisClient::delete_keys( const char *key)
    {
        if(keys(key))
        {
            if(getDataSize() < 1 || getBufferSize() < 1)
            {
                return 0;
            }

            char **ptr_data = new char*[getDataSize()];

            // Выделяем память для buf_data
            char *buf_data = new char[ getBufferSize() ];
            memcpy(buf_data, getData(), getBufferSize());

            long int offset = buf_data - getData(); // Опасное дело!
            int num_keys = getDataSize();
            for(int i =0; i< num_keys; i++)
            {
                ptr_data[i] = getData(i) + offset;
            }

            for(int i =0; i< num_keys; i++)
            {
                printf("del[%d]:'%s'\n", i, ptr_data[i]);
                del(ptr_data[i]);
            }

            // [SimpleRedisClient.cpp:1171]: (error) Mismatching allocation and deallocation: buf_data
            // Очищаем buf_data
            delete[] buf_data;
            delete[] ptr_data;
            return num_keys;
        }

        return -1;
    }
Esempio n. 12
0
bool Packet::updateAnalogIn2(const CmtAnalogInData& data, const uint16_t index)
{
	if (getDataSize(index) == 0)
		return false;
	if (m_infoList[index].m_analogIn2 == CMT_DATA_ITEM_NOT_AVAILABLE)
	{
		// add
		m_infoList[index].m_analogIn2 = m_msg.getDataSize();
		m_msg.resizeData(m_msg.getDataSize() + 2);
		m_infoList[index].m_size += 2;
	}
	// update
	m_msg.setDataShort(data.m_data, m_infoList[index].m_analogIn2);
	return true;
}
Esempio n. 13
0
void TR::X86DataSnippet::print(TR::FILE* pOutFile, TR_Debug* debug)
   {
   if (pOutFile == NULL)
      return;

   uint8_t *bufferPos = getSnippetLabel()->getCodeLocation();

   debug->printSnippetLabel(pOutFile, getSnippetLabel(), bufferPos, debug->getName(this));
   debug->printPrefix(pOutFile, NULL, bufferPos, getDataSize());

   const char* toString;
   switch (getDataSize())
      {
      case 8:
         toString = dqString();
         break;
      case 4:
         toString = ddString();
         break;
      case 2:
         toString = dwString();
         break;
      default:
         toString = dbString();
         break;
      }
   trfprintf(pOutFile, "%s \t%s", toString, hexPrefixString());

   for (int i=getDataSize()-1; i >= 0; i--)
      {
      trfprintf(pOutFile, "%02x", bufferPos[i]);
      }

   trfprintf(pOutFile,"%s\t%s ", hexSuffixString(), commentString());
   printValue(pOutFile, debug);
   }
Esempio n. 14
0
bool Packet::updateRawTemp(const uint16_t temp, const uint16_t index)
{
	if (getDataSize(index) == 0)
		return false;
	if (m_infoList[index].m_rawTemp == CMT_DATA_ITEM_NOT_AVAILABLE)
	{
		// add
		m_infoList[index].m_rawTemp = m_msg.getDataSize();
		m_msg.resizeData(m_msg.getDataSize() + 2);
		m_infoList[index].m_size += 2;
	}
	// update
	m_msg.setDataShort(temp, m_infoList[index].m_rawTemp);
	return true;
}
Esempio n. 15
0
bool Packet::updateSampleCounter(const uint16_t counter, const uint16_t index)
{
	if (getDataSize(index) == 0)
		return false;
	if (m_infoList[index].m_sc == CMT_DATA_ITEM_NOT_AVAILABLE)
	{
		// add
		m_infoList[index].m_sc = m_msg.getDataSize();
		m_msg.resizeData(m_msg.getDataSize() + 2);
		m_infoList[index].m_size += 2;
	}
	// update
	m_msg.setDataShort(counter, m_infoList[index].m_sc);
	return true;
}
Esempio n. 16
0
bool Packet::updateRawMag(const CmtShortVector& vec, const uint16_t index)
{
	if (getDataSize(index) == 0)
		return false;
	if (m_infoList[index].m_rawMag == CMT_DATA_ITEM_NOT_AVAILABLE)
	{
		// add
		m_infoList[index].m_rawMag = m_msg.getDataSize();
		m_msg.resizeData(m_msg.getDataSize() + 3*2);
		m_infoList[index].m_size += 3*2;
	}
	// update
	for (uint16_t i=0;i<3;++i)
		m_msg.setDataShort(vec.m_data[i], m_infoList[index].m_rawMag + (2*i));
	return true;
}
Esempio n. 17
0
bool Packet::updateStatus(const uint8_t data, const uint16_t index)
{
	if (getDataSize(index) == 0)
		return false;

	if (m_infoList[index].m_status == CMT_DATA_ITEM_NOT_AVAILABLE)
	{
		// add
		m_infoList[index].m_status = m_msg.getDataSize();
		m_msg.resizeData(m_msg.getDataSize() + 1);
		m_infoList[index].m_size += 1;
	}
	// update
	m_msg.setDataByte(data,m_infoList[index].m_status);
	return true;
}
Esempio n. 18
0
ATOM_BaseResourceLoader::LOADRESULT ATOM_ModelLoader::loadFromDisk (void)
{
	ATOM_STACK_TRACE(ATOM_ModelLoader::loadFromDisk);
	ATOM_BaseResourceLoader::LOADRESULT result = ATOM_BaseResourceLoader::loadFromDisk ();
	if (result != ATOM_BaseResourceLoader::LOADERR_OK)
	{
		return result;
	}

	if (!_model->memload (ATOM_GetRenderDevice(), getData(), getDataSize(), false, false))
	{
		return ATOM_BaseResourceLoader::LOADERR_FAILED;
	}

	return ATOM_BaseResourceLoader::LOADERR_OK;
}
Esempio n. 19
0
TextTable *
makeTextTable (TextTableData *ttd) {
  TextTable *table = malloc(sizeof(*table));

  if (table) {
    memset(table, 0, sizeof(*table));

    table->header.fields = getTextTableHeader(ttd);
    table->size = getDataSize(ttd->area);

    table->options.tryBaseCharacter = 1;

    resetDataArea(ttd->area);
  }

  return table;
}
Esempio n. 20
0
bool Packet::updateTemp(const double& temp, const uint16_t index)
{
	if (getDataSize(index) == 0)
		return false;

	uint16_t ds = getFPValueSize(index);

	if (m_infoList[index].m_temp == CMT_DATA_ITEM_NOT_AVAILABLE)
	{
		// add
		m_infoList[index].m_temp = m_msg.getDataSize();
		m_msg.resizeData(m_msg.getDataSize() + ds);
		m_infoList[index].m_size += ds;
	}
	// update
	m_msg.setDataFPValue(m_formatList[index].m_outputSettings, temp, m_infoList[index].m_temp);
	return true;
}
Esempio n. 21
0
bool Packet::updateOriQuat(const CmtQuat& data, const uint16_t index)
{
	const uint16_t numValues = 4;
	if (getDataSize(index) == 0)
		return false;

	uint16_t ds = getFPValueSize(index);

	if (m_infoList[index].m_oriQuat == CMT_DATA_ITEM_NOT_AVAILABLE)
	{
		// add
		m_infoList[index].m_oriQuat = m_msg.getDataSize();
		m_msg.resizeData(m_msg.getDataSize() + numValues*ds);
		m_infoList[index].m_size += numValues*ds;
	}
	// update
	m_msg.setDataFPValue(m_formatList[index].m_outputSettings, &data.m_data[0], m_infoList[index].m_oriQuat, numValues);
	return true;
}
Esempio n. 22
0
bool Packet::updateCalMag(const CmtVector& vec, const uint16_t index)
{
	const uint16_t numValues = 3;
	if (getDataSize(index) == 0)
		return false;

	uint16_t ds = getFPValueSize(index);

	if (m_infoList[index].m_calMag == CMT_DATA_ITEM_NOT_AVAILABLE)
	{
		// add
		m_infoList[index].m_calMag = m_msg.getDataSize();
		m_msg.resizeData(m_msg.getDataSize() + numValues*ds);
		m_infoList[index].m_size += numValues*ds;
	}
	// update
	m_msg.setDataFPValue(m_formatList[index].m_outputSettings, &vec.m_data[0], m_infoList[index].m_calMag, numValues);
	return true;
}
Esempio n. 23
0
BOOL LLImageTGA::decode(LLImageRaw* raw_image, F32 decode_time)
{
	llassert_always(raw_image);
	
	// Check to make sure that this instance has been initialized with data
	if (!getData() || (0 == getDataSize()))
	{
		setLastError("LLImageTGA trying to decode an image with no data!");
		return FALSE;
	}

	// Copy everything after the header.

	raw_image->resize(getWidth(), getHeight(), getComponents());

	if( (getComponents() != 1) &&
		(getComponents() != 3) &&
		(getComponents() != 4) )
	{
		setLastError("TGA images with a number of components other than 1, 3, and 4 are not supported.");
		return FALSE;
	}


	if( mOriginRightBit )
	{
		setLastError("TGA images with origin on right side are not supported.");
		return FALSE;
	}

	BOOL flipped = (mOriginTopBit != 0);
	BOOL rle_compressed = ((mImageType & 0x08) != 0);

	if( mColorMap )
	{
		return decodeColorMap( raw_image, rle_compressed, flipped );
	}
	else
	{
		return decodeTruecolor( raw_image, rle_compressed, flipped );
	}
}
Esempio n. 24
0
void ICMPv4PacketImpl::initPacket()
{
	if (_seq >= MAX_SEQ_VALUE) resetSequence();

	Header* icp = (Header*) packet(false);
	icp->type     = ECHO_REQUEST;
	icp->code     = 0;
	icp->checksum = 0;
	icp->seq      = ++_seq;
#if defined(POCO_VXWORKS)
	icp->id       = 0;
#else
	icp->id       = static_cast<UInt16>(Poco::Process::id());
#endif

	struct timeval* ptp = (struct timeval *) (icp + 1);
	*ptp = time();

	icp->checksum = checksum((UInt16*) icp, getDataSize() + sizeof(Header));
}
Esempio n. 25
0
PicturePtr FFMPEGVideoFrameConverter::convert( const FFMPEGFrame& srcFrame,
                                               const TextureFormat format )
{
    auto picture = std::make_shared<FFMPEGPicture>( srcFrame.getWidth(),
                                                    srcFrame.getHeight(),
                                                    format );

    const auto avFormat = _toAVPixelFormat( format );

    _impl->swsContext = sws_getCachedContext( _impl->swsContext,
                                              srcFrame.getWidth(),
                                              srcFrame.getHeight(),
                                              srcFrame.getAVPixelFormat(),
                                              picture->getWidth(),
                                              picture->getHeight(),
                                              avFormat,
                                              SWS_FAST_BILINEAR,
                                              nullptr, nullptr, nullptr );
    if( !_impl->swsContext )
        return PicturePtr();

    uint8_t* dstData[3];
    int linesize[3];
    for( size_t i = 0; i < 3; ++i )
    {
        dstData[i] = picture->getData( i );
        // width of image plane in pixels * bytes per pixel
        linesize[i] = picture->getDataSize( i ) /
                      picture->getTextureSize( i ).height();
    }

    const auto outputHeight = sws_scale( _impl->swsContext,
                                         srcFrame.getAVFrame().data,
                                         srcFrame.getAVFrame().linesize,
                                         0, srcFrame.getHeight(),
                                         dstData, linesize );
    if( outputHeight != picture->getHeight( ))
        return PicturePtr();

    return picture;
}
Esempio n. 26
0
bool Packet::updateOriEuler(const CmtEuler& data, const uint16_t index)
{
	const uint16_t numValues = 3;
	if (getDataSize(index) == 0)
		return false;

	uint16_t ds = getFPValueSize(index);

	if (m_infoList[index].m_oriEul == CMT_DATA_ITEM_NOT_AVAILABLE)
	{
		// add
		m_infoList[index].m_oriEul = m_msg.getDataSize();
		m_msg.resizeData(m_msg.getDataSize() + numValues*ds);
		m_infoList[index].m_size += numValues*ds;
	}
	// update
	m_msg.setDataFPValue(m_formatList[index].m_outputSettings, data.m_roll,  m_infoList[index].m_oriEul);
	m_msg.setDataFPValue(m_formatList[index].m_outputSettings, data.m_pitch, m_infoList[index].m_oriEul + ds);
	m_msg.setDataFPValue(m_formatList[index].m_outputSettings, data.m_yaw,   m_infoList[index].m_oriEul + 2*ds);
	return true;
}
Esempio n. 27
0
bool Packet::updateRawData(const CmtRawData& data, const uint16_t index)
{
	if (getDataSize(index) == 0)
		return false;
	if (m_infoList[index].m_rawData == CMT_DATA_ITEM_NOT_AVAILABLE)
	{
		// add
		m_infoList[index].m_rawData = m_msg.getDataSize();
		m_msg.resizeData(m_msg.getDataSize() + 3* 3*2 + 2);
		m_infoList[index].m_rawAcc = m_infoList[index].m_rawData;
		m_infoList[index].m_rawGyr = m_infoList[index].m_rawData + 3*2;
		m_infoList[index].m_rawMag = m_infoList[index].m_rawData + 6*2;
		m_infoList[index].m_rawTemp= m_infoList[index].m_rawData + 9*2;
		m_infoList[index].m_size += 3* 3*2 + 2;
	}
	// update
	int16_t* bare = (int16_t*) &data;
	for (uint16_t i=0;i<10;++i)
		m_msg.setDataShort(bare[i], m_infoList[index].m_rawData + (2*i));
	return true;
}
Esempio n. 28
0
bool Packet::updateRawGpsData(const CmtRawGpsData& data, const uint16_t index)
{
	if (getDataSize(index) == 0)
		return false;
	if (m_infoList[index].m_rawGpsData == CMT_DATA_ITEM_NOT_AVAILABLE)
	{
		// add
		m_infoList[index].m_rawGpsData = m_msg.getDataSize();
		m_msg.resizeData(m_msg.getDataSize() + (2+1) + (40 + 1));
		m_infoList[index].m_rawGpsPressure = m_infoList[index].m_rawGpsData;
		m_infoList[index].m_rawGpsPressureAge = m_infoList[index].m_rawGpsData + 2;

		m_infoList[index].m_rawGpsGpsData = m_infoList[index].m_rawGpsData + 3;
		m_infoList[index].m_rawGpsItow = m_infoList[index].m_rawGpsData + 3;
		m_infoList[index].m_rawGpsLatitude = m_infoList[index].m_rawGpsData + 3 + 4;
		m_infoList[index].m_rawGpsLongitude = m_infoList[index].m_rawGpsData + 3 + 8;
		m_infoList[index].m_rawGpsHeight = m_infoList[index].m_rawGpsData + 3 + 12;
		m_infoList[index].m_rawGpsVeln = m_infoList[index].m_rawGpsData + 3 + 16;
		m_infoList[index].m_rawGpsVele = m_infoList[index].m_rawGpsData + 3 + 20;
		m_infoList[index].m_rawGpsVeld = m_infoList[index].m_rawGpsData + 3 + 24;
		m_infoList[index].m_rawGpsHacc = m_infoList[index].m_rawGpsData + 3 + 28;
		m_infoList[index].m_rawGpsVacc = m_infoList[index].m_rawGpsData + 3 + 32;
		m_infoList[index].m_rawGpsSacc = m_infoList[index].m_rawGpsData + 3 + 36;
		m_infoList[index].m_rawGpsGpsAge = m_infoList[index].m_rawGpsData + 3 + 40;

		m_infoList[index].m_size += (2+1) + (40 + 1);
	}
	// update
	m_msg.setDataShort(data.m_pressure, m_infoList[index].m_rawGpsPressure);
	m_msg.setDataByte(data.m_pressureAge, m_infoList[index].m_rawGpsPressureAge);

	// lon,lat,height,hacc,vacc,veln,vele,veld
	int32_t* bareln = (int32_t*)&data.m_itow;
	for (uint16_t i=0; i<10;++i)
		m_msg.setDataLong(bareln[i],m_infoList[index].m_rawGpsGpsData + (4*i));

	// gpsAge
	m_msg.setDataByte(data.m_gpsAge,  m_infoList[index].m_rawGpsGpsAge);
	return true;
}
Esempio n. 29
0
bool Packet::updateOriMatrix(const CmtMatrix& data, const uint16_t index)
{
	const uint16_t numValues = 9;
	if (getDataSize(index) == 0)
		return false;

	uint16_t ds = getFPValueSize(index);

	if (m_infoList[index].m_oriMat == CMT_DATA_ITEM_NOT_AVAILABLE)
	{
		// add
		m_infoList[index].m_oriMat = m_msg.getDataSize();
		m_msg.resizeData(m_msg.getDataSize() + numValues*ds);
		m_infoList[index].m_size += numValues*ds;
	}
	// update
	uint16_t k = 0;
	for (int32_t i=0;i<3;++i)
		for (int32_t j=0;j<3;++j, k+=ds)
			m_msg.setDataFPValue(m_formatList[index].m_outputSettings, data.m_data[i][j], m_infoList[index].m_oriMat+k);
	return true;
}
Esempio n. 30
0
// Virtual
// Decode an in-memory PNG image into the raw RGB or RGBA format
// used within SecondLife.
BOOL LLImagePNG::decode(LLImageRaw* raw_image, F32 decode_time)
{
	llassert_always(raw_image);

    resetLastError();

    // Check to make sure that this instance has been initialized with data
    if (!getData() || (0 == getDataSize()))
    {
        setLastError("LLImagePNG trying to decode an image with no data!");
        return FALSE;
    }

	// Decode the PNG data into the raw image
	LLPngWrapper pngWrapper;
	if (! pngWrapper.readPng(getData(), raw_image))
	{
		setLastError(pngWrapper.getErrorMessage());
		return FALSE;
	}

	return TRUE;
}