anchor.diff:              <<"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([<<>>, {'^', <<"tag">>, [<<>>]}, <<>>], <<"{{ ^ ta g}}{{ / ta g}}">>)},
  +     {"{{^ 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">>)},
  +            <<"a{{=<< >>=}}b{{n}}c<<n>>d<<={{ }}=>>e{{m}}f<<m>>g">>)},
        {"{{=<< >>=}}<<#tag>><<{n}>><</tag>>",
  -      ?NT_S([{'#', <<"tag">>, [{'&', <<"n">>}]}], <<"{{=<< >>=}}<<#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.
  
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: 
  %% @doc Update delimiter part of the `parse/1'
  %%
  %% NewDelimiterBin :: e.g. `{{=%% %%=}}' -> `%% %%'
  -spec parse_delimiter(state(), NewDelimiterBin :: binary(), NextBin :: binary(), Result :: [tag()]) -> [tag()] | partial().
  parse_delimiter(State0, NewDelimiterBin, 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)
  