anchor.diff:  
   %% @doc Update delimiter part of the `parse/1'
   %%
  -%% `{{=NewStartDelimiter NewStopDelimiter=}}' coresspond to this. <br />
  -%% NewDelimiterBin is refers to a binary up to `=' from `='. <br />
  -%% (e.g. `{{=%% %%=}}' -> `=%% %%=')
  +%% NewDelimiterBin :: e.g. `{{=%% %%=}}' -> `%% %%'
   -spec parse_delimiter(state(), NewDelimiterBin :: binary(), NextBin :: binary(), Result :: [tag()]) -> [tag()] | partial().
   parse_delimiter(State0, NewDelimiterBin, NextBin, Result) ->
  -    State =
  -        try
  -            [_BeforeTheEqual, Delimiters, _AfterTheEqual] = binary:split(NewDelimiterBin, <<"=">>, [global]),
  -            [StartDelimiter | T] = binary:split(Delimiters, <<" ">>, [global]),
  -            [StopDelimiter  | _] = lists:reverse(T),
  -            State0#state{start = StartDelimiter, stop = StopDelimiter}
  -        catch
  -            error:{badmatch, _} -> error(?PARSE_ERROR)
  -        end,
  -    parse1(State, NextBin, Result).
  +    case binary:match(NewDelimiterBin, <<"=">>) of
  +        nomatch ->
  +            case [X || X <- binary:split(NewDelimiterBin, <<" ">>, [global]), X =/= <<>>] of
  +                [Start, Stop] -> parse1(State0#state{start = Start, stop = Stop}, NextBin, Result);
  +                _             -> error(?PARSE_ERROR)
  +            end;
  +        _ ->
  +            error(?PARSE_ERROR)
  +    end.
   
   %%----------------------------------------------------------------------------------------------------------------------
   %% Unit Tests
   %%----------------------------------------------------------------------------------------------------------------------
  +
  +-ifdef(TEST).
   
   -define(NT_S(X, Y), ?_assertEqual(#?MODULE{data=X}, ?MODULE:new(Y))).
   %% new_test generater (success case)
  
positive.code:         Tags         -> lists:reverse(Tags)
      end.
  
  %% @doc 1st phase of the `parse/1'
  %%
  %% ATTENTION: The result is a list that is inverted.
  -spec parse1(state(), Input :: binary(), Result :: [tag()]) -> [tag()] | partial().
  parse1(#state{start = Start} = State, Bin, Result) ->
      %% `<<"hoge{{tag}}foo">>' => `[<<"hoge">>, <<"tag}}foo">>]'
      case binary:split(Bin, Start) of
          []       -> Result;
          [B1]     -> [B1 | Result];
          [B1, B2] -> parse2(State, B2, [B1 | Result])
      end.
  
  %% @doc 2nd phase of the `parse/1'
  %%
  %% ATTENTION: The result is list that is inverted.
  -spec parse2(state(), Input :: binary(), Result :: [tag()]) -> [tag()] | partial().
  parse2(#state{stop = Stop} = State, Bin, Result) ->
      %% `<<"hoge}}foo...">>' => `[<<"hoge">>, <<"foo...">>]'
      case binary:split(Bin, Stop) of
          [B1, B2] ->
              %% TODO: must not replace !!
              Tag0 = binary:replace(B1, <<" ">>, <<>>, [global]),
              case Tag0 of
                  <<"{", Tag/binary>> ->
                      case B2 of
                          <<"}", B3/binary>> -> parse1(State, B3, [{'&', Tag} | Result]);
                          _                  -> error(?PARSE_ERROR)
                      end;
                  <<"&", Tag/binary>> ->
                      parse1(State, B2, [{'&', Tag} | Result]);
                  <<T, Tag/binary>> when T =:= $#; T =:= $^ ->
                      parse_loop(State, ?COND(T =:= $#, '#', '^'), Tag, B2, Result);
                  <<"=", _/binary>> ->
                      parse_delimiter(State, B1, B2, Result);
                  <<"!", _/binary>> ->
                      parse1(State, B2, Result);
                  <<"/", Tag/binary>> ->
                      {partial, {State, Tag, B2, Result}};
                  _  ->
                      parse1(State, B2, [{n, Tag0} | Result])
              end;
          _  -> error(?PARSE_ERROR)
      end.
  
  %% @doc Loop processing part of the `parse/1'
  %%
  
negative.code:             <<"a{{^t1}}b{{^t2}}c{{t3}}d{{/t2}}e{{/t1}}f">>)},
       {"{{^tag1}}{{^tag2}}{{/tag1}}{{tag2}}", ?NT_F(<<"{{^t1}}{{^t2}}{{/t1}}{{/t2}}">>)},
  
       {"{{^ tag}}{{/ tag}}",     ?NT_S([<<>>, {'^', <<"tag">>,  [<<>>]}, <<>>], <<"{{^ tag}}{{/ tag}}">>)},
       {"{{ ^tag }}{{ / tag }}",  ?NT_S([<<>>, {'^', <<"tag">>,  [<<>>]}, <<>>], <<"{{ ^tag }}{{ / tag }}">>)},
       {"{{ ^ tag }}{{ /tag }}",  ?NT_S([<<>>, {'^', <<"tag">>,  [<<>>]}, <<>>], <<"{{ ^ tag }}{{ /tag }}">>)},
       {"{{ ^ ta g}}{{ / ta g}}", ?NT_S([<<>>, {'^', <<"ta g">>, [<<>>]}, <<>>], <<"{{ ^ ta g}}{{ / ta g}}">>)},
  
       {"{{=<< >>=}}{{n}}<<n>><<={{ }}=>>{{n}}<<n>>",
        ?NT_S([<<"a">>, <<"b{{n}}c">>, {n, <<"n">>}, <<"d">>, <<"e">>, {n, <<"m">>}, <<"f<<m>>g">>],
              <<"a{{=<< >>=}}b{{n}}c<<n>>d<<={{ }}=>>e{{m}}f<<m>>g">>)},
       {"{{=<< >>=}}<<#tag>><<{n}>><</tag>>",
        ?NT_S([<<>>, <<>>, {'#', <<"tag">>, [<<>>, {'&', <<"n">>}, <<>>]}, <<>>], <<"{{=<< >>=}}<<#tag>><<{n}>><</tag>>">>)},
  
       {"{{=<<  >>=}}<<n>>",      ?NT_S([<<>>, <<>>, {n, <<"n">>}, <<>>], <<"{{=<<  >>=}}<<n>>">>)},
       {"{{ = << >> = }}<<n>>",   ?NT_S([<<>>, <<>>, {n, <<"n">>}, <<>>], <<"{{ = << >> = }}<<n>>">>)},
       {"{{=<= =>=}}<=n=>",       ?NT_F(<<"{{=<= =>=}}<=n=>">>)},
       {"{{ = < < >> = }}< <n>>", ?NT_F(<<"{{ = < < >> = }}< <n>>">>)}
      ].
  
  -endif.
  