anchor.diff:      %% Just the top level here.
       unify_prove_body(F, '.', A, 2, Next, Cps, Bs, Vn, Db);
   prove_functor({_}=Var, F0, A0, Next, Cps, Bs0, Vn0, Db) ->
  -    case {dderef(F0, Bs0),dderef(A0, Bs0)} of
  +    case {deref(F0, Bs0),deref(A0, Bs0)} of
   	{'.',2} ->				%He, he, he!
   	    Bs1 = add_binding(Var, [{Vn0}|{Vn0+1}], Bs0),
   	    prove_body(Next, Cps, Bs1, Vn0+2, Db);
  
positive.code:     end.
  
  %% prove_arg(Index, Term, Arg, Next, ChoicePoints, VarNum, Database) -> void.
  %%  Prove the goal arg(I, Ct, Arg), Index and Term have been dereferenced.
  
  prove_arg(I, [H|T], A, Next, Cps, Bs, Vn, Db) when is_integer(I) ->
      %% He, he, he!
      if  I == 1 -> unify_prove_body(H, A, Next, Cps, Bs, Vn, Db);
  	I == 2 -> unify_prove_body(T, A, Next, Cps, Bs, Vn, Db);
  	true -> {fail,Db}
      end;
  prove_arg(I, Ct, A, Next, Cps, Bs, Vn, Db)
    when is_integer(I), tuple_size(Ct) >= 2 ->
      if  I >= 1, I + 1 =< tuple_size(Ct) ->
  	    unify_prove_body(element(I+1, Ct), A, Next, Cps, Bs, Vn, Db);
  	true -> {fail,Db}
      end;
  prove_arg(I, Ct, _, _, _, _, _, Db) ->
      %%Type failure just generates an error.
      if  not(is_integer(I)) -> erlog_int:type_error(integer, I, Db);
  	true -> erlog_int:type_error(compound, Ct, Db)
      end.
  
  %% prove_functor(Term, Functor, Arity, Next, ChoicePoints, Bindings, VarNum, Database) -> void.
  %%  Prove the call functor(T, F, A), Term has been dereferenced.
  
negative.code: 
  prove_atom_chars(A, L, Next, Cps, Bs, Vn, Db) ->
      %% After a suggestion by Sean Cribbs.
      case deref(A, Bs) of
          Atom when is_atom(Atom) ->
              AtomList = [ list_to_atom([C]) || C <- atom_to_list(Atom) ],
              unify_prove_body(L, AtomList, Next, Cps, Bs, Vn, Db);
  