anchor.diff:                  match stack.Pop () with
                   | Empty -> ()
                   | Lf (_, listSet) ->
  -                    state <- ListSet.Fold (folder, listSet, state)
  +                    state <- List.fold folder state listSet
                       
                   (* OPTIMIZATION :   When one or both children of this node are leaves,
                                       we handle them directly since it's a little faster. *)
                   | Br (_, _, Lf (_, listSet1), Lf (_, listSet2)) ->
  -                    state <- ListSet.Fold (folder, listSet1, state)
  -                    state <- ListSet.Fold (folder, listSet2, state)
  +                    state <- List.fold folder state listSet1
  +                    state <- List.fold folder state listSet2
                       
                   | Br (_, _, Lf (_, listSet), right) ->
                       // Only handle the case where the left child is a leaf
                       // -- otherwise the traversal order would be altered.
  -                    state <- ListSet.Fold (folder, listSet, state)
  +                    state <- List.fold folder state listSet
                       stack.Push right
   
                   | Br (_, _, left, right) ->
  
positive.code:                 else
                      Lf (j, result)
              else
                  PatriciaHashSet.Join (valueHash, Lf (valueHash, Tail value), j, set)
          | Br (p, m, t0, t1) ->
              if matchPrefix (valueHash, p, m) then
                  if zeroBit (valueHash, m) then
  
negative.code:                 match stack.Pop () with
                  | Empty -> ()
                  | Lf (_, listSet) ->
                      state <- List.foldBack folder listSet state
                      
                  (* OPTIMIZATION :   When one or both children of this node are leaves,
                                      we handle them directly since it's a little faster. *)
                  | Br (_, _, Lf (_, listSet1), Lf (_, listSet2)) ->
                      state <- List.foldBack folder listSet1 state
                      state <- List.foldBack folder listSet2 state
                      
                  | Br (_, _, left, Lf (_, listSet)) ->
                      // Only handle the case where the right child is a leaf
                      // -- otherwise the traversal order would be altered.
                      state <- List.foldBack folder listSet state
                      stack.Push left
  
                  | Br (_, _, left, right) ->
  