anchor.diff:  
   load_dict([{N,X}|T], [Key|T1], Dict0, L) when N > 0->
       load_dict(T, T1, dict:store(X, Key, Dict0), 
  -	      [encode_obj(X),">",Key|L]);
  +          [encode_obj(X),">",Key|L]);
   load_dict(_, _, Dict, L) ->
       {Dict, L}.
   
  
positive.code: 
  %% intro() -> single line terminated with \n
  
  decode(Str) when is_binary(Str) ->
      case catch decode(Str, decode_init()) of
          {done, Term, Rest} -> {ok, Term, Rest};
          {more, _} = More -> More;
          {error, _} = Error -> Error;
          {'EXIT', Error} -> {error, Error}
      end.
  
  decode_init() -> {more, fun(I) -> decode(I, [[]], dict:new()) end}.
  
  decode(S, {more, Fun}) -> 
      Fun(S).
  
  decode1(S, Stack, D) ->
      decode(S, Stack, D).
  
  decode(<<$',T/binary>>, Stack, Dict) ->
      get_stuff(T, $', <<>>, Stack, Dict);
  decode(<<$~,T/binary>>, [[Int|Stack]|S1], Dict) when is_integer(Int), Int >= 0 ->
      collect_binary(Int, T, <<>>, [Stack|S1], Dict);
  decode(<<$~,_/binary>>, _Stack, _Dict) ->
      exit(tilde);
  decode(<<$%, T/binary>>, Stack, Dict) ->
      get_stuff(T, $%, <<>>, Stack, Dict);
  decode(<<$", T/binary>>, Stack, Dict) ->
      get_stuff(T, $", <<>>, Stack, Dict);
  decode(<<$`, T/binary>>, Stack, Dict) ->
      get_stuff(T, $`, <<>>, Stack, Dict);
  decode(<<$-, T/binary>>, Stack, Dict) ->
      collect_int(T, 0, '-', Stack, Dict);
  decode(<<H, T/binary>>, Stack, Dict) when $0 =< H, H =< $9 ->
      collect_int(T, H-$0, '+', Stack, Dict);
  decode(<<${, T/binary>>, Stack, Dict) ->
      decode1(T, [[]|Stack], Dict);
  decode(<<$}, T/binary>>, [H|Stack], Dict) ->
      decode1(T, push(list_to_tuple(reverse(H)),Stack), Dict);
  decode(<<$&, T/binary>>, [ [H1,H2|T1] | Stack], Dict) ->
      decode1(T, [[[H1|H2]|T1]|Stack], Dict);
  decode(<<$#, T/binary>>, Stack, Dict) ->
      decode1(T, push([], Stack), Dict);
  decode(<<$$, T/binary>>, [[X]], _Dict) ->
      {done, X, T};
  decode(<<$>,Key, T/binary>>, [[Val|R]|Stack], Dict) ->
      decode1(T, [R|Stack], dict:store(Key,Val,Dict));
  decode(<<H, T/binary>>, Stack, Dict) ->
      case special(H) of
  	true ->
  	    decode1(T, Stack, Dict);
  	false ->
  	    decode1(T, push(dict:fetch(H, Dict), Stack), Dict)
      end;
  decode(<<>>, Stack, Dict) ->
      {more, fun(I) -> decode1(I, Stack, Dict) end};
  decode(X, _Stack, _Dict) ->
      {error, {eof, X}}.
  		   
  get_stuff(<<$\\,H,T/binary>>, Stop, L, Stack, Dict) -> 
      get_stuff(T, Stop, <<L/binary,H>>, Stack, Dict);
  get_stuff(<<$',T/binary>>, $', L, Stack, Dict)  -> 
      decode1(T, push(list_to_existing_atom(z_convert:to_list(L)),Stack), Dict);
  get_stuff(<<$",T/binary>>, $", L, Stack, Dict)  -> 
      decode1(T, push(L,Stack), Dict);
  get_stuff(<<$`,T/binary>>, $`, L, [Top|Stack], Dict)  -> 
      decode1(T, push({'$TYPE', L, Top},Stack), Dict);
  get_stuff(<<$%,T/binary>>, $%, _L, Stack, Dict)  -> 
      decode1(T, Stack, Dict);
  get_stuff(<<H,T/binary>>, Stop, L, Stack, Dict) -> 
      get_stuff(T, Stop, <<L/binary, H>>, Stack, Dict);
  get_stuff(<<>>, Stop, L, Stack, Dict) ->
      {more, fun(I) ->		   
  		   get_stuff(I, Stop, L, Stack, Dict) end}.
  
  collect_binary(0, T, L, Stack, Dict) ->
      expect_tilde(T, push(L, Stack), Dict);
  collect_binary(N, <<H,T/binary>>, L, Stack, Dict) ->
      collect_binary(N-1, T, <<L/binary, H>>, Stack, Dict);
  collect_binary(N, <<>>, L, Stack, Dict) ->
      {more, fun(I) -> collect_binary(N, I, L, Stack, Dict) end}.
  
  expect_tilde(<<$~, T/binary>>, Stack, Dict) ->
      decode(T, Stack, Dict);
  expect_tilde(<<>>, Stack, Dict) ->
      {more, fun(I) -> expect_tilde(I, Stack, Dict) end};
  expect_tilde(<<H,_/binary>>, _, _) ->
      exit({expect_tilde, H}).
  
  push(X, [Top|Rest]) -> 
  
negative.code: special_chars() ->    
      " 0123456789{},~%#>\n\r\s\t\"'-&$".
  
  collect_int(<<H,T/binary>>, N, Sign, Stack, Dict, MaxSize) when  $0 =< H, H =< $9 ->
      collect_int(T, N*10 + H - $0, Sign, Stack, Dict, MaxSize);
  collect_int(<<>>, N, Sign, Stack, Dict, MaxSize) ->
      {more, fun(I) -> collect_int(I, N, Sign, Stack, Dict, MaxSize) end};
  collect_int(T, N, '+', Stack, Dict, MaxSize) ->
      decode1(T, push(N, Stack), Dict, MaxSize - erts_debug:size(N));
  collect_int(T, N, '-', Stack, Dict, MaxSize) ->
      decode1(T, push(-N, Stack), Dict, MaxSize - erts_debug:size(N)).
  
  %%---------------------------------------------------------------------
  
  