anchor.diff:  %% Table owners exits mess things up.
   dependent({_Lid1, { ets, {   _Op,                     [Table|_Rest]}}, _Msgs1},
             {_Lid2, {exit, {normal, {{_Heirs, Tables}, _Name, _Links}}}, _Msgs2},
  -          _ChkMsg, _Swap) ->
  +          _CheckMsg, _AllowSwap) ->
       lists:keymember(Table, 1, Tables);
   
   %% Heirs exit should also be monitored.
   %% Links exit should be monitored to be sure that messages are captured.
   dependent({Lid1, {exit, {normal, {{Heirs1, _Tbls1}, _Name1, Links1}}}, _Msgs1},
             {Lid2, {exit, {normal, {{Heirs2, _Tbls2}, _Name2, Links2}}}, _Msgs2},
  -          _ChkMsg, true) ->
  +          _CheckMsg, ?SYMMETRIC) ->
       lists:member(Lid1, Heirs2) orelse lists:member(Lid2, Heirs1) orelse
           lists:member(Lid1, Links2) orelse lists:member(Lid2, Links1);
   
  
positive.code: %% Sending using name to a process that may exit and unregister.
  dependent({_Lid1, {send,                     {TName, _TLid, _Msg}}, _Msgs1},
            {_Lid2, {exit, {normal, {_Tables, {ok, TName}, _Links}}}, _Msgs2},
            _ChkMsg, _Swap) ->
      true;
  
  %% Send using name before process has registered itself (or after ungeristering).
  dependent({_Lid1, {register,      {RegName, _TLid}}, _Msgs1},
            {_Lid2, {    send, {RegName, _Lid, _Msg}}, _Msgs2},
            _ChkMsg, _Swap) ->
      true;
  
  %% Two registers using the same name or the same process.
  dependent({_Lid1, {register, {RegName1, TLid1}}, _Msgs1},
            {_Lid2, {register, {RegName2, TLid2}}, _Msgs2},
            _ChkMsg, true) ->
      RegName1 =:= RegName2 orelse TLid1 =:= TLid2;
  
  %% Register a process that may exit.
  dependent({_Lid1, {register, {_RegName, TLid}}, _Msgs1},
            { TLid, {    exit,  {normal, _Info}}, _Msgs2},
            _ChkMsg, _Swap) ->
      true;
  
  %% Register for a name that might be in use.
  dependent({_Lid1, {register,                           {Name, _TLid}}, _Msgs1},
            {_Lid2, {    exit, {normal, {_Tables, {ok, Name}, _Links}}}, _Msgs2},
            _ChkMsg, _Swap) ->
      true;
  
  %% Whereis using name before process has registered itself.
  dependent({_Lid1, {register, {RegName, _TLid1}}, _Msgs1},
            {_Lid2, { whereis, {RegName, _TLid2}}, _Msgs2},
            _ChkMsg, _Swap) ->
      true;
  
  %% Process alive and exits
  dependent({_Lid1, {is_process_alive,            TLid}, _Msgs1},
            { TLid, {            exit, {normal, _Info}}, _Msgs2},
            _ChkMsg, _Swap) ->
      true;
  
  %% Process registered and exits
  dependent({_Lid1, {whereis,                          {Name, _TLid1}}, _Msgs1},
            {_Lid2, {   exit, {normal, {_Tables, {ok, Name}, _Links}}}, _Msgs2},
            _ChkMsg, _Swap) ->
      true;
  
  %% Monitor/Demonitor and exit.
  dependent({_Lid, {Linker,            TLid}, _Msgs1},
            {TLid, {  exit, {normal, _Info}}, _Msgs2},
            _ChkMsg, _Swap)
    when Linker =:= demonitor; Linker =:= link; Linker =:= unlink ->
      true;
  
  dependent({_Lid, {monitor, {TLid, _MonRef}}, _Msgs1},
            {TLid, {   exit, {normal, _Info}}, _Msgs2},
            _ChkMsg, _Swap) ->
      true;
  
  %% Trap exits flag and linked process exiting.
  dependent({Lid1, {process_flag,        {trap_exit, _Value, Links1}}, _Msgs1},
            {Lid2, {        exit, {normal, {_Tables, _Name, Links2}}}, _Msgs2},
            _ChkMsg, _Swap) ->
      lists:member(Lid2, Links1) orelse lists:member(Lid1, Links2);
  
  %% Swap the two arguments if the test is not symmetric by itself.
  dependent(TransitionA, TransitionB, ChkMsgs, true) ->
      dependent(TransitionB, TransitionA, ChkMsgs, false);
  dependent(_TransitionA, _TransitionB, _ChkMsgs, false) ->
      false.
  
  
  %% ETS table dependencies:
  
  dependent_ets(Op1, Op2) ->
      dependent_ets(Op1, Op2, false).
  
  dependent_ets({insert, [T, _, Keys1, KP, Objects1, true]},
                {insert, [T, _, Keys2, KP, Objects2, true]}, false) ->
      case ordsets:intersection(Keys1, Keys2) of
          [] -> false;
          Keys ->
  
negative.code: %% ETS operations live in their own small world.
  dependent({_Lid1, {ets, Op1}, _Msgs1},
            {_Lid2, {ets, Op2}, _Msgs2},
            _CheckMsg, ?SYMMETRIC) ->
      dependent_ets(Op1, Op2);
  
  %% Registering a table with the same name as an existing one.
  dependent({_Lid1, { ets, {   new,           [_Table, Name, Options]}}, _Msgs1},
            {_Lid2, {exit, {normal, {{_Heirs, Tables}, _Name, _Links}}}, _Msgs2},
            _CheckMsg, _AllowSwap) ->
      NamedTables = [N || {_Lid, {ok, N}} <- Tables],
      lists:member(named_table, Options) andalso
          lists:member(Name, NamedTables);
  