anchor.diff:      lists:member(Name, CrashedNodes).
   
   %% Is this fault allowed?
  +fault_allowed({call, _Mod, begin_receive_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, 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}) ->
  +fault_allowed({call, _Mod, crash, [Node]}, #fault_model_state{active_faults=ActiveFaults, send_omissions=SendOmissions0, receive_omissions=ReceiveOmissions0}) ->
  +    SendOmissions = lists:map(fun({Omission, true}) -> Omission end, dict:to_list(SendOmissions0)),
  +    ReceiveOmissions = lists:map(fun({Omission, true}) -> Omission end, dict:to_list(ReceiveOmissions0)),
  +
       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)).
  +    %% Or, an omission can be turned into a crash.
  +    (ActiveFaults =:= Tolerance andalso 
  +
  +        %% Destination node of receive omissions and source node of send omissions:
  +        %% Idea: crash where the existing fault is already occuring.
  +        (lists:keymember(Node, 2, ReceiveOmissions) orelse lists:keymember(Node, 1, SendOmissions))).
   
   %% Should we do node debugging?
   fault_debug(Line, Args) ->
  
positive.code:     FaultModelState#fault_model_state{active_faults=ActiveFaults - 1, send_omissions=SendOmissions};
  
  %% Crashing a node adds a node to the crashed state.
  fault_next_state(#fault_model_state{active_faults=ActiveFaults, crashed_nodes=CrashedNodes} = FaultModelState, _Res, {call, _Mod, crash, [Node]}) ->
      FaultModelState#fault_model_state{active_faults=ActiveFaults + 1, crashed_nodes=CrashedNodes ++ [Node]};
  
  fault_next_state(FaultModelState, _Res, _Call) ->
      FaultModelState.
  
  %% Send omission.
  fault_postcondition(_FaultModelState, {call, _Mod, begin_send_omission, [_SourceNode, _DestinationNode]}, ok) ->
  
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),
  