anchor.diff:      ActiveFaults = 0,
       CrashedNodes = [],
       SendOmissions = dict:new(),
  +    ReceiveOmissions = dict:new(),
  +
       #fault_model_state{active_faults=ActiveFaults, 
                          crashed_nodes=CrashedNodes, 
  -                       send_omissions=SendOmissions}.
  +                       send_omissions=SendOmissions,
  +                       receive_omissions=ReceiveOmissions}.
  +%% Receive omission.
  +fault_precondition(#fault_model_state{crashed_nodes=CrashedNodes}=FaultModelState, {call, _Mod, begin_receive_omission, [SourceNode, DestinationNode]}=Call) ->
  +    %% Fault must be allowed at this moment.
  +    fault_allowed(Call, FaultModelState) andalso 
  +
  +    %% Nodes must not be the same node.
  +    SourceNode =/= DestinationNode andalso
  +
  +    %% Both nodes have to be non-crashed.
  +    not lists:member(SourceNode, CrashedNodes) andalso not lists:member(DestinationNode, CrashedNodes);
  +
  +fault_precondition(#fault_model_state{receive_omissions=ReceiveOmissions}, {call, _Mod, end_receive_omission, [SourceNode, DestinationNode]}) ->
  +    %% We must be in the middle of a send omission to resolve it.
  +    case dict:find({SourceNode, DestinationNode}, ReceiveOmissions) of 
  +        {ok, _Value} ->
  +            true;
  +        error ->
  +            false
  +    end;
   
   %% Send omission.
   fault_precondition(#fault_model_state{crashed_nodes=CrashedNodes}=FaultModelState, {call, _Mod, begin_send_omission, [SourceNode, DestinationNode]}=Call) ->
  
positive.code:     lists:member(Name, CrashedNodes).
  
  %% Is this fault allowed?
  fault_allowed({call, _Mod, begin_send_omission, _Args}, #fault_model_state{active_faults=ActiveFaults}) ->
      Tolerance = ?NUM_NODES - 1,       %% Assumed N+1 fault-tolerance.
      ActiveFaults =< Tolerance;        %% We can tolerate another failure.
  
  fault_allowed({call, _Mod, crash, [Node]}, #fault_model_state{active_faults=ActiveFaults, crashed_nodes=CrashedNodes}) ->
      Tolerance = ?NUM_NODES - 1,       %% Assumed N+1 fault-tolerance.
      ActiveFaults =< Tolerance orelse  %% We can tolerate another failure.
  
      %% or, a send omission can be turned into a crash.
      (ActiveFaults =:= Tolerance andalso lists:member(Node, CrashedNodes)).
  
  %% Should we do node debugging?
  fault_debug(Line, Args) ->
  
negative.code:     fault_debug("fault precondition fired for ~p:~p(~p)", [Mod, Fun, Args]),
      false.
  
  %% Receive omission.
  fault_next_state(#fault_model_state{active_faults=ActiveFaults, receive_omissions=ReceiveOmissions0} = FaultModelState, _Res, {call, _Mod, begin_receive_omission, [SourceNode, DestinationNode]}) ->
      ReceiveOmissions = dict:store({SourceNode, DestinationNode}, true, ReceiveOmissions0),
      FaultModelState#fault_model_state{active_faults=ActiveFaults + 1, receive_omissions=ReceiveOmissions};
  
  fault_next_state(#fault_model_state{active_faults=ActiveFaults, receive_omissions=ReceiveOmissions0} = FaultModelState, _Res, {call, _Mod, end_receive_omission, [SourceNode, DestinationNode]}) ->
      ReceiveOmissions = dict:erase({SourceNode, DestinationNode}, ReceiveOmissions0),
      FaultModelState#fault_model_state{active_faults=ActiveFaults - 1, receive_omissions=ReceiveOmissions};
  
  %% Send omission.
  fault_next_state(#fault_model_state{active_faults=ActiveFaults, send_omissions=SendOmissions0} = FaultModelState, _Res, {call, _Mod, begin_send_omission, [SourceNode, DestinationNode]}) ->
      SendOmissions = dict:store({SourceNode, DestinationNode}, true, SendOmissions0),
  