anchor.diff:  walk_node(true, Walk, Acc, {_, _, Children}) ->
       walk_node(Walk, Acc, Children);
   
  +walk_node(true_for_all, _Walk, Acc, {_, _, Children}) ->
  +    walk_leaves(Children, Acc);
  +
   walk_node(true, _Walk, Acc, Leaf) ->
       [Leaf | Acc];
   
   walk_node(false, _Walk, Acc, _Any) ->
       Acc.
   
  +walk_leaves([], Acc) ->
  +    Acc;
  +
  +walk_leaves([{_, _, Nodes} | Rest], Acc) ->
  +    walk_leaves(Rest, walk_leaves(Nodes, Acc));
  +
  +walk_leaves(Leaves, Acc) ->
  +    Leaves ++ Acc.
  +
   %%
   
   walk_fold(_Walk, Acc, _Level, []) ->
  
positive.code: %% @doc Walks over nodes and leaves in a tree, effectively gathering list of
  %% leaves accepted by the user-defined function.
  %% User-defined function should decide, given entry type and its bound, if a node
  %% should be visited or a leaf should appear in the result.
  %% If you want to issue some specific locate query on a tree, start here.
  
  -spec walk(WalkFun, rtree()) -> [treeleaf()] when
      WalkFun :: fun((node | leaf, erstar_bound:bound()) -> boolean()).
  
  walk(_WalkFun, {?MODULE, _, {_, _, []}}) ->
      [];
  
negative.code:     DY = CY - RY,
      (DX * DX + DY * DY) =< Dist2.
  
  in_between(node, {X1, Y1, X2, Y2}, RX, RY, FT2, CT, CT2) ->
      HW = (X2 - X1) / 2,
      HH = (Y2 - Y1) / 2,
      DX = abs(X1 + HW - RX),
      DY = abs(Y1 + HH - RY),
      FX = DX + HW,
      FY = DY + HH,
      CX = max(DX - HW, 0),
      CY = max(DY - HH, 0),
      FD2 = FX * FX + FY * FY,
      if
          FD2 < FT2 ->
              false;
          CX > CT ->
              false;
          CY > CT ->
              false;
          FD2 =< CT2 ->
              if
                  CX * CX + CY * CY >= FT2 ->
                      true_for_all;
                  true ->
                      true
              end;
          CX =< 0 ->
              true;
          CY =< 0 ->
              true;
          true ->
              CD2 = CX * CX + CY * CY,
              CD2 =< CT2
      end;
  
  in_between(leaf, Bound, RX, RY, FT2, _, CT2) ->
  