anchor.diff:  insert_leaf(Leaf, Node0, Params) ->
       case has_leaves(Node0) of
           true ->
  -            insert_child([Leaf], Node0, Params);
  +            insert_child(Leaf, Node0, Params);
           _False ->
               {SubNode0, Node} = pick_subnode(bound(Leaf), Node0),
               SubNode = insert_leaf(Leaf, SubNode0, Params),
               insert_child(SubNode, Node, Params)
       end.
   
  -pick_subnode(Bound, {_, Bound, Children}) ->
  -    {Picked, Rest} = pick_node(Bound, Children),
  -    {Picked, {Bound, Rest}}.
  +pick_subnode(Against, {_, Bound, Children}) ->
  +    {Picked, Rest} = pick_node(Against, Children),
  +    {Picked, newnode(Bound, Rest)}.
   
   pick_node(Bound, Nodes = [Node | _]) ->
       pick_node(has_leaves(Node), Bound, Nodes).
  
positive.code: unify_bounds([Node | Rest], Bound) ->
      unify_bounds(Rest, erstar_bound:unify(Bound, bound(Node))).
  
  split_nodes(Nodes, _) ->
      %% dummy
      {Part, Rest} = take_part([], Nodes, length(Nodes) div 2),
      [newnode(Part), newnode(Rest)].
  
  take_part(Part, Rest, 0) ->
      {Part, Rest};
  
negative.code: pick_node(_False, Bound, Nodes) ->
      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).
  
  unify_bounds([], Bound) ->
      Bound;
  