anchor.diff:  
   %%--------------------------------------------------------------------
   %% Function: to_lower_list(Keys)
  -%%           Keys = list() of string(), the name of a field in a sip 
  -%%           message 
  +%%           Keys = list() of string(), the name of a field in a sip
  +%%           message
   %% Descrip.: convert header key, to a standard format - lowercase and
  -%%           verbose string() 
  +%%           verbose string()
   %% Returns : list() of string()
   %%--------------------------------------------------------------------
   to_lower_list(Keys) ->
  
positive.code: 
  %%--------------------------------------------------------------------
  %% Function: mod(Key, Func, List)
  %%           Key = string(), the name of a field in a sip message 
  %%           Func = fun()
  %%           List = keylist record()
  %% Descrip.: apply Func to all elements E; 
  %%           E#keyelem{item = F(E#keyelem.item)} - in List, where
  %%           E#keyelem.casekey == to_lower(Key)
  %%           A new #keyelem{key=Key, 
  %%                          casekey=to_lower(CaseKey), 
  %%                          item=Func([])} 
  %%           is added if Key isn't found
  %% Returns : keylist record()
  %%--------------------------------------------------------------------
  
negative.code: 
  
  %%--------------------------------------------------------------------
  %% Note: It may be preferable to store the #keyelem.casekey field as
  %% a atom() rather than a string() - this should speed up
  %% patternmatching, but don't store random strings as atom(), as
  %% atoms are not GCed. It may be possible to convert the headers tags
  %% to atom() when parsed initialy so that yxa can treat them as atom()
  %% internaly and only output them as string().
  %%
  %% Note: this module does some costly list operations, appendning
  %% elements to the end of lists.
  %% There may be datastructure better suited for this need, of adding
  %% elements to both front and end of lists, but note that most
  %% #keyelem.item are probably short, so that the overhead of smarter
  %% datastructures may still be more costly.
  %% It may also be benificial, when several elements are added to the
  %% end of a list - to reverse it, append the new elements in revese
  %% order and then reverse the new list back to it's proper order.
  %% This results in O(3N+2M) rather than O(N * M) (aproximate - M
  %% grows for each element in N) list hd/1 calls
  %% (N = new list of elements to add, M = the orginal list). If N is
  %% small compared to M this results in roughly a O(2M) vs a O(N*M)
  %% algorithm.
  %%--------------------------------------------------------------------
  