anchor.diff:  init([Partition]) ->
       PreparedTx = open_table(Partition),
       CommittedTx = ets:new(committed_tx, [set]),
  -    {ok, #state{partition = Partition,
  +    {ok, #state{
  +        partition = Partition,
           prepared_tx = PreparedTx,
           committed_tx = CommittedTx,
           read_servers = ?READ_CONCURRENCY,
  -        prepared_dict = orddict:new()}}.
  +        prepared_dict = orddict:new()
  +    }}.
   
   %% @doc The table holding the prepared transactions is shared with concurrent
   %%      readers, so they can safely check if a key they are reading is being updated.
  
positive.code:         true ->
              case TxWriteSet of
                  [{Key, _Type, _Update} | _] ->
                      Dict = set_prepared(PreparedTx, TxWriteSet, TxId, PrepareTime, dict:new()),
                      NewPrepare = dc_utilities:now_microsec(),
                      ok = reset_prepared(PreparedTx, TxWriteSet, TxId, NewPrepare, Dict),
              NewPreparedDict = orddict:store(NewPrepare, TxId, PreparedDict),
                      LogRecord = #log_operation{tx_id = TxId,
                          op_type = prepare,
                          log_payload = #prepare_log_payload{prepare_time = NewPrepare}},
                      LogId = log_utilities:get_logid_from_key(Key),
                      Node = log_utilities:get_key_partition(Key),
                      Result = logging_vnode:append(Node, LogId, LogRecord),
                      {Result, NewPrepare, NewPreparedDict};
                  _ ->
                      {{error, no_updates}, 0, PreparedDict}
              end;
          false ->
              {{error, write_conflict}, 0, PreparedDict}
      end.
  
  set_prepared(_PreparedTx, [], _TxId, _Time, Acc) ->
      Acc;
  set_prepared(PreparedTx, [{Key, _Type, _Update} | Rest], TxId, Time, Acc) ->
      ActiveTxs = case ets:lookup(PreparedTx, Key) of
                      [] ->
  
negative.code:     Result = clocksi_readitem_server:check_partition_ready(Node, Partition, ?READ_CONCURRENCY),
      {reply, Result, SD0};
  
  handle_command({prepare, Transaction, WriteSet}, _Sender, State = #state{
      partition = _Partition,
      prepared_tx = PreparedTx,
      committed_tx = CommittedTx,
      prepared_dict = PreparedDict
  }) ->
  
      PrepareTime = dc_utilities:now_microsec(),
      {Result, NewPrepare, NewPreparedDict} = prepare(Transaction, WriteSet, CommittedTx, PreparedTx, PrepareTime, PreparedDict),
      case Result of
  