public void Main(string argument)
        {
            PistonAction action;
            string       group;

            if (string.IsNullOrEmpty(argument))
            {
                if (!string.IsNullOrEmpty(_runningArguments))
                {
                    argument = _runningArguments;
                }
                else
                {
                    Echo("No arguments. Exiting.");
                    return;
                }
            }
            else
            {
                var args = argument.Split(' ');
                if (args.Length < 2)
                {
                    Echo("ERROR: Insufficient number of arguments (Expects [GROUP_NAME] [COMMAND])");
                    return;
                }

                action = ParsePistonAction(args[1]);
                if (action == PistonAction.Unknown)
                {
                    Echo($"ERROR: Invalid argument: {args[1]}");
                    return;
                }

                if (action == PistonAction.Reverse)
                {
                    action = _lastCommand == PistonAction.Extend ? PistonAction.Retract : PistonAction.Extend;
                }

                _lastCommand = action;
            }

            Echo($"Start: {action} on group {args[0]}");

            var pistonGroup = GridTerminalSystem.GetBlockGroupWithName(args[0]);

            if (pistonGroup == null)
            {
                Echo($"ERROR: Group '{args[0]}' does not exist");
                return;
            }

            var pistons = new List <IMyPistonBase>();

            pistonGroup.GetBlocksOfType(pistons);
            if (pistons.Count == 0)
            {
                Echo($"ERROR: Group '{args[0]}' has no pistons in it");
                return;
            }

            var sortedPistons = SortPistonsByAssignedNumber(pistons);

            Echo($"Number of pistons in group is {sortedPistons.Count}");

            var done = true;

            foreach (var piston in GetPistons(sortedPistons, action))
            {
                if (!piston.Enabled || !piston.IsWorking)
                {
                    continue;
                }

                switch (action)
                {
                case PistonAction.Extend:
                    done = ProcessExtend(piston);
                    break;

                case PistonAction.Retract:
                    done = ProcessRetract(piston);
                    break;
                }

                if (!done)
                {
                    break;
                }
            }

            if (done)
            {
                _runningArguments       = "";
                Runtime.UpdateFrequency = UpdateFrequency.None;
                Echo("Done");
            }
            else
            {
                _runningArguments = argument;
                // Only ask for updates during chain operation
                Runtime.UpdateFrequency = UpdateFrequency.Update10;
            }
        }
 private static IEnumerable <IMyPistonBase> GetPistons(Dictionary <int, IMyPistonBase> sortedPistons,
                                                       PistonAction action)
 {
     return(action == PistonAction.Extend ? sortedPistons.Values : sortedPistons.Values.Reverse());
 }