anchor.diff:  -spec atom_table(bdict()) -> {non_neg_integer(), [[non_neg_integer(),...]]}.
   
   atom_table(#asm{atoms=Atoms}) ->
  -    NumAtoms = gb_trees:size(Atoms),
  -    Sorted = lists:keysort(2, gb_trees:to_list(Atoms)),
  -    Fun = fun({A,_}) ->
  -		  L = atom_to_list(A),
  -		  [length(L)|L]
  -	  end,
  -    AtomTab = lists:map(Fun, Sorted),
  -    {NumAtoms,AtomTab}.
  +    NumAtoms = maps:size(Atoms),
  +    Sorted = lists:keysort(2, maps:to_list(Atoms)),
  +    {NumAtoms,[begin
  +                   L = atom_to_list(A),
  +                   [length(L)|L]
  +               end || {A,_} <- Sorted]}.
   
   %% Returns the table of local functions.
   %%    local_table(Dict) -> {NumLocals, [{Function, Arity, Label}...]}
  
positive.code: %%    atom(Atom, Dict) -> {Index,Dict'}
  -spec atom(atom(), bdict()) -> {pos_integer(), bdict()}.
  
  atom(Atom, #asm{atoms=Atoms0}=Dict) when is_atom(Atom) ->
      case gb_trees:lookup(Atom, Atoms0) of
  	{value,Index} ->
  	    {Index,Dict};
  	none ->
  	    NextIndex = gb_trees:size(Atoms0) + 1,
  	    Atoms = gb_trees:insert(Atom, NextIndex, Atoms0),
  	    {NextIndex,Dict#asm{atoms=Atoms}}
      end.
  
  %% Remembers an exported function.
  
negative.code: 
  -type index() :: non_neg_integer().
  
  -type atom_tab()   :: #{atom() => index()}.
  -type import_tab() :: gb_trees:tree(mfa(), index()).
  -type fname_tab()  :: gb_trees:tree(Name :: term(), index()).
  -type line_tab()   :: gb_trees:tree({Fname :: index(), Line :: term()}, index()).
  -type literal_tab() :: dict:dict(Literal :: term(), index()).
  
  -record(asm,
  	{atoms = #{}                :: atom_tab(),
  	 exports = []		    :: [{label(), arity(), label()}],
  	 locals = []		    :: [{label(), arity(), label()}],
  	 imports = gb_trees:empty() :: import_tab(),
  