anchor.diff:  			    _ ->
   				{Chunk0,N+byte_size(Bin)}
   			end,
  -		    indexify(Fd,AddrAdj,Chunk,N1);
  +		    indexify(Fd,DecodeOpts,Chunk,N1);
   		eof ->
   		    eof
   	    end
  
positive.code: %%%-----------------------------------------------------------------
  %%% Parse memory in crashdump version 0.1 and newer
  %%%
  parse_heap_term([$l|Line0], Addr, BinAddrAdj, D0) ->	%Cons cell.
      {H,"|"++Line1,D1} = parse_term(Line0, BinAddrAdj, D0),
      {T,Line,D2} = parse_term(Line1, BinAddrAdj, D1),
      Term = [H|T],
      D = gb_trees:insert(Addr, Term, D2),
      {Term,Line,D};
  parse_heap_term([$t|Line0], Addr, BinAddrAdj, D) ->	%Tuple
      {N,":"++Line} = get_hex(Line0),
      parse_tuple(N, Line, Addr, BinAddrAdj, D, []);
  parse_heap_term([$F|Line0], Addr, _BinAddrAdj, D0) ->	%Float
      {N,":"++Line1} = get_hex(Line0),
      {Chars,Line} = get_chars(N, Line1),
      Term = list_to_float(Chars),
      D = gb_trees:insert(Addr, Term, D0),
      {Term,Line,D};
  parse_heap_term("B16#"++Line0, Addr, _BinAddrAdj, D0) -> %Positive big number.
      {Term,Line} = get_hex(Line0),
      D = gb_trees:insert(Addr, Term, D0),
      {Term,Line,D};
  parse_heap_term("B-16#"++Line0, Addr, _BinAddrAdj, D0) -> %Negative big number
      {Term0,Line} = get_hex(Line0),
      Term = -Term0,
      D = gb_trees:insert(Addr, Term, D0),
      {Term,Line,D};
  parse_heap_term("B"++Line0, Addr, _BinAddrAdj, D0) ->	%Decimal big num
      case string:to_integer(Line0) of
  	{Int,Line} when is_integer(Int) ->
  	    D = gb_trees:insert(Addr, Int, D0),
  	    {Int,Line,D}
      end;
  parse_heap_term([$P|Line0], Addr, _BinAddrAdj, D0) ->	% External Pid.
      {Pid0,Line} = get_id(Line0),
      Pid = ['#CDVPid'|Pid0],
      D = gb_trees:insert(Addr, Pid, D0),
      {Pid,Line,D};
  parse_heap_term([$p|Line0], Addr, _BinAddrAdj, D0) ->   % External Port.
      {Port0,Line} = get_id(Line0),
      Port = ['#CDVPort'|Port0],
      D = gb_trees:insert(Addr, Port, D0),
      {Port,Line,D};
  parse_heap_term("E"++Line0, Addr, _BinAddrAdj, D0) ->	%Term encoded in external format.
      {Bin,Line} = get_binary(Line0),
      Term = binary_to_term(Bin),
      D = gb_trees:insert(Addr, Term, D0),
      {Term,Line,D};
  parse_heap_term("Yh"++Line0, Addr, _BinAddrAdj, D0) ->	%Heap binary.
      {Term,Line} = get_binary(Line0),
      D = gb_trees:insert(Addr, Term, D0),
      {Term,Line,D};
  parse_heap_term("Yc"++Line0, Addr, BinAddrAdj, D0) ->	%Reference-counted binary.
      {Binp0,":"++Line1} = get_hex(Line0),
      {Offset,":"++Line2} = get_hex(Line1),
      {Sz,Line} = get_hex(Line2),
      Binp = Binp0 bor BinAddrAdj,
      Term = case lookup_binary_index(Binp) of
                 [{_,Start}] -> cdvbin(Offset,Sz,{'#CDVBin',Start});
  	       [] -> '#CDVNonexistingBinary'
  	   end,
      D = gb_trees:insert(Addr, Term, D0),
      {Term,Line,D};
  parse_heap_term("Ys"++Line0, Addr, BinAddrAdj, D0) ->	%Sub binary.
      {Binp0,":"++Line1} = get_hex(Line0),
      {Offset,":"++Line2} = get_hex(Line1),
      {Sz,Line} = get_hex(Line2),
      Binp = Binp0 bor BinAddrAdj,
      Term = case lookup_binary_index(Binp) of
                 [{_,Start}] -> cdvbin(Offset,Sz,{'#CDVBin',Start});
  	       [] ->
  
negative.code: %%% Read message queue.
  %%%
  
  read_messages(Fd,Pid,DecodeOpts,Dict) ->
      case lookup_index(?proc_messages,Pid) of
  	[{_,Start}] ->
  	    pos_bof(Fd,Start),
  	    read_messages1(Fd,DecodeOpts,Dict,[]);
  	[] ->
  	    []
      end.
  read_messages1(Fd,DecodeOpts,Dict,Acc) ->
      %% This function is never called if the dump is truncated in {?proc_heap,Pid}
      case bytes(Fd) of
  	"=" ++ _next_tag ->
  	    lists:reverse(Acc);
  	Line ->
  	    Msg = parse_message(Line,DecodeOpts,Dict),
  	    read_messages1(Fd,DecodeOpts,Dict,[Msg|Acc])
      end.
      
  parse_message(Line0, DecodeOpts, D) ->
      {Msg,":"++Line1,_} = parse_term(Line0, DecodeOpts, D),
      {Token,Line,_} = parse_term(Line1, DecodeOpts, D),
      [] = skip_blanks(Line),
      {Msg,Token}.
      
  