anchor.diff:                {Node,T,Added,[{new_nodes,[Other|_]=NewNodes},_Abcast,_Ops]} <- Ns],
       Act ++ Pass.
   
  -show_spurious(NodeTrace, Spurious) ->
  -    Pairs = [{Node,ActionNode} || {{Node,ActionNode}, _Time} <- Spurious],
  -    S = sofs:restriction(sofs:relation(NodeTrace), sofs:set(Pairs)),
  +show_spurious(NodeTraceL, SpuriousL) ->
  +    TraceDomL = [{Node,ActionNode} ||
  +                    {{Node,ActionNode}, _Ts} <- NodeTraceL],
  +    SpuriousDomL = [{Node,ActionNode} ||
  +                       {{Node,ActionNode}, _Times} <- SpuriousL],
  +    S = sofs:restriction(sofs:relation(NodeTraceL), sofs:set(SpuriousDomL)),
  +    %% Some spurious lost:
  +    Spurious = sofs:restriction(sofs:relation(SpuriousL), sofs:set(TraceDomL)),
       [foo || 
           {{{Node,ANode},Times},
  -         {{Node,ANode},Ts}} <- lists:zip(family(Spurious), 
  +         {{Node,ANode},Ts}} <- lists:zip(family(sofs:to_external(Spurious)),
                                            sofs:to_external(S)),
  -        show_spurious(Node, ANode, Times, lists:keysort(2, Ts))].
  -
  -show_spurious(Node, ActionNode, Times, Ts) ->
  +        show_spurious2(Node, ANode, Times, lists:keysort(2, Ts))].
  +
  +show_spurious2(Node, ActionNode, Times, Ts) ->
       io:format("** Actions for ~p on node ~p **~n", [ActionNode, Node]),
       lists:map(fun(T) -> spurious(Node, T, Times) end, Ts),
       io:format("-- End of actions for ~p on node ~p --~n", [ActionNode, Node]),
  
positive.code: %%% For one thing, the trace from all nodes are written onto the file
  %%% as one single term. One term per node would be better. &c.
  
  -compile(export_all).
  
  -record(state, {connect_all, known = [], synced = [],
  		resolvers = [], syncers = [], node_name = node(),
  		the_locker, the_deleter, the_registrar, trace = [],
                  global_lock_down
                 }).
  
  %% Compatible with different versions.
  state(#state{}=S) ->
      S;
  state({state, ConnectAll, Known, Synced, LockersResolvers, Syncers,
         NodeName, TheLocker, TheDeleter}) ->
      %% r10b: Lockers, r10b_patched, r11b: Resolvers
      #state{connect_all = ConnectAll, known = Known, synced = Synced,
             resolvers = LockersResolvers, syncers = Syncers, 
             node_name = NodeName, the_locker = TheLocker, 
             the_deleter = TheDeleter, the_registrar = undefined, trace = []};
  state({state, ConnectAll, Known, Synced, Resolvers, Syncers,
         NodeName, TheLocker, TheDeleter, Trace}) ->
      %% r11b, some time before r11b-3
      #state{connect_all = ConnectAll, known = Known, synced = Synced,
             resolvers = Resolvers, syncers = Syncers, 
             node_name = NodeName, the_locker = TheLocker, 
             the_deleter = TheDeleter, the_registrar = undefined, 
             trace = Trace};
  state({state, ConnectAll, Known, Synced, Resolvers, Syncers,
         NodeName, TheLocker, TheDeleter, TheRegistrar, Trace}) ->
      %% r11b, some time after r11b-3
      #state{connect_all = ConnectAll, known = Known, synced = Synced,
             resolvers = Resolvers, syncers = Syncers, 
             node_name = NodeName, the_locker = TheLocker, 
             the_deleter = TheDeleter, the_registrar = TheRegistrar, 
             trace = Trace, global_lock_down = false};
  state(Else) ->
      Else.
  
  %%% Trace tuples look like {Node, Now, Message, Nodes, Extra}.
  %%% Nodes is the list as returned by nodes().
  
negative.code:     [setelement(2, adj_tag(T, Base), adjust_time(element(2, T), Base)) || 
          T <- Ts].
  
  adj_tag({Node, Time, {M, Node2}, Nodes, Extra}=T, _Base) ->
      if
          M =:= new_resolver;
          M =:= kill_resolver;
          M =:= exit_resolver ->
              {Node, Time, {M, Node2}, Nodes, Extra};
          true ->
              T
      end.
  