int run(int argc, char *argv[])
    {
        po::positional_options_description p;
        p.add("input", -1);

        try {
            po::store(po::command_line_parser(argc,
                        argv).options(desc).positional(p).run(), vm);
            po::notify(vm);

            if (vm.count("manager"))
                *manager_mode = true;

            if (vm.count("input"))
                *args = vm["input"].as < CmdArgs >();

            if (vm.count("log-file"))
                *trace = 0;

            if (vm.count("log-stdout"))
                *trace = 1;

            if (vm.count("help"))
                return show_help(generic);

            if (vm.count("version"))
                return show_version();

            if (vm.count("infos"))
                return show_infos();

            if (vm.count("list"))
                return show_package_list();

            if (vm.count("restart"))
                return remove_configuration_file();

            if (vm.count("package"))
                return PROGRAM_OPTIONS_PACKAGE;

            if (vm.count("remote"))
                return PROGRAM_OPTIONS_REMOTE;

            if (vm.count("config"))
                return PROGRAM_OPTIONS_CONFIG;
        } catch (const std::exception &e) {
            std::cerr << e.what() << std::endl;

            return PROGRAM_OPTIONS_FAILURE;
        }

        std::cerr << _("Nothing to do. Use package, remote or config mode."
                " See the help.\n");

        return PROGRAM_OPTIONS_END;
    }

int main(int argc, char ** argv)
{
#ifdef ENABLE_GETTEXT
	setlocale(LC_ALL, "");
	bindtextdomain(PACKAGE_NAME, LOCALEDIR);
#endif

	static struct option longopts[] =
	{
		{ "version", no_argument, NULL, 'v' },
		{ "help", no_argument, NULL, 'h' },
		{ "input", required_argument, NULL, 'i' },
		{ "output", required_argument, NULL, 'o' },
		{ "config", required_argument, NULL, 'c' },
		{ 0, 0, 0, 0 },
	};

	static int oc;
	static char *input_file, *output_file, *config_file;

	while((oc = getopt_long(argc, argv, "vh?i:o:c:", longopts, NULL)) != -1)
	{
		switch (oc)
		{
		case 'v':
			show_version();
			return 0;
		case 'h':
		case '?':
			show_usage();
			return 0;
		case 'i':
			input_file = mstrcpy(optarg);
			break;
		case 'o':
			output_file = mstrcpy(optarg);
			break;
		case 'c':
			config_file = mstrcpy(optarg);
			break;
		}
	}

	if (config_file == NULL)
	{
		config_file = mstrcpy(OPENCC_DEFAULT_CONFIG_SIMP_TO_TRAD);
	}

	convert(input_file, output_file, config_file);

	free(input_file);
	free(output_file);
	free(config_file);

	return 0;
}

static void get_options(int argc, char **argv, const char *progname)
{
	char c;

	while((c = getopt(argc, argv, "d:r:s:k:w:f:o:vh")) != (char) -1) {
		switch (c) {
		case 'r':
			repeat_filename = optarg;
			break;
		case 's':
			if(*optarg == 'd') {
				rectangle_size = -1;
				max_mem_kb = strtol(optarg + 1, 0, 10);
				if(max_mem_kb <= 0)
					max_mem_kb = ULONG_MAX;
			} else
				rectangle_size = atoi(optarg);
			if(rectangle_size == 0) {
				fprintf(stderr, "Invalid rectangle size %s\n", optarg);
				exit(1);
			}
			break;
		case 'k':
			kmer_size = atoi(optarg);
			break;
		case 'w':
			window_size = atoi(optarg);
			break;
		case 'o':
			output_filename = optarg;
			break;
		case 'd':
			debug_flags_set(optarg);
			break;
		case 'v':
			show_version(progname);
			exit(0);
		case 'h':
			show_help(progname);
			exit(0);
		}
	}

	if(argc - optind == 1) {
		sequence_filename = argv[optind++];
	} else if(argc - optind == 2) {
		sequence_filename = argv[optind++];
		second_sequence_filename = argv[optind++];
	} else {
		show_help(progname);
		fprintf(stderr, "Incorrect number of arguments. Expected 1 or 2, got %d\n", argc - optind);
		exit(1);
	}

}

static kbool_t konoha_shell(konoha_t konoha)
{
	void *handler = dlopen("libreadline" K_OSDLLEXT, RTLD_LAZY);
	void *f = (handler != NULL) ? dlsym(handler, "readline") : NULL;
	kreadline = (f != NULL) ? (char* (*)(const char*))f : readline;
	f = (handler != NULL) ? dlsym(handler, "add_history") : NULL;
	kadd_history = (f != NULL) ? (int (*)(const char*))f : add_history;
	show_version((CTX_t)konoha);
	shell((CTX_t)konoha);
	return true;
}

void
show_usage (char *my_name)
{
    show_version (my_name);
    fprintf (stderr, "\nusage: %s [options] port1 port2\n", my_name);
    fprintf (stderr, "Connects two JACK ports together.\n\n");
    fprintf (stderr, "        -s, --server <name>   Connect to the jack server named <name>\n");
    fprintf (stderr, "        -v, --version         Output version information and exit\n");
    fprintf (stderr, "        -h, --help            Display this help message\n\n");
    fprintf (stderr, "For more information see http://jackaudio.org/\n");
}

int main(int argc, char **argv)
{
        MalelfDissect dissect;
        MalelfInfect infect;
        Disas disas;
        Database database;
        Analyse analyse;
        _u8 error = MALELF_SUCCESS;

        if (argc == 1) {
                _malelf_help();
                return -1;
        }

        if (strncmp(argv[1], DISSECT, sizeof(DISSECT)) == 0) {
                error = malelf_dissect_init(&dissect, argc, argv);
                malelf_dissect_finish(&dissect);
        } else if (strncmp(argv[1],
                           SHELLCODE,
                           sizeof (SHELLCODE)) == 0) {
                malelf_shellcode_init(argc, argv);
                malelf_shellcode_finish();
        } else if (strncmp(argv[1], INFECT, sizeof(INFECT)) == 0) {
                malelf_infect_init(&infect, argc, argv);
                malelf_infect_finish(&infect);
        } else if (strncmp(argv[1], DYNAMIC_ANALYSIS, sizeof(DYNAMIC_ANALYSIS)) == 0) {
                malelf_dynanalyse_init(argc, argv);
                malelf_dynanalyse_finish();
        } else if (strncmp(argv[1], DISAS, sizeof(DISAS)) == 0) {
                disas_init(&disas, argc, argv);
                disas_finish(&disas);
        } else if (strncmp(argv[1], DATABASE, sizeof(DATABASE)) == 0) {
                database_init(&database, argc, argv);
                database_finish(&database);
        } else if (strncmp(argv[1], ANALYSE, sizeof(ANALYSE)) == 0) {
                error = analyse_init(&analyse, argc, argv);
                analyse_finish(&analyse);
        } else if (strncmp(argv[1], "-v", 2) ||
                   strncmp(argv[1], "--version", 9)) {
                show_version(*argv);
        } else {
                _malelf_help();
        }

        if (MALELF_SUCCESS != error) {
                if (MALELF_ERROR != error) {
                        MALELF_PERROR(error);
                }

                return error;
        }

        return 0;
}

int
main(int nArgc, char* Argv[]){
	time_t	nStartTm, nEndTm;
	int	nRet;

	g_logFile = fopen("log.txt", "a");
	if ( g_logFile == NULL ){
		write_log(LT_SCREEN,"Error: Can't open log file!\n");
		goto exit;
	}

	nStartTm = time(NULL);
	if ( nArgc == 1 ){
		write_log(LT_SCREEN,"Error: the number of argument is error\n");
		goto exit;
	}
	else if ( nArgc == 2 ){
		if ( strcmp(Argv[1], "-h") == 0 ){
			show_help();
			return 0;
		}
		else if ( strcmp(Argv[1], "-v") == 0 ){
			show_version();
			return 0;
		}
		else {
			write_log(LT_SCREEN,"Error: invalid option '%s'\n", Argv[1]);			
			goto exit;
		}
	}
	
	if (Exec_Command(Argv) == 0)
		goto exit;
	
	nRet = 0;
	goto exit2;
 exit:
	nRet = 1;
	write_log(LT_SCREEN,"Please add '-h' option to get the detail help!\n");

 exit2:
	nEndTm = time(NULL);
	write_log(LT_BOTH,"\n--------------------------------------------------------\n");
	write_log(LT_BOTH,"Task end, total use time: %d min, %d sec\n",
	       (int)(nEndTm - nStartTm)/60, (int)(nEndTm - nStartTm)%60);

	db_uninit();
	str_operate_uninit();

	SAFE_CLOSE_FILE(g_logFile);

	return nRet;
}

int main(int argc, char **argv) {
  int fin, res;
  off_t position;

  int optc;
  int optindex=0;

  struct option optvalues[] = {
    {"help", 0, 0, 'h'},
    {"version", 0, 0, 'v'},
    {NULL, 0, NULL, 0}
  };

  if (argc < 2 || argc > 3) {
    usage("Missing or bad options/arguments");
    exit(-1);
  }

  while (1) {
    optc=getopt_long_only(argc,argv,"hv", optvalues, &optindex);
    if (optc=='h')
      usage(NULL);
    else if (optc=='v')
      show_version(VERSION);
    else if (optc==-1) break;
    else usage("Unknown option or other error\n");
  }

  if (optind >= argc) {
    usage("Missing filename argument.");
  }

  fin = open (argv[optind], O_RDONLY);
  if (fin < 0) {
    fprintf(stderr,"failed to open file %s for read\n", argv[optind]);
    exit(-1);
  }
  optind++;
  if (optind >= argc) {
    usage("Missing offset argument.");
  }
  position = atoll(argv[optind]);
  if (position <(off_t)0) {
    fprintf(stderr,"please specify an offset >= 0.\n");
    fprintf(stderr,"usage: %s infile offset\n", argv[0]);
    exit(-1);
  }
  /* input file, starting position in file, length of buffer for reading */
  res = dump_mw_header(fin);

  res = dump_from_first_page_id_after_offset(fin, position);
  exit(res);
}

static void show_help(void)
{
	show_version();
	fprintf(stderr,
		"-h --help      -  show this text and exit\n"
		"-v --version   -  show version and exit\n"
		"-r --reader    -  the reader to use\n"
		"-w --wait      -  wait for a card to be inserted\n"
		"-p --print     -  print the datafile\n"
		"-t --stats     -  show usage counts of keys\n"
		"-x --exec      -  execute a program with data in env vars.\n");
}

void show_usage()
{
	show_version();
	printf(_("Usage:\n"));
	printf(_("  opencc_dict -i input_file -o output_file\n\n"));
	printf(_("    -i input_file\n"));
	printf(_("      Read data from input_file.\n"));
	printf(_("    -o output_file\n"));
	printf(_("      Write converted data to output_file.\n"));
	printf(_("\n"));
	printf(_("\n"));
}

static void show_version_full (void)
{
    write_log ("\n");
    show_version ();
    write_log ("\nCopyright 1995-2002 Bernd Schmidt\n");
    write_log ("          1999-2005 Toni Wilen\n");
    write_log ("          2003-2005 Richard Drummond\n\n");
    write_log ("See the source for a full list of contributors.\n");

    write_log ("This is free software; see the file COPYING for copying conditions.  There is NO\n");
    write_log ("warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n");
}

int main(int argc, char *argv[])
{
	int c, lpnumber;
	char *p;

	if (argc <= 0)		/* in case not provided in (x)inetd config */
		progname = "p910nd";
	else {
		progname = argv[0];
		if ((p = strrchr(progname, '/')) != 0)
			progname = p + 1;
	}
	lpnumber = '0';
	while ((c = getopt(argc, argv, "bi:f:v")) != EOF) {
		switch (c) {
		case 'b':
			bidir = 1;
			break;
		case 'f':
			device = optarg;
			break;
		case 'i':
			bindaddr = optarg;
			break;
		case 'v':
			show_version();
			break;
		default:
			usage();
			break;
		}
	}
	argc -= optind;
	argv += optind;
	if (argc > 0) {
		if (isdigit(argv[0][0]))
			lpnumber = argv[0][0];
	}
	/* change the n in argv[0] to match the port so ps will show that */
	if ((p = strstr(progname, "p910n")) != NULL)
		p[4] = lpnumber;

	/* We used to pass (LOG_PERROR|LOG_PID|LOG_LPR|LOG_ERR) to syslog, but
	 * syslog ignored the LOG_PID and LOG_PERROR option.  I.e. the intention
	 * was to add both options but the effect was to have neither.
	 * I disagree with the intention to add PERROR.  --Stef  */
	openlog(p, LOG_PID, LOG_LPR);
	if (is_standalone())
		server(lpnumber);
	else
		one_job(lpnumber);
	return (0);
}

static void
show_help (void)
{
	show_version ();
	
	printf ("-c --cpuusage		Display CPU usage.\n");
	printf ("-d --debug		Display debugging output.\n");
	printf ("-F --farenheit		Display temperature in farenheit.\n");
	printf ("-h --help		Display this help.\n");
	printf ("-i[FILE] --icon[=FILE]	Set the icon filename, or disable the icon.\n");
	printf ("-v --version		Display version information.\n");

	printf ("\nLong options may be passed with a single dash.\n\n");
}

void slave_get_options (int *argc,char ***argv, int *force, struct slave_database *sdb) {
    int opt;
    char *hour,*min;

    while ((opt = getopt (*argc,*argv,"a:n:fl:c:ohv")) != -1) {
        switch (opt) {
        case 'a':
            sdb->limits.autoenable.flags |= AEF_ACTIVE;
            hour = optarg;
            if ((min = strchr (hour,':')) == NULL) {
                usage ();
                exit (1);
            }
            *min = '\0';
            min++;
            sdb->limits.autoenable.h = atoi (hour) % 24;
            sdb->limits.autoenable.m = atoi (min) % 60;
            printf ("Autoenable time from command line: %02i:%02i\n",sdb->limits.autoenable.h,sdb->limits.autoenable.m);
            break;
        case 'n':
            sdb->limits.nmaxcpus = atoi (optarg);
            sdb->flags |= SDBF_SETMAXCPUS;
            break;
        case 'c':
            strncpy(sdb->conf,optarg,PATH_MAX-1);
            printf ("Reading config file from: '%s'\n",sdb->conf);
            break;
        case 'f':
            *force = 1;
            fprintf (stderr,"WARNING: Forcing usage of pre-existing shared memory (-f). Do not do this unless you really know what it means.\n");
            break;
        case 'l':
            log_level_severity_set (atoi(optarg));
            printf ("Logging level set to: %s\n",log_level_str(loglevel));
            break;
        case 'o':
            log_level_out_set (L_ONSCREEN);
            printf ("Logging on screen.\n");
            break;
        case 'v':
            show_version (*argv);
            exit (0);
        case '?':
        case 'h':
            usage();
            exit (0);
        }
    }
}

int main(int argc, char *argv[]) 
{
#if defined(_WIN32) || defined(__CYGWIN__)
	const char * port = "COM1";
#else
	const char * port = "/dev/ttyS11";
#endif
	int fcnt;
	char * fnam[64];
	extern char *optarg;	/* getopt */
	extern int optind;	/* getopt */
	int c;

	/* the program name start just after the last slash */
	if ((progname = (char *)strrchr(argv[0], '/')) == NULL)
		progname = argv[0];
	else
		progname++;

	/* parse the command line options */
	while ((c = getopt(argc, argv, "dvhp:")) > 0) {
		switch (c) {
		case 'v':
			show_version();
			return 0;
		case 'h':
			show_usage();
			return 1;
		case 'p':
			port = optarg;
			break;
		default:
			parse_err(optarg);
			return 2;
		}
	}

	if (optind < argc) {
		fcnt = 0;
		do {
			fnam[fcnt++] = argv[optind];
			optind++;
		} while (optind < argc);

		return ymodem_send(port, fcnt, fnam); 
	}

	return ymodem_recv(port); 
}

/*
 * Description: Displays the various available commands.
 */
static void show_usage ()
{
  int	   i ;

  show_version() ;

  printf( "Available Commands are:\n\n" ) ;

  for	( i = 0; i < tLength; i++ )
	{
	  printf( "\t%c  %-15s  %-30s\n", myCmdStruct[i].c
				  	, myCmdStruct[i].string
				  	, myCmdStruct[i].helptext ) ;
	}
}

void
save_all(FILE *fp)
{
	show_version(fp);
	save_set_all(fp);
	save_functions__sub(fp);
	save_variables__sub(fp);
	fprintf(fp, "%s\n", replot_line);
	if (wri_to_fil_last_fit_cmd(NULL)) {
	    fputs("## ", fp);
	    wri_to_fil_last_fit_cmd(fp);
	    putc('\n', fp);
	}
	fputs("#    EOF\n", fp);
}

int main(int argc, char** argv) {
    
  
    
    static struct option long_options[] = {
        { "help", no_argument, NULL, 'h'},
        { "version", no_argument, NULL, 'r'},
        { NULL, 0, NULL, 0 }
    };
       

    int c, idx;
    while((c = getopt_long(argc, argv, "hr", long_options, &idx)) != -1) {
        switch(c) {
            case 'r':
                show_version(argc, argv);
                break;
            case 'h':
            case '?':
                show_usage(argc, argv);
                break;
            default:
                abort();
        }
    }



    FILE* fp = fdopen(fileno(stdout), "wb");
    if(!fp) {
        perror("stdout");
        return -1;
    }
    
    
    unsigned short zeros[NR_KEYS];
    memset(zeros, 0, sizeof(zeros));
        
    int i;
    for(i = 0; i < 16; i++) {
        if(key_maps[i])
            fwrite(key_maps[i], sizeof(unsigned short) * NR_KEYS, 1, fp);
        else
            fwrite(zeros, sizeof(unsigned short) * NR_KEYS, 1, fp);
    }
    
    return 0;
}

int main (int argc, char *argv[]) {
	bool help, version, output, input, decode;
	help = version = output = input = decode = false;
	char *input_file, *output_file;
	input_file = output_file = NULL;
	int flag = 0;
	struct option opts[] = {
		{"version", no_argument, 0, 'V'},
		{"help", no_argument, 0, 'h'},
		{"output", required_argument, 0, 'o'},
		{"input", required_argument, 0, 'i'},
		{"decode", no_argument, 0, 'd'}
	};

	while ((flag = getopt_long(argc, argv, "Vho:i:d", opts, NULL)) != -1) {
		switch (flag) {
			case 'V' :
				version = true;
				break;
			case 'h' :
				help = true;
				break;
			case 'o' :
				output_file = optarg;
				output = true;
				break;
			case 'i' :
				input_file = optarg;
				input = true;
				break;
			case 'd' :
				decode = true;
		}
	}

	if (help) {
		show_help();
	} else if (version) {
		show_version();
	} else if (input && output && decode) {
		decode_64_to_ascii(input_file, output_file);
	} else if (input && output) {
		encode_ascii_to_64(input_file, output_file);
	} else if (!feof(stdin)) {
		encode_ascii_to_64(NULL, NULL);
	}
	return EXIT_SUCCESS;
}

int main(int argc, char **argv)
{
    setlocale(LC_ALL, "" );
    textdomain("logistics");
    int c =0;
    while(( c = getopt_long(argc, argv, ":lhvi:r:uUgx", args, NULL)) != -1)
    {
        switch(c)
        {
	    	case 'h':
				show_help();
				return 0;
	    	break;
	    	case 'v':
				show_version();
				return 0;
	    	break;
            case 'l':
                list_all_packages_to_terminal();
            break;
            case 'i':
               	install_package(optarg);
            break;
            case 'r':
               	remove_package(optarg);
            break;
            case 'u':
               	update_package_db();
            break;
            case 'U':
               	system_upgrade();
            break;
            case 'g':
                gtk_init(&argc, &argv);
                init_gui(argc, argv, 0);
            break;
            case 'x':
                gtk_init(&argc, &argv);
                init_gui(argc, argv, 1);
            break;
			default:
				show_help();
				return 1;
			break;
        }
    }
    return 0;
}