anchor.diff:  operation_val(add) -> 1;
   operation_val(remove) -> -1.
   
  --spec change_table(iblt(), cell_operation(), key(), value()) -> iblt().
  +-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,
  -                                      Key, Value, Operation),
  +                                      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(), key(), value(), cell_operation()) -> [cell()].
  -change_cell(Column, CellNr, Key, Value, 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, 
  
positive.code: 
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  
  -spec get(iblt(), key()) -> value() | not_found.
  get(#iblt{ table = T, hfs = Hfs, col_size = ColSize }, Key) ->
      p_get(T, Hfs, ColSize, Key).
  
  -spec p_get(table(), ?REP_HFS:hfs(), non_neg_integer(), key()) -> value() | not_found.
  p_get([], _, _, _) -> not_found;
  p_get([{ColNr, Col} | T], Hfs, ColSize, Key) ->
      Cell = lists:nth((?REP_HFS:apply_val(Hfs, ColNr, Key) rem ColSize) + 1, Col),
  
negative.code: % @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()) -> [{?RT:key(), value()}].
  list_entries(IBLT) ->
      p_list_entries(IBLT, []).
  
  -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
          [] -> lists:flatten(Acc);
          L ->
              NewIBLT = lists:foldl(fun({Key, Val}, NT) -> 
                                            delete(NT, Key, Val) 
                                    end, IBLT, L),
              p_list_entries(NewIBLT, [L, Acc])
      end.
  
  % tries to find any pure entry 
  -spec get_any_entry(table(), [{?RT:key(), value()}]) -> [{?RT:key(), value()}].
  get_any_entry([], Acc) -> 
      Acc;
  get_any_entry([{_, Col} | T], Acc) ->
      Result = [{decode_key(Key), Val} || {_, Key, _, Val, _} = Cell <- Col,
                                          is_pure(Cell)],
      if 
          Result =:= [] -> get_any_entry(T, lists:append([Result, Acc]));
          true -> Result
  