anchor.diff:      Parser1 = add_error(Parser, Error,
         "An implicit key must not span several lines", []),
       queue_impl_key2(Parser1);
  -queue_impl_key(#yaml_parser{chars_idx = Index,
  +queue_impl_key(Delta, #yaml_parser{chars_idx = Index,
       ik_stack = [#impl_key{chars_idx = Impl_Index} = Impl_Key | _]} = Parser)
  -  when Index > Impl_Index + 1024 ->
  +  when (Index + Delta) > Impl_Index + 1024 ->
       %% An implicit key must not take more than 1024 characters.
       Error = #yaml_parsing_error{
         name   = invalid_implicit_key,
  
positive.code:         ?IN_BLOCK_CTX(Parser1) -> allow_impl_key(Parser1, true);
          true                   -> Parser1
      end,
      do_find_next_token(Parser2);
  
  do_find_next_token(
    #yaml_parser{chars = [$\r], raw_eos = false} = Parser) ->
      %% Can't be sure it's a newline. It may be followed by a LF.
      return(Parser);
  do_find_next_token(
    #yaml_parser{doc_version = Version, chars = [C | _] = Chars} = Parser)
    when ?IS_NEWLINE(C) orelse (Version == {1,1} andalso ?IS_NEWLINE_11(C)) ->
      Parser1 = next_line(Parser, Chars),
      Parser2 = if
          ?IN_BLOCK_CTX(Parser1) -> allow_impl_key(Parser1, true);
          true                   -> Parser1
      end,
      do_find_next_token(Parser2);
  
  %% End-of-stream reached.
  do_find_next_token(#yaml_parser{chars = [], raw_eos = true} = Parser) ->
      next_state(Parser, fun end_stream/1);
  
  %% Wait for more data.
  do_find_next_token(#yaml_parser{chars = []} = Parser) ->
      return(Parser);
  
  %% Next token found!
  do_find_next_token(Parser) ->
      Parser1 = warn_if_non_ascii_line_break(Parser),
      Parser2 = check_for_closed_block_collections(Parser1),
      next_state(Parser2, fun determine_token_type/1).
  
  %%
  %% Token type.
  %%
  
  %% Not enough data to determine the token type.
  determine_token_type(#yaml_parser{chars_len = Len, raw_eos = false} = Parser)
    when Len < 4 ->
      return(Parser);
  
  %% BOM, before a document only!
  determine_token_type(
    #yaml_parser{chars = [C | Rest], doc_started = false} = Parser)
    when ?IS_BOM(C) ->
      Parser1 = next_col(Parser, 1, Rest),
      next_state(Parser1, fun find_next_token/1);
  determine_token_type(
    #yaml_parser{chars = [C | Rest], doc_started = true} = Parser)
    when ?IS_BOM(C) ->
      %% A BOM is forbidden after the document start. Because it's not
      %% fatal during parsing, we only add a warning. Note that the YAML
  
negative.code:       cur_coll     = New_Coll,
        parent_colls = [Cur_Coll | Colls]
      },
      queue_token_keep_last_pos(Parser2, Token, next_insert_at(Insert_At, 1));
  queue_token_check_collection_start(
    #yaml_parser{
      cur_coll = #bcoll{indent = Indent} = Cur_Coll,
  