public static Op FetchNextInstruction(IState state, ref ushort pc, ref ushort sp)
 {
     var firstWord = state.Get(pc++);
     return 0 == (firstWord & 0xF) ?
         (Op)DecodeNonBasic(state, firstWord, ref pc, ref sp) :
         (Op)DecodeBasic(state, firstWord, ref pc, ref sp);
 }

 /// <summary>
 /// Constructor
 /// </summary>
 /// <param name="tacticalBlockage"></param>
 /// <param name="currentState"></param>
 public EncounteredBlockageState(ITacticalBlockage tacticalBlockage, IState planningState, BlockageRecoveryDEFCON defcon, SAUDILevel saudi)
 {
     this.TacticalBlockage = tacticalBlockage;
     this.PlanningState = planningState;
     this.Saudi = saudi;
     this.Defcon = defcon;
 }

 static void state_StateChanged(IState newState)
 {
     state.StateChanged -= state_StateChanged;
     state = newState;
     state.StateChanged += state_StateChanged;
     state.Start();
 }

 /// <summary>
 /// Constructs a <b>StateInfo</b> with the given configuration settings 
 /// and states collection.
 /// </summary>
 /// <param name="configSettings">The configuration settings.</param>
 /// <param name="states">The collection of states.</param>
 public StateInfo(
     Hashtable configSettings,
     IState[] states)
 {
     this.configSettings = configSettings;
     this.States = states;
 }

 internal OperationFailedException(IReadOnlyList<IState> operationStates, IReadOnlyList<IState> successStates, IState actualState)
     : base($"Operation failed. Expected a transition from one of [{String.Join(", ", operationStates)}] to one of [{String.Join(", ", successStates)}], but actually reached {actualState}")
 {
     this.OperationStates = operationStates;
     this.SuccessStates = successStates;
     this.ActualState = actualState;
 }

 public NewsCrawlerState(MachineContext context, IState prev)
     : base(context)
 {
     this.prev = prev;
     this._timer = new Util.StaticTimer(TimeSpan.FromMinutes(3));
     InitRssFeed();
 }

		public void Set(AudioClip changeClip, float fadeTime, IState<PlayState> nextState)
		{
			this.audio.SwapSource();
			this.audio.main.clip = changeClip;
			this.fadeTime = fadeTime;
			this.nextState = nextState;
		}

 /// <summary>
 /// Constructor
 /// </summary>
 /// <param name="lane"></param>
 public StayInLaneState(ArbiterLane lane, Probability confidence, IState previous)
 {
     this.Lane = lane;
     this.internalLaneState = new InternalState(lane.LaneId, lane.LaneId, confidence);
     this.IgnorableWaypoints = new List<IgnorableWaypoint>();
     this.CheckPreviousState(previous);
 }

 public void StepHandler(IState state)
 {
     //IEnumerable<AbstractStep> availableSteps = state.GetAvailableSteps();
     //BuildGraph(availableSteps);
     AbstractStep optimalStep = MakeDecision(state);
     _Game.DoStep(optimalStep, _PlayerType);
 }

 public GoldState(IState state)
     : base(state)
 {
     Interest = 0.05m;
     LowerLimit = 1000m;
     UpperLimit = 10000000m;
 }

 public async Task Start(IState initialState, Session session,
     CancellationToken cancellationToken = default(CancellationToken))
 {
     Logging.Logger.Write("Version 1.0.5 : 2016.08.02 14:18", Logging.LogLevel.Self, ConsoleColor.Yellow);
     var state = initialState;
     do
     {
         try
         {
             state = await state.Execute(session, cancellationToken);
         }
         catch (InvalidResponseException)
         {
             session.EventDispatcher.Send(new ErrorEvent
             {
                 Message = "Niantic Servers unstable, throttling API Calls."
             });
         }
         catch (OperationCanceledException)
         {
             session.EventDispatcher.Send(new ErrorEvent { Message = "Current Operation was canceled." });
             state = _initialState;
         }
         catch (Exception ex)
         {
             session.EventDispatcher.Send(new ErrorEvent { Message = ex.ToString() });
             state = _initialState;
         }
     } while (state != null);
 }

        public override void Explore(IState state, string description)
        {
            _state = ((IQuantumState)state);
            this.Text = description;

            Start();
        }

        public bool ChangeState(StateContext context, IState toState, string oldStateName)
        {
            try
            {
                var filterInfo = GetFilters(context.Job);

                var electStateContext = new ElectStateContext(context, toState, oldStateName);
                var electedState = ElectState(electStateContext, filterInfo.ElectStateFilters);

                var applyStateContext = new ApplyStateContext(context, electedState, oldStateName);
                ApplyState(applyStateContext, filterInfo.ApplyStateFilters);

                // State transition was succeeded.
                return true;
            }
            catch (Exception ex)
            {
                var failedState = new FailedState(ex)
                {
                    Reason = "An exception occurred during the transition of job's state"
                };

                var applyStateContext = new ApplyStateContext(context, failedState, oldStateName);

                // We should not use any state changed filters, because
                // some of the could cause an exception.
                ApplyState(applyStateContext, Enumerable.Empty<IApplyStateFilter>());

                // State transition was failed due to exception.
                return false;
            }
        }

        public virtual bool Find(IState initialState)
        {
            if (Strategy == null) return false;

            Strategy.Add(new Node(initialState));
            while (Strategy.Count() > 0)
            {
                var n = Strategy.Remove();
                if (n.Parent != null && n.Successor != null)
                {
                    var eventArgs = new StateExpansionEventArgs(n.Parent.State, n.Successor, n.Cost, n.Depth);
                    OnSuccessorExpanded(this, eventArgs);

                    if (eventArgs.CancelExpansion)
                        return false;
                }

                if (n.State.IsTerminal)
                {
                    CreateSolution(n);
                    return true;
                }

                foreach (var node in n.Expand(_closed))
                {
                    Strategy.Add(node);
                    if (_closed != null) _closed.Add(node.State);
                }

            }

            return false;
        }

		public void Enter(IFiniteStateMachine stateMachine, IState oldState) {
			this.EditorForm.editorcontrol.MouseEnter += onMouseEnter;
			this.EditorForm.editorcontrol.MouseLeave += onMouseLeave;
			this.EditorForm.editorcontrol.MouseDown += onMouseDown;
			this.EditorForm.editorcontrol.MouseUp += onMouseUp;
			this.EditorForm.editorcontrol.MouseDoubleClick += onMouseDoubleClick;
		}

        void Start()
        {
            var idleState = new AIStateIdle(this, 0);
            var wanderState = new AIStateWander(this, 1);
            var combatState = new AIStateCombat(this, 2);
            var hideState = new AIStateHide(this, 3);
            var getHealthState = new AIStateGetHealth(this, 4);

            idleState.WanderID = wanderState.ID;
            idleState.CombatID = combatState.ID;
            idleState.GetHealthID = getHealthState.ID;

            idleState.TimeMax = 5f;

            wanderState.IdleID = idleState.ID;
            wanderState.CombatID = combatState.ID;
            wanderState.GetHealthID = getHealthState.ID;

            combatState.IdleID = idleState.ID;
            combatState.HideID = hideState.ID;

            hideState.IdleID = idleState.ID;

            getHealthState.IdleID = idleState.ID;

            states = new IState[]{idleState, wanderState, combatState, hideState, getHealthState};

            Begin(idleState);
        }

 public RedState(IState state)
     : base(state)
 {
     Interest = decimal.Zero;
     LowerLimit = -100m;
     UpperLimit = decimal.Zero;
 }

 public async Task Start(IState initialState, Session session, CancellationToken cancellationToken = default(CancellationToken))
 {
     _ctx = session;
     var state = initialState;
     do
     {
         try
         {
             state = await state.Execute(session, cancellationToken);
         }
         catch (InvalidResponseException)
         {
             session.EventDispatcher.Send(new ErrorEvent { Message = "The PokemonGo servers are having a bad time, chill." });
         }
         catch (OperationCanceledException)
         {
             session.EventDispatcher.Send(new ErrorEvent { Message = "The bot was stopped." });
             return;
         }
         catch (Exception ex)
         {
             session.EventDispatcher.Send(new ErrorEvent { Message = ex.ToString() });
             state = _initialState;
         }
     } while (state != null);
 }

 public async Task Start(IState initialState, Session session,
     CancellationToken cancellationToken = default(CancellationToken))
 {
     var state = initialState;
     do
     {
         try
         {
             state = await state.Execute(session, cancellationToken);
         }
         catch (InvalidResponseException)
         {
             session.EventDispatcher.Send(new ErrorEvent
             {
                 Message = "Niantic Servers unstable, throttling API Calls."
             });
         }
         catch (OperationCanceledException)
         {
             session.EventDispatcher.Send(new ErrorEvent {Message = "Current Operation was canceled."});
             state = _initialState;
         }
         catch (Exception ex)
         {
             session.EventDispatcher.Send(new ErrorEvent {Message = ex.ToString()});
             state = _initialState;
         }
     } while (state != null);
 }

 public void RegisterState(string name, IState state)
 {
     if (!m_States.ContainsKey(name))
     {
         m_States[name] = state;
     }
 }