anchor.diff:  %% perform the update.
   handle_call({update, Id, Operation, Actor}, _From,
               #state{store=Store, counter=Counter}=State) ->
  -    {ok, Result} = case ?CORE:update(Id, Operation, Actor, ?CLOCK_INCR, Store) of
  -                       {error, not_found} ->
  -                           case Id of
  -                               {StorageId, TypeId} ->
  -                                   {ok, {Id, _, _, _}} = ?CORE:declare(StorageId,
  -                                                                       TypeId,
  -                                                                       ?CLOCK_INIT,
  -                                                                       Store),
  -                                   ?CORE:update(Id, Operation, Actor,
  -                                                ?CLOCK_INCR, Store)
  -                           end;
  -                       X ->
  -                           X
  +    Result0 = ?CORE:update(Id, Operation, Actor, ?CLOCK_INCR, Store),
  +    Result1 = not_found_handling(Result0, Id, State, ?CORE, update,
  +                                 [Id, Operation, Actor, ?CLOCK_INCR, Store]),
  +    {ok, Result} = case Result1 of
  +                       {found, Result2} ->
  +                           Result2;
  +                       _ ->
  +                           Result1
                      end,
       {reply, {ok, Result}, State#state{counter=increment_counter(Counter)}};
   
  
positive.code: %% clock to be incremented again and a subsequent broadcast.  However,
  %% this could change if the other module is later refactored.
  handle_call({bind, Id, Metadata0, Value}, _From,
              #state{store=Store, actor=Actor, counter=Counter}=State) ->
      {_Time, Result} = timer:tc(?CORE,
                                 bind,
                                 [Id, Value, ?CLOCK_MERG, Store]),
      Result1 = case Result of
                    {error, not_found} ->
                        case Id of
                            {StorageId, TypeId} ->
                                {ok, {Id, _, _, _}} = ?CORE:declare(StorageId,
                                                                    TypeId,
                                                                    ?CLOCK_INIT,
                                                                    Store),
                                {_Time0, Result0} = timer:tc(?CORE,
                                                             bind,
                                                             [Id, Value,
                                                              ?CLOCK_MERG, Store]),
                                Result0;
                            _ ->
                                {error, not_found}
                        end;
                    X ->
                        X
                end,
      {reply, Result1, State#state{counter=increment_counter(Counter)}};
  
  %% Bind two variables together.
  handle_call({bind_to, Id, DVId}, _From, #state{store=Store}=State) ->
  
negative.code:     {_Time, Value} = timer:tc(?CORE,
                                read,
                                [Id, Threshold, Store, From, ReplyFun, ?BLOCKING]),
      Result0 = not_found_handling(Value, Id, State, timer, tc,
                                   [?CORE, read, [Id, Threshold, Store, From,
                                                  ReplyFun, ?BLOCKING]]),
      case Result0 of
          {error, not_found} ->
              {reply, {error, not_found}, State};
          {found, Result} ->
              Result;
          {_NewTime, Result} ->
              Result
      end;
  
  %% Spawn a process to perform a filter.
  