anchor.diff:          _ -> exit({error, {haxe_encode, {bad_char, C}}})
       end.
   
  -encode_object(Props, Cache) ->
  -    {Result, Cache2} = encode_object_rest(Props, Cache),
  +encode_object(Props, Cache, Vsn) ->
  +    {Result, Cache2} = encode_object_rest(Props, Cache, Vsn),
       {[$o | Result], Cache2}.
  -encode_object_rest(Props, Cache) ->
  +encode_object_rest(Props, Cache, Vsn) ->
       {EncodedProps, Cache1} =
           lists:foldl(
             fun({Key, Value}, {Acc, Cache2}) ->
                     {EncodedKey, Cache3} =
                         case Key of
  -                          L when is_list(L) -> encode_string(L, Cache2);
  -                          A when is_atom(A) -> encode_string(atom_to_list(A), Cache2);
  +                          L when is_list(L) -> encode_string(L, Cache2, Vsn);
  +                          A when is_atom(A) -> encode_string(atom_to_list(A), Cache2, Vsn);
                             _ -> exit({error, {haxe_encode, {bad_key, Key}}})
                         end,
  -                  {EncodedVal, Cache4} = encode(Value, Cache3),
  +                  {EncodedVal, Cache4} = encode(Value, Cache3, Vsn),
                     case Acc of
                         [] -> {[[EncodedKey, EncodedVal]], Cache4};                                        _  -> {[[EncodedKey, EncodedVal] | Acc], Cache4}
                     end
  
positive.code:         Token -> {done, {ok, Token}, Rest}
      end.
  
  token_identifier(C) ->
      case C of
          $i -> int;
          $d -> float;
          $s -> string;
          $j -> utf8;
          $n -> null;
          $t -> true;
          $f -> false;   
  
negative.code:                         undefined;
                      _ ->
                          dict:store(Str, dict:size(Cache), Cache)
                  end,
              {Result, NewCache};
          {true, Idx} ->
              {[$R | integer_to_list(Idx)], Cache}
      end.
  encode_string2(S, $y) ->
      {ok, [$y, integer_to_list(length(S)), $: | S]};
  encode_string2(S, FirstChar) ->
      encode_string2(S, FirstChar, []).
  encode_string2([], FirstChar, Acc) ->
      Str = lists:reverse(Acc),
      Len = integer_to_list(length(Str)),
      {ok, [FirstChar, Len, $: | Str]};
  encode_string2([C | Cs], FirstChar, Acc) ->
      case C of
  