anchor.diff:      let rec intersect (input : CharDiet) (stream : CharDiet) : CharDiet =
           if AvlTree.Height stream > AvlTree.Height input then
               intersect stream input
  -        elif AvlTree.IsEmptyTree stream then
  -            Empty
           else
  +        match stream with
  +        | Empty -> Empty
  +        | _ ->
               #if DEBUG
               let inputCount = count input
               let streamCount = count stream
  
positive.code: 
      /// Returns a new set with the elements of the second set removed from the first.
      let difference (input : CharDiet) (stream : CharDiet) : CharDiet =
          if AvlTree.IsEmptyTree stream then
              input
          else
              #if DEBUG
              /// The minimum possible number of elements in the resulting set.
              let minPossibleResultCount =
                  let inputCount = count input
                  let streamCount = count stream
                  GenericMaximum 0 (inputCount - streamCount)
              #endif
  
              let result, _, _ =
  
negative.code:         | _ ->
              AvlTree<'T>.CompareStacks (comparer, [s1], [s2])
  
      /// Join two trees together with the specified root element.
      /// Takes two trees representing disjoint sets and combines them, returning
      /// a new balanced tree representing the union of the two sets and the given root element.
      /// The resulting tree may be unbalanced.
          // NOTE : Are we sure about this? It looks like the resulting tree will _always_
          // be balanced in this implementation.
      static member Join comparer root l (r : AvlTree<'T>) =
          match l, r with
          | Empty, Empty ->
              AvlTree.Singleton root
          | Empty, _ ->
              AvlTree.Insert (comparer, r, root)
          | _, Empty ->
              AvlTree.Insert (comparer, l, root)
          | Node (ll, lr, lx, lh), Node (rl, rr, rx, rh) ->
              if lh > rh + 2u then
                  AvlTree.Balance (comparer, ll, AvlTree.Join comparer root lr r, lx)
              else if rh > lh + 2u then
                  AvlTree.Balance (comparer, AvlTree.Join comparer root l rl, rr, rx)
              else
                  AvlTree.Create (root, l, r)
  
      /// Reroot of balanced trees.
      /// Takes two trees representing disjoint sets and combines them, returning
      /// a new balanced tree representing the union of the two sets.
      static member Reroot comparer l (r : AvlTree<'T>) =
          match l, r with
          | Empty, Empty ->
              Empty
          | set, Empty
          | Empty, set ->
              set
          | Node (_,_,_,lh), Node (_,_,_,rh) ->
              if lh > rh then
                  let root, l' = AvlTree.ExtractMax l
                  AvlTree.Join comparer root l' r
              else
                  let root, r' = AvlTree.ExtractMin r
                  AvlTree.Join comparer root l r'
  
  
  /// A Discrete Interval Encoding Tree (DIET) specialized to the 'char' type.
  