Пример #1
0
static int do_show(int argc, char **argv)
{
	DIR *dir;
	struct dirent *d;
	long flags, owner = -1, group = -1;

	dir = opendir("/sys/class/net");
	if (!dir) {
		perror("opendir");
		return -1;
	}
	while ((d = readdir(dir))) {
		if (d->d_name[0] == '.' &&
		    (d->d_name[1] == 0 || d->d_name[1] == '.'))
			continue;

		if (read_prop(d->d_name, "tun_flags", &flags))
			continue;

		read_prop(d->d_name, "owner", &owner);
		read_prop(d->d_name, "group", &group);

		printf("%s:", d->d_name);
		print_flags(flags);
		if (owner != -1)
			printf(" user %ld", owner);
		if (group != -1)
			printf(" group %ld", group);
		printf("\n");
	}
	closedir(dir);
	return 0;
}
Пример #2
0
/*
 * read_props reads either the full set of properties for instance 'instance'
 * (including defaults - pulling them in from inetd where necessary) if
 * 'instance' is non-null, else just the defaults from inetd. The properties
 * are returned in an allocated inetd_prop_t array, which must be freed
 * using free_instance_props(). If an error occurs NULL is returned and 'err'
 * is set to indicate the cause, else a pointer to the read properties is
 * returned.
 */
static inetd_prop_t *
read_props(scf_handle_t *h, const char *instance, size_t *num_elements,
    scf_error_t *err)
{
	inetd_prop_t	*ret = NULL;
	int		i;
	boolean_t	defaults_only = (instance == NULL);

	if ((ret = malloc(sizeof (inetd_properties))) == NULL) {
		*err = SCF_ERROR_NO_MEMORY;
		return (NULL);
	}
	(void) memcpy(ret, &inetd_properties, sizeof (inetd_properties));

	if (defaults_only)
		instance = INETD_INSTANCE_FMRI;
	for (i = 0; ret[i].ip_name != NULL; i++) {
		if (defaults_only && !ret[i].ip_default)
			continue;

		switch (*err = read_prop(h, &ret[i], i, instance,
		    defaults_only ? PG_NAME_SERVICE_DEFAULTS : ret[i].ip_pg)) {
		case 0:
			break;
		case SCF_ERROR_INVALID_ARGUMENT:
			goto failure_cleanup;
		case SCF_ERROR_NOT_FOUND:
			/*
			 * In non-default-only mode where we're reading a
			 * default property, since the property wasn't
			 * found in the instance, try and read inetd's default
			 * value.
			 */
			if (!ret[i].ip_default || defaults_only)
				continue;
			switch (*err = read_prop(h, &ret[i], i,
			    INETD_INSTANCE_FMRI, PG_NAME_SERVICE_DEFAULTS)) {
			case 0:
				ret[i].from_inetd = B_TRUE;
				continue;
			case SCF_ERROR_NOT_FOUND:
				continue;
			default:
				goto failure_cleanup;
			}
		default:
			goto failure_cleanup;
		}
	}

	*num_elements = i;
	return (ret);

failure_cleanup:
	free_instance_props(ret);
	return (NULL);
}
Пример #3
0
static void set_prop(gmx_atomprop_t aps, int eprop)
{
    gmx_atomprop *ap2           = (gmx_atomprop*) aps;
    const char   *fns[epropNR]  = { "atommass.dat", "vdwradii.dat", "dgsolv.dat", "electroneg.dat", "elements.dat" };
    double        fac[epropNR]  = { 1.0,    1.0,  418.4, 1.0, 1.0 };
    double        def[epropNR]  = { 12.011, 0.14, 0.0, 2.2, -1 };
    aprop_t      *ap;

    ap = &ap2->prop[eprop];
    if (!ap->bSet)
    {
        ap->db  = gmx_strdup(fns[eprop]);
        ap->def = def[eprop];
        read_prop(aps, eprop, fac[eprop]);

        if (debug)
        {
            fprintf(debug, "Entries in %s: %d\n", ap->db, ap->nprop);
        }

        if ( ( (!aps->bWarned) && (eprop == epropMass) ) || (eprop == epropVDW))
        {
            printf("\n"
                   "WARNING: Masses and atomic (Van der Waals) radii will be guessed\n"
                   "         based on residue and atom names, since they could not be\n"
                   "         definitively assigned from the information in your input\n"
                   "         files. These guessed numbers might deviate from the mass\n"
                   "         and radius of the atom type. Please check the output\n"
                   "         files if necessary.\n\n");
            aps->bWarned = TRUE;
        }
    }
}
Пример #4
0
static void set_prop(gmx_atomprop_t aps,int eprop) 
{
  gmx_atomprop *ap2 = (gmx_atomprop*) aps;
  const char *fns[epropNR]  = { "atommass.dat", "vdwradii.dat", "dgsolv.dat", "electroneg.dat", "elements.dat" };
  double fac[epropNR] = { 1.0,    1.0,  418.4, 1.0, 1.0 };
  double def[epropNR] = { 12.011, 0.14, 0.0, 2.2, -1 };
  aprop_t *ap;

  ap = &ap2->prop[eprop];
  if (!ap->bSet) {
    ap->db  = strdup(fns[eprop]);
    ap->def = def[eprop];
    read_prop(aps,eprop,fac[eprop]);
    
    if (debug)
      fprintf(debug,"Entries in %s: %d\n",ap->db,ap->nprop);

    if ( ( (!aps->bWarned) && (eprop == epropMass) ) || (eprop == epropVDW)) {
      printf("\n");
      printf("WARNING: masses and atomic (Van der Waals) radii will be determined\n");
      printf("         based on residue and atom names. These numbers can deviate\n");
      printf("         from the correct mass and radius of the atom type.\n");
      printf("\n");
      aps->bWarned = TRUE;
    }
  }
}
Пример #5
0
/*
 * Try and read each of the method properties for the method 'method' of
 * instance 'inst', and return a table containing all method properties. If an
 * error occurs, NULL is returned, with 'err' set to indicate the cause.
 * Otherwise, a pointer to an inetd_prop_t table is returned containing all
 * the method properties, and each of the properties is flagged according to
 * whether it was present or not, and if it was present its value is set in
 * the property's entry in the table.
 */
static inetd_prop_t *
read_method_props(const char *inst, instance_method_t method, scf_error_t *err)
{
	inetd_prop_t	*ret;
	int		i;

	debug_msg("Entering read_method_props");

	if ((ret = calloc(1, sizeof (method_props))) == NULL) {
		*err = SCF_ERROR_NO_MEMORY;
		return (NULL);
	}

	(void) memcpy(ret, method_props, sizeof (method_props));
	for (i = 0; ret[i].ip_name != NULL; i++) {
		*err = read_prop(rep_handle, &ret[i], i, inst,
		    methods[method].name);
		if ((*err != 0) && (*err != SCF_ERROR_NOT_FOUND)) {
			destroy_method_props(ret);
			return (NULL);
		}
	}

	return (ret);
}
Пример #6
0
string ConfigElem::read_string( const char *propname, const char *dflt ) const
{
    string temp;
    if (read_prop( propname, &temp))
        return temp;
    else
        return dflt;
}
int mnl_utl_load_property(MNL_CONFIG_T* prConfig)
{
    int idx;
    int cnt = sizeof(mnl_prop_path)/sizeof(mnl_prop_path[0]);
    int res = 0;
    for (idx = 0; idx < cnt; idx++)
    {
        if (!read_prop(prConfig, mnl_prop_path[idx]))
            break;
    }

    //Add for reading property set by YGPS
    char result[6] = {0};
    if(property_get(MNL_CONFIG_STATUS, result, NULL)){
       	prConfig->dbg2file = result[2] - '0';
      	MNL_MSG("dbg2file: %d\n", prConfig->dbg2file);
       	prConfig->debug_nmea = result[3] - '0';
       	MNL_MSG("debug_nmea:%d \n", prConfig->debug_nmea);
       	prConfig->BEE_enabled = result[4] - '0';
       	MNL_MSG("BEE_enabled: %d", prConfig->BEE_enabled);
       	//prConfig->test_mode = result[5] - '0';
       	//MNL_MSG("test_mode: %d", prConfig->test_mode);  
    }else{
        MNL_ERR("Config is not set yet, ignore");
    }
    
    

    MNL_MSG("========================================\n");
    if (idx < cnt) /*successfully read property from file*/  {
        MNL_MSG("[setting] reading from %s\n", mnl_prop_path[idx]);
        res = 0;
    } else {
        MNL_MSG("[setting] load default value\n");
        res = -1;
    }
    MNL_MSG("dev_dsp/dev_gps : %s %s\n", prConfig->dev_dsp, prConfig->dev_gps);
    MNL_MSG("init_speed/link_speed: %d %d\n", prConfig->init_speed, prConfig->link_speed);
    MNL_MSG("pmtk_conn/socket_port/dev_dbg : %d %d %s\n", prConfig->pmtk_conn, prConfig->socket_port, 
                             prConfig->dev_dbg);
    MNL_MSG("debug_nmea/debug_mnl: %d 0x%04X\n", prConfig->debug_nmea, prConfig->debug_mnl);
    MNL_MSG("nmea2file/dbg2file: %d/%d\n", prConfig->nmea2file, prConfig->dbg2file);
    MNL_MSG("time-out: %d %d %d %d %d %d\n", prConfig->timeout_init, prConfig->timeout_monitor, prConfig->timeout_wakeup,
                                    prConfig->timeout_ttff, prConfig->timeout_sleep, prConfig->timeout_pwroff);
    MNL_MSG("EPO_Enabled: %d\n", prConfig->EPO_enabled);
    MNL_MSG("BEE_Enabled: %d\n", prConfig->BEE_enabled);
    MNL_MSG("SUPL_Enabled: %d\n", prConfig->SUPL_enabled);
    MNL_MSG("SUPLSI_Enabled: %d\n", prConfig->SUPLSI_enabled);
    MNL_MSG("EPO_priority: %d\n", prConfig->EPO_priority);
    MNL_MSG("BEE_priority: %d\n", prConfig->BEE_priority);
    MNL_MSG("SUPL_priority: %d\n", prConfig->SUPL_priority);
    MNL_MSG("AVAILIABLE_AGE: %d", prConfig->AVAILIABLE_AGE);
    MNL_MSG("RTC_DRIFT: %d", prConfig->RTC_DRIFT);
    MNL_MSG("TIME_INTERVAL: %d", prConfig->TIME_INTERVAL);	
    MNL_MSG("========================================\n");
    return res;
}
Пример #8
0
string ConfigElem::read_string( const char *propname ) const
{
    string temp;
    if (read_prop( propname, &temp))
    {
        return temp;
    }
    else
    {
        prop_not_found( propname );
        return ""; // this is not reached, prop_not_found throws
    }
}
Пример #9
0
int elf_ppc64_load(int argc, char **argv, const char *buf, off_t len,
			struct kexec_info *info)
{
	struct mem_ehdr ehdr;
	char *cmdline, *modified_cmdline = NULL;
	const char *devicetreeblob;
	uint64_t max_addr, hole_addr;
	char *seg_buf = NULL;
	off_t seg_size = 0;
	struct mem_phdr *phdr;
	size_t size;
#ifdef NEED_RESERVE_DTB
	uint64_t *rsvmap_ptr;
	struct bootblock *bb_ptr;
#endif
	int result, opt;
	uint64_t my_kernel, my_dt_offset;
	uint64_t my_opal_base = 0, my_opal_entry = 0;
	unsigned int my_panic_kernel;
	uint64_t my_stack, my_backup_start;
	uint64_t toc_addr;
	uint32_t my_run_at_load;
	unsigned int slave_code[256/sizeof (unsigned int)], master_entry;

	/* See options.h -- add any more there, too. */
	static const struct option options[] = {
		KEXEC_ARCH_OPTIONS
		{ "command-line",       1, NULL, OPT_APPEND },
		{ "append",             1, NULL, OPT_APPEND },
		{ "ramdisk",            1, NULL, OPT_RAMDISK },
		{ "initrd",             1, NULL, OPT_RAMDISK },
		{ "devicetreeblob",     1, NULL, OPT_DEVICETREEBLOB },
		{ "dtb",                1, NULL, OPT_DEVICETREEBLOB },
		{ "args-linux",		0, NULL, OPT_ARGS_IGNORE },
		{ 0,                    0, NULL, 0 },
	};

	static const char short_options[] = KEXEC_OPT_STR "";

	if (info->file_mode)
		return elf_ppc64_load_file(argc, argv, info);

	/* Parse command line arguments */
	initrd_base = 0;
	initrd_size = 0;
	cmdline = 0;
	ramdisk = 0;
	devicetreeblob = 0;
	max_addr = 0xFFFFFFFFFFFFFFFFULL;
	hole_addr = 0;

	while ((opt = getopt_long(argc, argv, short_options,
					options, 0)) != -1) {
		switch (opt) {
		default:
			/* Ignore core options */
			if (opt < OPT_ARCH_MAX)
				break;
		case OPT_APPEND:
			cmdline = optarg;
			break;
		case OPT_RAMDISK:
			ramdisk = optarg;
			break;
		case OPT_DEVICETREEBLOB:
			devicetreeblob = optarg;
			break;
		case OPT_ARGS_IGNORE:
			break;
		}
	}

	if (!cmdline)
		fprintf(stdout, "Warning: append= option is not passed. Using the first kernel root partition\n");

	if (ramdisk && reuse_initrd)
		die("Can't specify --ramdisk or --initrd with --reuseinitrd\n");

	/* Need to append some command line parameters internally in case of
	 * taking crash dumps.
	 */
	if (info->kexec_flags & KEXEC_ON_CRASH) {
		modified_cmdline = xmalloc(COMMAND_LINE_SIZE);
		memset((void *)modified_cmdline, 0, COMMAND_LINE_SIZE);
		if (cmdline) {
			strncpy(modified_cmdline, cmdline, COMMAND_LINE_SIZE);
			modified_cmdline[COMMAND_LINE_SIZE - 1] = '\0';
		}
	}

	/* Parse the Elf file */
	result = build_elf_exec_info(buf, len, &ehdr, 0);
	if (result < 0) {
		free_elf_info(&ehdr);
		return result;
	}

	/* Load the Elf data. Physical load addresses in elf64 header do not
	 * show up correctly. Use user supplied address for now to patch the
	 * elf header
	 */

	phdr = &ehdr.e_phdr[0];
	size = phdr->p_filesz;
	if (size > phdr->p_memsz)
		size = phdr->p_memsz;

	my_kernel = hole_addr = locate_hole(info, size, 0, 0, max_addr, 1);
	ehdr.e_phdr[0].p_paddr = hole_addr;
	result = elf_exec_load(&ehdr, info);
	if (result < 0) {
		free_elf_info(&ehdr);
		return result;
	}

	/* If panic kernel is being loaded, additional segments need
	 * to be created.
	 */
	if (info->kexec_flags & KEXEC_ON_CRASH) {
		result = load_crashdump_segments(info, modified_cmdline,
						max_addr, 0);
		if (result < 0)
			return -1;
		/* Use new command line. */
		cmdline = modified_cmdline;
	}

	/* Add v2wrap to the current image */
	elf_rel_build_load(info, &info->rhdr, purgatory,
				purgatory_size, 0, max_addr, 1, 0);

	/* Add a ram-disk to the current image
	 * Note: Add the ramdisk after elf_rel_build_load
	 */
	if (ramdisk) {
		if (devicetreeblob) {
			fprintf(stderr,
			"Can't use ramdisk with device tree blob input\n");
			return -1;
		}
		seg_buf = slurp_file(ramdisk, &seg_size);
		hole_addr = add_buffer(info, seg_buf, seg_size, seg_size,
			0, 0, max_addr, 1);
		initrd_base = hole_addr;
		initrd_size = seg_size;
	} /* ramdisk */

	if (devicetreeblob) {
		/* Grab device tree from buffer */
		seg_buf = slurp_file(devicetreeblob, &seg_size);
	} else {
		/* create from fs2dt */
		create_flatten_tree(&seg_buf, &seg_size, cmdline);
	}

	result = fixup_dt(&seg_buf, &seg_size);
	if (result < 0)
		return result;

	my_dt_offset = add_buffer(info, seg_buf, seg_size, seg_size,
				0, 0, max_addr, -1);

#ifdef NEED_RESERVE_DTB
	/* patch reserve map address for flattened device-tree
	 * find last entry (both 0) in the reserve mem list.  Assume DT
	 * entry is before this one
	 */
	bb_ptr = (struct bootblock *)(seg_buf);
	rsvmap_ptr = (uint64_t *)(seg_buf + be32_to_cpu(bb_ptr->off_mem_rsvmap));
	while (*rsvmap_ptr || *(rsvmap_ptr+1))
		rsvmap_ptr += 2;
	rsvmap_ptr -= 2;
	*rsvmap_ptr = cpu_to_be64(my_dt_offset);
	rsvmap_ptr++;
	*rsvmap_ptr = cpu_to_be64((uint64_t)be32_to_cpu(bb_ptr->totalsize));
#endif

	if (read_prop("/proc/device-tree/ibm,opal/opal-base-address",
		      &my_opal_base, sizeof(my_opal_base)) == 0) {
		my_opal_base = be64_to_cpu(my_opal_base);
		elf_rel_set_symbol(&info->rhdr, "opal_base",
				   &my_opal_base, sizeof(my_opal_base));
	}

	if (read_prop("/proc/device-tree/ibm,opal/opal-entry-address",
		      &my_opal_entry, sizeof(my_opal_entry)) == 0) {
		my_opal_entry = be64_to_cpu(my_opal_entry);
		elf_rel_set_symbol(&info->rhdr, "opal_entry",
				   &my_opal_entry, sizeof(my_opal_entry));
	}

	/* Set kernel */
	elf_rel_set_symbol(&info->rhdr, "kernel", &my_kernel, sizeof(my_kernel));

	/* Set dt_offset */
	elf_rel_set_symbol(&info->rhdr, "dt_offset", &my_dt_offset,
				sizeof(my_dt_offset));

	/* get slave code from new kernel, put in purgatory */
	elf_rel_get_symbol(&info->rhdr, "purgatory_start", slave_code,
			sizeof(slave_code));
	master_entry = slave_code[0];
	memcpy(slave_code, phdr->p_data, sizeof(slave_code));
	slave_code[0] = master_entry;
	elf_rel_set_symbol(&info->rhdr, "purgatory_start", slave_code,
				sizeof(slave_code));

	if (info->kexec_flags & KEXEC_ON_CRASH) {
		my_panic_kernel = 1;
		/* Set panic flag */
		elf_rel_set_symbol(&info->rhdr, "panic_kernel",
				&my_panic_kernel, sizeof(my_panic_kernel));

		/* Set backup address */
		my_backup_start = info->backup_start;
		elf_rel_set_symbol(&info->rhdr, "backup_start",
				&my_backup_start, sizeof(my_backup_start));

		/* Tell relocatable kernel to run at load address
		 * via word before slave code in purgatory
		 */

		elf_rel_get_symbol(&info->rhdr, "run_at_load", &my_run_at_load,
				sizeof(my_run_at_load));
		if (my_run_at_load == KERNEL_RUN_AT_ZERO_MAGIC)
			my_run_at_load = 1;
			/* else it should be a fixed offset image */
		elf_rel_set_symbol(&info->rhdr, "run_at_load", &my_run_at_load,
				sizeof(my_run_at_load));
	}

	/* Set stack address */
	my_stack = locate_hole(info, 16*1024, 0, 0, max_addr, 1);
	my_stack += 16*1024;
	elf_rel_set_symbol(&info->rhdr, "stack", &my_stack, sizeof(my_stack));

	/* Set toc */
	toc_addr = my_r2(&info->rhdr);
	elf_rel_set_symbol(&info->rhdr, "my_toc", &toc_addr, sizeof(toc_addr));

	/* Set debug */
	elf_rel_set_symbol(&info->rhdr, "debug", &my_debug, sizeof(my_debug));

	my_kernel = 0;
	my_dt_offset = 0;
	my_panic_kernel = 0;
	my_backup_start = 0;
	my_stack = 0;
	toc_addr = 0;
	my_run_at_load = 0;
	my_debug = 0;
	my_opal_base = 0;
	my_opal_entry = 0;

	elf_rel_get_symbol(&info->rhdr, "opal_base", &my_opal_base,
			   sizeof(my_opal_base));
	elf_rel_get_symbol(&info->rhdr, "opal_entry", &my_opal_entry,
			   sizeof(my_opal_entry));
	elf_rel_get_symbol(&info->rhdr, "kernel", &my_kernel, sizeof(my_kernel));
	elf_rel_get_symbol(&info->rhdr, "dt_offset", &my_dt_offset,
				sizeof(my_dt_offset));
	elf_rel_get_symbol(&info->rhdr, "run_at_load", &my_run_at_load,
				sizeof(my_run_at_load));
	elf_rel_get_symbol(&info->rhdr, "panic_kernel", &my_panic_kernel,
				sizeof(my_panic_kernel));
	elf_rel_get_symbol(&info->rhdr, "backup_start", &my_backup_start,
				sizeof(my_backup_start));
	elf_rel_get_symbol(&info->rhdr, "stack", &my_stack, sizeof(my_stack));
	elf_rel_get_symbol(&info->rhdr, "my_toc", &toc_addr,
				sizeof(toc_addr));
	elf_rel_get_symbol(&info->rhdr, "debug", &my_debug, sizeof(my_debug));

	dbgprintf("info->entry is %p\n", info->entry);
	dbgprintf("kernel is %llx\n", (unsigned long long)my_kernel);
	dbgprintf("dt_offset is %llx\n",
		(unsigned long long)my_dt_offset);
	dbgprintf("run_at_load flag is %x\n", my_run_at_load);
	dbgprintf("panic_kernel is %x\n", my_panic_kernel);
	dbgprintf("backup_start is %llx\n",
		(unsigned long long)my_backup_start);
	dbgprintf("stack is %llx\n", (unsigned long long)my_stack);
	dbgprintf("toc_addr is %llx\n", (unsigned long long)toc_addr);
	dbgprintf("purgatory size is %zu\n", purgatory_size);
	dbgprintf("debug is %d\n", my_debug);
	dbgprintf("opal_base is %llx\n", (unsigned long long) my_opal_base);
	dbgprintf("opal_entry is %llx\n", (unsigned long long) my_opal_entry);

	return 0;
}
Пример #10
0
/**
	Open a CSV file and parse it as
 **/
int csv_reader::open(const char *file){
	char line[1024];
	char filename[128];
	int has_cols = 0;
	int linenum = 0;
	int i = 0;
	OBJECT *obj = OBJECTHDR(this);
	weather *wtr = 0;

	if(file == 0){
		gl_error("csv_reader has no input file name!");
		/* TROUBLESHOOT
			No input file was specified for the csv_reader object.  Double-check the
			input model and re-run GridLAB-D.
		*/
		return 0;
	}

	strncpy(filename, file, 127);
	infile = fopen(filename, "r");
	if(infile == 0){
		gl_error("csv_reader could not open \'%s\' for input!", file);
		/* TROUBLESHOOT
			The specified input file could not be opened for reading.  Verify that no
			other applications are using that file, double-check the input model, and
			re-run GridLAB-D.
		*/
		return 0;
	}

	if(columns_str[0] != 0){
		if(0 == read_header(columns_str)){
			gl_error("csv_reader::open ~ column header read failure from explicit headers");
			return 0;
		} else {
			has_cols = 1;
		}
	}
	while(fgets(line, 1024, infile) > 0){
		++linenum;
		// consume leading whitespace?
		// comments following valid lines?
		size_t _len = strlen(line);
		if(line[0] == '#'){	// comment
			continue;
		}
		else if(strlen(line) < 1){
			continue; // blank line
		}
		else if(line[0] == '$'){	// property
			if(0 == read_prop(line+1)){
				gl_error("csv_reader::open ~ property read failure on line %i", linenum);
				return 0;
			} else {
				continue;
			}
		}
		else if(has_cols == 0){
			if(0 == read_header(line)){
				gl_error("csv_reader::open ~ column header read failure on line %i", linenum);
				return 0;
			} else {
				has_cols = 1;
			}
		} else {
			if(0 == read_line(line)){
				gl_error("csv_reader::open ~ data line read failure on line %i", linenum);
				return 0;
			} else {
				++sample_ct;
			}
		}
	}

	/* move list into double pointer */
	samples = (weather**)malloc(sizeof(weather *) * (size_t) sample_ct);
	for(i = 0, wtr = weather_root; i < sample_ct && wtr != NULL; ++i, wtr=wtr->next){
		samples[i] = wtr;
	}
	sample_ct = i; // if wtr was the limiting factor, truncate the count

//	index = -1;	// forces to start on zero-eth index

	// post-process
	// calculate object lat/long
	obj->latitude = lat_deg + (lat_deg > 0 ? lat_min : -lat_min) / 60;
	obj->longitude = long_deg + (long_deg > 0 ? long_min : -long_min / 60);

	return 1;
}