anchor.diff:  
   %% @private
   read(Node, Key) ->
  +    ImplementationModule = implementation_module(),
  +
       ?PROPERTY_MODULE:command_preamble(Node, [read, Node, Key]),
   
  -    Result = rpc:call(?NAME(Node), implementation_module(), read, [Key], 4000),
  -
  -    ?PROPERTY_MODULE:command_conclusion(Node, [write, Node, Key]),
  +    Result = rpc:call(?NAME(Node), ImplementationModule, read, [Key], ImplementationModule:timeout()),
  +    node_debug("read of key ~p returned: ~p", [Key, Result]),
  +
  +    ?PROPERTY_MODULE:command_conclusion(Node, [read, Node, Key]),
   
       Result.
   
   %% @private
   write(Node, Key, Value) ->
  +    ImplementationModule = implementation_module(),
  +
       ?PROPERTY_MODULE:command_preamble(Node, [write, Node, Key, Value]),
   
  -    Result = rpc:call(?NAME(Node), implementation_module(), write, [Key, Value], 4000),
  +    Result = rpc:call(?NAME(Node), implementation_module(), write, [Key, Value], ImplementationModule:timeout()),
  +    node_debug("write of key ~p value ~p returned: ~p", [Key, Value, Result]),
   
       ?PROPERTY_MODULE:command_conclusion(Node, [write, Node, Key, Value]),
   
  
positive.code: 
  %% Assertion commands.
  node_assertion_functions() ->
      [verify].
  
  %% Global functions.
  node_global_functions() ->
  
negative.code:     NodeState;
  node_next_state(_State, NodeState, _Response, {call, ?MODULE, read, [_Node, _Key]}) ->
      NodeState;
  node_next_state(_State, NodeState, {badrpc, timeout}, {call, ?MODULE, write, [_Node, _Key, _Value]}) ->
      NodeState;
  node_next_state(_State, #node_state{store=Store0}=NodeState, _Response, {call, ?MODULE, write, [_Node, Key, Value]}) ->
      Store = dict:store(Key, Value, Store0),
      node_debug("store is now: ~p", [dict:to_list(Store)]),
      NodeState#node_state{store=Store};
  node_next_state(_State, NodeState, Response, Command) ->
      node_debug("generic state transition made for response: ~p command: ~p", [Response, Command]),
  