anchor.diff:  
   -export(
      [
  -      parse/1
  +      parse/2
      ]).
   
  -parse({file, XmlFile}) ->
  +parse({file, XmlFile}, Options) ->
      {RootElem, []} = xmerl_scan:file(XmlFile),
  -   init(RootElem);
  -
  -parse(XmlText) ->
  +   init(RootElem, Options);
  +
  +parse(XmlText, Options) ->
      {RootElem, []} = xmerl_scan:string(XmlText),
  -   init(RootElem).
  -
  -init(RootElem) ->
  +   init(RootElem, Options).
  +
  +init(RootElem, Options) ->
      Dicts = erlang_fast_dicts:init(),
      DictName = string_to_dic(get_attribute(dictionary, RootElem, global)),
      Dicts1 = erlang_fast_dicts:new_dict(DictName, Dicts),
      Dicts2 = erlang_fast_dicts:new_dict(?type_dictionary(<<"any">>), Dicts1),
  -   {Dicts3, TList} = parse_template(RootElem, Dicts2, DictName, erlang_fast_templates:init()),
  +   {Dicts3, TList} = parse_template(RootElem, Dicts2, DictName, Options, erlang_fast_templates:init()),
      {Dicts3, #templates{
            ns = get_bin_attribute(ns, RootElem),
            templateNs = get_bin_attribute(templateNs, RootElem),
            dictionary = DictName,
            tlist = TList}}.
   
  -parse_template([], Dicts, _DefDict, Templates) ->
  +parse_template([], Dicts, _DefDict, _Options, Templates) ->
      {Dicts, Templates};
   
  -parse_template(#xmlElement{name = templates, content = Childs}, Dicts, DefDict, Templates) ->
  -   parse_template(Childs, Dicts, DefDict, Templates);
  -
  -parse_template([XmlElem = #xmlElement{content = Childs} | Rest], Dicts, DefDict, Templates) ->
  +parse_template(#xmlElement{name = templates, content = Childs}, Dicts, DefDict, Options, Templates) ->
  +   parse_template(Childs, Dicts, DefDict, Options, Templates);
  +
  +parse_template([XmlElem = #xmlElement{content = Childs} | Rest], Dicts, DefDict, Options, Templates) ->
      TemplateName = get_bin_attribute(name, XmlElem),
      DictName = string_to_dic(get_attribute(dictionary, XmlElem, DefDict)),
      Dicts1 = erlang_fast_dicts:new_dict(DictName, Dicts),
      Dicts2 = erlang_fast_dicts:new_dict(?template_dictionary(TemplateName), Dicts1),
  -   {Dicts3, Instructions, _} = parse_instruction(Childs, Dicts2, DictName),
  +   {Dicts3, Instructions, _} = parse_instruction(Childs, Dicts2, DictName, Options),
      Template = #template{
                     name = get_bin_attribute(name, XmlElem),
                     templateNs = get_bin_attribute(templateNs, XmlElem),
  
positive.code:                   dictionary = DictName,
                    instructions = Instructions},
     Templates1 = erlang_fast_templates:add_template(Template, Templates),
     parse_template(Rest, Dicts3, DefDict, Templates1);
  
  parse_template([#xmlText{} | Rest], Dicts, DefDict, Templates) ->
     parse_template(Rest, Dicts, DefDict, Templates);
  
  parse_template([#xmlComment{} | Rest], Dicts, DefDict, Templates) ->
     parse_template(Rest, Dicts, DefDict, Templates).
  
  parse_instruction([], Dicts, _DefDict) ->
     {Dicts, [], false};
  
  parse_instruction([I = #xmlElement{name = typeRef} | Tail], Dicts, DefDict) ->
     TypeName = get_attribute(name, I),
     Dicts1 = erlang_fast_dicts:new_dict(?type_dictionary(TypeName), Dicts),
     {Dicts2, Instructions, NeedPMap} = parse_instruction(Tail, Dicts1, DefDict),
     {Dicts2, [#typeRef{
              name = get_bin_attribute(name, I),
              ns = get_bin_attribute(ns, I)} | Instructions], NeedPMap or false};
  
  parse_instruction([I = #xmlElement{name = templateRef} | Tail], Dicts, DefDict) ->
     {Dicts1, Instructions, NeedPMap} = parse_instruction(Tail, Dicts, DefDict),
     {Dicts1, [#templateRef{
              name = get_bin_attribute(name, I),
              templateNs = get_bin_attribute(templateNs, I),
              ns = get_bin_attribute(ns, I)} | Instructions], NeedPMap or false};
  
  parse_instruction([I = #xmlElement{name = string = T, content = Childs} | Tail], Dicts, DefDict) ->
     OpName = get_bin_attribute(name, I),
     {Dicts1, Instructions, NeedPMap} = parse_instruction(Tail, Dicts, DefDict),
     {Dicts2, Operator} = parse_op(OpName, T, Childs, Dicts1, DefDict),
     Presence = get_attribute(presence, I, "mandatory"),
     Instr =  case get_attribute(charset, I, "ascii") of
  
negative.code:                   #field{
                       type = string,
                       name = OpName,
                       disp_name = get_disp_name(Options, OpName, string_to_id(get_attribute(id, I))),
                       ns = get_bin_attribute(ns, I),
                       id = string_to_id(get_attribute(id, I)),
                       presence = string_to_presence(Presence),
  