anchor.diff:      %% Everything we think we wrote is there.
       StoreToNodeResult = dict:fold(fun(Key, Value, Acc) ->
           All = dict:fold(fun(Node, Results, Acc1) ->
  -            case dict:find(Key, Results) of 
  -                {ok, Value} ->
  +            % node_debug("looking at reuslts: ~p", [Results]),
  +
  +            case Results of 
  +                badrpc ->
  +                    node_debug("=> node crashed, considering valid.", []),
                       Acc1 andalso true;
  -                Other ->
  -                    node_debug("Node ~p did not contain result for key: ~p, instead: ~p, should have: ~p", [Node, Key, Other, Value]),
  -                    node_debug("=> Results for node ~p are: ~p", [Node, dict:to_list(Results)]),
  -                    Acc1 andalso false
  +                _ ->
  +                    case dict:find(Key, Results) of 
  +                        {ok, Value} ->
  +                            Acc1 andalso true;
  +                        Other ->
  +                            node_debug("Node ~p did not contain result for key: ~p, instead: ~p, should have: ~p", [Node, Key, Other, Value]),
  +                            node_debug("=> Results for node ~p are: ~p", [Node, dict:to_list(Results)]),
  +                            Acc1 andalso false
  +                    end
               end
           end, true, AllResults),
   
           Acc andalso All
       end, true, Store),
  +
  +    %% Everything we think we wrote is there.
  +    NodesMissingValues = dict:fold(fun(Key, Value, Acc) ->
  +        NodesAcc = dict:fold(fun(Node, Results, Acc1) ->
  +            % node_debug("looking at reuslts: ~p", [Results]),
  +
  +            case Results of 
  +                badrpc ->
  +                    node_debug("=> node crashed, considering valid.", []),
  +                    Acc1 ++ [Node];
  +                _ ->
  +                    case dict:find(Key, Results) of 
  +                        {ok, Value} ->
  +                            Acc1;
  +                        Other ->
  +                            node_debug("Node ~p did not contain result for key: ~p, instead: ~p, should have: ~p", [Node, Key, Other, Value]),
  +                            node_debug("=> Results for node ~p are: ~p", [Node, dict:to_list(Results)]),
  +                            Acc1 ++ [Node]
  +                    end
  +            end
  +        end, [], AllResults),
  +
  +        lists:usort(Acc ++ NodesAcc)
  +    end, [], Store),
   
       %% Everything there is something we wrote.
       NodeToStoreResult = dict:fold(fun(Node, Results, Acc) ->
  
positive.code:         end
      end, true, AllResults),
  
      node_debug("=> written values: ~p", [dict:to_list(Store)]),
      node_debug("=> StoreToNodeResult: ~p", [StoreToNodeResult]),
      node_debug("=> NodeToStoreResult: ~p", [NodeToStoreResult]),
  
      StoreToNodeResult andalso NodeToStoreResult;
  node_postcondition(_NodeState, Command, Response) ->
      node_debug("generic postcondition fired (this probably shouldn't be hit) for command: ~p with response: ~p", 
                 [Command, Response]),
  
negative.code:             default;
          Other ->
              list_to_atom(Other)
      end.
  
  %% @private
  fault_tolerance() ->
      case os:getenv("FAULT_TOLERANCE") of 
          false ->
              0;
          ToleranceString ->
              list_to_integer(ToleranceString)
      end.