anchor.diff:      of
   	Result ->
               loop_state_callback_result(
  -              P, Debug, S,
  -              Q, State_Data, TransOpts, Result)
  +              P, Debug, S, Q, State_Data,
  +              NextEventsR, Hibernate, TimeoutsR, Postpone,
  +              StateCall, Result)
       catch
   	Result ->
               loop_state_callback_result(
  -              P, Debug, S,
  -              Q, State_Data, TransOpts, Result);
  +              P, Debug, S, Q, State_Data,
  +              NextEventsR, Hibernate, TimeoutsR, Postpone,
  +              StateCall, Result);
   	Class:Reason:Stacktrace ->
   	    terminate(Class, Reason, Stacktrace, P, Debug, S, Q)
       end;
   loop_state_callback(
  -  P, Debug, S, Q, State_Data, TransOpts, Actions) ->
  +  P, Debug, S, Q, State_Data,
  +  NextEventsR, Hibernate, TimeoutsR, Postpone,
  +  StateCall, Actions) when is_list(Actions) ->
       %% Tunneled actions from enter/8
       CallEnter = true,
       loop_actions_list(
  -      P, Debug, S, Q, State_Data, TransOpts, Actions, CallEnter).
  +      P, Debug, S, Q, State_Data,
  +      NextEventsR, Hibernate, TimeoutsR, Postpone,
  +      CallEnter, StateCall, Actions).
   
   %% Process the result from the state function.
   %% When TransOpts =:= trans_opts it was a state function call,
   %% otherwise it is an option tuple and it was a state enter call.
   %%
   loop_state_callback_result(
  -  P, Debug, S, Q, {State,_Data} = State_Data, TransOpts, Result) ->
  +  P, Debug, S, Q, {State,_Data} = State_Data,
  +  NextEventsR, Hibernate, TimeoutsR, Postpone,
  +  StateCall, Result) ->
       %%
       case Result of
   	{next_state,State,NewData} ->
               loop_actions(
  -              P, Debug, S, Q, {State,NewData}, TransOpts,
  -              [], false);
  +              P, Debug, S, Q, {State,NewData},
  +              NextEventsR, Hibernate, TimeoutsR, Postpone,
  +              false);
   	{next_state,NextState,NewData}
  -          when ?state_call(TransOpts) ->
  +          when StateCall ->
               loop_actions(
  -              P, Debug, S, Q, {NextState,NewData}, TransOpts,
  -              [], true);
  +              P, Debug, S, Q, {NextState,NewData},
  +              NextEventsR, Hibernate, TimeoutsR, Postpone,
  +              true);
   	{next_state,_NextState,_NewData} ->
               terminate(
                 error,
  
positive.code:             end
      end;
  loop_callback_mode_result(
    P, Debug, S,
    Q, State_Data, TransOpts, CallbackEvent,
    CallbackMode, [], NewCallbackMode, NewStateEnter) ->
      %%
      case NewCallbackMode of
  
negative.code: 		NextState =:= State ->
  		    loop_keep_state(
                        P, Debug, S,
                        Events, NextState_NewData,
                        NextEventsR, Hibernate, TimeoutsR, Postponed_1);
  		true ->
  		    loop_state_change(
                        P, Debug, S,
                        Events, NextState_NewData,
                        NextEventsR, Hibernate, TimeoutsR, Postponed_1)
  	    end;
          _ ->
              %% With sys_debug
  