string ISyncWork.Run(IWorkContext context)
 {
    var command = new CommandParser(context.Command).Parse();
    var route = new CommandRouteInterpretter(command).GetRoute();
    context.CommandInterpretter.AddSyncRoute(route);
    return "";
 }

        static void Main(string[] args)
        {
            var commandParser = new CommandParser();

            Console.WriteLine("Hello World!");
            Console.ReadKey();
        }

        public override void Create(CommandParser Parser)
        {
            Core.StandardMessage("version", "Build: RMUD Hadad <s0>");
            Core.StandardMessage("commit", "Commit: <s0>");
            Core.StandardMessage("no commit", "Commit version not found.");

            Parser.AddCommand(
                Or(
                    KeyWord("VERSION"),
                    KeyWord("VER")))
                .Manual("Displays the server version currently running.")
                .ProceduralRule((match, actor) =>
                {
                    var buildVersion = System.Reflection.Assembly.GetExecutingAssembly().GetName().Version.ToString();

                    MudObject.SendMessage(actor, "@version", buildVersion);

                    if (System.IO.File.Exists("version.txt"))
                        MudObject.SendMessage(actor, "@commit", System.IO.File.ReadAllText("version.txt"));
                    else
                        MudObject.SendMessage(actor, "@no commit");

                    foreach (var module in Core.IntegratedModules)
                        MudObject.SendMessage(actor, module.Info.Description);

                    return PerformResult.Continue;
                });
        }

 public void TestParseMultiply()
 {
     var commandParser = new CommandParser();
     string testInput = "2*8";
     var result = commandParser.Parse(testInput);
     Assert.AreEqual(16, result);
 }

 public void TestParseSubtract()
 {
     var commandParser = new CommandParser();
     string testInput = "2-6";
     var result = commandParser.Parse(testInput);
     Assert.AreEqual(-4, result);
 }

 public void TestParseDivde()
 {
     var commandParser = new CommandParser();
     string testInput = "8/2";
     var result = commandParser.Parse(testInput);
     Assert.AreEqual(4, result);
 }

 public void TestParseMod()
 {
     var commandParser = new CommandParser();
     string testInput = "8%3";
     var result = commandParser.Parse(testInput);
     Assert.AreEqual(2, result);
 }

 public void TestParseAdd()
 {
     var commandParser = new CommandParser();
     string testInput = "2+6";
     var result = commandParser.Parse(testInput);
     Assert.AreEqual(8, result);
 }

        ///<summary>
        ///This gets the users message and passes it on to everyone currently
        ///playing.
        ///</summary>
        ///<param name="p">The player who invoked the command.</param>
        ///<param name="cp">The options the player sent along.</param>
        public override void doCommand(Player p, CommandParser cp)
        {
            string you = "You chat: {x{o{y\'{x{o{b" + cp.Arguments + "{x{o{y\'{x\n\r";
            string everyone = "\n\r" + p.Name + " chats: {o{y\'{x{o{b" + cp.Arguments + "{x{o{y\'{x\n\r";

            Mud.mudSuroden.writeAll(p, everyone, you);
        }

		public override void Create(CommandParser Parser)
		{
			Parser.AddCommand(
				new KeyWord("LOOK", false),
				new LookProcessor(),
				"Look around at your suroundings.");
		}

 private void HandleAddBlackListCmd(CommandParser.Command param)
 {
     ulong gUID = 0uL;
     ulong.TryParse(param.GetParam(1), out gUID);
     MC2S_AddBlackList mC2S_AddBlackList = new MC2S_AddBlackList();
     mC2S_AddBlackList.GUID = gUID;
     Globals.Instance.CliSession.Send(315, mC2S_AddBlackList);
 }

        public void Parse_EmptyCommand_ShouldHaveNoTokens()
        {
            CommandParser parser = new CommandParser();

            var tokens = parser.Parse(string.Empty).Tokens.ToArray();

            Assert.IsTrue(tokens.Length == 0);
        }

        public void cmdParser_HandlesNegativeNumbers()
        {
            FakeDeveloperConsole console = new FakeDeveloperConsole();
            CommandParser parser = new CommandParser("-12", console);

            CommandToken token = parser.Tokens[0];
            Assert.AreEqual(CommandTokenKind.Number, token.Kind);
        }

        public static void Main()
        {
            var reader = new ConsoleReader();
            var writer = new ConsoleWriter();
            var commandParser = new CommandParser();

            Engine.Start(reader, writer, commandParser);
        }

        public void cmdParser_HandlesCodeBlock()
        {
            FakeDeveloperConsole console = new FakeDeveloperConsole();
            CommandParser parser = new CommandParser("{Test()}", console);

            CommandToken token = parser.Tokens[0];
            Assert.AreEqual(CommandTokenKind.CodeBlock, token.Kind);
        }

        public void Parse_NullCommand_ShouldHaveNoTokens()
        {
            CommandParser parser = new CommandParser();

            var tokens = parser.Parse(null).Tokens.ToArray();

            Assert.IsTrue(tokens.Length == 0);
        }

        public void cmdParser_HandlesNegativePrefixedWordAsWord()
        {
            FakeDeveloperConsole console = new FakeDeveloperConsole();
            CommandParser parser = new CommandParser("-hello", console);

            CommandToken token = parser.Tokens[0];
            Assert.AreEqual(CommandTokenKind.Word, token.Kind);
            Assert.AreEqual("-hello", token.String);
        }

		public override void Create(CommandParser Parser)
		{
			Parser.AddCommand(
				new Sequence(
					new KeyWord("GO", true),
					new Cardinal("DIRECTION")),
				new GoProcessor(),
				"Move between rooms.");
		}

        public override CommandParser CreateCustomOpts(CommandParser cli)
        {
            cli.Argument("p", "password",
                         "Password will be passed via environment variable PGPASSWORD; this could be security issue on some systems",
                         "database-password",
                         CommandArgumentFlags.TakesParameter, (p, v) => Options.Add("password", v));

            return cli;
        }

        public void Parse_OneWordCommand_ShouldHaveOneToken()
        {
            CommandParser parser = new CommandParser();

            var tokens = parser.Parse("test").Tokens.ToArray();

            Assert.IsTrue(tokens.Length == 1);
            Assert.AreEqual("test", tokens[0]);
        }