anchor.diff:  
   -ignore_xref([start_vnode/1]).
   
  --record(state, {partition, table}).
  +-record(state, {partition, variables}).
   
   -record(dv, {value,
                next = undefined,
  
positive.code:                     NextKey = next_key(DV#dv.next, DV#dv.type),
                      BindingList = lists:append(DV#dv.binding_list, [FromId]),
                      DV1 = DV#dv{binding_list=BindingList, next=NextKey},
                      true = ets:insert(Table, {TargetId, DV1}),
                      reply_fetch(FromId, FromP, DV1),
                      {noreply, State}
                  end
      end;
  
  handle_command({reply_fetch, FromId, FromP, FetchDV}, _From,
                 State=#state{table=Table}) ->
        if
          FetchDV#dv.bounded == true ->
              Value = FetchDV#dv.value,
              Next = FetchDV#dv.next,
              Type = FetchDV#dv.type,
              write(Type, Value, Next, FromId, Table),
              reply_to_all([FromP], {ok, Next});
          true ->
              [{_,DV}] = ets:lookup(Table, FromId),
              DV1 = DV#dv{next= FetchDV#dv.next},
              ets:insert(Table, {FromId, DV1}),
              reply_to_all([FromP], {ok, FetchDV#dv.next})
        end,
        {noreply, State};
  
  handle_command({notify_value, Id, Value}, _From,
                 State=#state{table=Table}) ->
      [{_, DV}] = ets:lookup(Table, Id),
      Next = DV#dv.next,
      Type = DV#dv.type,
      write(Type, Value, Next, Id, Table),
      {noreply, State};
  
  handle_command({thread, Module, Function, Args}, _From, State) ->
  
negative.code:                 [_H|_T] ->
                      {reply, ok, State};
                  _ ->
                      true = ets:insert(Variables, {Id, V#dv{lazy=true, creator=From}}),
                      {noreply, State}
                  end
      end;
  
  handle_command({read, X}, From,
                 State=#state{variables=Variables}) ->
      [{_Key, V}] = ets:lookup(Variables, X),
      Value = V#dv.value,
      Bounded = V#dv.bounded,
      Creator = V#dv.creator,
  