anchor.diff:      term().
   
   handle_any(Fun, Args, State, PosMod, PosUser) ->
  +    handle_any(Fun, Args, State, PosMod, PosUser, undefined).
  +
  +
  +%% @private
  +-spec handle_any(atom(), list(), tuple(), pos_integer(), pos_integer(), pos_integer()) ->
  +    {ok, tuple()} |
  +    {ok, term(), tuple()} |
  +    {error, term(), tuple()} |
  +    {error, term(), term(), tuple()} |
  +    term().
  +
  +handle_any(Fun, Args, State, PosMod, PosUser, PosTimeout) ->
       SubMod = element(PosMod, State),
       User = element(PosUser, State),
       Args1 = Args++[User],
       case erlang:function_exported(SubMod, Fun, length(Args1)) of
           true ->
  -            proc_reply(apply(SubMod, Fun, Args1), PosUser, State);
  +            proc_reply(apply(SubMod, Fun, Args1), PosUser, PosTimeout, State);
           false ->
               ok
       end.
   
   
   %% @private
  -proc_reply(Term, PosUser, State) ->
  +proc_reply(Term, PosUser, PosTimeout, State) ->
       case Term of
           {reply, Reply, User1} ->
  -            {reply, Reply, setelement(PosUser, State, User1)};
  -        {reply, Reply, User1, Timeout} ->
  +            Timeout = case PosTimeout of
  +                undefined -> infinity;
  +                _ -> element(PosTimeout, State)
  +            end,
               {reply, Reply, setelement(PosUser, State, User1), Timeout};
  +        {reply, Reply, User1, Timeout1} ->
  +            {reply, Reply, setelement(PosUser, State, User1), Timeout1};
           {noreply, User1} ->
  -            {noreply, setelement(PosUser, State, User1)};
  -        {noreply, User1, Timeout} ->
  +            Timeout = case PosTimeout of
  +                undefined -> infinity;
  +                _ -> element(PosTimeout, State)
  +            end,
               {noreply, setelement(PosUser, State, User1), Timeout};
  +        {noreply, User1, Timeout1} ->
  +            {noreply, setelement(PosUser, State, User1), Timeout1};
           {stop, Reason, User1} ->
               {stop, Reason, setelement(PosUser, State, User1)};
           {stop, Reason, Reply, User1} ->
  
positive.code:     end.
  
  
  %% @private
  -spec handle_call(term(), {pid(), term()}, tuple(), pos_integer(), pos_integer()) ->
      {reply, term(), tuple()} |
      {reply, term(), tuple(), timeout() | hibernate} |
      {noreply, tuple()} |
      {noreply, tuple(), timeout() | hibernate} |
      {stop, term(), term(), tuple()} |
      {stop, term(), tuple()}.
  
  handle_call(Msg, From, State, PosMod, PosUser) ->
      handle_call(handle_call, Msg, From, State, PosMod, PosUser).
  
  
  %% @private
  -spec handle_call(atom(), term(), {pid(), term()}, tuple(), 
                    pos_integer(), pos_integer()) ->
      {reply, term(), tuple()} |
      {reply, term(), tuple(), timeout() | hibernate} |
      {noreply, tuple()} |
      {noreply, tuple(), timeout() | hibernate} |
      {stop, term(), term(), tuple()} |
      {stop, term(), tuple()}.
  
  handle_call(Fun, Msg, From, State, PosMod, PosUser) ->
      SubMod = element(PosMod, State),
      User = element(PosUser, State),
      case erlang:function_exported(SubMod, Fun, 3) of
          true ->
              proc_reply(SubMod:Fun(Msg, From, User), PosUser, State);
          false ->
              {noreply, State}
      end.
  
negative.code: 
  %% @private
  -spec handle_any(atom(), list(), tuple(), pos_integer(), pos_integer()) ->
      {ok, tuple()} |
      {ok, term(), tuple()} |
      {error, term(), tuple()} |
  