anchor.diff:      length(active_faults(FaultModelState)).
   
   %% Resolvable faults.
  -fault_num_resolvable_faults(#fault_model_state{send_omissions=SendOmissions0, receive_omissions=ReceiveOmissions0}) ->
  +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),
  +    ResolvableFaults = lists:usort(SendOmissions ++ ReceiveOmissions ++ GeneralOmissions),
       length(ResolvableFaults).
   
   %% The nodes that are faulted.
  -active_faults(#fault_model_state{crashed_nodes=CrashedNodes, send_omissions=SendOmissions0, receive_omissions=ReceiveOmissions0}) ->
  +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]),
  
positive.code: 
      %% Remove all interposition funs.
      NodesToCrash = lists:foldl(fun(Node, ToCrash) ->
          fault_debug("getting interposition funs at node ~p", [Node]),
  
          case rpc:call(?NAME(Node), ?MANAGER, get_interposition_funs, []) of 
              {badrpc, nodedown} ->
  
negative.code:     CrashedNodes = [],
      SendOmissions = dict:new(),
      ReceiveOmissions = dict:new(),
      GeneralOmissions = [],
  
      #fault_model_state{tolerance=Tolerance,
                         crashed_nodes=CrashedNodes, 
                         send_omissions=SendOmissions,
                         receive_omissions=ReceiveOmissions,
                         general_omissions=GeneralOmissions}.
  
  %% General omission.
  fault_precondition(#fault_model_state{crashed_nodes=CrashedNodes, general_omissions=GeneralOmissions}=FaultModelState, {call, _Mod, begin_omission, [Node]}=Call) ->
      %% Fault must be allowed at this moment.
      fault_allowed(Call, FaultModelState) andalso 
  
      %% Both nodes have to be non-crashed.
      not lists:member(Node, GeneralOmissions) andalso not lists:member(Node, CrashedNodes);
  
  fault_precondition(#fault_model_state{crashed_nodes=CrashedNodes, general_omissions=GeneralOmissions}, {call, _Mod, end_omission, [Node]}) ->
      %% We must be in the middle of a general omission to resolve it.
      lists:member(Node, GeneralOmissions) andalso not lists:member(Node, CrashedNodes);
  
  %% Receive omission.
  fault_precondition(#fault_model_state{crashed_nodes=CrashedNodes, receive_omissions=ReceiveOmissions}=FaultModelState, {call, _Mod, begin_receive_omission, [SourceNode, DestinationNode]}=Call) ->
  