自学教程：C++ string_length函数代码示例

//+   external put : t -> string -> put_flag -> unit//+          = "caml_cursor_put"value caml_cursor_put(value cursor, value vdata, value vflag) {  CAMLparam3(cursor,vdata,vflag);  DBT key, data;  int flags, err;    test_cursor_closed(cursor);  zerob(&key,sizeof(DBT)); zerob(&data,sizeof(DBT));  data.data = String_val(vdata);  data.size = string_length(vdata);  flags = Flag_val(vflag, cursor_put_flags);  err = UW_cursor(cursor)->c_put(UW_cursor(cursor), &key, &data, flags);  if (err != 0) {     if (err == DB_KEYEXIST) { raise_key_exists(); }    raise_db(db_strerror(err));   }  CAMLreturn (Val_unit);}

char* buscarPagina(int32_t PID, int32_t numeroDePagina){	char* paginaBuscada = malloc(configuracion->tamano_pagina);	t_nodoOcupado* nodo = encontrarNodoPorPID(espacioOcupado,PID);	int32_t ubicacionPagina = nodo->comienzo + numeroDePagina;	memcpy(paginaBuscada,archivoMapeado->memoria + ubicacionPagina*configuracion->tamano_pagina,configuracion->tamano_pagina);	uint32_t byteInicial = nodo->comienzo * configuracion->tamano_pagina;	bool vacio = string_is_empty(paginaBuscada);	uint32_t tamanio;	if(vacio)	{		tamanio = 0;		log_info(SwapLog,"Lectura solicitada por proceso con PID %d, byte inicial %d y tamanio %d y contenido: %s",PID,byteInicial,tamanio,"pagina vacia/0");	}	else	{		tamanio = string_length(paginaBuscada);		log_info(SwapLog,"Lectura solicitada por proceso con PID %d, byte inicial %d y tamanio %d y contenido: %s",PID,byteInicial,tamanio,paginaBuscada);	}	return paginaBuscada;}

object io_file_as_port(object filename, unsigned long port_type){	char *name;	unsigned long namelen;	FILE *f;	namelen = string_length(filename);	name = xmalloc(namelen + 1);	memcpy(name, string_value(filename), namelen);	name[namelen] = 0;	if ((f = fopen(name, (port_type == PORT_TYPE_INPUT) ? "r" : "w+")) == NULL) {		xfree(name);		error("Cannot open file -- io-file-as-port", filename);	}	xfree(name);	return make_port(f, port_type);}

string *string_substr(string *s, size_t pos, size_t len){  string *result;  size_t n, l = string_length(s);  if (pos > l)    return NULL;  result = malloc(sizeof *result);  if (!result)    return NULL;  n = l - pos < len ? l - pos : len;  buffer_init(&result->buffer);  buffer_reserve(&result->buffer, n + 1);  buffer_insert(&result->buffer, 0, string_data(s) + pos, n);  string_data(result)[n] = 0;  return result;}

DLL_VARIABLE void object_format(object_t* obj, format_fn_t cb, void* ctxt){	switch(obj->o_type) {		case object_type_string: {			cstring_t str = object_to_string(obj, "", 0);			(*cb)( "/"", 1, ctxt);			(*cb)(string_data(&str), string_length(&str), ctxt);			(*cb)( "/"", 1, ctxt);			break;		}		case object_type_table: {			size_t idx;			(*cb)(" { ", 3, ctxt);			for( idx = 0; idx < object_length(obj); ++ idx) {				if(0 != idx)					(*cb)(" , ", 3, ctxt);				object_format(object_element_at(obj, idx), cb, ctxt);			}			(*cb)(" } ", 3, ctxt);			break;		}		case object_type_array: {			size_t idx;			(*cb)(" [ ", 3, ctxt);			for( idx = 0; idx < object_length(obj); ++ idx) {				if(0 != idx)					(*cb)(" , ", 3, ctxt);				object_format(object_element_at(obj, idx), cb, ctxt);			}			(*cb)(" ] ", 3, ctxt);			break;		}		default: {			cstring_t s = object_to_string(obj, NULL, 0);			(*cb)(s.str, s.len, ctxt);		}	}}

uint32_t font_bake_string(font_t font, const char* string, float xstart, float ystart, vector_t* outVertices){	FOUNDATION_ASSERT((uint32_t)font <= array_size(s_fontCtx.fonts));	FOUNDATION_ASSERT(string != nullptr && outVertices != nullptr);	font_data_t& fontData = s_fontCtx.fonts[font];	const uint32_t entryLen = string_length(string);	float x = 0; float y = 0;		for(uint32_t c=0; c < entryLen; ++c)	{		const char character = string[c];		const uint32_t charStart = c*4;				if(character < 32 && character >= 128)			continue;		stbtt_aligned_quad q;	    stbtt_GetBakedQuad(	    	fontData.cdata, 	    	MINT_FONT_BITMAPSIZE, 	    	MINT_FONT_BITMAPSIZE, 	    	(int)character - 32, 	    	&x, &y, 	    	&q, 	    	1	    );	   	    outVertices[charStart+0] = vector(xstart + q.x0, ystart - q.y0, q.s0, q.t0);	    outVertices[charStart+1] = vector(xstart + q.x1, ystart - q.y0, q.s1, q.t0);		outVertices[charStart+2] = vector(xstart + q.x1, ystart - q.y1, q.s1, q.t1);	    outVertices[charStart+3] = vector(xstart + q.x0, ystart - q.y1, q.s0, q.t1);	    /*for(uint32_t d=0; d < 4; ++d)	    	log_infof("Vert %d 	Pos: %f,%f 	UV: %f,%f", charStart+d, vector_x(outVertices[charStart+d]), vector_y(outVertices[charStart+d]), vector_z(outVertices[charStart+d]), vector_w(outVertices[c+d]));*/        	}	return entryLen;}

main(){    char string[100];    printf("Enter a string/n");    gets(string);    int length=string_length(string);    if(length<=0)        {        printf("Not enough characters/n");        }    else    if(length>100)        {           printf("Too many characters/n");        }    else        {        reverse_string(string, length);        printf("Reverse of entered string is %s /n", string);        return 0;        }    }

// Variable argumented sprintf: Print the string of this object using fmt_string as formatter string.void t_string::sprintf(char* fmt_string, ...){        va_list pars;        va_start(pars, fmt_string);        // Initialize string as having nothing.        this->copy("");        // Go over the string: Every time a formatting string is found by %.., it is processed.        for(int i_str = 0; i_str < string_length(fmt_string); i_str++)        {                if(fmt_string[i_str] == '%')                {                        // Check the formatter character.                        i_str++;                        if(fmt_string[i_str] == 'd')                        {                                int _num = va_arg(pars,int);                                this->concat_int(_num);                        }                        else if(fmt_string[i_str] == 'c')

//envia un mensaje a un socketbool sendMessage(int socket, char * message){	int total = 0;	int n = 0;	int len = string_length(message);	//bucle hasta enviar todoo el packete (send devuelve los byte que envio)	while(total < len)	{		if ((n = send(socket, message, len, 0)) == -1)		{			//perror("send");			close(socket);			return false;		}		total += n;	}	free(message);	return true;}

value store_float(value v_string, value v_off, value v_val){    CAMLparam2(v_string, v_off);    CAMLlocal1(result);    int off, len;    char *str;    double x;    /* Get arguments */    str = String_val(v_string);    len = string_length(v_string);    off = Int_val(v_off);    x = Double_val(v_val);    /* Check bounds */    if(off < 0 || off > len - 8 || off & 7)        failwith("store_float");    /* Get the number */    *(double *)(str + off) = x;    CAMLreturn(Val_unit);}

void input_box_view(){    int maxx = mgetmaxx();    int maxy = mgetmaxy();    /// view ///    mclear_online(maxy-2);    mclear_lastline();        mvprintw(maxy-2, 0, "%s", gInputBoxMsg);        move(maxy-1, 0);        const int len = string_length(gInputBoxInput);    int i;    for(i=0; i< len && i<maxx-1; i++) {        printw("%c", string_c_str(gInputBoxInput)[i]);    }    //move_immediately(maxy -1, gInputBoxCursor);    move(maxy -1, gInputBoxCursor);}

status_t prepend_and_write_to_log(log_t *log, string_t *message, char	*prepend, size_t size){	status_t error = SUCCESS;	string_t final_message;	string_initialize(&final_message);	string_assign_from_char_array_with_size(&final_message, prepend, size);	string_concatenate(&final_message, message);	error = write_log(log, string_c_str(&final_message),		string_length(&final_message));	if (error)	{		goto exit0;	}exit0:	string_uninitialize(&final_message);	return error;}

value store_int64(value v_string, value v_off, value v_val){    CAMLparam3(v_string, v_off, v_val);    CAMLlocal1(result);    int off, len;    char *str;    int64 i;    /* Get arguments */    str = String_val(v_string);    len = string_length(v_string);    off = Int_val(v_off);    i = Int64_val(v_val);    /* Check bounds */    if(off < 0 || off > len - 8 || off & 3)        failwith("store_int64");    /* Get the number */    *(int64 *)(str + off) = i;    CAMLreturn(Val_unit);}

value load_int32(value v_string, value v_off){    CAMLparam2(v_string, v_off);    CAMLlocal1(result);    int off, len;    char *str;    int32 i;    /* Get arguments */    str = String_val(v_string);    len = string_length(v_string);    off = Int_val(v_off);    /* Check bounds */    if(off < 0 || off > len - 4 || off & 3)        failwith("load_int32");    /* Get the number */    i = *(int32 *)(str + off);    result = copy_int32(i);    CAMLreturn(result);}

value load_float(value v_string, value v_off){    CAMLparam2(v_string, v_off);    CAMLlocal1(result);    int off, len;    char *str;    double x;    /* Get arguments */    str = String_val(v_string);    len = string_length(v_string);    off = Int_val(v_off);    /* Check bounds */    if(off < 0 || off > len - 8 || off & 7)        failwith("load_float");    /* Get the number */    x = *(double *)(str + off);    result = copy_double(x);    CAMLreturn(result);}

//Well, you need a main...int main () {std::string test_string("This is the string to test");//This calls the function outputString, which is defined in the same file, below.//int something = outputString(5);//This calls the external function return_input//int return_input_result = return_input(50);//This calls another external function, string_lengthint string_size = string_length(test_string);//std::cout << "return_input returns: " << return_input_result << "/n";std::cout << "string_length returns: " << string_size << "/n";std::cout << test_string.length() << std::endl;return 0;}

VIOAPI  void  output_comments(    FILE     *file,    STRING   comments ){    int   i, len;    if( comments != NULL )    {        len = string_length( comments );        (void) output_character( file, COMMENT_CHAR1 );        for( i = 0;  i < len;  ++i )        {            (void) output_character( file, comments[i] );            if( comments[i] == '/n' && i < len - 1 )                (void) output_character( file, COMMENT_CHAR1 );        }        if( len > 0 && comments[len-1] != '/n' )            (void) output_character( file, (char) '/n' );    }}

void add_space (char* str, int length){	int max_spaces = max_length - length; //счётчик недостающих пробелов	int i=0;	int spaces=0;	int spaces_left=0;	while (i!=length)	{		if (str[i]==' ') spaces++;		i++;	}	if (spaces != 0) 	{		int k = max_spaces/spaces; //кол-во пробелов на промежуток		spaces_left = max_spaces % spaces;		for (i = 0; i<=max_length; i++)		{			if (max_spaces != 0)				if (str[i]==' ') 					for (int j=1; j<=k; j++)					{						string_insert(str,' ',i+1);						i++;					}		}	}	i = string_length(str);	if (i < max_length)	{		while (str[i]!=' ') i--;		while (spaces_left != 0)		{			string_insert(str,' ',i+1);			spaces_left--;		}	}}

/* Error.chpl:55 */static void ioerror(syserr error, chpl_string msg, chpl_string path, int64_t _ln, c_string _fn) {  int32_t call_tmp;  chpl_bool call_tmp2;  int32_t strerror_err;  c_string call_tmp3;  _ref_int32_t _ref_tmp_ = NULL;  c_string call_tmp4;  int64_t call_tmp5;  c_string call_tmp6;  c_string_copy call_tmp7;  c_string call_tmp8;  c_string call_tmp9;  c_string_copy call_tmp10;  c_string call_tmp11;  c_string_copy call_tmp12;  c_string call_tmp13;  c_string_copy call_tmp14;  call_tmp = qio_err_iserr(error);  call_tmp2 = (call_tmp != INT32(0));  if (call_tmp2) {    strerror_err = INT32(0);    _ref_tmp_ = &strerror_err;    call_tmp3 = sys_strerror_syserr_str(error, _ref_tmp_);    c_string_from_string(&call_tmp4, &path, _ln, _fn);    call_tmp5 = string_length(call_tmp4);    call_tmp6 = quote_string(path, call_tmp5, _ln, _fn);    call_tmp7 = string_concat(call_tmp3, " ", _ln, _fn);    c_string_from_string(&call_tmp8, &msg, _ln, _fn);    call_tmp9 = ((c_string)(call_tmp7));    call_tmp10 = string_concat(call_tmp9, call_tmp8, _ln, _fn);    call_tmp11 = ((c_string)(call_tmp10));    call_tmp12 = string_concat(call_tmp11, " with path ", _ln, _fn);    call_tmp13 = ((c_string)(call_tmp12));    call_tmp14 = string_concat(call_tmp13, call_tmp6, _ln, _fn);    chpl_error(call_tmp14, _ln, _fn);  }  return;}

int hashify_read_hashes( stream_t* file, hashify_string_t** hashes ){	//Read in hashes in file	char* line;	char line_buffer[HASHIFY_LINEBUFFER_LENGTH];	do	{		stream_read_line_buffer( file, line_buffer, HASHIFY_LINEBUFFER_LENGTH-1, '/n' );		line = string_strip( line_buffer, "/n/r" );		if( ( string_find_string( line, "define", 0 ) != STRING_NPOS ) && ( string_find_string( line, "static_hash", 0 ) != STRING_NPOS ) )		{			//Format is: #define HASH_<hashstring> static_hash_string( "<string>", 0x<hashvalue>ULL )			char** tokens = string_explode( line, " /t", false );			if( array_size( tokens ) >= 6 )			{				hashify_string_t hash_string;				string_copy( hash_string.string, string_strip( string_strip( tokens[3], "," ), "/"" ), HASHIFY_STRING_LENGTH );				hash_string.hash = string_to_uint64( tokens[4], true );				if( hash( hash_string.string, string_length( hash_string.string ) ) != hash_string.hash )				{					log_errorf( ERROR_INVALID_VALUE, "  hash output file is out of date, %s is set to 0x%llx but should be 0x%llx ", hash_string.string, hash_string.hash, hash( hash_string.string, string_length( hash_string.string ) ) );					string_array_deallocate( tokens );					return HASHIFY_RESULT_OUTPUT_FILE_OUT_OF_DATE;				}				array_push_memcpy( *hashes, &hash_string );			}			string_array_deallocate( tokens );		}	} while( !stream_eos( file ) );	return 0;}

cStr *html_escape(cStr * in){    register char *s;    register int len;    cStr *out;    s = string_chars(in);    len = string_length(in);    /* incase they don't need it */    if (!memchr(s, '<', len) && !memchr(s, '>', len) && !memchr(s, '&', len))        return string_dup(in);    /* doh, they do.. */    out = string_new(len);    for (; *s != '/0'; s++) {        switch (*s) {        case '<':            out = string_add_chars(out, "&lt;", 4);            break;        case '>':            out = string_add_chars(out, "&gt;", 4);            break;        case '&':            out = string_add_chars(out, "&amp;", 5);            break;        case '/"':             /* Added double-quote, Patch #1, Bruce Mitchner */            out = string_add_chars(out, "&quot;", 6);            break;        default:            out = string_addc(out, *s);        }    }    return out;}

int main(){   /// Ввод данных   std::cout << "Your text: ";   char * text = new char[STRING_LENGTH];   memset(text, 0, STRING_LENGTH * sizeof(char));   gets(text);   /// Обработка данных   int words_count = word_counter(text);   char ** words = string_to_words(text);   char ** bricks = new char * [words_count];   memset(bricks, 0, words_count * sizeof(char *));   for (int index = 0; index < words_count; ++index)   {       bricks[index] = string_bricking(words[index]);   }   /// Вывод результатов   std::cout << "String length: " << string_length(text) << std::endl;   std::cout << "String: " << std::endl;   string_print(text);   std::cout << std::endl;   std::cout << "String to words: " << std::endl;   words_print(words, words_count);   std::cout << "Bricked string: " << std::endl;   words_print(bricks, words_count);   /// Освобаждение оесурсов   words_free(&bricks, words_count);   words_free(&words, words_count);   delete [] text;   return 0;}

valuePvm_spawn_native(value task, value argv, value flag, value host,		  value ntasks, value tids){  char **cargv;  unsigned i;  int numt;  unsigned cntasks = Int_val(ntasks);  int *ctids;  char *chost;  cargv = malloc((Wosize_val(argv)+1)*sizeof(char*));  ctids = malloc(cntasks*sizeof(int));  for(i = 0; i < Wosize_val(argv); i++) cargv[i] = String_val(Field(argv, i));  cargv[Wosize_val(argv)] = NULL;  chost = (string_length(host) == 0 ? NULL : String_val(host));  numt = pvm_spawn(String_val(task), cargv, Int_val(flag),chost,cntasks,ctids);  if (numt<0) {free(cargv); free(ctids);TreatError(numt);}  for(i = 0; i < cntasks; i++) modify(&Field(tids, i), Val_int(ctids[i]));  free(cargv); free(ctids);  return Val_int(numt);}

//+   external init :  t -> string -> get_flag list -> string//+          = "caml_cursor_init"value caml_cursor_init(value cursor, value vkey, value vflags) {  CAMLparam3(cursor,vkey,vflags);  CAMLlocal1(rval);  DBT key,data;  int flags = convert_flag_list(vflags,cursor_get_flags) | DB_SET;  int err;  test_cursor_closed(cursor);  zerob(&key,sizeof(DBT)); zerob(&data,sizeof(DBT));  key.data = String_val(vkey);  key.size = string_length(vkey);    err = UW_cursor(cursor)->c_get(UW_cursor(cursor), &key, &data, flags);  if (err != 0) {     if (err == DB_NOTFOUND) { raise_not_found(); }    raise_db(db_strerror(err));  }  rval = alloc_string(data.size);  memcpy (String_val(rval), data.data, data.size);  CAMLreturn (rval);}

void cmsg_append(byte color, cptr str){    if (!_msg_count)        cmsg_add(color, str);    else    {        msg_ptr m = msg_get(0);        assert(m);        /* You tunnel into the granite wall. <x17> The heroism wears off.           Not: You tunnel into the granite wall. The heroism wears off. <x17> */        if (m->count > 1)        {            cmsg_add(color, str);            return;        }        if (string_length(m->msg) && strlen(str) > 1)            string_append_c(m->msg, ' ');        if (color != m->color)            string_printf(m->msg, "<color:%c>%s</color>", attr_to_attr_char(color), str);        else            string_append_s(m->msg, str);    }}

/* Similar, but calls the finalize fn with the pointer and the length,   as required by, e.g. munmap */value svec_wrap_cptr2(value cptr, value finalize, value lengthv){   value sv, buffv;  size_t len;  len = Long_val(lengthv) - sizeof(header_t) - sizeof(value);  if (jit_ffi_debug)      fprintf(stderr,"svec_wrap_cptr2: calling alloc_final: finalize=%p  buffer=%p(length=%ld[%d])./n",	      (void *) finalize,(void *)cptr,Long_val(lengthv),len);  sv = alloc_final(SvecSize + 1, &svec_finalize2 , SvecHeapSpace, MAX_FFI_ALLOC);  if (jit_ffi_debug)      fprintf(stderr,"svec_wrap_cptr2: calling mosml_ffi_alloc_wrap: buffer=%p(length=%d)./n",	      (void *)cptr,len);  buffv = (value) mosml_ffi_alloc_wrap((void *)cptr,len);  if (jit_ffi_debug)      fprintf(stderr,"svec_wrap_cptr2: initializing: finalize=%p  buffv=%p(length=%d[%ld])./n",	      (void *) finalize,(void *)buffv,len,string_length(buffv));  initialize((value *) Svec_val(sv), buffv);  initialize(&Field(sv,2), Val_long(len));  initialize(&Field(sv,3), finalize);  initialize(&Field(sv,4), Long_val(lengthv));  return sv;}

/** ** Get the w_Package for a class, creating it if it does not already exist. */w_package getPackageForClazz(w_clazz clazz, w_instance loader) {  w_string class_name = clazz->dotified;  w_instance effective_loader = loader ? loader : systemClassLoader;  w_hashtable ht = loader2packages(effective_loader);  w_string package_name;  w_int i;  w_int j;  w_package p;  for (i = 0; string_char(class_name, i) == '['; ++i);   for (j = string_length(class_name) - 1; string_char(class_name, j) != '.'; --j);   package_name = j > i ? w_substring(class_name, i, j - i) : registerString(string_empty);  ht_lock(ht);  p = (w_package)ht_read_no_lock(ht, (w_word)package_name);  if (!p) {    p = createPackage(package_name, effective_loader);    ht_write_no_lock(ht, (w_word)package_name, (w_word)p);  }  clazz->package = p;  ht_unlock(ht);  deregisterString(package_name);  return p;}

void exceptionCPU(t_nodo_proceso_ejecutando* procesoEjecutando,		struct pollfd** socketsCPU, int* cantSocketsCpu, t_datosEnviar* paquete){	t_pcb* pcb = unserializePCB(paquete->data);	char* textoError = malloc(paquete->data_size - sizeof(t_pcb));	memcpy(textoError, paquete->data + sizeof(t_pcb),			paquete->data_size - sizeof(t_pcb));	debugTrackPCP(			" Exception on the process with pid: %d, on the CPU  %d. Exception details: %s",			pcb->pid, procesoEjecutando->cpu.pid, textoError);	log_warning(log_kernel, "Exception on process. Exception details: %s",textoError);	procesoEjecutando->proceso.pcb = *pcb;	debugTrackPCP("Updating PCB.");	t_datosEnviar* mensaje = pedirPaquete(textoError,			PROGRAMA_PAQUETE_PARA_IMPRIMIR, string_length(textoError) + 1);	common_send(procesoEjecutando->proceso.soquet_prog, mensaje, NULL );	destruirPaquete(mensaje);	pcp_exitProcess(procesoEjecutando);	free(procesoEjecutando);	free(textoError);}

static INTVALPIO_unix_send(theINTERP, ParrotIOLayer *layer, ParrotIO * io, STRING *s){    int error, bytes, byteswrote, maxwrite;    bytes = string_length(s);    byteswrote = 0;    maxwrite = 2048;AGAIN:    /*     * Ignore encoding issues for now.     */    if((error = send(io->fd, (char *)PObj_bufstart(s) + byteswrote,                            PObj_buflen(s), 0)) >= 0) {        byteswrote += error;        if(byteswrote >= bytes) {            return byteswrote;        }        else if(bytes - byteswrote < maxwrite) {            maxwrite = bytes - byteswrote;        }        goto AGAIN;    }    else {        switch(errno) {            case EINTR:        goto AGAIN;#ifdef EWOULDBLOCK            case EWOULDBLOCK:  goto AGAIN;#else            case EAGAIN:       goto AGAIN;#endif            case EPIPE:        close(io->fd);                               return -1;            default:           return -1;        }    }}

obj basic_num_to_string_obj( obj a, unsigned radix ){    char buf[100];    if (FIXNUM_P(a)) {        return make_string( fixnum_to_string( &buf[100], a, radix ) );    } else if (LONGFLOAT_P(a)) {        snprintf( buf, 100, "%g", extract_float(a) );        if (!strchr( buf,'.') && !strchr(buf,'e')) {            strcat( buf, "." );        }        return make_string( buf );    } else if (OBJ_ISA_PTR_OF_CLASS(a,bignum_class)) {        return bignum_to_string_obj( a, radix );    } else if (OBJ_ISA_PTR_OF_CLASS(a,mp_rational_class)) {        return rational_to_string_obj( a, radix );    } else if (OBJ_ISA_PTR_OF_CLASS(a,rect_complex_class)) {        obj r;        char *str;        obj re = basic_num_to_string_obj( gvec_ref( a, SLOT(0) ), radix );        obj im = basic_num_to_string_obj( gvec_ref( a, SLOT(1) ), radix );        unsigned len = string_length(re) + string_length(im) + 1;        if (string_text(im)[0] != '-') {            len++;        }        r = bvec_alloc( len+1, string_class );        str = string_text( r );        memcpy( str, string_text( re ), string_length( re ) );        str += string_length( re );        if (string_text(im)[0] != '-') {            *str++ = '+';        }        memcpy( str, string_text( im ), string_length( im ) );        str += string_length( im );        *str++ = 'i';        *str = 0;        return r;    } else {        return FALSE_OBJ;    }}