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 j, y)
                       action.Invoke (int k, x)
                       
                   | Br (_, _, left, Lf (k, x)) ->
  -                    // Only handle the case where the right child is a leaf -- otherwise
  -                    // the traversal order would be altered.
  +                    // Only handle the case where the right child is a leaf
  +                    // -- otherwise the traversal order would be altered.
                       action.Invoke (int k, x)
                       stack.Push left
   
  
positive.code:                 (key, (if zeroBit (key, m) then t0 else t1))
  
      //
      static member CountOriginal (map : PatriciaMap<'T>) : int =
          // OPTIMIZE : We can 'strictify' this by adding an accumulator argument, so we'll
          // only need to use continuations for one side of the tree (left or right child).
          // We may also be able to eliminate continuations altogether by using an explicit
          // stack (either an F# list or System.Collections.Generic.Stack<'T>).
          let rec count (t : PatriciaMap<'T>) cont =
              match t with
              | Empty ->
                  cont 0
              | Lf (_,_) ->
                  cont 1
              | Br (_, _, left, right) ->
                  count left <| fun leftCount ->
                  count right <| fun rightCount ->
                      leftCount + rightCount
                      |> cont
  
          count map id
  
      // TODO : This is an experimental version of count which is optimized for performance.
      // It should work, but we need to do some tests to be sure. Once we're confident it's correct
      // we'll remove the original 'Count' function and use this once instead.
      static member Count (map : PatriciaMap<'T>) : int =
          match map with
          | Empty -> 0
  
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
  
  