anchor.diff:  
   compile(B) ->
       Words = to_words(<<B/binary, " ">>, <<>>, []),
  -    Functions = get_functions(Words),
  -    AWords = remove_after_define(Words),
  +    Macros = get_macros(Words),
  +    YWords = remove_macros(Words),
  +    ZWords = apply_macros(Macros, YWords),
  +    Functions = get_functions(ZWords),
  +    AWords = remove_after_define(ZWords),
       BWords = replace_name_function(AWords, Functions),
       to_opcodes(BWords, Functions, []).
  +remove_macros(Words) -> remove_macros(Words, []).
  +remove_macros([], Out) -> Out;
  +remove_macros([<<":m">>|Words], Out) ->
  +    {_, B} = split(<<";">>, Words),
  +    remove_macros(B, Out);
  +remove_macros([W|Words], Out) ->
  +    remove_macros(Words, Out ++ [W]).
  +apply_macros(Macros, Words) -> apply_macros(Macros, Words, []).
  +apply_macros(_, [], Out) -> Out;
  +apply_macros(Macros, [W|Words], Out) -> 
  +    NOut = case dict:find(W, Macros) of
  +	       error -> Out ++ [W];
  +	       {ok, Val} -> Out ++ Val
  +	   end,
  +    apply_macros(Macros, Words, NOut).
  +get_macros(Words) ->
  +    get_macros(Words, dict:new()).
  +get_macros([<<":m">>|[Name|R]], Functions) ->
  +    %Make sure Name isn't on the restricted list.
  +    {Code, T} = split(<<";">>, R),
  +    Code2 = apply_macros(Functions, Code),
  +    %Opcodes = to_opcodes(Code, Functions, []),
  +    NewFunctions = dict:store(Name, Code2, Functions),
  +    get_macros(T, NewFunctions);
  +get_macros([], Functions) -> Functions;
  +get_macros([_|T], Functions) -> get_macros(T, Functions).
   get_functions(Words) ->
       get_functions(Words, dict:new()).
   get_functions([<<":">>|[Name|R]], Functions) ->
  +    %Make sure Name isn't on the restricted list.
       {Code, T} = split(<<";">>, R),
       Opcodes = to_opcodes(Code, Functions, []),
       NewFunctions = dict:store(Name, hash:doit(Opcodes),Functions),
  
positive.code:     to_opcodes(R, F, [1|Out]);
  to_opcodes([<<"hash">>|R], F, Out) ->
      to_opcodes(R, F, [0|Out]);
  to_opcodes([], _, Out) -> flip(Out);
  to_opcodes([Name|R], Functions, Out) ->
      case dict:find(Name, Functions) of
  
negative.code: 	{ok, Val} -> rnf(T, Functions, [Val|Out])
      end.
  b2i(X) -> list_to_integer(binary_to_list(X)).
  to_opcodes([<<"binary">>|[B|R]], Functions, Out) ->
      to_opcodes(R, Functions, [base64:decode(B)|Out]);
  to_opcodes([<<"integer">>|[I|R]], Functions, Out) ->
      to_opcodes(R, Functions, [{integer, b2i(I)}|Out]);
  to_opcodes([<<"fraction">>|[T|[B|R]]], Functions, Out) ->
      to_opcodes(R, Functions, [{f, b2i(T), b2i(B)}|Out]);
  to_opcodes([<<"false">>|R], Functions, Out) ->
      to_opcodes(R, Functions, [false|Out]);
  