public ParsedArguments(string[] args) {
            var p = new OptionSet {
                {"sum", "If set Sum will be calculated", _ => _SumValues = true},
                {"max", "If set show Max value", _ => _MaxValue = true},
                {"min", "If set show Min value", _ => _MinValue = true},
                {"dir=", "Output directory", dir => _OutputDirectory = GetValidPath(dir)}, {
                    "count=", "Count of items to be generated. This value is mandatory.", count => {
                        if (!_CountIsSet && int.TryParse(count, out _Count) && _Count > 0) {
                            _CountIsSet = true;
                        }
                    }
                }
            };

            p.Parse(args);

            if (!ArgsAreValid) {
                Trace.WriteLine("Parameter args does not contain valid value for count.");

                using (var stringWriter = new StringWriter()) {
                    p.WriteOptionDescriptions(stringWriter);
                    _ErrorMessage = stringWriter.ToString();
                }
            }
        }

		public override void Run (IEnumerable<string> args)
		{
			string rootPath = null;

			var options = new OptionSet () {
				{ "r=|root=", "Specify which documentation root to use. Default is $libdir/monodoc", v => rootPath = v },
			};

			var extra = Parse (options, args, "index", 
			                   "[OPTIONS]+ ACTION",
			                   "Create Monodoc indexes depending on ACTION. Possible values are \"tree\" or \"search\" for, respectively, mdoc tree and lucene search");
			if (extra == null)
				return;

			var root = string.IsNullOrEmpty (rootPath) ? RootTree.LoadTree () : RootTree.LoadTree (rootPath);

			foreach (var action in extra) {
				switch (action) {
				case "tree":
					RootTree.MakeIndex (root);
					break;
				case "search":
					RootTree.MakeSearchIndex (root);
					break;
				}
			}
		}

        public InstanceConfiguration Parse(IList<string> args)
        {
            var cfg = new InstanceConfiguration
                {
                    AppName = string.Empty,
                    Help = false,
                    Verbose = false,
                    ExtraParams = new List<string>()
                };

            var p = new OptionSet
                {
                    {"app=", v => cfg.AppName = v},
                    {"i|install", v => cfg.Install = v != null},
                    {"v|verbose", v => cfg.Verbose = v != null},
                    {"h|?|help", v => cfg.Help = v != null},
                };
            cfg.OptionSet = p;

            if (args == null || !args.Any())
            {
                cfg.Help = true;
                return cfg;
            }

            cfg.ExtraParams = p.Parse(args);
            cfg.AppName = cfg.AppName.Trim('"', '\'');
            return cfg;
        }

        public override void Run(ApplicationContext appContext, IEnumerable<string> args)
        {
            string release = null;
            string env = null;
            var dryRun = false;
            var resume = false;
            var noCache = appContext.UserConfig.Cache.Disabled;
            var noBeeps = false;

            var p = new OptionSet
            {
                { "r=|release=", "Select which release to use, instead of the default.", v => release = v },
                { "e=|env=|environment=", "Select which environment to use, instead of the default.", v => env = v },
                { "n|dry-run", "Don't actually run actions, just print what would be done and exit.", v => dryRun = v != null },
                { "s|resume", "Resume a failed deploy, if possible.", v => resume = v != null },
                { "C|no-cache", "Disable cache.", v => noCache = v != null },
                { "B|no-beeps", "Disable buzzer.", v => noBeeps = v != null }
            };

            var extra = Parse(p, args,
                CommandConstants.Deploy,
                "[OPTIONS]+");
            if (extra == null)
                return;

            var runContext = RunContext.Create(appContext, CommandConstants.Deploy, release, env, dryRun);
            RunCore(DeployContext.Create(runContext, resume, noCache, noBeeps));
        }

        public Options(params string[] args)
        {
            Port = DefaultPort;
            AssemblyPaths = new Collection<string>();

            options = new OptionSet
                          {
                              {
                                  "p|port=",
                                  "the {PORT} the server should listen on (default=" + DefaultPort + ").",
                                  (int v) => Port = v
                                  },
                              {
                                  "a|assembly=",
                                  "an assembly to search for step definition methods.",
                                  v => AssemblyPaths.Add(v)
                                  },
                              {
                                  "h|?|help",
                                  "show this message and exit.",
                                  v => ShowHelp = v != null
                                  }
                          };
            options.Parse(args);
        }

    public static int Main(string[] args)
    {
        TextWriter writer = Console.Out;
        string method_name = null;
        string formatter = null;
        bool show_help = false;

        var os = new OptionSet () {
            { "formatter=", "Source code formatter. Valid values are: 'csharp-coregraphics'", v => formatter = v },
            { "out=", "Source code output", v => writer = new StreamWriter (v) },
            { "h|?|help", "Displays the help", v => show_help = true },
        };

        var svg = os.Parse (args);
        string path = (svg.Count > 1) ? String.Concat (svg) : svg [0];

        if (show_help)
            Usage (os, null);

        var parser = new SvgPathParser ();

        switch (formatter) {
        case "csharp-coregraphics":
        case "cs-cg":
            parser.Formatter = new CSharpCoreGraphicsFormatter (writer);
            break;
        default:
            Usage (os, "error: unkown {0} code formatter", formatter);
            break;
        }

        parser.Parse (path, method_name);
        return 0;
    }

 internal override bool IsInsertionTrigger(SourceText text, int characterPosition, OptionSet options)
 {
     var ch = text[characterPosition];
     return ch == ' ' ||
         (CompletionUtilities.IsStartingNewWord(text, characterPosition) &&
         options.GetOption(CompletionOptions.TriggerOnTypingLetters, LanguageNames.CSharp));
 }

		public override void Run (IEnumerable<string> args)
		{
			string current_library = "";

			var options = new OptionSet () {
				{ "o|out=", 
					"{FILE} to generate/update documentation within.\n" + 
					"If not specified, will process " + file + ".\n" +
					"Set to '-' to skip updates and write to standard output.",
					v => file = v },
				{ "library=",
					"The {LIBRARY} that the following --type=TYPE types should be a part of.",
					v => current_library = v },
				{ "type=",
					"The full {TYPE} name of a type to copy into the output file.",
					v => AddTypeToLibrary (current_library, v) },
			};
			directories = Parse (options, args, "export-ecma-xml", 
					"[OPTIONS]+ DIRECTORIES",
					"Export mdoc documentation within DIRECTORIES into ECMA-format XML.\n\n" +
					"DIRECTORIES are mdoc(5) directories as produced by 'mdoc update'.");
			if (directories == null || directories.Count == 0)
				return;

			Update ();
		}

        public override void AddIndentBlockOperations(List<IndentBlockOperation> list, SyntaxNode node, OptionSet optionSet, NextAction<IndentBlockOperation> nextOperation)
        {
            nextOperation.Invoke(list);

            var queryExpression = node as QueryExpressionSyntax;
            if (queryExpression != null)
            {
                var firstToken = queryExpression.FromClause.Expression.GetFirstToken(includeZeroWidth: true);
                var lastToken = queryExpression.FromClause.Expression.GetLastToken(includeZeroWidth: true);
                AddIndentBlockOperation(list, queryExpression.FromClause.FromKeyword, firstToken, lastToken);

                for (int i = 0; i < queryExpression.Body.Clauses.Count; i++)
                {
                    // if it is nested query expression
                    var fromClause = queryExpression.Body.Clauses[i] as FromClauseSyntax;
                    if (fromClause != null)
                    {
                        firstToken = fromClause.Expression.GetFirstToken(includeZeroWidth: true);
                        lastToken = fromClause.Expression.GetLastToken(includeZeroWidth: true);
                        AddIndentBlockOperation(list, fromClause.FromKeyword, firstToken, lastToken);
                    }
                }

                // set alignment line for query expression
                var baseToken = queryExpression.GetFirstToken(includeZeroWidth: true);
                var endToken = queryExpression.GetLastToken(includeZeroWidth: true);
                if (!baseToken.IsMissing && !baseToken.Equals(endToken))
                {
                    var startToken = baseToken.GetNextToken(includeZeroWidth: true);
                    SetAlignmentBlockOperation(list, baseToken, startToken, endToken);
                }
            }
        }

        public static void Main(string [] args)
        {
            // Parse the command line options
            bool show_help       = false;
            OptionSet option_set = new OptionSet () {
                { "v|version", _("Print version information"), v => { PrintVersion (); } },
                { "h|help", _("Show this help text"), v => show_help = v != null }
            };

            try {
                option_set.Parse (args);

            } catch (OptionException e) {
                Console.Write ("SparkleShare: ");
                Console.WriteLine (e.Message);
                Console.WriteLine ("Try `sparkleshare --help' for more information.");
            }

            if (show_help)
                ShowHelp (option_set);

            // Initialize the controller this way so that
            // there aren't any exceptions in the OS specific UI's
            Controller = new SparkleController ();
            Controller.Initialize ();

            if (Controller != null) {
                UI = new SparkleUI ();
                UI.Run ();
            }
        }

    /// <summary>Parameters: num_files weight_1 .. weight_n file_1 .. file_n output_file</summary>
    /// <param name="args">the command-line arguments</param>
    public static void Main(string[] args)
    {
        AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler(Handlers.UnhandledExceptionHandler);

        // parse command-line parameters

        string prediction_file = null;
        //string score_file      = null;
           	var p = new OptionSet() {
           			{ "data-dir=",              v => data_dir = v         },
            { "prediction-file=",       v => prediction_file = v  },
            { "sigmoid",                v => sigmoid = v != null  },
            { "pairwise-probability",   v => pairwise_prob = v != null   },
            { "pairwise-wins",          v => pairwise_wins = v != null   },
            { "rated-probability",      v => rated_prob = v != null      },
            { "constant-rating",        v => constant_rating = v != null },
            //{ "score-file=",            v => score_file = v },
           	  	};
           		IList<string> extra_args = p.Parse(args);

        string rated_file = extra_args[0];

        // combine files
        IList<double> test_scores;
        IList<double> validation_scores;

        if (constant_rating)
        {
            test_scores = ReadFile(rated_file);
            validation_scores = ReadFile(ValidationFilename(rated_file));
        }
        else
        {
            string rating_file = extra_args[1];
            test_scores = CombineFiles(rated_file, rating_file);
            validation_scores = CombineFiles(ValidationFilename(rated_file), ValidationFilename(rating_file));
        }

        // compute error on validation set
        string validation_candidates_file = Path.Combine(data_dir, "mml-track2/validationCandidatesIdx2.txt");
        string validation_hits_file       = Path.Combine(data_dir, "mml-track2/validationHitsIdx2.txt");
        var candidates = Track2Items.Read(validation_candidates_file);
        var hits       = Track2Items.Read(validation_hits_file);
        double error = KDDCup.EvaluateTrack2(Decide(validation_scores), candidates, hits);
        Console.WriteLine("ERR {0:F7}", error);

        if (prediction_file != null)
        {
            WritePredictions(Decide(test_scores), prediction_file);
            WritePredictions(Decide(validation_scores), ValidationFilename(prediction_file));
        }

        /*
        if (score_file != null)
        {
            WriteScores(test_scores, score_file);
            WriteScores(test_scores, ValidationFilename(score_file));
        }
        */
    }

        /// <summary>
        /// Method performing the check command
        /// </summary>
        /// <param name="argsList">
        /// Command line like style
        /// </param>
        public static void Check(IEnumerable<string> argsList)
        {
            string outname = null;
            bool help = false;
            var op = new OptionSet() {
                {"check", "Command name, consumes token", v => int.Parse("0")},
                {"save|outname=", "Output of the tabulation filename", v => outname = v},
                {"help|h", "Shows this help message", v => help = true}
            };

            List<string> checkList = op.Parse(argsList);
            if (1 > checkList.Count || help) {
                Console.WriteLine ("Usage --check [--options] res-basis res-list...");
                op.WriteOptionDescriptions(Console.Out);
                return;
            }
            var list = new List<ResultSummary> ();
            var B = JsonConvert.DeserializeObject<ResultSummary> (File.ReadAllText (checkList [0]));
            foreach(string arg in checkList) {
                var R = JsonConvert.DeserializeObject<ResultSummary> (File.ReadAllText (arg));
                R.Parametrize (B);
                R.ResultName = arg;
                R.QueryList = null;
                list.Add (R);
                // Console.WriteLine (JsonConvert.SerializeObject(R, Formatting.Indented));
            }

            var s = JsonConvert.SerializeObject (list, Formatting.Indented);
            Console.WriteLine (s);
            if (outname != null) {
                File.WriteAllText(outname, s);
            }
        }

		static void Main(string[] args) {
			Application.EnableVisualStyles();
			Application.SetCompatibleTextRenderingDefault(false);

			try {
				// use command-line parameters if provided (used by auto-update functionality)
				bool showHelp = false;
				bool skipUpdateCheck = false;

				_options = new OptionSet {
			        {"h|help", "Show this short help text", v => showHelp = true},
			        {"k|killpid=", "Kill calling (old) process (to be used by updater)", KillDanglingProcess },
			        {"c|cleanupdate=", "Delete (old) executable (to be used by updater)", RemoveOldExecutable },
					{"s|skip-update-check", "Skip update check)", v => skipUpdateCheck = true },
			    };
				_options.Parse(args);
				if (showHelp) {
					ShowHelp();
					return;
				}

				Application.Run(new MainForm(skipUpdateCheck));
			}

			catch (Exception exc) {
				MessageBox.Show("An error ocurred: " + exc.Message + "\r\n\r\nCallstack: " + exc.StackTrace);
			}
		}

 /// <summary>
 /// Display the help text for this command line program.
 /// </summary>
 /// <param name="os"></param>
 private void Help(OptionSet os)
 {
     Console.WriteLine("Usage: " + System.AppDomain.CurrentDomain.FriendlyName + " [-?|--help] [-iINPUT|--input=INPUT] [-oOUTPUT|--output=OUTPUT] [-sSTICKY|--sticky=STICKY] [-aSORTATTRIBUTES|--attributes=SORTATTRIBUTES]");
     Console.WriteLine();
     Console.WriteLine("Option:");
     os.WriteOptionDescriptions(Console.Out);
 }

		internal static CacheIndentEngine CreateEngine(string text, out SourceText sourceText, OptionSet options = null)
		{
			if (options == null) {
				options = FormattingOptionsFactory.CreateMono ();
				//	options.AlignToFirstIndexerArgument = formatOptions.AlignToFirstMethodCallArgument = true;
			}

			var sb = new StringBuilder ();
			int offset = 0;
			for (int i = 0; i < text.Length; i++) {
				var ch = text [i];
				if (ch == '$') {
					offset = i;
					continue;
				}
				sb.Append (ch);
			}


			sourceText = SourceText.From (sb.ToString ());

			var result = new CacheIndentEngine (new CSharpIndentEngine (options));
			result.Update (sourceText, offset);
			return result;
		}

 public void BindCommadLineParameters(OptionSet optionSet)
 {
     optionSet
         .Add("i|include=", "Include files to the package", _includes.Add)
         .Add("o|output=", "Name of the output file", x => _outputFileName = x)
         .Add("cn=", "CN of the certificate", x => _cn = x);
 }

 static void ShowHelp(OptionSet p)
 {
     Console.WriteLine("Usage: omnisharp -s /path/to/sln [-p PortNumber]");
     Console.WriteLine();
     Console.WriteLine("Options:");
     p.WriteOptionDescriptions(Console.Out);
 }

        public static void Main(string[] args)
        {
            var showHelp = false;

            var options = new OptionSet()
            {
                {
                    "h|help",
                    "show this message and exit",
                    v => showHelp = v != null
                    },
            };

            List<string> extras;

            try
            {
                extras = options.Parse(args);
            }
            catch (OptionException e)
            {
                Console.Write("{0}: ", GetExecutableName());
                Console.WriteLine(e.Message);
                Console.WriteLine("Try `{0} --help' for more information.", GetExecutableName());
                return;
            }

            if (extras.Count < 1 || extras.Count > 2 ||
                showHelp == true)
            {
                Console.WriteLine("Usage: {0} [OPTIONS]+ input_cnd [output_file]", GetExecutableName());
                Console.WriteLine();
                Console.WriteLine("Options:");
                options.WriteOptionDescriptions(Console.Out);
                return;
            }

            var inputPath = extras[0];
            var outputPath = extras.Count > 1 ? extras[1] : null;

            var cnd = new ConditionalsFile();
            using (var input = File.OpenRead(inputPath))
            {
                cnd.Deserialize(input);
            }

            if (outputPath == null)
            {
                DumpConditionals(Console.Out, cnd);
            }
            else
            {
                using (var output = File.Create(outputPath))
                {
                    var writer = new StreamWriter(output);
                    DumpConditionals(writer, cnd);
                    writer.Flush();
                }
            }
        }

        public static void Main(string[] args)
        {
            var sgopts = new StubGenOptions ();
            var opts = new OptionSet () {
                { "o=|output-dir=", "Directory to generate classes in. Defaults to current directory", v => sgopts.OutputDir = v },
                { "no-header", "Do not put header with license in generated files", v => sgopts.NoHeader = true },
                { "l|license=", "Name of the license or path to a text file with license text (defaults to MIT/X11)", v => sgopts.LicenseName = v },
                { "a|author=", "Author name", v => sgopts.AuthorName = v },
                { "e|email=", "Author email", v => sgopts.AuthorEmail = v },
                { "c|copyright=", "Copyright holder", v => sgopts.CopyrightHolder = v },
                { "f|force|overwrite-all", "Overwrite all files without prompting.", v => sgopts.OverwriteAll = true },
                { "d|debug", "Show more information on errors.", v => sgopts.Debug = true },
                { "p|private|non-public", "Include private/internal members in the outline.", v => sgopts.IncludeNonPublic = true },
                { "h|help|?", "Show this help screen", v => sgopts.ShowHelp = true }
            };

            if (sgopts.ShowHelp)
                ShowHelp (opts);

            List <string> assemblies = opts.Parse (args);
            if (assemblies == null || assemblies.Count == 0)
                ShowHelp (opts);

            foreach (string ap in assemblies)
                ProcessAssembly (ap, sgopts);
        }

        private static void Main(string[] args)
        {
            IStatCalculator stats = null;
            bool showErrors = true;
            bool showHelp = false;

            var p = new OptionSet
            {
                { "b|burndown", "Get burndown chart data", v => {
                    stats = new BurndownStats();
                }},
                { "c|cfd", "Get cumulative flow chart data", v => { stats = new CumulativeFlowStats(); }},
                { "t|table", "Summarize issues in sprint", v => { stats = new ContentTableStats(); }},
                { "e|errors", "Turn on or off list of issues with state errors (defaults to on)",
                    v => { showErrors = v != null; } },
                { "h|?|help", "Display this help message", v => showHelp = v != null }
            };
            List<String> extras = p.Parse(args);

            if (showHelp)
            {
                ShowHelp(p);
                return;
            }

            IList<Tuple<string, string>> repos = GetRepoNames(extras);

            if (stats == null)
            {
                stats = new BurndownStats();
            }

            var program = new Program(stats, repos, showErrors);
            program.Go();
        }