anchor.diff:                  | Lf (k, x) ->
                       action.Invoke (int k, x)
                       
  -                (* OPTIMIZATION :   When one or both children of this node are leaves, we handle
  -                                    them directly since it's a little faster. *)
  +                (* OPTIMIZATION :   When one or both children of this node are leaves,
  +                                    we handle them directly since it's a little faster. *)
                   | Br (_, _, Lf (k, x), Lf (j, y)) ->
                       action.Invoke (int k, x)
                       action.Invoke (int j, y)
                       
                   | Br (_, _, Lf (k, x), right) ->
  -                    // Only handle the case where the left child is a leaf -- otherwise
  -                    // the traversal order would be altered.
  +                    // Only handle the case where the left child is a leaf
  +                    // -- otherwise the traversal order would be altered.
                       action.Invoke (int k, x)
                       stack.Push right
   
  
positive.code:                 | Lf (_,_) ->
                      count <- count + 1u
                      
                  (* OPTIMIZATION :   When one or both children of this node are leaves, we handle
                                      them directly since it's a little faster. *)
                  | Br (_, _, Lf (_,_), Lf (_,_)) ->
                      count <- count + 2u
                      
  
negative.code:                 | Lf (k, x) ->
                      state <- folder.Invoke (int k, x, state)
                      
                  (* OPTIMIZATION :   When one or both children of this node are leaves,
                                      we handle them directly since it's a little faster. *)
                  | Br (_, _, Lf (k, x), Lf (j, y)) ->
                      state <- folder.Invoke (int j, y, state)
                      state <- folder.Invoke (int k, x, state)
                      
                  | Br (_, _, left, Lf (k, x)) ->
                      // Only handle the case where the right child is a leaf
                      // -- otherwise the traversal order would be altered.
                      state <- folder.Invoke (int k, x, state)
                      stack.Push left
  
  