anchor.diff:      fault_debug("fault precondition fired for ~p:~p(~p)", [Mod, Fun, Args]),
       false.
   
  +%% General omission.
  +fault_next_state(_State, #fault_model_state{general_omissions=GeneralOmissions} = FaultModelState, _Res, {call, _Mod, begin_omission, [Node]}) ->
  +    FaultModelState#fault_model_state{general_omissions=GeneralOmissions ++ [Node]};
  +
  +fault_next_state(_State, #fault_model_state{general_omissions=GeneralOmissions} = FaultModelState, _Res, {call, _Mod, end_omission, [Node]}) ->
  +    FaultModelState#fault_model_state{general_omissions=GeneralOmissions -- [Node]};
  +
   %% Receive omission.
   fault_next_state(_State, #fault_model_state{receive_omissions=ReceiveOmissions0} = FaultModelState, _Res, {call, _Mod, begin_receive_omission, [SourceNode, DestinationNode]}) ->
       ReceiveOmissions = dict:store({SourceNode, DestinationNode}, true, ReceiveOmissions0),
  
positive.code:                         dict:to_list(ReceiveOmissions0)),
      % fault_debug("=> => receive_omissions: ~p", [ReceiveOmissions]),
  
      lists:usort(SendOmissions ++ ReceiveOmissions ++ CrashedNodes).
  
  %% Is crashed?
  fault_is_crashed(#fault_model_state{crashed_nodes=CrashedNodes}, Name) ->
      lists:member(Name, CrashedNodes).
  
  %% Is this fault allowed?
  fault_allowed({call, _Mod, begin_send_omission, [SourceNode, _DestinationNode] = _Args}, #fault_model_state{tolerance=Tolerance}=FaultModelState) ->
      %% We can tolerate another failure.
      NumActiveFaults = num_active_faults(FaultModelState),
  
negative.code:     length(active_faults(FaultModelState)).
  
  %% Resolvable faults.
  fault_num_resolvable_faults(#fault_model_state{general_omissions=GeneralOmissions, send_omissions=SendOmissions0, receive_omissions=ReceiveOmissions0}) ->
      SendOmissions = lists:map(fun({{SourceNode, _DestinationNode}, true}) -> SourceNode end, 
                          dict:to_list(SendOmissions0)),
      ReceiveOmissions = lists:map(fun({{_SourceNode, DestinationNode}, true}) -> DestinationNode end, 
                          dict:to_list(ReceiveOmissions0)),
      ResolvableFaults = lists:usort(SendOmissions ++ ReceiveOmissions ++ GeneralOmissions),
      length(ResolvableFaults).
  
  %% The nodes that are faulted.
  active_faults(#fault_model_state{crashed_nodes=CrashedNodes, general_omissions=GeneralOmissions, send_omissions=SendOmissions0, receive_omissions=ReceiveOmissions0}) ->
      SendOmissions = lists:map(fun({{SourceNode, _DestinationNode}, true}) -> SourceNode end, 
                          dict:to_list(SendOmissions0)),
      % fault_debug("=> => send_omissions: ~p", [SendOmissions]),
  