anchor.diff:  	     {bad_action_from_state_function,Action},
   	     ?STACKTRACE()};
   	postpone when Postpone =/= forbidden ->
  +	    NewPostpone = true,
   	    parse_actions(
   	      Debug, S, State, Actions,
  -	      Hibernate, TimeoutsR, true, NextEventsR);
  +	      Hibernate, TimeoutsR, NewPostpone, NextEventsR);
   	{next_event,Type,Content} ->
   	    case event_type(Type) of
   		true when NextEventsR =/= forbidden ->
  
positive.code: 
  %% Interpret all callback return variants
  parse_event_result(
    AllowStateChange, Debug, S, TimerRefs, TimerTypes, CancelTimers,
    Events, Event, State, Data, Hibernate, Result) ->
      case Result of
  	stop ->
  	    terminate(
  	      exit, normal, ?STACKTRACE(), Debug,
  	      S#{
  		timer_refs := TimerRefs,
  		timer_types := TimerTypes,
  		cancel_timers := CancelTimers,
  		hibernate := Hibernate},
  	      [Event|Events]);
  	{stop,Reason} ->
  	    terminate(
  	      exit, Reason, ?STACKTRACE(), Debug,
  	      S#{
  		timer_refs := TimerRefs,
  		timer_types := TimerTypes,
  		cancel_timers := CancelTimers,
  		hibernate := Hibernate},
  	      [Event|Events]);
  	{stop,Reason,NewData} ->
  	    terminate(
  	      exit, Reason, ?STACKTRACE(), Debug,
  	      S#{
  		data := NewData,
  		timer_refs := TimerRefs,
  		timer_types := TimerTypes,
  		cancel_timers := CancelTimers,
  		hibernate := Hibernate},
  	      [Event|Events]);
  	%%
  	{stop_and_reply,Reason,Replies} ->
  	    Q = [Event|Events],
  	    reply_then_terminate(
  	      exit, Reason, ?STACKTRACE(), Debug,
  	      S#{
  		timer_refs := TimerRefs,
  		timer_types := TimerTypes,
  		cancel_timers := CancelTimers,
  		hibernate := Hibernate},
  	      Q, Replies);
  	{stop_and_reply,Reason,Replies,NewData} ->
  	    Q = [Event|Events],
  	    reply_then_terminate(
  	      exit, Reason, ?STACKTRACE(), Debug,
  	      S#{
  		data := NewData,
  		timer_refs := TimerRefs,
  		timer_types := TimerTypes,
  		cancel_timers := CancelTimers,
  		hibernate := Hibernate},
  	      Q, Replies);
  	%%
  	{next_state,State,NewData} ->
  	    {NewData,State,[],false};
  	{next_state,NextState,NewData} when AllowStateChange ->
  	    {NewData,NextState,[],true};
  	{next_state,State,NewData,Actions} ->
  	    {NewData,State,Actions,false};
  	{next_state,NextState,NewData,Actions} when AllowStateChange ->
  	    {NewData,NextState,Actions,true};
  	%%
  	{keep_state,NewData} ->
  	    {NewData,State,[],false};
  	{keep_state,NewData,Actions} ->
  	    {NewData,State,Actions,false};
  	keep_state_and_data ->
  	    {Data,State,[],false};
  	{keep_state_and_data,Actions} ->
  	    {Data,State,Actions,false};
  	%%
  	{repeat_state,NewData} ->
  	    {NewData,State,[],true};
  	{repeat_state,NewData,Actions} ->
  	    {NewData,State,Actions,true};
  	repeat_state_and_data ->
  	    {Data,State,[],true};
  	{repeat_state_and_data,Actions} ->
  	    {Data,State,Actions,true};
  	%%
  	_ ->
  	    terminate(
  	      error,
  	      {bad_return_from_state_function,Result},
  	      ?STACKTRACE(),
  	      Debug,
  	      S#{
  		timer_refs := TimerRefs,
  		timer_types := TimerTypes,
  		cancel_timers := CancelTimers,
  		hibernate := Hibernate},
  	      [Event|Events])
      end.
  
  
  parse_enter_actions(
    Debug, S, State, Actions,
    Hibernate, TimeoutsR) ->
      Postpone = forbidden,
      NextEventsR = forbidden,
      parse_actions(
  
negative.code:       postponed => P,
        %%
        %% The following fields are finally set from to the arguments to
        %% loop_event_actions/9 when it finally loops back to loop/3
        %% in loop_event_result/11
        timer_refs => TimerRefs,
        timer_types => TimerTypes,
        hibernate => Hibernate,
  