anchor.diff:  
   %% @doc Part of the `parse/1'
   %%
  +%% 2nd Argument: [TagBinary(may exist unnecessary spaces to the end), RestBinary]
   %% ATTENTION: The result is a list that is inverted.
  +-spec parse2(state(), iolist(), Result :: [tag()]) -> {state(), [tag()]} | endtag().
   parse2(State, [B1, B2], Result) ->
       parse1(State, B2, [{'&', remove_space_from_edge(B1)} | Result]);
   parse2(_, _, _) ->
  -    error(?PARSE_ERROR).
  +    error({?PARSE_ERROR, unclosed_tag}).
   
   %% @doc Part of the `parse/1'
   %%
  +%% 2nd Argument: [TagBinary(may exist unnecessary spaces to the end), RestBinary]
   %% ATTENTION: The result is a list that is inverted.
  +-spec parse3(state(), iolist(), Result :: [tag()]) -> {state(), [tag()]} | endtag().
   parse3(State, [B1, B2], Result) ->
       case remove_space_from_head(B1) of
           <<"&", Tag/binary>> ->
  
positive.code: 
  %% @doc Update delimiter part of the `parse/1'
  %%
  %% Parse_BinaryDelimiterBin :: e.g. `{{=%% %%=}}' -> `%% %%'
  -spec parse_delimiter(state(), Parse_BinaryDelimiterBin :: binary(), NextBin :: binary(), Result :: [tag()]) -> [tag()] | partial().
  parse_delimiter(State0, Parse_BinaryDelimiterBin, NextBin, Result) ->
      case binary:match(Parse_BinaryDelimiterBin, <<"=">>) of
          nomatch ->
              case [X || X <- binary:split(Parse_BinaryDelimiterBin, <<" ">>, [global]), X =/= <<>>] of
                  [Start, Stop] -> parse1(State0#state{start = Start, stop = Stop}, NextBin, Result);
                  _             -> error(?PARSE_ERROR)
              end;
          _ ->
              error(?PARSE_ERROR)
      end.
  
  %% @doc Remove the space from the edge.
  
negative.code: -spec parse(state(), binary()) -> [tag()].
  parse(State, Bin) ->
      case parse1(State, Bin, []) of
          {endtag, {_, OtherTag, _, _, _}} ->
              error({?PARSE_ERROR, {section_is_incorrect, <<"#", OtherTag/binary>>}});
          {_, Tags} ->
              lists:reverse(Tags)
      end.
  
  %% @doc Part of the `parse/1'
  %%
  %% ATTENTION: The result is a list that is inverted.
  -spec parse1(state(), Input :: binary(), Result :: [tag()]) -> {state(), [tag()]} | endtag().
  parse1(#state{start = Start, stop = Stop} = State, Bin, Result) ->
      case binary:split(Bin, Start) of
          []                       -> {State, Result};
  