anchor.diff:  % @doc lists all correct entries of this structure
   %     correct entries can be retrieved out of pure cells
   %     a pure cell := count = 1 and check_sum(keySum)=keyHashSum and check_sum(valSum)=valHashSum
  --spec list_entries(iblt()) -> [{key(), value()}].
  +-spec list_entries(iblt()) -> [{?RT:key(), value()}].
   list_entries(IBLT) ->
       p_list_entries(IBLT, []).
   
  --spec p_list_entries(iblt(), [{key(), value()}]) -> [{key(), value()}].
  +-spec p_list_entries(iblt(), Acc) -> Acc when is_subtype(Acc, [{?RT:key(), value()} | [{?RT:key(), value()}]]).
   p_list_entries(#iblt{ table = T } = IBLT, Acc) ->
       case get_any_entry(T, []) of
  -        [] -> Acc;
  +        [] -> lists:flatten(Acc);
           L ->
               NewIBLT = lists:foldl(fun({Key, Val}, NT) -> 
                                             delete(NT, Key, Val) 
                                     end, IBLT, L),
  -            p_list_entries(NewIBLT, lists:append([L, Acc]))
  +            p_list_entries(NewIBLT, [L, Acc])
       end.
   
   % tries to find any pure entry 
  --spec get_any_entry(table(), [{key(), value()}]) -> [{key() | value()}].
  +-spec get_any_entry(table(), [{?RT:key(), value()}]) -> [{?RT:key(), value()}].
   get_any_entry([], Acc) -> 
       Acc;
   get_any_entry([{_, Col} | T], Acc) ->
  -    Result = [{Key, Val} || {Count, Key, KCheck, Val, ValCheck} <- Col, 
  -                            is_pure({Count, Key, KCheck, Val, ValCheck})],
  +    Result = [{decode_key(Key), Val} || {_, Key, _, Val, _} = Cell <- Col,
  +                                        is_pure(Cell)],
       if 
           Result =:= [] -> get_any_entry(T, lists:append([Result, Acc]));
           true -> Result
  
positive.code:     Val;
  resize(Val, Div) when Val rem Div /= 0 -> 
      resize(Val + 1, Div).
  
negative.code: operation_val(add) -> 1;
  operation_val(remove) -> -1.
  
  -spec change_table(iblt(), cell_operation(), ?RT:key(), value()) -> iblt().
  change_table(#iblt{ hfs = Hfs, table = T, item_count = ItemCount, col_size = ColSize } = IBLT, 
               Operation, Key, Value) ->
      NT = lists:foldl(
             fun({ColNr, Col}, NewT) ->
                     NCol = change_cell(Col, 
                                        ?REP_HFS:apply_val(Hfs, ColNr, Key) rem ColSize,
                                        encode_key(Key), Value, Operation),
                     [{ColNr, NCol} | NewT]
             end, [], T),
      IBLT#iblt{ table = NT, item_count = ItemCount + operation_val(Operation)}.   
  
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  
  -spec change_cell([cell()], pos_integer(), integer(), value(), cell_operation()) -> [cell()].
  change_cell(Column, CellNr, Key, Value, Operation) ->
      {HeadL, [Cell | TailL]} = lists:split(CellNr, Column),
      {Count, KeySum, KHSum, ValSum, VHSum} = Cell,
      lists:flatten([HeadL, 
  