anchor.diff:  
   %%
   
  -maybe_reroot(Roots) when is_list(Roots) ->
  +maybe_reroot({reinsert, Nodes, Root}, Params) ->
  +    insert_bulk(Nodes, Root, setelement(4, Params, 0));
  +
  +maybe_reroot(Roots, _Params) when is_list(Roots) ->
       newnode(Roots);
   
  -maybe_reroot(Root) ->
  +maybe_reroot(Root, _Params) ->
       Root.
   
  -update_root(RStar, Root) ->
  -    setelement(3, RStar, maybe_reroot(Root)).
  +update_root(RStar, Root, Params) ->
  +    setelement(3, RStar, maybe_reroot(Root, Params)).
   
   %%
   
  
positive.code: pick_node(_False, Bound, Nodes, _Params) ->
      needs_least(area, Bound, Nodes).
  
  insert_child(List, Node, Params) when is_list(List) ->
      insert_children(List, Node, Params);
  
  insert_child(Child, {_, _, Children}, Params = {_, MaxCap, _, _}) when length(Children) + 1 > MaxCap ->
      split_nodes([Child | Children], Params);
  
  insert_child(Child, {_, Bound, Children}, _Params) ->
      newnode(erstar_bound:unify(Bound, bound(Child)), [Child | Children]).
  
  insert_children(Cs, {_, _, CsWere}, Params = {_, MaxCap, _, _}) when length(Cs) + length(CsWere) > MaxCap ->
      split_nodes(Cs ++ CsWere, Params);
  
  insert_children(Cs, {_, Bound, CsWere}, _Params) ->
      NowBound = unify_bounds(Cs, Bound),
      newnode(NowBound, Cs ++ CsWere).
  
  
negative.code: unify_bounds([Node | Rest], Bound) ->
      unify_bounds(Rest, erstar_bound:unify(Bound, bound(Node))).
  
  split_nodes(Extra, BoundWas, Nodes, Level, {_, _, _, ReinsertCount}) when Level > 1, ReinsertCount > 0 ->
      Bound = unify_bounds(Extra, BoundWas),
      BoundCenter = erstar_bound:center(Bound),
      SortedNodes = lists:sort(fun (N1, N2) -> not compare_distance(N1, N2, BoundCenter) end, Extra ++ Nodes),
      {DistantNodes, Rest} = take_part([], SortedNodes, ReinsertCount),
      {reinsert, DistantNodes, newnode(Rest)};
  
  split_nodes(Extra, _Bound, Nodes, _Level, {MinCap, _, _, _}) ->
      {NodesByLower, NodesByUpper} = choose_axis(Extra ++ Nodes, MinCap),
      Result0 = choose_split_axis(NodesByLower, MinCap),
      Result1 = choose_split_axis(NodesByUpper, MinCap),
      split_nodes_by_distrib(Result0, Result1).
  
  compare_distance(N1, N2, Center) ->
      C1 = erstar_bound:center(bound(N1)),
      C2 = erstar_bound:center(bound(N2)),
      distance2(C1, Center) < distance2(C2, Center).
  
  distance2({X1, Y1}, {X2, Y2}) ->
      DX = X1 - X2,
      DY = Y1 - Y2,
      DX * DX + DY * DY.
  
  choose_split_axis(Nodes, MinCap) ->
      G = get_distrib_goodness(overlap, Nodes, MinCap),
  