public override void Run(string[] args)
        {
            options = new CmdParserOptionSet()
            {
               { "h|help", "Display this help information. To see online help, use: git help <command>", v=>OfflineHelp()},
               { "p=", "Each '-p' indicates the id of a parent commit object", v => cmd.P = v },
            };

            try
            {
                List<String> Arguments = ParseOptions(args);
                if (arguments.Count > 0)
                {
                    cmd.Arguments = arguments;
                    cmd.Execute();
                }
                else
                {
                    OfflineHelp();
                }
            }
            catch (Exception e)
            {
                cmd.OutputStream.WriteLine(e.Message);
            }
        }

        public override void Run(string[] args)
        {
            options = new CmdParserOptionSet()
            {
               { "h|help", "Display this help information. To see online help, use: git help <command>", v=>OfflineHelp()},
               { "o=", "Directory in which to place the individual messages", v => cmd.O = v },
               { "b", "If any file doesn't begin with a From line, assume it is a single mail message instead of signaling error", v => cmd.B = true },
               { "d=", "Instead of the default 4 digits with leading zeros, different precision can be specified for the generated filenames", v => cmd.D = v },
               { "f=", "Skip the first <nn> numbers, for example if -f3 is specified, start the numbering with 0004", v => cmd.F = v },
            };

            try
            {
                List<String> Arguments = ParseOptions(args);
                if (arguments.Count > 0)
                {
                    cmd.Arguments = arguments;
                    cmd.Execute();
                }
                else
                {
                    OfflineHelp();
                }
            }
            catch (Exception e)
            {
                cmd.OutputStream.WriteLine(e.Message);
            }
        }

        public override void Run(string[] args)
        {
            cmd.Quiet = false;

            options = new CmdParserOptionSet()
            {
               { "h|help", "Display this help information. To see online help, use: git help <command>", v=>OfflineHelp()},
               { "q|quiet", "Do not issue an error message if the <name> is not a symbolic ref but a detached HEAD; instead exit with non-zero status silently", v => cmd.Quiet = true },
               { "m=", "Update the reflog for <name> with <reason>", v => cmd.M = v },
            };

            try
            {
                List<String> arguments = ParseOptions(args);
                if (arguments.Count > 0)
                {
                    cmd.Arguments = arguments;
                    cmd.Execute();
                }
                else
                {
                    OfflineHelp();
                }
            }
            catch (Exception e)
            {
                cmd.OutputStream.WriteLine(e.Message);
            }
        }

        public override void Run(string[] args)
        {
            options = new CmdParserOptionSet()
            {
               { "h|help", "Display this help information. To see online help, use: git help <command>", v=>OfflineHelp()},
               { "shared=", "Only used with the 'init' command", v => cmd.Shared = v },
               { "template=", "Only used with the 'init' command", v => cmd.Template = v },
               { "r|revision=", "Used with the 'fetch' command", v => cmd.Revision = v },
               { ":|stdin", "Only used with the 'set-tree' command", v => cmd.Stdin = true },
               { "rmdir", "Only used with the 'dcommit', 'set-tree' and 'commit-diff' commands", v => cmd.Rmdir = true },
               { "e|edit", "Only used with the 'dcommit', 'set-tree' and 'commit-diff' commands", v => cmd.Edit = true },
               { "l|find-copies-harder=", "Only used with the 'dcommit', 'set-tree' and 'commit-diff' commands", v => cmd.FindCopiesHarder = v },
               { "A|authors-file=", "", v => cmd.AuthorsFile = v },
            };

            try
            {
                List<String> Arguments = ParseOptions(args);
                if (arguments.Count > 0)
                {
                    cmd.Arguments = arguments;
                    cmd.Execute();
                }
                else
                {
                    OfflineHelp();
                }
            }
            catch (Exception e)
            {
                cmd.OutputStream.WriteLine(e.Message);
            }
        }

        public override void Run(string[] args)
        {
            options = new CmdParserOptionSet()
            {
               { "h|help", "Display this help information. To see online help, use: git help <command>", v=>OfflineHelp()},
               { "format=", "Format of the resulting archive: 'tar' or 'zip'", v => cmd.Format = v },
               { "l|list", "Show all available formats", v => cmd.List = true },
               { "v|verbose", "Report progress to stderr", v => cmd.Verbose = true },
               { "prefix=", "Prepend <prefix>/ to each filename in the archive", v => cmd.Prefix = v },
               { "o|output=", "Write the archive to <file> instead of stdout", v => cmd.Output = v },
               { "worktree-attributes", "Look for attributes in", v => cmd.WorktreeAttributes = true },
               { "remote=", "Instead of making a tar archive from the local repository, retrieve a tar archive from a remote repository", v => cmd.Remote = v },
               { "exec=", "Used with --remote to specify the path to the 'git-upload-archive' on the remote side", v => cmd.Exec = v },
            };

            try
            {
                List<String> arguments = ParseOptions(args);
                if (arguments.Count > 0)
                {
                    cmd.Arguments = arguments;
                    cmd.Execute();
                }
                else
                {
                    OfflineHelp();
                }
            }
            catch (Exception e)
            {
                cmd.OutputStream.WriteLine(e.Message);
            }
        }

        public override void Run(string[] args)
        {
            options = new CmdParserOptionSet()
            {
               { "h|help", "Display this help information. To see online help, use: git help <command>", v=>OfflineHelp()},
               { "v", "Be verbose about what is going on, including progress status", v => cmd.V = true },
               { "o=", "Write the generated pack index into the specified file", v => cmd.O = v },
               { "stdin", "When this flag is provided, the pack is read from stdin instead and a copy is then written to <pack-file>", v => cmd.Stdin = true },
               { "fix-thin", "It is possible for 'git-pack-objects' to build \"thin\" pack, which records objects in deltified form based on objects not included in the pack to reduce network traffic", v => cmd.FixThin = true },
               // [Mr Happy] I have no idea how OptionSet handles the two lines below this one.
               //            might or might not work, haven't tested yet.
               { "keep", "Before moving the index into its final destination create an empty", v => cmd.Keep = true },
               { "keep=", "Like --keep create a", v => cmd.KeepMsg = v },
               { "index-version=", "This is intended to be used by the test suite only", v => cmd.IndexVersion = v },
               { "strict", "Die, if the pack contains broken objects or links", v => cmd.Strict = true },
            };

            try
            {
                List<String> arguments = ParseOptions(args);
                if (arguments.Count > 0)
                {
                    cmd.Arguments = arguments;
                    cmd.Execute();
                }
                else
                {
                    OfflineHelp();
                }
            }
            catch (Exception e)            
            {
                cmd.OutputStream.WriteLine(e.Message);
            }
        }

        public override void Run(string[] args)
        {
            options = new CmdParserOptionSet()
            {
               { "h|help", "Display this help information. To see online help, use: git help <command>", v=>OfflineHelp()},
               { "receive-pack=", "Path to the 'git-receive-pack' program on the remote end", v => cmd.ReceivePack = v },
               { "exec=", "Same as --receive-pack=<git-receive-pack>", v => cmd.Exec = v },
               { "all", "Instead of explicitly specifying which refs to update, update all heads that locally exist", v => cmd.All = true },
               { "dry-run", "Do everything except actually send the updates", v => cmd.DryRun = true },
               { "force", "Usually, the command refuses to update a remote ref that is not an ancestor of the local ref used to overwrite it", v => cmd.Force = true },
               { "verbose", "Run verbosely", v => cmd.Verbose = true },
               { "thin", "Spend extra cycles to minimize the number of objects to be sent", v => cmd.Thin = true },
            };

            try
            {
                List<String> arguments = ParseOptions(args);
                if (arguments.Count > 0)
                {
                    cmd.Arguments = arguments;
                    cmd.Execute();
                }
                else
                {
                    OfflineHelp();
                }
            }
            catch (Exception e)
            {
                cmd.OutputStream.WriteLine(e.Message);
            }
        }

        public override void Run(string[] args)
        {
            options = new CmdParserOptionSet()
            {
               { "h|help", "Display this help information. To see online help, use: git help <command>", v=>OfflineHelp()},
               { "k", "Usually the program 'cleans up' the Subject: header line to extract the title line for the commit log message, among which (1) remove 'Re:' or 're:', (2) leading whitespaces, (3) '[' up to ']', typically '[PATCH]', and then prepends \"[PATCH] \"", v => cmd.K = true },
               { "b", "When -k is not in effect, all leading strings bracketed with '[' and ']' pairs are stripped", v => cmd.B = true },
               { "u", "The commit log message, author name and author email are taken from the e-mail, and after minimally decoding MIME transfer encoding, re-coded in UTF-8 by transliterating them", v => cmd.U = true },
               { "encoding=", "Similar to -u but if the local convention is different from what is specified by i18n", v => cmd.Encoding = v },
               { "n", "Disable all charset re-coding of the metadata", v => cmd.N = true },
               { "scissors", "Remove everything in body before a scissors line", v => cmd.Scissors = true },
               { "no-scissors", "Ignore scissors lines", v => cmd.NoScissors = true },
            };

            try
            {
                List<String> Arguments = ParseOptions(args);
                if (arguments.Count > 0)
                {
                    cmd.Arguments = arguments;
                    cmd.Execute();
                }
                else
                {
                    OfflineHelp();
                }
            }
            catch (Exception e)
            {
                cmd.OutputStream.WriteLine(e.Message);
            }
        }

        public override void Run(string[] args)
        {
            options = new CmdParserOptionSet()
            {
               { "h|help", "Display this help information. To see online help, use: git help <command>", v=>OfflineHelp()},
               { "log", "In addition to branch names, populate the log message with one-line descriptions from the actual commits that are being merged", v => cmd.Log = true },
               { "no-log", "Do not list one-line descriptions from the actual commits being merged", v => cmd.Log = false },
					// [obsolete]
               //{ "summary", "Synonyms to --log and --no-log; these are deprecated and will be removed in the future", v => cmd.Summary = true },
               //{ "no-summary", "Synonyms to --log and --no-log; these are deprecated and will be removed in the future", v => cmd.NoSummary = true },
               { "F|file=", "Take the list of merged objects from <file> instead of stdin", v =>
               	{
               		//cmd.File = v 
               	}
               },
            };

            try
            {
                List<String> arguments = ParseOptions(args);
                if (arguments.Count > 0)
                {
						  //cmd.Arguments = arguments;
						  //cmd.Execute();
                }
                else
                {
                    OfflineHelp();
                }
            }
            catch (Exception e)            
            {
					 //cmd.OutputStream.WriteLine(e.Message);
            }
        }

        public override void Run(string[] args)
        {
            options = new CmdParserOptionSet()
            {
               { "h|help", "Display this help information. To see online help, use: git help <command>", v=>OfflineHelp()},
               { "f", "If an existing replace ref for the same object exists, it will be overwritten (instead of failing)", v => cmd.F = true },
               { "d", "Delete existing replace refs for the given objects", v => cmd.D = true },
               { "l=", "List replace refs for objects that match the given pattern (or all if no pattern is given)", v => cmd.L = v },
            };

            try
            {
                List<String> arguments = ParseOptions(args);
                if (arguments.Count > 0)
                {
                    cmd.Arguments = arguments;
                    cmd.Execute();
                }
                else
                {
                    OfflineHelp();
                }
            }
            catch (Exception e)
            {
                cmd.OutputStream.WriteLine(e.Message);
            }
        }

        public override void Run(string[] args)
        {
            options = new CmdParserOptionSet()
            {
               { "h|help", "Display this help information. To see online help, use: git help <command>", v=>OfflineHelp()},
               { "all", "Processes all packs", v => cmd.All = true },
               { "alt-odb", "Don't require objects present in packs from alternate object directories to be present in local packs", v => cmd.AltOdb = true },
               { "verbose", "Outputs some statistics to stderr", v => cmd.Verbose = true },
            };

            try
            {
                List<String> arguments = ParseOptions(args);
                if (arguments.Count > 0)
                {
                    cmd.Arguments = arguments;
                    cmd.Execute();
                }
                else
                {
                    OfflineHelp();
                }
            }
            catch (Exception e)            
            {
                cmd.OutputStream.WriteLine(e.Message);
            }
        }

        public override void Run(string[] args)
        {
            options = new CmdParserOptionSet()
            {
               { "h|help", "Display this help information. To see online help, use: git help <command>", v=>OfflineHelp()},
               { "a|all", "Output all merge bases for the commits, instead of just one", v => cmd.All = true },
            };

            try
            {
                List<String> arguments = ParseOptions(args);
                if (arguments.Count > 0)
                {
                    cmd.Arguments = arguments;
                    cmd.Execute();
                }
                else
                {
                    OfflineHelp();
                }
            }
            catch (Exception e)            
            {
                cmd.OutputStream.WriteLine(e.Message);
            }
        }

        public override void Run(string[] args)
        {
            options = new CmdParserOptionSet()
            {
               { "h|help", "Display this help information. To see online help, use: git help <command>", v=>OfflineHelp()},
               { "m=", "Use the given note message (instead of prompting)", v => cmd.M = v },
               { "F=", "Take the note message from the given file", v => cmd.F = v },
            };

            try
            {
                List<String> arguments = ParseOptions(args);
                if (arguments.Count > 0)
                {
                    cmd.Arguments = arguments;
                    cmd.Execute();
                }
                else
                {
                    OfflineHelp();
                }
            }
            catch (Exception e)
            {
                cmd.OutputStream.WriteLine(e.Message);
            }
        }

        public override void Run(String[] args)
        {
            options = new CmdParserOptionSet()
            {
                { "h|help", "Display this help information. To see online help, use: git help <command>", v=>OfflineHelp()},
            #if ported
                { "n|dry-run", "Dry run", v=> {isDryRun = true;}},
                { "f|force", "Override the up-to-date check", v=>{isForced = true;}},
                { "q|quiet", "Be quiet", v=>{isQuiet = true;}},
                { "cached", "Only remove from the index", v=>{isCached = true;}},
                { "r", "Allow recursive removal", v=>{allowRecursiveRemoval = true;}},
                { "ignore-match", "Exit with a zero status even if nothing is matched", v=>{ignoreUnmatch = true;}},
            #endif
            };

            try
            {
                List<String> arguments = ParseOptions(args);
                if (arguments.Count > 0)
                {
                    DoRm(arguments);
                }
                else
                {
                    OfflineHelp();
                }
            } catch (OptionException e) {
                Console.WriteLine(e.Message);
            }
        }

        public override void Run(string[] args)
        {
            options = new CmdParserOptionSet()
            {
               { "h|help", "Display this help information. To see online help, use: git help <command>", v=>OfflineHelp()},
               { "L=", "This option may be given up to three times, and specifies labels to be used in place of the corresponding file names in conflict reports", v => cmd.L = v },
               { "p", "Send results to standard output instead of overwriting `<current-file>`", v => cmd.P = true },
               { "q", "Quiet; do not warn about conflicts", v => cmd.Q = true },
            };

            try
            {
                List<String> arguments = ParseOptions(args);
                if (arguments.Count > 0)
                {
                    cmd.Arguments = arguments;
                    cmd.Execute();
                }
                else
                {
                    OfflineHelp();
                }
            }
            catch (Exception e)
            {
                cmd.OutputStream.WriteLine(e.Message);
            }
        }

        public override void Run(string[] args)
        {
            options = new CmdParserOptionSet()
            {
               { "h|help", "Display this help information. To see online help, use: git help <command>", v=>OfflineHelp()},
               { "m", "Perform a merge, not just a read", v => cmd.M = true },
               { "reset", "Same as -m, except that unmerged entries are discarded         instead of failing", v => cmd.Reset = true },
               { "u", "After a successful merge, update the files in the work tree with the result of the merge", v => cmd.U = true },
               { "i", "Usually a merge requires the index file as well as the files in the working tree are up to date with the current head commit, in order not to lose local changes", v => cmd.I = true },
               { "v", "Show the progress of checking files out", v => cmd.V = true },
               { "trivial", "Restrict three-way merge by 'git-read-tree' to happen only if there is no file-level merging required, instead of resolving merge for trivial cases and leaving conflicting files unresolved in the index", v => cmd.Trivial = true },
               { "aggressive", "Usually a three-way merge by 'git-read-tree' resolves the merge for really trivial cases and leaves other cases unresolved in the index, so that Porcelains can implement different merge policies", v => cmd.Aggressive = true },
               { "prefix=", "Keep the current index contents, and read the contents of named tree-ish under directory at `<prefix>`", v => cmd.Prefix = v },
               { "exclude-per-directory=", "When running the command with `-u` and `-m` options, the merge result may need to overwrite paths that are not tracked in the current branch", v => cmd.ExcludePerDirectory = v },
               { "index-output=", "Instead of writing the results out to `$GIT_INDEX_FILE`, write the resulting index in the named file", v => cmd.IndexOutput = v },
            };

            try
            {
                List<String> arguments = ParseOptions(args);
                if (arguments.Count > 0)
                {
                    cmd.Arguments = arguments;
                    cmd.Execute();
                }
                else
                {
                    OfflineHelp();
                }
            }
            catch (Exception e)            
            {
                cmd.OutputStream.WriteLine(e.Message);
            }
        }

        public override void Run(string[] args)
        {
            options = new CmdParserOptionSet()
            {
               { "h|help", "Display this help information. To see online help, use: git help <command>", v=>OfflineHelp()},
               { "y|no-prompt", "Do not prompt before launching a diff tool", v => cmd.NoPrompt = true },
               { "prompt", "Prompt before each invocation of the diff tool", v => cmd.Prompt = true },
               { "t|tool=", "Use the diff tool specified by <tool>", v => cmd.Tool = v },
            };

            try
            {
                List<String> arguments = ParseOptions(args);
                if (arguments.Count > 0)
                {
                    cmd.Arguments = arguments;
                    cmd.Execute();
                }
                else
                {
                    OfflineHelp();
                }
            }
            catch (Exception e)
            {
                cmd.OutputStream.WriteLine(e.Message);
            }
        }

        public override void Run(string[] args)
        {
            options = new CmdParserOptionSet()
            {
               { "h|help", "Display this help information. To see online help, use: git help <command>", v=>OfflineHelp()},
               { "t", "Instead of the content, show the object type identified by <object>", v => cmd.T = true },
               { "s", "Instead of the content, show the object size identified by <object>", v => cmd.S = true },
               { "e=", "Suppress all output; instead exit with zero status if <object> exists and is a valid object", v => cmd.E = v },
               { "p=", "Pretty-print the contents of <object> based on its type", v => cmd.P = v },
               { "batch", "Print the SHA1, type, size, and contents of each object provided on stdin", v => cmd.Batch = true },
               { "batch-check", "Print the SHA1, type, and size of each object provided on stdin", v => cmd.BatchCheck = true },
            };

            try
            {
                List<String> arguments = ParseOptions(args);
                if (arguments.Count > 0)
                {
                    cmd.Arguments = arguments;
                    cmd.Execute();
                }
                else
                {
                    OfflineHelp();
                }
            }
            catch (Exception e)            
            {
                cmd.OutputStream.WriteLine(e.Message);
            }
        }

        public override void Run(string[] args)
        {
            options = new CmdParserOptionSet()
            {
               { "h|help", "Display this help information. To see online help, use: git help <command>", v=>OfflineHelp()},
               { "n", "Do not remove anything; just report what it would remove", v => cmd.N = true },
               { "v", "Report all removed objects", v => cmd.V = true },
               { "expire=", "Only expire loose objects older than <time>", v => cmd.Expire = v },
            };

            try
            {
                List<String> arguments = ParseOptions(args);
                if (arguments.Count > 0)
                {
                    cmd.Arguments = arguments;
                    cmd.Execute();
                }
                else
                {
                    OfflineHelp();
                }
            }
            catch (Exception e)
            {
                cmd.OutputStream.WriteLine(e.Message);
            }
        }

        public override void Run(string[] args)
        {
            cmd.Quiet = false;

            options = new CmdParserOptionSet()
            {
               { "h|help", "Display this help information. To see online help, use: git help <command>", v=>OfflineHelp()},
               { "aggressive", "Usually 'git-gc' runs very quickly while providing good disk space utilization and performance", v => cmd.Aggressive = true },
               { "auto", "With this option, 'git-gc' checks whether any housekeeping is required; if not, it exits without performing any work", v => cmd.Auto = true },
               { "prune=", "Prune loose objects older than date (default is 2 weeks ago, overridable by the config variable `gc", v => cmd.Prune = v },
               { "no-prune", "Do not prune any loose objects", v => cmd.NoPrune = true },
               { "quiet", "Suppress all progress reports", v => cmd.Quiet = true },
            };

            try
            {
                List<String> Arguments = ParseOptions(args);
                if (arguments.Count > 0)
                {
                    cmd.Arguments = arguments;
                    cmd.Execute();
                }
                else
                {
                    OfflineHelp();
                }
            }
            catch (Exception e)
            {
                cmd.OutputStream.WriteLine(e.Message);
            }
        }