Esempio n. 1
0
int			my_printf(int fd, char *str, ...)
{
  va_list	ap;
  t_fonct	*tab;
  t_print	pri;

  pri.fd = fd;
  tab = NULL;
  tab = init_struct(tab);
  pri.i = 0;
  if (str == NULL || tab == NULL)
    return (-1);
  va_start(ap, str);
  while (pri.i < my_strlen(str))
    {
      if (str[pri.i] == '%')
	pri.i = print_fct(ap, tab, str, pri);
      else
	my_putchar_in(fd, str[pri.i]);
      pri.i++;
    }
  va_end(ap);
  free(tab);
  return (0);
}
Esempio n. 2
0
double			ft_atof(char *num)
{
	t_atof		a;
	int			i;

	i = 0;
	if (!num || !*num)
		return (0);
	init_struct(&a);
	get_sign(&num, &a);
	while (num[i] != '\0')
	{
		if (num[i] >= '0' && num[i] <= '9')
			get_int(num[i], &a);
		else if (num[i] == '.')
		{
			if (a.fraction)
				return (a.sign * (a.integer_part + a.fraction_part
				/ a.divisor));
			else
				a.fraction = 1;
		}
		else
			return (a.sign * (a.integer_part + a.fraction_part / a.divisor));
		i++;
	}
	return (a.sign * (a.integer_part + a.fraction_part / a.divisor));
}
Esempio n. 3
0
void		pipe_in_list(char **tmp, t_list *list, int **pipe_fd, int nb_pipe)
{
  t_command	*command;
  int		fd[2];
  int		i;
  int		j;

  i = 0;
  j = 0;
  if ((command = malloc(sizeof(t_command))) == NULL)
    exit (0);
  init_struct(command);
  while (nb_pipe > 0)
    {
      add_pipe(pipe_fd, command, fd, j);
      command->data = my_str_to_wordtab(tmp[i++], ' ');
      my_insert_pushfront(list, command);
      command->input = fd[0];
      j += 2;
      nb_pipe -= 1;
    }
  command->output = -1;
  command->data = my_str_to_wordtab(tmp[i], ' ');
  my_insert_pushfront(list, command);
}
Esempio n. 4
0
int				main(int argc, char **argv)
{
	char		*line;
	t_check		check;
	t_cells		*cells;

	cells = NULL;
	line = NULL;
	FT_INIT(int, verif, 1);
	init_struct(&check, argc, argv);
	while (verif)
	{
		verif = get_next_line(0, &line);
		if (!check_lemin(line, &check, &cells))
		{
			ft_putstr("ERROR\n");
			free_chaine(&check.start_list, &check);
			return (-1);
		}
		if (verif)
		{
			ft_putendl(line);
			ft_memdel((void*)&line);
		}
	}
	free_chaine(&check.start_list, &check);
	return (1);
}
Esempio n. 5
0
int			main(int argc, char **argv)
{
	t_struck			s;
	t_pc				*proc;
	unsigned long long	i[3];

	if (argc == 1)
		ft_usage();
	init_struct(&s);
	proc = NULL;
	check_valid_file(&s, argv, 0);
	map_gen(&s, &proc, -1, i);
	s.pro = &proc;
	if (s.rep & GRAPH)
	{
		init_graph(&s);
		mlx_hook(s.img.win, 2, (1l << 0), key_functions, &s);
		mlx_hook(s.img.menu, 2, (1l << 0), key_functions, &s);
		s.rep ^= STOP;
		mlx_loop_hook(s.img.mlx, aff_graph, &s);
		mlx_loop(s.img.mlx);
	}
	else
		launching_vm(&s);
	return (0);
}
char		*fget_next_line(FILE *fd)
{
  t_struct	tbl;
  static char	buf[BUF_SIZE];
  static int	i = 0;
  static int	lu = 0;

  if (!init_struct(&tbl))
    return (0);
  while (1)
    {
      if (i >= lu)
	{
	  lu = (int)fread(buf, 1, BUF_SIZE, fd);
	  if (lu == 0)
	    return ((tbl.s[0]) ? (end_of(tbl.s, tbl.j)) : (0));
	  i = 0;
	}
      if ((tbl.j + 1) == tbl.taille)
	realloc_s(&tbl);
      if (buf[i] == '\n' || !buf[i])
	{
	  i++;
	  return (end_of(tbl.s, tbl.j));
	}
      tbl.s[tbl.j++] = buf[i++];
    }
}
Esempio n. 7
0
int		check_format(const char *format)
{
    t_struct	form;
    int			i;

    i = 0;
    init_struct(&form);
    while ((check_options(format[i], &form)) == 1)
        i++;
    while ((check_minimal_large(format[i], &form)) == 1)
        i++;
    if (format[i] == '.')
    {
        form.prec = 0;
        while ((check_precision(format[++i], &form)) == 1)
            continue;
    }
    while (format[i] == 'h' || format[i] == 'l' || format[i] == 'j'
            || format[i] == 'z')
    {
        check_size_modifier(format + i, &form);
        i++;
        if ((&form)->hh > 0 || (&form)->ll > 0)
            i++;
    }
    check_type(format[i]) == 1 ? (&form)->type = format[i] : 0;
    return (check_block(ft_strsub(format, 0, i + 1), &form));
}
Esempio n. 8
0
File: main.c Progetto: y0ja/ft_ls
int		main(int ac, char **av)
{
	t_params	p;
	t_dlist		*dirs_to_open;
	t_dlist		*nav;
	t_dlist		*dir_files;
	t_colors	*colors;

	dir_files = NULL;
	init_struct(&p);
	get_linked_lists(&dirs_to_open, &p, ac, av);
	nav = dirs_to_open;
	while (nav)
	{
		if (nav->before != NULL || nav->next != NULL)
			ft_print_twostr(nav->content, ":\n");
		get_da_list(&dir_files, &p, nav->content);
		if_forest_params(&dir_files, nav, &p, 1);
		ft_dlstdel(&dir_files, del_struct);
		if (nav->next)
			ft_putchar('\n');
		nav = nav->next;
	}
	ft_dlstdel(&nav, NULL);
	if (p.colors)
		free(p.colors_tab);
	return (0);
}
Esempio n. 9
0
void		init_lum_shadow(t_all *infos, t_object *object,
				t_pixel *pixel, t_eye *eye)
{
  t_spot	*tmp_spot;
  t_coord	pt_inter;
  t_coord	v_norm;
  t_eye		eye_tmp;
  double	shadow;

  init_struct(eye, &eye_tmp, &pt_inter, pixel);
  lum_shadow(infos, &pt_inter, object, pixel);
  tmp_spot = infos->spots;
  shadow = 0;
  while (tmp_spot != NULL)
    {
      new_eye_posi(&eye_tmp, tmp_spot, &pt_inter);
      if (calc_obj(infos->objects, object, &eye_tmp) > 0)
        shadow += ((double) WIN(tmp_spot->intensity, 0, 100)) / SHADOW_FACTOR;
      tmp_spot = tmp_spot->next;
    }
  set_shadows(pixel, &shadow);
  if (object->reflexion > 0 && ++infos->travels < TRAVEL_LIMIT)
    {
      calc_vector_n(object, &pt_inter, &v_norm);
      init_reflection(&eye_tmp, eye, &v_norm, &pt_inter);
      reflection(infos, object, pixel, &eye_tmp);
    }
}
Esempio n. 10
0
int main()
{
    // Allocate space for the structs
    struct point p1;
    struct point p2;
   
    // Initialize the structs by passing them to init_struct
    // Notice that we pass a pointer to init_struct 
    init_struct(&p1, 4, 5);
    init_struct(&p2, 6, 7); 

    // Print the values of p1 and p2:
    printf("P1's values: %d, %d\n", p1.x, p1.y);
    printf("P2's values: %d, %d\n", p2.x, p2.y);

    return 0;
}
int main() {

    init_struct(st, "This is str", 10, 20);

    func();

    printf("Use GDB\n");

    return 0;
}
Esempio n. 12
0
int				main(int argc, char **argv)
{
	t_cloud		data;

	init_struct(&data);
	if (argc != 2)
		error_fdf("fdf");
	parser(argv, &data);
	draw_points(data.start_node, &data);
    mlx_hook(data.win, 2, (1L << 0), distrib_key, &data);
	mlx_loop(data.mlx);
	return (0);
}
Esempio n. 13
0
int		init_value(t_all *all, char **tab)
{
  char		*str;

  if ((all->objects = malloc(sizeof(t_object) * get_size(tab))) == NULL)
    return (put_error_int("Error : malloc failed\n"));
  init_struct(all, get_size(tab));
  get_window(all, tab[0]);
  get_name(all, tab[1]);
  get_eye(all, tab[3]);
  init_get_object(all, tab + 5);
  init_get_light(all, tab + 5);
  /* printf("name %s eyex %G eyey%G eyez%G X%d Y%d\n", all->my.name, all->eye.x, all->eye.y, all->eye.z, all->my.x_size, all->my.y_size); */
}
Esempio n. 14
0
void add_after (nei_list* node, int rank, int coord_x, int coord_y, int bix, int bsx, int biy, int bsy){
  nei_list *nn = (nei_list*) malloc (sizeof(nei_list));
  if (nn != NULL){
  	nn->rank = rank;
    nn->point = init_struct(coord_x, coord_y);
    nn->inter = init_borne(bix, bsx, biy, bsy);

    nn->prev = node;
    nn->next = node->next;
    
    node->next->prev = nn;
    node->next = nn;
  }
}
Esempio n. 15
0
int		main(int ac, char **av)
{
	t_p4		*p4;

	p4 = NULL;
	if (error_usage(ac, av) == -1)
		return (-1);
	ft_putendl("\n\tWelcome to puissance 4");
	ft_putendl("");
	p4 = init_struct(p4, av);
	put_gameboard(p4);
	whoplaysfirst(p4);
	return (0);
}
Esempio n. 16
0
void	run(double nbMesures, double moyArith, double moyHarmo, double ecTy)
{
  bool		_end = false;
  t_variable	_var;
  t_result	_res;
  double	nbAdd = 0;
  int		n;
  char		p[SIZE_BUFFER];

  memset(p, '\0', SIZE_BUFFER);
  init_struct(&_var, &_res, nbMesures, moyArith, moyHarmo, ecTy);
  while (!_end)
    {
      nbAdd = write(1, "indtast din vaerdi : ", 21);
      n = read(0, p, SIZE_BUFFER - 1);
      p[n - 1] = '\0';
      if (n > 1 && n < SIZE_BUFFER)
	{
	  if (strncmp("ende", p, n) == 0)
	    _end = true;
	  else if (verif_number(p))
	    {
	      nbAdd = atof(p);
	      moy_arith(&_var, &_res, nbAdd);
	      moy_quadra(&_var, &_res, nbAdd);
	      moy_harmo(&_var, &_res, nbAdd);
	      ec_type(&_var, &_res, nbAdd);
	      printresult(&_res);
	      usleep(500);
	    }
	}
      memset(p, '\0', SIZE_BUFFER);
      init_struct(&_var, &_res, _res.newNbMesures, _res.newMoyArith,
		  _res.newMoyHarmo, _res.newEcTy);
    }
}
Esempio n. 17
0
File: main.c Progetto: YliesC/42sh
int		main(int ac, char **av, char **env)
{
  t_utils	utils;
  char		*path_history;

  ac = (int)ac;
  av = (char **)av;
  path_history = create_path_history();
  init_struct(&utils);
  add_history_to_list(&(utils.history));
  check_env(&utils, env);
  my_read(&utils);
  add_history_to_file(path_history, utils.history);
  my_free(&utils);
  return (utils.my_exit);
}
Esempio n. 18
0
static int init_rw_queue(struct zcopy_hash_table * zht, struct map_addr_info * addrinfo, pthread_mutex_t ** lock, int read)
{
	int err = -1;
	int i = 0;
	init_struct(zht, addrinfo);

	if(rw_disabled(read))
		return 0;

	addrinfo->map_size = read ? zc.rx_size : zc.wx_size ;
	addrinfo->ht_map_size = read ? zc.rx_ht_size : zc.wx_ht_size;
	addrinfo->map_flag = read ? ZCOPY_MAP_RX : ZCOPY_MAP_WX;
	addrinfo->ht_map_flag = read ? ZCOPY_MAP_HT_RX : ZCOPY_MAP_HT_WX;

	err = mmap_rw_mem(addrinfo);
	if(err)
		goto err;

	err = init_queue_info(zht, addrinfo, read);
	if(err)
		goto err;

	*lock = (pthread_mutex_t *)malloc(sizeof(pthread_mutex_t) * zc.thread_num);
	if(*lock == NULL)
	{
		E("lock malloc memory failed.\n");
		err = -1;
		goto err;
	}
	for(i = 0; i < zc.thread_num; ++i)
	{
		if((err = pthread_mutex_init(&(*lock)[i], NULL)) != 0)
		{
			E("pthread mutex init failed.\n");
			goto err;
		}
	}
	D("%s: skb_count %llu, hash_count %u, bucket_count_per_queue %u.\n", read ? "read" : "write", zht->ht->zkb_count, \
			zht->ht->hash_count, zht->ht->bucket_count_per_queue);

	return 0;
err:
	release_rw_mem(zht, addrinfo);
	return err;
}
Esempio n. 19
0
int			main(int ac, char **av)
{
  t_serv		serv;
  struct sockaddr_in	sin;
  struct sockaddr_in	csin;

  if (ac != 2)
    {
      write(2, "Usage : ./serveur port\n", 24);
      exit(EXIT_FAILURE);
    }
  serv.sin = &sin;
  serv.csin = &csin;
  serv.port = atoi(av[1]);
  init_serv(&serv, getprotobyname("TCP"));
  init_struct(&serv);
  get_clients(&serv);
  xclose(serv.s);
  return (EXIT_SUCCESS);
}
Esempio n. 20
0
/*-----------------------------------------------------------------------------------------------------------
 *
 * FUNCTION:               read_from_server
 *
 * PROGRAMMER/DESIGNER:    Martin Minkov
 *
 * INTERFACE:              void read_from_server(int msg_id, long clientPID)
 *                              int msg_id:     The ID of the message queue
 *                              long clientPID: The PID of the running client process     
 *
 * RETURNS:                void
 *
 * NOTES:                  Calls a blocking reading call on the message queue. Once data is read, the 
 *                         function will print any information to the user via the console. If the server
 *                         sends an error message or end of file message, the program will exit and
 *                         prompt the user for another file name.
 *
 * ---------------------------------------------------------------------------------------------------------*/
void read_from_server(int msg_id, long clientPID)
{
	long pid = clientPID, result, flag = 0;
	msgbuf *msg = { 0 };
	msg = init_struct(msg);

	while ((result = read_message (msg_id, pid, msg)) != -1)
	{
		printf("%s", msg->msg_data);
		if (((strstr(msg->msg_data, ERROR)) != NULL) || (msg->msg_done == 1))
		{
			flag = 1;
		}
		if (flag == 1)
		{
			free(msg);
			break;
		}
	}
}
int		init_value(t_all *all, char **tab)
{
  all->nb_obj = get_size(tab);
  if ((all->objects = malloc(sizeof(t_object) * get_size(tab))) == NULL)
    return (put_error_int("Error : malloc failed\n"));
  init_struct(all, get_size(tab));
  write(1, "\n", 1);
  get_window(all, tab[0]);
  write(1, "Z", 1);
  get_name(all, tab[1]);
  write(1, "Q", 1);
  get_eye(all, tab[3]);
  write(1, "S", 1);
  init_get_object(all, tab + 5);
  write(1, "D", 1);
  init_get_light(all, tab + 5);
  write(1, "W", 1);
  write(1, "\n", 1);
  return (0);
}
Esempio n. 22
0
int		mbis(int ac, char **av)
{
  t_rt		*core;

  render = 0;
  redraw = 0;
  if (!(core = my_xmalloc(sizeof(t_rt))))
    return (-1);
  core->cluster = 1;
  core->save = NULL;
  if (ac >= 3 && (check_save_opt(&av[2], core)))
    {
      free(core);
      return (-1);
    }
  if (init_struct(core, av[1]) == -1
      || mlx_node(core) == -1)
    return (1);
  free_rt(core);
  return (0);
}
Esempio n. 23
0
int				main(int argc, char **argv)
{
	t_stack	*stack;
	char	*tmp;
	int		size;

	if (argc < 2)
		error_fn(argv[0], 0);
	if (argc == 2)
		tmp = argv[1];
	if (argc > 2)
		tmp = get_string(argc, argv);
	check_string(tmp, argc);
	init_struct(&stack, tmp, argc);
	size = get_tab(tmp, stack);
	init_stack_b(stack, size);
	if ((size == 1 || check_sort_tab(stack, size) == 0))
		ft_putstr("");
	else
		size > 80 ? quick_sort(stack, size) : bubble_sort(stack, size);
	free_stack(stack);
	return (0);
}
Esempio n. 24
0
/*-----------------------------------------------------------------------------------------------------------
 *
 * FUNCTION:                main 
 *
 * PROGRAMMER/DESIGNER:     Martin Minkov
 *
 * INTERFACE:               int main(int argc, char* argv[])
 *
 * RETURNS:                 int - If the function failed or succeeded
 *
 * NOTES:                   Initializes the message queue that will be used for communication between the
 *                          client and server. If a user specified a command line argument, it is assumed
 *                          that they want higher priority, so the value will be stored in the message
 *                          data structure. 
 *
 * ---------------------------------------------------------------------------------------------------------*/
int main(int argc, char* argv[])
{
	int msg_id;
	key_t key = 0;
	
	msgbuf *msg = { 0 };
	msg = init_struct(msg);

	signal(SIGINT, cleanup_client); 
	//Check if priority was assigned
	if (argc == 2)
	{
		msg->msg_priority = atoi(argv[1]);
	}
	else
	{
		msg->msg_priority = 1;
	}
	//Create message queue
	msg_id = create_queue(key);

	read_file_name(msg_id, msg);
	return 0;
}
Esempio n. 25
0
int		main(int argc, char **argv)
{
	t_env	*env;

	if (argc > 1 && argc <= 3)
	{
		env = (t_env *)malloc(sizeof(t_env));
		if (ft_strcmp(argv[1], "/dev/random") == 0)
			return (0);
		read_that_file(argv[1], env);
		if (init_struct(env) == 0 || env->map == NULL )
		{
			ft_putstr("d1\n");
			return (0);
		}
		if (argc == 3)
			check_argv(argv[2], env);
		mlx_key_hook(env->win, ft_key_hook, env);
		mlx_expose_hook(env->win, expose_hook, env);
		mlx_do_sync(env->mlx);
		mlx_loop(env->mlx);
	}
	return (0);
}
Esempio n. 26
0
int 			main(int argc, char **argv)
{
    int 		fd;
    t_cloud 	data;
    t_node 		nodes;


    init_struct(&data);
    if (argc <= 1 || argc >= 3)
    	return (argc <= 1 ? error("Too few arguments")
    		: error("Too many arguments"));
	if (argc != 2)
    	return (error("Error parameters"));
    if ((fd = open(argv[1], O_RDONLY)) == -1)
    	return (error("Error open file"));
    if (!parser(fd, &data, &nodes))
    	return (error("Parsing Error"));
    close(fd);
    draw_points(data.start_node, &data);
    mlx_hook(data.win, 2, (1L << 0), distrib_key, &data);
 //   mlx_key_hook(data.win, distrib_key, &data);
	mlx_loop(data.mlx);
    return (0);
}
Esempio n. 27
0
// ------------------------------------------------------------------
// Funcion que realiza un post al WS
// ------------------------------------------------------------------
int PostToWS(const char *url, const char *postData, char result[2048])
{
	char tmp[1024];
	char tmpb[1024];
	int exitStatus = 0;
	CURL* curl;
	CURLcode res;	
	struct WritePOST wtext;
	struct ReadPOST rtext;
   init_struct(&rtext);	
	
	/* Headers */ 
	struct curl_slist *headers = NULL;
	headers = curl_slist_append(headers, "Accept: application/json");
	headers = curl_slist_append(headers, "Content-Type: application/json");
	headers = curl_slist_append(headers, "charsets: utf-8");
	// Parameters for call 
	wtext.ptr = postData;
	wtext.sizeleft = strlen(postData);
	/* Initialise libcurl */
	curl_global_init(CURL_GLOBAL_ALL);	
	/* Get a curl handle */
	curl = curl_easy_init(); 
	if(curl) 
	{
		//printf("%s", url);
		/* First set the URL that is about to receive our POST. */ 
		curl_easy_setopt(curl, CURLOPT_URL, url);
		curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
		/* Now specify we want to POST data */ 
		curl_easy_setopt(curl, CURLOPT_POST, 1L);
		/* we want to use our own read function */ 
		curl_easy_setopt(curl, CURLOPT_READFUNCTION, read_callback);
		/* pointer to pass to our read function */ 
		curl_easy_setopt(curl, CURLOPT_READDATA, &wtext);
		/* get verbose debug output please */ 
		//curl_easy_setopt(curl, CURLOPT_VERBOSE, 1L);
		/* Set the expected POST size. If you want to POST large amounts of data,
			consider CURLOPT_POSTFIELDSIZE_LARGE */ 
		curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, (curl_off_t)wtext.sizeleft);
		/* we want to use our own write function */ 
		curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_callback);
		/* pointer to pass to our write function */ 
		curl_easy_setopt(curl, CURLOPT_WRITEDATA, &rtext);
		/* Perform the request, res will get the return code */ 
		res = curl_easy_perform(curl);
		if(res) 
		{
			sprintf(tmp, "ERROR: %s", curl_easy_strerror(res));
			printf("%s\n", tmp);
			exitStatus = 0;
		}
		else
		{
			if(rtext.ptr != NULL)
			{
				if(strlen(rtext.ptr) > 0)
				{		
					sprintf(result, "%s", rtext.ptr);
					// Imprimir resultados del WS
					printf("\nA: %s\n", result);
				}
				else
				{
					printf("\nA: if(strlen(rtext.ptr) > 0) es falso");
				}
				free(rtext.ptr);				
			}
			exitStatus = 1;
		}
		/* always cleanup */ 
		curl_easy_cleanup(curl);
	}
	else 
	{
		exitStatus = 0;
	}
	/* Return the exit status */
	return exitStatus;
}
Esempio n. 28
0
int mat_fill_info (struct reglist * rl, mxArray ** D)
{
  int i;
  mxArray * map;
  mxArray * board;
  mxArray * regblock;
  mxArray * tmp;
  mxClassID mat_class;
  int numchan;

  init_struct (rl, D);

  for (i=0; i<rl->num_regblocks; i++)
  {
    map = mxGetField (*D, 0, rl->r[i].rb.map);
    if (map == NULL)
      return -1;
    board = mxGetField (map, 0, rl->r[i].rb.board);
    if (board == NULL)
      return -1;

    regblock = mxCreateStructMatrix(1, 1, sizeof(fieldnames)/sizeof(char *), fieldnames);

    switch (rl->r[i].rb.typeword & GCP_REG_TYPE)
    {
      case GCP_REG_UINT:
        tmp = mxCreateString("uint32");
        break;
      case GCP_REG_INT:
	tmp = mxCreateString("int32");
        break;
      case GCP_REG_USHORT:
        tmp = mxCreateString("uint16");
        break;
      case GCP_REG_SHORT:
        tmp = mxCreateString("int16");
        break;
      case GCP_REG_UCHAR:
	tmp = mxCreateString("uint8");
        break;
      case GCP_REG_CHAR:
	tmp = mxCreateString("int8");
        break;
      case GCP_REG_FLOAT:
	tmp = mxCreateString("single");
        break;
      case GCP_REG_DOUBLE:
	tmp = mxCreateString("double");
        break;

      /* Just treat UTC times as a UINT64, for now. */
      case GCP_REG_UTC:
	tmp = mxCreateString("utc");
        break;

      default: 
        PR ("Skipping register of type 0x%lx.\n", rl->r[i].rb.typeword & GCP_REG_TYPE);
	tmp = mxCreateString("unknown");
    }
    mxSetField (regblock, 0, "class", tmp);
    tmp = mxCreateDoubleScalar (rl->r[i].rb.spf);
    mxSetField (regblock, 0, "spf", tmp);
    tmp = mxCreateDoubleScalar (rl->r[i].rb.nchan);
    mxSetField (regblock, 0, "nchan", tmp);
    tmp = mxCreateLogicalScalar (rl->r[i].rb.spf > 1);
    mxSetField (regblock, 0, "is_fast", tmp);
    tmp = mxCreateLogicalScalar (rl->r[i].rb.do_arc);
    mxSetField (regblock, 0, "do_arc", tmp);

    mxSetField (board, 0, rl->r[i].rb.regblock, regblock);
  }
  return 0;
}