anchor.diff:          if isEmpty t1 then t2
           elif isEmpty t2 then t1
           else
  -            match t1 with
  -            | :? SetTreeNode<'T> as t1n ->
  -                match t2 with
  -                | :? SetTreeNode<'T> as t2n -> // (t1l < k < t1r) AND (t2l < k2 < t2r) 
  +            if t1.Height = 1 then add comparer t1.Key t2
  +            else
  +                if t2.Height = 1 then add comparer t2.Key t1
  +                else
  +                    let t1n = asNode t1
  +                    let t2n = asNode t2 // (t1l < k < t1r) AND (t2l < k2 < t2r) 
                       // Divide and Conquer:
                       //   Suppose t1 is largest.
                       //   Split t2 using pivot k1 into lo and hi.
  
positive.code:         let cont() =
              match l1, l2 with 
              | (x1 :: t1), _ when not (isEmpty x1) ->
                  match x1 with
                  | :? SetTreeNode<'T> as x1n ->
                      compareStacks comparer (x1n.Left :: (SetTreeNode (x1n.Key, empty, x1n.Right, 0) :> SetTree<'T>) :: t1) l2
                  | _ -> compareStacks comparer (empty :: SetTree x1.Key :: t1) l2
              | _, (x2 :: t2) when not (isEmpty x2) ->
                  match x2 with
                  | :? SetTreeNode<'T> as x2n ->
                      compareStacks comparer l1 (x2n.Left :: (SetTreeNode (x2n.Key, empty, x2n.Right, 0) :> SetTree<'T>  ) :: t2)
                  | _ -> compareStacks comparer l1 (empty :: SetTree x2.Key :: t2)
              | _ -> failwith "unexpected state in SetTree.compareStacks"
          
          match l1, l2 with 
          | [], [] ->  0
  
negative.code:     let rec partitionAux comparer f (t:SetTree<'T>) acc = 
          if isEmpty t then acc
          else
              if t.Height = 1 then partition1 comparer f t.Key acc
              else
                  let tn = asNode t 
                  let acc = partitionAux comparer f tn.Right acc 
                  let acc = partition1 comparer f tn.Key acc
                  partitionAux comparer f tn.Left acc
  
      let partition comparer f s = partitionAux comparer f s (empty, empty)
  
      let rec minimumElementAux (t:SetTree<'T>) n = 
          if isEmpty t then n
          else
              if t.Height = 1 then t.Key
              else
                  let tn = asNode t
                  minimumElementAux tn.Left tn.Key
  
      and minimumElementOpt (t:SetTree<'T>) = 
          if isEmpty t then None
          else
              if t.Height = 1 then Some t.Key
              else
                  let tn = asNode t
                  Some(minimumElementAux tn.Left tn.Key) 
  
      and maximumElementAux (t:SetTree<'T>) n = 
          if isEmpty t then n
          else
              if t.Height = 1 then t.Key
              else
                  let tn = asNode t
                  maximumElementAux tn.Right tn.Key 
  
      and maximumElementOpt (t:SetTree<'T>) = 
          if isEmpty t then None
          else
              if t.Height = 1 then Some t.Key
              else
                  let tn = asNode t
                  Some(maximumElementAux tn.Right tn.Key)
  
      let minimumElement s = 
          match minimumElementOpt s with 
  