/*
* this function allows the user to double the # of buckets at run time
* -returns pointer to the hash_table - or NULL if error
*/
hash_table* double_table_size (hash_table* table, int num_of_buckets)
{
/* allocate memory for a new hash table - double the size */
/* students may use "realloc()" if they understand it properly! - not required */
hash_table* new_table = create_hash_table(num_of_buckets * 2);
if (new_table) {
int i;
for (i=0; i<table->num_of_buckets; i++) {
while (table->table[i]) {
char * name = table->table[i]->value;
add_to_table(new_table, name);
delete_from_table(table, name);
}
}
delete_table(table);
return new_table;
} else {
return NULL;
}
/* move data from old hash table to new hash table - if necessary */
/* don't forget to free old hash table memory before returning */
}
void dr_exit(void)
{
#ifdef SHOW_RESULTS
/* Print all the cbr's seen over the life of the process, and
* whether we saw taken, not taken, or both.
*/
int i;
for (i=0; i<HASH_TABLE_SIZE; i++) {
if (table[i] != NULL) {
elem_t *iter;
for (iter = table[i]->head; iter != NULL; iter = iter->next) {
cbr_state_t state = iter->state;
if (state == CBR_TAKEN) {
dr_printf(""PFX": taken\n", iter->addr);
}
else if (state == CBR_NOT_TAKEN) {
dr_printf(""PFX": not taken\n", iter->addr);
}
else {
ASSERT(state == (CBR_TAKEN | CBR_NOT_TAKEN));
dr_printf(""PFX": both\n", iter->addr);
}
}
}
}
#endif
delete_table(table);
}
void ObPSTest::SetUp()
{
ASSERT_TRUE(NULL != mysql_init(&my_));
fprintf(stderr, "Connecting server %s:%d...\n", HOST, PORT);
ASSERT_TRUE(NULL != mysql_real_connect(&my_, HOST, USER, PASSWD, "test", PORT, NULL, 0));
delete_table();
create_table();
generate_data();
}
Automate *automate_accessible( const Automate * automate){
Automate* clone = copier_automate(automate);
Ensemble* etats = creer_ensemble(NULL, NULL, NULL);
Ensemble_iterateur it_etat;
Ensemble_iterateur it_lettre;
// On calcule l'ensemble des états accessibles
for(it_etat = premier_iterateur_ensemble(get_initiaux(automate));
! iterateur_ensemble_est_vide( it_etat );
it_etat = iterateur_suivant_ensemble( it_etat )){
ajouter_elements(etats, etats_accessibles(automate, get_element(it_etat)));
ajouter_element(etats, get_element(it_etat));
}
// On détermine les états qui ne sont pas accessibles => ceux qui sont dans get_etats mais pas dans etats
Ensemble* non_accessible = creer_difference_ensemble(get_etats(automate), etats);
// On parcourt l'ensemble obtenu
for(it_etat = premier_iterateur_ensemble(non_accessible);
! iterateur_ensemble_est_vide( it_etat );
it_etat = iterateur_suivant_ensemble( it_etat )){
const intptr_t etat_courant = get_element(it_etat);
// On cherche toutes les transitions partant d'un état
for(it_lettre = premier_iterateur_ensemble(get_alphabet(automate));
! iterateur_ensemble_est_vide( it_lettre );
it_lettre = iterateur_suivant_ensemble( it_lettre )){
Cle cle;
initialiser_cle( &cle, etat_courant, get_element(it_lettre));
Table_iterateur it = trouver_table( clone->transitions, (intptr_t) &cle );
// Si on trouve une transition partant d'un état non accessible
if( !iterateur_est_vide( it ) ){
delete_table( clone->transitions, (intptr_t) &cle); // on la supprime
}
}
// si c'est un état final, on pense à le supprimer
if (est_un_etat_final_de_l_automate(automate, etat_courant))
{
retirer_element(clone->finaux, etat_courant);
}
// si c'est un état initial, on pense à le supprimer
if (est_un_etat_initial_de_l_automate(automate, etat_courant))
{
retirer_element(clone->initiaux, etat_courant);
}
}
// On supprime tous les états non accessibles de l'automate
deplacer_ensemble(clone->etats, etats);
return clone;
}
static void
dec_table_refc(Process* c_p, HashTable* old_table)
{
erts_aint_t refc = erts_atomic_dec_read_nob(&old_table->refc);
if (refc == 0) {
HashTable* to_delete;
while ((to_delete = next_to_delete()) != NULL) {
delete_table(c_p, to_delete);
}
}
}
Variant::~Variant()
{
switch (type)
{
case STRING:
delete[] data.string.str;
break;
case FUSERDATA:
((love::Object *) data.userdata)->release();
break;
case TABLE:
delete_table(data.table);
default:
break;
}
}
int main(int argc, char *argv[]){
TABLE *table = create_table();
read_table(stdin, table);
// print_table(table);
PIECE_LIST *list = create_piece_list(table);
QUEUE *queue = create_queue();
list_moves(table, queue, list);
print_queue(queue);
//printf("-----------------------------------------------------\n");
// print_table(table);
delete_queue(&queue);
delete_list(&list);
//printf("-----------------------------------------------------\n");
// print_table(table);
delete_table(&table);
return 0;
}
void
microscopes::lda::state::remove_table(size_t eid, size_t word_index) {
size_t tid = table_assignments_[eid][word_index];
if (tid > 0)
{
size_t k = dish_assignments_[eid][tid];
MICROSCOPES_DCHECK(k > 0, "k <= 0");
// decrease counters
size_t v = get_word(eid, word_index);
MICROSCOPES_DCHECK(v < nwords(), "Word out of bounds");
n_kv[k].decr(v, 1);
n_k.decr(k, 1);
n_jt[eid][tid] -= 1;
n_jtv[eid][tid][v] -= 1;
if (n_jt[eid][tid] == 0)
{
delete_table(eid, tid);
}
}
}
void
dr_exit(void)
{
delete_table(table);
}
int dropDatabase(char *str){
FILE *dicionario;
int cnt = 0, cod_db = busca(str,1), n = 0;
char *nome_tabela = (char *)malloc(sizeof(char)*TAMANHO_NOME_TABELA+1);
if (nome_tabela == NULL)
{
printf("Out of memory.\nAborting...\n");
abort();
}
char **tables;
tables = (char**) malloc (sizeof(char*)*200);
if (tables == NULL)
{
printf("Out of memory.\nAborting...\n");
abort();
}
if(cod_db == -2)
{
printf("There is no registered table named %s\n", str);
return 0;
}
if((dicionario = fopen("fs_object.dat","a+b")) == NULL)//abrindo dicionario
{
if(nome_tabela != NULL)free(nome_tabela);
if(tables != NULL)free(tables);
printf("Error while opening the database file\n");
return 0;
}
while(fgetc (dicionario) != EOF)
{
fseek(dicionario, -1, 1);
fread(nome_tabela, sizeof(char), TAMANHO_NOME_TABELA, dicionario); //Lê somente o nome da tabela
n = 0;
char **aux_name = tokenize(nome_tabela,'_',&n);
if (n >= 2)
{
n = atoi(aux_name[0]);
// Verifica se o nome dado pelo usuario existe no dicionario de dados.
if(n == cod_db)
{
cnt++;
}
}
if(aux_name != NULL)free(aux_name);
fseek(dicionario, 28, 1);
}
if(cnt == 0)
{
reescreve(str);
if(nome_tabela != NULL)free(nome_tabela);
fclose(dicionario);
return 1;
}
else
{
fclose(dicionario);
if((dicionario = fopen("fs_object.dat","a+b")) == NULL)
{
if( nome_tabela != NULL)free(nome_tabela);
if( tables != NULL)free(tables);
printf("Error while opening the database file\n");
return 0;
}
cnt = 0;
n = 0;
while(fgetc (dicionario) != EOF)
{
fseek(dicionario, -1, 1);
fread(nome_tabela, sizeof(char), TAMANHO_NOME_TABELA, dicionario); //Lê somente o nome da tabela
n = strlen(nome_tabela);
if (n >= 2) {
char **str = tokenize(nome_tabela,'_',&n);
n = atoi(str[0]);
// Verifica se o nome dado pelo usuario existe no dicionario de dados.
if(n == cod_db)
{
tables[cnt] = strdup(nome_tabela);
if (tables[cnt] == NULL)
{
if(tables != NULL)free(tables);
if(nome_tabela != NULL)free(nome_tabela);
printf("Out of memory.\nAborting...\n");
abort();
}
cnt++;
}
if(str != NULL) free(str);
}
fseek(dicionario, 28, 1);
}
n = cnt;
while(cnt > 0)
{
// printf("%s\n",tables[cnt-1]);
int del = delete_table(tables[cnt-1]);
if (del == SUCCESS)
{
cnt--;
}
}
reescreve(str);
if(tables != NULL)free(tables);
if(nome_tabela != NULL)free(nome_tabela);
fclose(dicionario);
return 1;
}
return 0;
}
/**
* <A short one line description>
*
* <Longer description>
* <May span multiple lines or paragraphs as needed>
*
* @param Description of method's or function's input parameter
* @param ...
* @return Description of the return value
*/
int main(int argc, char* argv[])
{
int ch;
/* keypress character */
printf("Welcome to poorman's db, type ? for help\n");
printf(TABLE_OPERATIONS_PROMPT);
printf("keypress = %08x\n ", ch);
create_table();
return 0;
while((ch = getchar()) != EOF){
switch (ch)
{
case 0x31:
create_table();
break;
case 0x32:
delete_table();
break;
case 0x33:
list_tables();
break;
case 0x34:
select_table();
break;
case 0x35:
return 0;
break;
default:
printf("Command not recognized.\n Type ? for help\n");
continue;
}
}
return 0;
#if 0
struct record rec;
sprintf(rec.field[3], "onurkom\n");
printf("--->%s\n", rec.field[3]);
//printf("size of fx is %d\n", sizeof(rec.field));
return 0;
#endif
#if 0
char fx[4][16] = {"1asdasd\n", "2adsasdas\n", "3asdsadas\n", "4asdadasd\n"};
struct record rec;
sprintf(fx[3], "onur\n");
printf("--->%s\n", fx[3]);
printf("size of fx is %d\n", sizeof(fx));
char S[10][11];
int i,j,k;
char A;
for (i=0;i<=9;i++){
scanf ("%s",A);
for (j=0;j<=10;j++)
{
S[i][j]=A;
}
}
for (i=0;i<=9;i++){
for (j=0;j<=10;j++)
{
printf("i=%d j=%d data=%s\n", i,j,S[i][j]);
}
}
#endif
#if 0
int i,j,k=0;
for(i=0; i<4; i++)
for(j=0; j<4; j++)
{
sprintf((rec.field[j][i]), "y%d\n", k);
printf("field %d %d is now %d\n", i,j,k);
k++;
}
for(i=0; i<4; i++)
for(j=0; j<4; j++)
{
printf("i=%d j=%d field=%s\n", i,j,rec.field[i][j]);
}
#endif
printf("here\n");
return 0;
}
int
main(int argc, char **argv)
{
int nocol_short, nocol_long, nocol_float, nocol_double;
int status;
char **argval, **arglabel;
int i, nbrow = NBROW, nbcol=NBCOL, sel[NBROW];
short sval, s_colbuf[NBROW], s_key;
long lval, l_colbuf[NBROW];
float fval, f_colbuf[NBROW];
double dval, d_colbuf[NBROW];
char ident[20];
char selection[30];
TABLE table;
/* init_session() checking */
printf("IOLIB environment routines :\n\n");
fflush(stdout);
init_session(argv,argc,&arglabel,&argval);
/* set_control_level(WARNING); */
printf("Table creation ...");
fflush(stdout);
strcpy(ident,"Dummy table");
create_table(&table,"chk_tbl_io",nbrow,nbcol,'W',ident);
printf("Ok\n");
fflush(stdout);
/*
printf("Column creation ...(format Characters) ");
fflush(stdout);
nocol_char = create_col(&table,":TEXT",CHAR,'N',"A20",NULL);
if (nocol_char < 0) {
printf("Problem creating column TEXT, status returned = %d\n", nocol_char);
exit (-1);
}
printf("Ok\n");
fflush(stdout);
printf("Writing into created column ...");
fflush(stdout);
for (i=0; i<nbrow; i++) {
sprintf(text,"String no %2d",i);
WR_tbl(&table,i,nocol_char,text);
}
printf("Ok\n");
fflush(stdout);
*/
printf("Column creation ...(format Short) ");
fflush(stdout);
nocol_short = create_col(&table,":SHORT",SHORT,'N',"I2",NULL);
if (nocol_short < 0) {
printf("Problem creating column SHORT, status returned = %d\n", nocol_short);
exit (-1);
}
printf("Ok\n");
fflush(stdout);
printf("Writing into created column ...");
fflush(stdout);
for (i=0; i<nbrow; i++) {
sval = (short)i;
WR_tbl(&table,i,nocol_short,&sval);
}
printf("Ok\n");
fflush(stdout);
printf("Column creation ...(format Long) ");
fflush(stdout);
nocol_long = create_col(&table,":LONG",LONG,'N',"I4",NULL);
if (nocol_long < 0) {
printf("Problem creating column LONG, status returned = %d\n", nocol_long);
exit (-1);
}
printf("Ok\n");
fflush(stdout);
printf("Writing into created column ...");
fflush(stdout);
for (i=0; i<nbrow; i++) {
lval = (long)i;
WR_tbl(&table,i,nocol_long,&lval);
}
printf("Ok\n");
fflush(stdout);
printf("Column creation ...(format Float) ");
fflush(stdout);
nocol_float = create_col(&table,":FLOAT",FLOAT,'N',"F9.6",NULL);
if (nocol_float < 0) {
printf("Problem creating column FLOAT, status returned = %d\n", nocol_float);
exit (-1);
}
printf("Ok\n");
fflush(stdout);
printf("Writing into created column ...");
fflush(stdout);
for (i=0; i<nbrow; i++) {
fval = (float)i;
WR_tbl(&table,i,nocol_float,&fval);
}
printf("Ok\n");
fflush(stdout);
printf("Column creation ...(format Double) ");
fflush(stdout);
nocol_double = create_col(&table,":DOUBLE",DOUBLE,'N',"E15.5",NULL);
if (nocol_double < 0) {
printf("Problem creating column DOUBLE, status returned = %d\n", nocol_double);
exit (-1);
}
printf("Ok\n");
fflush(stdout);
printf("Writing into created column ...");
fflush(stdout);
for (i=0; i<nbrow; i++) {
dval = (double)i;
WR_tbl(&table,i,nocol_double,&dval);
}
printf("Ok\n\n");
fflush(stdout);
for (i=0; i<nbrow; i++) {
if (i%2 == 0)
sel[i] = 0;
else
sel[i] = 1;
}
write_selection(&table,sel,"check_selection");
printf("Saving created table ...");
fflush(stdout);
close_table(&table);
printf("Ok\n");
fflush(stdout);
printf("Opening previous table ...");
fflush(stdout);
open_table(&table,"chk_tbl_io","I");
printf("Ok\n");
fflush(stdout);
printf("Handling selection ...");
fflush(stdout);
handle_select_flag(&table,'W',selection);
printf("Ok\n");
fflush(stdout);
printf("Reading columns info ...");
fflush(stdout);
/* nocol_char = get_col_ref(&table,":TEXT"); */
nocol_short = get_col_ref(&table,":SHORT");
nocol_long = get_col_ref(&table,":LONG");
nocol_float = get_col_ref(&table,":FLOAT");
nocol_double = get_col_ref(&table,":DOUBLE");
printf("Ok\n");
nbrow = table.row;
/*
printf("Reading previous column ...(format Characters) ");
fflush(stdout);
RD_col(&table,nocol_char,c_colbuf);
for (i=0; i<nbrow; i++) {
sprintf(text,"String no %2d",i);
if (strcmp(text,(c_colbuf+i*21)) != 0) {
printf("FATAL : Unexpected values in table, line %d\n",i);
return(-1);
}
}
printf("Ok\n");
printf("Reading previous column item by item ...(format Characters) ");
fflush(stdout);
for (i=0; i<nbrow; i++) {
RD_tbl(&table,i,nocol_char,Rtext);
sprintf(text,"String no %2d",i);
if (strcmp(text,Rtext) != 0) {
printf("FATAL : Unexpected values in table, line %d\n",i);
printf("*%s* is not *%s*\n", Rtext, text);
return(-1);
}
}
printf("Ok\n");
*/
printf("Reading previous column ...(format Short) ");
fflush(stdout);
s_colbuf[0] = 0;
RD_col(&table,nocol_short,s_colbuf);
printf("Ok\n");
printf("Searching for no 501 ... ");
fflush(stdout);
s_key = 501;
status = search_in_col(&table,nocol_short,&s_key);
if (status >= 0)
printf("Found in line %d\n",status);
else {
printf("Unable to find it\n");
return(-1);
}
printf("Searching for no 500 ... ");
fflush(stdout);
s_key = 500;
status = search_in_col(&table,nocol_short,&s_key);
if (status >= 0)
printf("Found in line %d\n",status);
else {
printf("Unable to find it (not selected)\n");
}
for (i=0; i<nbrow; i++) {
if (s_colbuf[i] != (short)(2*i+1)) {
printf("FATAL : Unexpected values in table, line %d\n",i);
printf("Read %d, Expected %d\n",s_colbuf[i],2*i+1);
return(-1);
}
}
printf("Ok\n");
printf("Reading previous column item by item ...(format Short) ");
fflush(stdout);
for (i=0; i<nbrow; i++) {
RD_tbl(&table,i,nocol_short,&sval);
if (sval != (short)(2*i+1)) {
printf("FATAL : Unexpected values in table, line %d\n",i);
return(-1);
}
}
printf("Ok\n");
printf("Reading previous column ..(format Long) ");
fflush(stdout);
RD_col(&table,nocol_long,l_colbuf);
for (i=0; i<nbrow; i++) {
if (l_colbuf[i] != (long)(2*i+1)) {
printf("FATAL : Unexpected values in table, line %d\n",i);
return(-1);
}
}
printf("Ok\n");
printf("Reading previous column item by item ...(format Long) ");
fflush(stdout);
for (i=0; i<nbrow; i++) {
RD_tbl(&table,i,nocol_long,&lval);
if (lval != (long)(2*i+1)) {
printf("FATAL : Unexpected values in table, line %d\n",i);
return(-1);
}
}
printf("Ok\n");
printf("Reading previous column ...(format Float) ");
fflush(stdout);
RD_col(&table,nocol_float,f_colbuf);
for (i=0; i<nbrow; i++) {
if (f_colbuf[i] != (float)(2*i+1)) {
printf("FATAL : Unexpected values in table, line %d\n",i);
return(-1);
}
}
printf("Ok\n");
printf("Reading previous column item by item ...(format Float) ");
fflush(stdout);
for (i=0; i<nbrow; i++) {
RD_tbl(&table,i,nocol_float,&fval);
if (fval != (float)(2*i+1)) {
printf("FATAL : Unexpected values in table, line %d\n",i);
return(-1);
}
}
printf("Ok\n");
printf("Reading previous column ..(format Double) ");
fflush(stdout);
RD_col(&table,nocol_double,d_colbuf);
for (i=0; i<nbrow; i++) {
if (ABS(d_colbuf[i] - (double)(2*i+1)) > 1e-8) {
printf("FATAL : Unexpected values in table, line %d\n",i);
return(-1);
}
}
printf("Ok\n");
printf("Reading previous column item by item ...(format Double) ");
fflush(stdout);
for (i=0; i<nbrow; i++) {
RD_tbl(&table,i,nocol_double,&dval);
if (ABS(dval - (double)(2*i+1)) > 1e-8) {
printf("FATAL : Unexpected values in table, line %d\n",i);
return(-1);
}
}
printf("Ok\n");
fflush(stdout);
printf("Deleting previous table ...");
fflush(stdout);
delete_table(&table);
printf("Ok\n");
fflush(stdout);
exit_session(0);
return(0);
}
/*
void dump() const {
for (size_t i = 0; i < table_.size(); ++i) {
std::cout << "[" << i << "] ";
const kvp* target = table_[i];
int ctr = 0;
while (target != nullptr) {
if (0 < ctr) {
std::cout << " --> ";
}
if (table_[i] == nullptr) {
std::cout << "(null)";
} else {
std::cout << target->key << " => " << target->value;
}
target = target->next;
++ctr;
}
std::cout << std::endl;
}
std::cout << std::endl;
}
*/
~hashmap() {
delete_table(table_.load());
}
Automate * creer_automate_de_concatenation(
const Automate* automate1, const Automate* automate2
){
/**
* \par Implémentation
*
* On créé un automate, copie de automate1 avec comme états finaux ceux de automate2
*/
Automate* concat = copier_automate(automate1);
deplacer_ensemble(concat->finaux, automate2->finaux);
/**
* Puis on créé un modificateur qui nous permet de passer en paramètres de fonction
* l'automate de destination et une valeur de décalage des états.
* Cette valeur permet de ne pas avoir deux états avec la même valeur.
*/
int decalage = get_max_etat(automate1);
AutomateInt* modificateur = creer_automate_int();
modificateur->automate = concat;
modificateur->valeur = decalage;
/**
* On ajoute les transitions de l'automate 2 avec les états décalés.
*/
pour_toute_transition(automate2, incrementer_etats_transition, modificateur);
liberer_automate_int(modificateur);
/**
* Pour chaque état initial du second automate
*/
Ensemble_iterateur initial2;
for(
initial2 = premier_iterateur_ensemble(get_initiaux(automate2));
! iterateur_ensemble_est_vide( initial2 );
initial2 = iterateur_suivant_ensemble( initial2 )){
/**
* Pour chaque lettre de son alphabet
*/
Ensemble_iterateur lettre;
for(
lettre = premier_iterateur_ensemble(get_alphabet(automate2));
! iterateur_ensemble_est_vide(lettre);
lettre = iterateur_suivant_ensemble(lettre)){
Cle cle;
printf("initial2 : %d\n", (int) get_element(initial2));
printf("lettre : %c\n", (char) get_element(lettre));
initialiser_cle(&cle, (int) get_element(initial2), (char) get_element(lettre));
Table_iterateur destination = trouver_table(automate2->transitions, (intptr_t) &cle);
printf("avant clé\n");
print_cle(&cle);
printf("après clé\n");
if (!iterateur_est_vide(destination)){
AutomateTransition* modif_trans = creer_automate_transition();
modif_trans->automate = concat;
modif_trans->lettre = get_element(lettre);
Ensemble* destinations = (Ensemble*) get_valeur(destination);
Ensemble_iterateur etat_dest;
/**
* Pour chaque transition de la forme (i2, a2, q2), avec i2 intial, a2 lettre de l'alphabet
* et q2 état de l'automate2
*/
for(
etat_dest = premier_iterateur_ensemble(destinations);
! iterateur_ensemble_est_vide(etat_dest);
etat_dest = iterateur_suivant_ensemble(etat_dest)){
modif_trans->destination = get_element(etat_dest)+decalage;
/**
* On ajoute une transition dans l'automate de concaténation ayant pour origine
* un état initial, la lettre a2 et l'état q2
*/
pour_tout_element(get_finaux(automate1), simuler_epsilon_transition, modif_trans);
}
initialiser_cle(&cle, (int) get_element(initial2) + decalage, get_element(lettre));
delete_table(concat->transitions, (intptr_t) &cle);
liberer_automate_transition(modif_trans);
}
}
}
return concat;
}
Variant *Variant::fromLua(lua_State *L, int n, bool allowTables)
{
Variant *v = NULL;
size_t len;
const char *str;
if (n < 0) // Fix the stack position, we might modify it later
n += lua_gettop(L) + 1;
switch (lua_type(L, n))
{
case LUA_TBOOLEAN:
v = new Variant(luax_toboolean(L, n));
break;
case LUA_TNUMBER:
v = new Variant(lua_tonumber(L, n));
break;
case LUA_TSTRING:
str = lua_tolstring(L, n, &len);
v = new Variant(str, len);
break;
case LUA_TLIGHTUSERDATA:
v = new Variant(lua_touserdata(L, n));
break;
case LUA_TUSERDATA:
v = new Variant(extractudatatype(L, n), lua_touserdata(L, n));
break;
case LUA_TNIL:
v = new Variant();
break;
case LUA_TTABLE:
if (allowTables)
{
bool success = true;
std::vector<std::pair<Variant*, Variant*> > *table = new std::vector<std::pair<Variant*, Variant*> >();
lua_pushnil(L);
while (lua_next(L, n))
{
Variant *key = fromLua(L, -2, false);
if (!key)
{
success = false;
lua_pop(L, 2);
break;
}
Variant *value = fromLua(L, -1, false);
if (!value)
{
delete key;
success = false;
lua_pop(L, 2);
break;
}
table->push_back(std::make_pair(key, value));
lua_pop(L, 1);
}
if (success)
v = new Variant(table);
else
delete_table(table);
}
break;
}
return v;
}
