anchor.diff:          Ok -> Ok
       end.
   
  -%% Value fields
  -get_field(#data{ type=uint64,
  -                 offset=DataOffset,
  -                 bits=Bits },
  -          #object{ offset=ObjOffset,
  -                   segment=Segment }) ->
  -    <<_:ObjOffset/binary-unit:64,
  -      _:DataOffset/binary-unit:64,
  -      _:Bits/bits,
  -      Value:64/integer-little-unsigned,
  -      _/binary>> = Segment,
  -    Value;
  -get_field(#data{ type=uint32,
  -                 offset=DataOffset,
  -                 bits=Bits },
  -          #object{ offset=ObjOffset,
  -                   segment=Segment }) ->
  -    <<_:ObjOffset/binary-unit:64,
  -      _:DataOffset/binary-unit:64,
  -      _:Bits/bits,
  -      Value:32/integer-little-unsigned,
  -      _/binary>> = Segment,
  -    Value;
  -get_field(#data{ type=uint16,
  -                 offset=DataOffset,
  -                 bits=Bits },
  -          #object{ offset=ObjOffset,
  -                   segment=Segment }) ->
  -    <<_:ObjOffset/binary-unit:64,
  -      _:DataOffset/binary-unit:64,
  -      _:Bits/bits,
  -      Value:16/integer-little-unsigned,
  -      _/binary>> = Segment,
  -    Value;
  +get_field(Field, Object)
  +  when is_record(Field, data) ->
  +    get_data(Field, Object);
  +get_field(Field, Object)
  +  when is_record(Field, ptr) ->
  +    get_ptr(Field, Object).
   
   %% Enum field
  -get_field(#data{ type={enum, Type},
  -                 offset=DataOffset },
  -          #object{ offset=ObjOffset,
  -                   segment=Segment }=Object) ->
  +get_data(#data{ type={enum, Type},
  +                offset=DataOffset },
  +         #object{ offset=ObjOffset,
  +                  segment=Segment }=Object) ->
       <<_:ObjOffset/binary-unit:64,
         _:DataOffset/binary-unit:64,
         Value:16/integer-little,
  
positive.code:              )
      end.
  
  get_list(#list_ptr{ count=0 }) -> [];
  get_list(#list_ptr{ 
              offset=Offset, size=composite, 
              count=TotalWordCount, segment=Segment }) ->
      <<_:Offset/binary-unit:64,
        C:32/integer-little,
        _/binary>> = Segment,
      ElementCount = C bsr 2,
      ElementSize = TotalWordCount div ElementCount,
      lists:seq(Offset + 1, Offset + TotalWordCount, ElementSize).     
  
  get_segment_object(Id, #object{ segments=S }) ->
      #object{ segment=lists:nth(Id + 1, S), 
  
negative.code:             {FieldName, FieldValue}
      end;
  
  %% Value field
  get_data(#data{ type=Type,
                  offset=DataOffset,
                  bits=Bits },
           #object{ offset=ObjOffset,
                    segment=Segment }) ->
      Offset = ObjOffset + DataOffset,
      get_value(Type, Offset, Bits, Segment).
  
  
  %% List fields
  get_ptr(#ptr{ type={list, Type} }=Ptr, Object) ->
      case dereference_ptr(Ptr, Object) of
          #list_ptr{ size=composite, 
                     segment=S }=L ->
              {ok, T} = get_type(Type, Object),
              [Object#object{ offset=O, type=T, segment=S } || O <- get_offset_list(L)];
          #list_ptr{ segment=S }=L -> 
              [get_value(Type, O, B, S) || {O, B} <- get_offset_list(L)]
      end;
  
  %% Text field
  get_ptr(#ptr{ type=text }=Ptr, Object) ->
      #list_ptr{
         offset=Offset, 
         size=8,
  