/* Trim zero blocks of the beginning and end of the object. */
static int default_trim(int fd, uint64_t oid, const struct siocb *iocb,
uint64_t *poffset, uint32_t *plen)
{
trim_zero_blocks(iocb->buf, poffset, plen);
if (iocb->offset < *poffset) {
sd_debug("discard between %d, %ld, %" PRIx64, iocb->offset,
*poffset, oid);
if (discard(fd, iocb->offset, *poffset) < 0)
return -1;
}
if (*poffset + *plen < iocb->offset + iocb->length) {
uint64_t end = iocb->offset + iocb->length;
if (end == get_objsize(oid))
/* This is necessary to punch the last block */
end = round_up(end, BLOCK_SIZE);
sd_debug("discard between %ld, %ld, %" PRIx64, *poffset + *plen,
end, oid);
if (discard(fd, *poffset + *plen, end) < 0)
return -1;
}
return 0;
}
const char * configstring (const char * file, const char * part, const char * item, const char * text)
{
FILE *fp;
if (file && part && item) {
if ((fp = fopen (file, "rb"))) {
for (c = getc (fp); c != EOF; discard (fp)) {
while (isblank (c)) {
c = getc (fp);
}
if (c != '[') {
continue;
}
do {
c = getc (fp);
}
while (isblank (c));
if (!compare (fp, part)) {
continue;
}
if (c != ']') {
continue;
}
for (discard (fp); (c != '[') && (c != EOF); discard (fp)) {
while (isblank (c)) {
c = getc (fp);
}
if (c == ';') {
continue;
}
if (!compare (fp, item)) {
continue;
}
if (c != '=') {
continue;
}
do {
c = getc (fp);
}
while (isblank (c));
collect (fp);
text = buffer;
break;
}
break;
}
fclose (fp);
}
}
if (text) {
text = strdup(text);
}
return text;
}
/*
removes an element within the list
data data of the element to find
data_size size of data
//*/
int removeelement(const char* data, const unsigned int data_size)
{
// checks
if(NULL == data) return -1;
// find and delete
element_t* tmp = find(data, data_size);
if(NULL == tmp){
fprintf(stderr, "element \"%s\" not found in list\n", data);
return -1;
}
// element was first
if(tmp == first){
// list only has one element
if(first == last){
// TODO use discard first.. reset elements
return 0;
}
first = first->next;
if(0 != discard(&tmp)){
return -1;
}
tmp = NULL;
return 0;
}
// get prev element
element_t* prev = first;
while(prev->next){
if(prev->next == tmp){
break;
}
}
// next element
element_t* next = prev->next;
if(NULL == next){
return removelastelement();
}
// unlink
prev->next = next;
// delete
if(0 != discard(&tmp)){
return -1;
}
return 0;
}
inline Checkpoint mpi_plain(
MPI_Comm communicator,
I&& integrand,
std::vector<std::size_t> const& iteration_calls,
Checkpoint chkpt = make_plain_chkpt<numeric_type_of<I>>(),
Callback callback = mpi_callback<Checkpoint>()
) {
using T = numeric_type_of<I>;
int rank = 0;
MPI_Comm_rank(communicator, &rank);
int world = 0;
MPI_Comm_size(communicator, &world);
auto generator = chkpt.generator();
std::vector<T> buffer;
std::size_t const usage = integrand.dimensions() *
random_number_usage<T, decltype (generator)>();
// perform iterations
for (auto calls : iteration_calls)
{
generator.discard(usage * discard_before(calls, rank, world));
// the number of function calls for each MPI process
std::size_t const sub_calls = (calls / world) +
(static_cast <std::size_t> (rank) < (calls % world) ? 1 : 0);
auto const result = plain_iteration(integrand, sub_calls, generator);
generator.discard(usage * discard_after(calls, sub_calls, rank, world));
auto const& new_result = allreduce_result(
communicator,
result,
buffer,
std::vector<T>(),
calls
);
chkpt.add(new_result, generator);
if (!callback(communicator, chkpt))
{
break;
}
}
return chkpt;
}
/*
* fall:
* Drop an item someplace around here.
*/
int
fall(struct linked_list *item, int pr)
{
register struct object *obj ;
register struct room *rp ;
static coord fpos ;
int ret;
obj = (struct object *) ldata(item) ;
rp = roomin(&hero);
if (obj->o_flags & CANRETURN) {
add_pack(item, TRUE);
return TRUE;
}
else if (fallpos(&obj->o_pos, &fpos, TRUE)) {
if (obj->o_flags & CANBURN && ntraps + 1 < MAXTRAPS + MAXTRAPS) {
mvaddch(fpos.y, fpos.x, FIRETRAP);
traps[ntraps].tr_type = FIRETRAP;
traps[ntraps].tr_flags = ISFOUND;
traps[ntraps].tr_show = FIRETRAP;
traps[ntraps].tr_pos.y = fpos.y;
traps[ntraps++].tr_pos.x = fpos.x;
if (rp != NULL)
rp->r_flags &= ~ISDARK;
discard(item);
ret = FALSE;
}
else {
mvaddch(fpos.y, fpos.x, obj->o_type) ;
obj->o_pos = fpos ;
attach(lvl_obj, item) ;
ret = TRUE;
}
if (rp != NULL &&
(!(rp->r_flags & ISDARK) ||
(rp->r_flags & HASFIRE))) {
light(&hero) ;
mvwaddch(cw, hero.y, hero.x, PLAYER) ;
}
return ret;
}
if (pr) {
if (obj->o_type == WEAPON)
addmsg("The %s", weaps[obj->o_which]);
else
addmsg(inv_name(obj, TRUE));
msg(" vanishes as it hits the ground.");
}
discard(item) ;
return FALSE;
}
int toplevel(pstate *state) {
UNPACK_STATE();
int found = 0;
while(curr <= eof) {
qscan3('{','[','#');
switch(*curr) {
case '{': discard(); found += new_dict(state); break;
case '[': discard(); found += new_list(state); break;
case '#': discard(); found ++; break;
default: discard(); // EOF
}
}
return found;
}
void WriteMail::init()
{
m_toolbar = new QToolBar(this);
addToolBar(m_toolbar);
m_widgetStack = new QStackedWidget(this);
m_cancelAction = new QAction(Qtmail::icon("cancel"),tr("Close"),this);
connect( m_cancelAction, SIGNAL(triggered()), this, SLOT(discard()) );
addAction(m_cancelAction);
m_draftAction = new QAction(Qtmail::icon("saveToDraft"),tr("Save in drafts"),this);
connect( m_draftAction, SIGNAL(triggered()), this, SLOT(draft()) );
m_draftAction->setWhatsThis( tr("Save this message as a draft.") );
addAction(m_draftAction);
m_sendAction = new QAction(Qtmail::icon("sendmail"),tr("Send"),this);
connect( m_sendAction, SIGNAL(triggered()), this, SLOT(sendStage()) );
m_sendAction->setWhatsThis( tr("Send the message.") );
addAction(m_sendAction);
m_accountSelection = new QComboBox(m_toolbar);
connect( m_accountSelection, SIGNAL(currentIndexChanged(int)), this, SLOT(accountSelectionChanged(int)) );
m_selectComposerWidget = new SelectComposerWidget(this);
m_selectComposerWidget->setObjectName("selectComposer");
connect(m_selectComposerWidget, SIGNAL(selected(QPair<QString,QMailMessage::MessageType>)),
this, SLOT(composerSelected(QPair<QString,QMailMessage::MessageType>)));
connect(m_selectComposerWidget, SIGNAL(cancel()), this, SLOT(discard()));
m_widgetStack->addWidget(m_selectComposerWidget);
setCentralWidget(m_widgetStack);
QMenuBar* mainMenuBar = new QMenuBar();
setMenuBar(mainMenuBar);
QMenu* file = mainMenuBar->addMenu("File");
file->addAction(m_sendAction);
file->addAction(m_draftAction);
file->addSeparator();
file->addAction(m_cancelAction);
m_toolbar->addAction(m_sendAction);
m_toolbar->addAction(m_draftAction);
m_toolbar->addWidget(m_accountSelection);
m_toolbar->addSeparator();
setWindowTitle(tr("Compose"));
setGeometry(0,0,defaultWidth,defaultHeight);
}
void QQuickDialog::click(QPlatformDialogHelper::StandardButton button, QPlatformDialogHelper::ButtonRole role)
{
setVisible(false);
m_clickedButton = static_cast<StandardButton>(button);
emit buttonClicked();
switch (role) {
case QPlatformDialogHelper::AcceptRole:
emit accept();
break;
case QPlatformDialogHelper::RejectRole:
emit reject();
break;
case QPlatformDialogHelper::DestructiveRole:
emit discard();
break;
case QPlatformDialogHelper::HelpRole:
emit help();
break;
case QPlatformDialogHelper::YesRole:
emit yes();
break;
case QPlatformDialogHelper::NoRole:
emit no();
break;
case QPlatformDialogHelper::ApplyRole:
emit apply();
break;
case QPlatformDialogHelper::ResetRole:
emit reset();
break;
default:
qWarning("unhandled Dialog button %d with role %d", (int)button, (int)role);
}
}
// This one puts some data inside the ring buffer.
void RingBuffer::put(AudioBuffer& buf)
{
std::lock_guard<std::mutex> l(lock_);
const size_t sample_num = buf.frames();
const size_t buffer_size = buffer_.frames();
if (buffer_size == 0)
return;
size_t len = putLength();
if (buffer_size - len < sample_num)
discard(sample_num);
size_t toCopy = sample_num;
// Add more channels if the input buffer holds more channels than the ring.
if (buffer_.channels() < buf.channels())
buffer_.setChannelNum(buf.channels());
size_t in_pos = 0;
size_t pos = endPos_;
while (toCopy) {
size_t block = toCopy;
if (block > buffer_size - pos) // Wrap block around ring ?
block = buffer_size - pos; // Fill in to the end of the buffer
buffer_.copy(buf, block, in_pos, pos);
in_pos += block;
pos = (pos + block) % buffer_size;
toCopy -= block;
}
endPos_ = pos;
not_empty_.notify_all();
}
void
fall(struct linked_list *item, int pr)
{
struct object *obj;
struct room *rp;
static coord fpos;
obj = (struct object *) ldata(item);
if (fallpos(&obj->o_pos, &fpos, TRUE))
{
mvaddrawch(fpos.y, fpos.x, obj->o_type);
obj->o_pos = fpos;
if ((rp = roomin(&hero)) != NULL && !(rp->r_flags & ISDARK))
{
light(&hero);
mvwaddrawch(cw, hero.y, hero.x, PLAYER);
}
attach(lvl_obj, item);
return;
}
if (pr)
if (obj->o_type == WEAPON) /* BUGFUX: Identification trick */
msg("Your %s vanishes as it hits the ground.", w_names[obj->o_which]);
else
msg("%s vanishes as it hits the ground.", inv_name(obj,TRUE));
discard(item);
}
static int
type1crypt(i_ctx_t *i_ctx_p,
int (*proc)(byte *, const byte *, uint, ushort *))
{
os_ptr op = osp;
crypt_state state;
uint ssize;
check_type(op[-2], t_integer);
state = op[-2].value.intval;
if (op[-2].value.intval != state)
return_error(e_rangecheck); /* state value was truncated */
check_read_type(op[-1], t_string);
check_write_type(*op, t_string);
ssize = r_size(op - 1);
if (r_size(op) < ssize)
return_error(e_rangecheck);
discard((*proc)(op->value.bytes, op[-1].value.const_bytes, ssize,
&state)); /* can't fail */
op[-2].value.intval = state;
op[-1] = *op;
r_set_size(op - 1, ssize);
pop(1);
return 0;
}
void EditEnumerationDialog::updateCurrentItem()
{
discard();
auto const item = m_dialog->itemList->currentItem();
if (item != nullptr)
item->setText(m_dialog->currentItem->text());
}
/*
* playhand:
* Do up one hand of the game
*/
int
playhand(bool mycrib)
{
int deckpos;
werase(Compwin);
wrefresh(Compwin);
werase(Tablewin);
wrefresh(Tablewin);
knownum = 0;
deckpos = deal(mycrib);
sorthand(chand, FULLHAND);
sorthand(phand, FULLHAND);
makeknown(chand, FULLHAND);
prhand(phand, FULLHAND, Playwin, FALSE);
discard(mycrib);
if (cut(mycrib, deckpos))
return TRUE;
if (peg(mycrib))
return TRUE;
werase(Tablewin);
wrefresh(Tablewin);
if (score(mycrib))
return TRUE;
return FALSE;
}
/**
* Destroy descriptor ring
*
* @v netfront Netfront device
* @v ring Descriptor ring
* @v discard Method used to discard outstanding buffer, or NULL
*/
static void netfront_destroy_ring ( struct netfront_nic *netfront,
struct netfront_ring *ring,
void ( * discard ) ( struct io_buffer * ) ){
struct xen_device *xendev = netfront->xendev;
struct xen_hypervisor *xen = xendev->xen;
struct io_buffer *iobuf;
unsigned int id;
/* Flush any outstanding buffers */
while ( ! netfront_ring_is_empty ( ring ) ) {
id = ring->ids[ ring->id_cons & ( ring->count - 1 ) ];
iobuf = netfront_pull ( netfront, ring, id );
if ( discard )
discard ( iobuf );
}
/* Unpublish shared ring reference */
netfront_rm ( netfront, ring->ref_key );
/* Revoke access from shared ring */
xengrant_invalidate ( xen, ring->ref );
/* Free page */
free_dma ( ring->sring.raw, PAGE_SIZE );
ring->sring.raw = NULL;
}
void qore_program_private::del(ExceptionSink* xsink) {
printd(5, "QoreProgram::del() pgm: %p (base_object: %d)\n", pgm, base_object);
if (thr_init)
thr_init->deref(xsink);
if (base_object) {
deleteThreadData(xsink);
// delete thread local storage key
delete thread_local_storage;
base_object = false;
}
// have to delete global variables first because of destructors.
// method call can be repeated
qore_root_ns_private::clearData(*RootNS, xsink);
// delete all global variables, class static vars and constants
RootNS->deleteData(xsink);
// delete defines
for (dmap_t::iterator i = dmap.begin(), e = dmap.end(); i != e; ++i)
discard(i->second, xsink);
dmap.clear();
// method call can be repeated
sb.del();
//printd(5, "QoreProgram::~QoreProgram() this: %p deleting root ns %p\n", this, RootNS);
delete RootNS;
RootNS = 0;
}
void
fall(THING *obj, int pr)
{
PLACE *pp;
coord fpos;
if (fallpos(&obj->o_pos, &fpos))
{
pp = INDEX(fpos.y, fpos.x);
pp->p_ch = obj->o_type;
obj->o_pos = fpos;
if (cansee(fpos.y, fpos.x))
{
if (pp->p_monst != NULL)
pp->p_monst->t_oldch = obj->o_type;
else
mvaddch(fpos.y, fpos.x, obj->o_type);
}
attach(lvl_obj, obj);
return;
}
if (pr)
{
if (has_hit)
{
endmsg();
has_hit = FALSE;
}
msg("the %s vanishes as it hits the ground",
weap_info[obj->o_which].oi_name);
}
discard(obj);
}
void HttpClient::reset(FXbool forceclose){
if (forceclose)
close();
else
discard();
clear();
}
void Sprite::copyFrom(const Sprite &sprite) {
discard();
if (sprite._surfacePaletted.pixels) {
_surfacePaletted.copyFrom(sprite._surfacePaletted);
_transparencyMap = new uint8[_surfacePaletted.w * _surfacePaletted.h];
memcpy(_transparencyMap, sprite._transparencyMap, _surfacePaletted.w * _surfacePaletted.h);
}
if (sprite._surfaceTrueColor.pixels)
_surfaceTrueColor.copyFrom(sprite._surfaceTrueColor);
_palette = sprite._palette;
_fileName = sprite._fileName;
_fromCursor = sprite._fromCursor;
_defaultX = sprite._defaultX;
_defaultY = sprite._defaultY;
_feetX = sprite._feetX;
_feetY = sprite._feetY;
_flippedHorizontally = sprite._flippedHorizontally;
_flippedVertically = sprite._flippedVertically;
_scale = sprite._scale;
_scaleInverse = sprite._scaleInverse;
}
int checkGreatHall(int player, struct gameState *post)
{
int old_numActions = post->numActions;
struct gameState pre;
memcpy(&pre, post, sizeof(struct gameState));
int r = great_hall(player, post, 0);
//what great_hall is supposed to do
if(pre.deckCount[player] < 1)
{
shuffle( player, &pre);
}
pre.hand[player][pre.handCount[player]] = pre.deck[player][pre.deckCount[player]-1];
pre.handCount[player]++;
pre.deckCount[player]--;
pre.numActions++:
discard(0, player, &pre, 0);
// check if post and pre are the same
if( pre.deckCount[player] == post->deckCount[player])
{
if (pre.handCount[player] == post->handCount[player])
{
if(pre.dicardCount[player] == post->discardCount[player])
{ if(pre.numActions == post->numActions)
{
return 0;
}
}
}
}
return -1;
}
gl::Error StreamingIndexBufferInterface::reserveBufferSpace(unsigned int size, GLenum indexType)
{
unsigned int curBufferSize = getBufferSize();
unsigned int writePos = getWritePosition();
if (size > curBufferSize)
{
gl::Error error = setBufferSize(std::max(size, 2 * curBufferSize), indexType);
if (error.isError())
{
return error;
}
setWritePosition(0);
}
else if (writePos + size > curBufferSize || writePos + size < writePos)
{
gl::Error error = discard();
if (error.isError())
{
return error;
}
setWritePosition(0);
}
return gl::Error(GL_NO_ERROR);
}
int main(){
//initialize loop variables and value return variables
int i, j, k, p, r;
//seed our RNG for different combos of 3 empty piles
srand(time(NULL));
//declare seed for RNG as initialize argument
int seed = 19191;
int numPlayers = 2;
//declare player 1 (all tests are symmetric across players here)
int player = 0;
//set supply pile contents to anything, all that matters for this test
//is their respective counts.
int kingdom[10] = {adventurer, council_room, feast, gardens, mine
, remodel, smithy, village, baron, great_hall};
struct gameState state;
printf("Test for great hall card effect\n===================\n");
//initialize gamestate
memset(&state, 0, sizeof(struct gameState));
r = initializeGame(numPlayers,kingdom,seed,&state);
state.whoseTurn = player;
assert(handActionIncrease(&state)==1);
memset(&state, 0, sizeof(struct gameState));
r = initializeGame(numPlayers,kingdom,seed,&state);
state.whoseTurn = player;
assert(emptyDeck(&state)==1);
memset(&state, 0, sizeof(struct gameState));
r = initializeGame(numPlayers,kingdom,seed,&state);
state.whoseTurn = player;
assert(discard(&state)==1);
printf("All tests successful!\n\n");
return 0;
}
void SchematicSceneBuilder::add_wire_component(
std::map<std::string, std::string> props
)
{
if(!discard(props)) {
Wire* item = static_cast<Wire*>(
SchematicScene::itemByType(SchematicScene::WireItemType));
bool ok;
double to_x = QString::fromStdString(props["to_x"]).toDouble(&ok);
if(!ok)
to_x = SchematicScene::GridStep;
double to_y = QString::fromStdString(props["to_y"]).toDouble(&ok);
if(!ok)
to_y = SchematicScene::GridStep;
bool conn = QString::fromStdString(props["conn"]).toInt(&ok);
if(!ok)
conn = false;
item->setWire(QLineF(QPointF(0, 0), QPointF(to_x, to_y)));
item->setConnectedJunctions(conn);
scene_->addSupportedItem(item, false);
grid_coordinate(item, props);
items_.push_back(item);
}
}
void LineBehavior::circle(vector<RobotState>* robots) {
// update diameter extremities
if (robots->at(1).getTouch()) {
ofVec2f pos = robots->at(1).getPosition();
robots->at(1).setGoal(pos);
}
if (robots->at(2).getTouch()) {
ofVec2f pos = robots->at(2).getPosition();
robots->at(2).setGoal(pos);
}
// get diameter extremities
ofVec2f p1 = robots->at(1).getGoal();
ofVec2f p2 = robots->at(2).getGoal();
// count number of needed robots
float d = PI * p1.distance(p2);
float current_spacing = d / (nmid+3);
if (current_spacing < minspacing || current_spacing > maxspacing) {
nmid = max(0, min(nbRobots-3, (int)(d / spacing) - 3));
nmid = 2 * (int)(nmid/2); // has to be even
}
// update interpolating robots
ofVec2f o = (p1+p2)/2;
for (int i=0; i<nmid/2; i++) {
//
int k = i;
float a = 180 * (k+1) / (float)(nmid/2 + 1);
ofVec2f p = o + (p2 - o).rotate(a);
robots->at(3 + i*2).setGoal(p);
robots->at(3 + i*2).setColor(ofColor(0, 0, 255));
ofVec2f p_ = o + (p1 - o).rotate(a);
robots->at(3 + i*2 + 1).setGoal(p_);
robots->at(3 + i*2 + 1).setColor(ofColor(0, 0, 255));
}
// put remaining robots aside
discard(robots, nmid + 3, robots->size()-1);
// translate
int translating = 0;
for (int i=3; i < 3+nmid; i++)
if (robots->at(i).getTouch())
translating = i;
if (translating > 0) {
ofVec2f goal = robots->at(translating).getGoal();
ofVec2f pos = robots->at(translating).getPosition();
ofVec2f delta = pos - goal;
for (int i=1; i < 3+nmid; i++) {
ofVec2f goali = robots->at(i).getGoal();
robots->at(i).setGoal(goali + delta);
}
}
}
void MinionEquipment::updateOwners(const vector<Item*> items) {
for (const Item* item : items)
if (owners.count(item->getUniqueId())) {
const Creature* c = owners.at(item->getUniqueId());
if (c->isDead() || !needs(c, item, true, true))
discard(item);
}
}
void MinionEquipment::updateOwners(const vector<Item*> items) {
for (const Item* item : items)
if (auto owner = owners.getMaybe(item)) {
const Creature* c = *owner;
if (c->isDead() || !needs(c, item, true, true))
discard(item);
}
}
static int
s_fileno_write_flush(register stream * s)
{
int result = s_process_write_buf(s, false);
discard(fsync(sfileno(s)));
return result;
}
void LineBehavior::line(vector<RobotState>* robots) {
// update line extremities
if (robots->at(1).getTouch()) {
ofVec2f pos = robots->at(1).getPosition();
robots->at(1).setGoal(pos);
}
if (robots->at(2).getTouch()) {
ofVec2f pos = robots->at(2).getPosition();
robots->at(2).setGoal(pos);
}
// get line extremities
ofVec2f p1 = robots->at(1).getGoal();
ofVec2f p2 = robots->at(2).getGoal();
// count number of needed robots
float d = p1.distance(p2);
float current_spacing = d / (nmid+1);
if (current_spacing < minspacing || current_spacing > maxspacing)
nmid = max(0, min(nbRobots-3, (int)(d / spacing) - 1));
// update interpolating robots
for (int i=0; i<nmid; i++) {
// insert/remove in the middle
int k;
if (i%2 == 0)
k = i/2;
else
k = (nmid-1) - (i-1)/2;
float t = (k+1) / (float)(nmid + 1);
ofVec2f p = p1 + t * (p2 - p1);
robots->at(3+i).setGoal(p);
robots->at(3+i).setColor(ofColor(0, 0, 255));
}
// put remaining robots aside
discard(robots, nmid + 3, robots->size()-1);
// translate
int translating = 0;
for (int i=3; i < 3+nmid; i++)
if (robots->at(i).getTouch())
translating = i;
if (translating > 0) {
ofVec2f goal = robots->at(translating).getGoal();
ofVec2f pos = robots->at(translating).getPosition();
ofVec2f delta = pos - goal;
for (int i=1; i < 3+nmid; i++) {
ofVec2f goali = robots->at(i).getGoal();
robots->at(i).setGoal(goali + delta);
}
}
}
bool MinionEquipment::canTakeItem(const Creature* c, const Item* it) {
if (const Creature* owner = getOwner(it)) {
if (c == owner) {
if (!needs(c, it)) {
discard(it);
return false;
}
return true;
}
if (owner->isDead())
discard(it);
else
return false;
}
if (!getEquipmentType(it) || !c->isHumanoid())
return false;
return needs(c, it);
}
JASEL_NODISCARD JASEL_ATTR_ASSUME_ALIGNED(align) JASEL_CXX14_CONSTEXPR T *assume_aligned(T *u)
{
#if 1
discard(JASEL_ASSUME_ALIGNED(u, align));
#else
JASEL_ASSUME(check_aligned<align>(u));
#endif
return u;
}
void free (BufferHeader* bh)
{
assert(bh->size > 0);
assert(bh->size <= size_);
assert(bh->store == BUFFER_IN_MEM);
assert(bh->ctx == this);
if (SEQNO_NONE == bh->seqno_g) discard (bh);
}
