anchor.diff:                 interval = Interval,
                  batch_of_msgs = BatchOfMsgs} = State) ->
       {NextStatus, Interval_1} =
  -        case (Interval >= MaxInterval andalso
  +        case ((Interval + StepInterval) >= MaxInterval andalso
                 BatchOfMsgs =< MinBatchProcs) of
               true ->
                   {?ST_SUSPENDING, MaxInterval};
  
positive.code: consume(#state{mq_properties = #mq_properties{
                                    publisher_id = PublisherId,
                                    mod_callback = Mod,
                                    mqdb_id = BackendMessage,
                                    regular_batch_of_msgs = NumOfBatchProcs
                                   }} = _State) ->
      consume(PublisherId, Mod, BackendMessage, NumOfBatchProcs).
  
  %% @doc Consume a message
  %% @private
  -spec(consume(atom(), atom(), atom(), non_neg_integer()) ->
               ok | not_found | {error, any()}).
  consume(_,_,_,0) ->
      ok;
  consume(Id, Mod, BackendMessage, NumOfBatchProcs) ->
      try
  
negative.code:     ok = run(Id),
      {next_state, NextStatus, State#state{status = NextStatus}};
  
  idling(#event_info{event = ?EVENT_INCR_WT},
         #state{mq_properties = #mq_properties{max_interval  = MaxInterval,
                                               step_interval = StepInterval},
                interval = Interval} = State) ->
      NextStatus = ?ST_IDLING,
      Interval_1 = incr_interval_fun(Interval, MaxInterval, StepInterval),
      {next_state, NextStatus, State#state{status = NextStatus,
                                           interval = Interval_1}};
  idling(#event_info{event = ?EVENT_DECR_WT},
         #state{mq_properties = #mq_properties{regular_interval = RegInterval}} = State) ->
      NextStatus = ?ST_IDLING,
      {next_state, NextStatus, State#state{status = NextStatus,
                                           interval = RegInterval}};
  idling(#event_info{event = ?EVENT_INCR_BP},
         #state{mq_properties = #mq_properties{regular_batch_of_msgs  = RegBatchOfMsgs}} = State) ->
      NextStatus = ?ST_IDLING,
      {next_state, NextStatus, State#state{batch_of_msgs = RegBatchOfMsgs,
                                           status = NextStatus}};
  idling(#event_info{event = ?EVENT_DECR_BP},
         #state{mq_properties = #mq_properties{min_batch_of_msgs  = MinBatchOfMsgs,
                                               step_batch_of_msgs = StepBatchOfMsgs},
                batch_of_msgs = BatchOfMsgs} = State) ->
      NextStatus = ?ST_IDLING,
      BatchOfMsgs_1 = decr_batch_procs_fun(BatchOfMsgs, MinBatchOfMsgs, StepBatchOfMsgs),
      {next_state, NextStatus, State#state{batch_of_msgs = BatchOfMsgs_1,
                                           status = NextStatus}};
  idling(_, State) ->
      NextStatus = ?ST_IDLING,
      {next_state, NextStatus, State#state{status = NextStatus}}.
  