anchor.diff:                  Id = lmq_queue:pull_async(Pid, Timeout),
                   dict:store(Id, Q, Acc)
               end, dict:new(), Queues),
  +            gen_fsm:send_event_after(Timeout, cancel),
               State = S#state{from=From, regexp=Regexp, timeout=Timeout,
  -                            mapping=Mapping,
  -                            end_time=lmq_misc:unixtime()+Timeout/1000},
  -            {next_state, waiting, State, get_timeout(State)}
  +                            mapping=Mapping},
  +            {next_state, waiting, State}
       end;
   
   idle(Event, _From, State) ->
       ?UNEXPECTED(Event, idle),
  -    {reply, error, idle, State, get_timeout(State)}.
  +    {reply, error, idle, State}.
   
   waiting({maybe_pull, QName}, #state{}=S) ->
       case re:compile(S#state.regexp) of
  
positive.code:                     Pid = lmq_queue_mgr:get(QName),
                      Id = lmq_queue:pull_async(Pid, S#state.timeout),
                      Mapping = dict:store(Id, {QName, Pid}, S#state.mapping),
                      {next_state, waiting, S#state{mapping=Mapping}, get_timeout(S)};
                  _ ->
                      {next_state, waiting, S, get_timeout(S)}
              end;
          {error, _} ->
              {next_state, waiting, S, get_timeout(S)}
      end;
  
  waiting(timeout, #state{}=S) ->
      cancel_pull(S#state.mapping),
  
negative.code: 
  waiting(Event, State) ->
      ?UNEXPECTED(Event, waiting),
      {reply, error, waiting, State}.
  
  finalize(timeout, State) ->
      {stop, normal, State};
  
  finalize(Event, State) ->
      ?UNEXPECTED(Event, finalize),
      {reply, error, finalize, State}.
  
  handle_info({Id, #message{}=M}, waiting, #state{mapping=Mapping}=S) ->
      {Name, _} = dict:fetch(Id, Mapping),
  