anchor.diff:  %% Issue a local bind, which should increment the local clock and
   %% broadcast the result.
   handle_call({bind, Id, Value}, _From,
  -            #state{store=Store, actor=Actor, counter=Counter}=State) ->
  +            #state{store=Store, actor=Actor}=State) ->
       lasp_marathon_simulations:log_message_queue_size("bind/2"),
   
       Result0 = ?CORE:bind(Id, Value, ?CLOCK_INCR(Actor), Store),
       Result = declare_if_not_found(Result0, Id, State, ?CORE, bind,
                                     [Id, Value, ?CLOCK_INCR(Actor), Store]),
  -    {reply, Result, State#state{counter=increment_counter(Counter)}};
  +    {reply, Result, State};
   
   %% Incoming bind operation; merge incoming clock with the remote clock.
   %%
  
positive.code:     schedule_memory_utilization_report(),
  
      {ok, #state{actor=Actor,
                  counter=Counter,
                  store=Store,
                  gc_counter=GCCounter}}.
  
  
negative.code: %% necessary, where the vclock is serialized *per-node*.
  %%
  handle_call({update, Id, Operation, CRDTActor}, _From,
              #state{store=Store, actor=Actor}=State) ->
      lasp_marathon_simulations:log_message_queue_size("update"),
  
      Result0 = ?CORE:update(Id, Operation, CRDTActor, ?CLOCK_INCR(Actor),
                             ?CLOCK_INIT(Actor), Store),
      {ok, Result} = declare_if_not_found(Result0, Id, State, ?CORE, update,
                                          [Id, Operation, Actor, ?CLOCK_INCR(Actor), Store]),
      {reply, {ok, Result}, State};
  
  %% Spawn a function.
  handle_call({thread, Module, Function, Args},
  