anchor.diff:  
       let inline height (t:SetTree<'T>) = 
           if isEmpty t then 0
  -        else
  -            match t with 
  -            | :? SetTreeNode<'T> as tn -> tn.Height
  -            | _ -> 1
  +        else t.Height 
   
   #if CHECKED
       let rec checkInvariant (t:SetTree<'T>) =
           // A good sanity check, loss of balance can hit perf
           if isEmpty t then true
           else
  -            match t with 
  -            | :? SetTreeNode<'T> as tn  ->
  +            if t.Height = 1 then true
  +            else
  +                let tn = asNode t
                   let h1 = height tn.Left 
                   let h2 = height tn.Right 
                   (-2 <= (h1 - h2) && (h1 - h2) <= 2) && checkInvariant tn.Left && checkInvariant tn.Right
  -            | _ -> true
   #endif
   
       [<Literal>]
  
positive.code:         else
              SetTreeNode (k, l, r, m+1) :> SetTree<'T>
  
      let inline private asNode(value:SetTree<'T>) : SetTreeNode<'T> =
          value :?> SetTreeNode<'T>
          
      let rebalance t1 v t2 =
          let t1h = height t1 
          let t2h = height t2 
  
negative.code:         if isEmpty t then SetTree k
          else
              let c = comparer.Compare(k, t.Key)
              if t.Height = 1 then
                  // nb. no check for rebalance needed for small trees, also be sure to reuse node already allocated 
                  if c < 0   then SetTreeNode (k, empty, t, 2) :> SetTree<'T>
                  elif c = 0 then t
                  else            SetTreeNode (k, t, empty, 2) :> SetTree<'T>
              else
                  let tn = asNode t
                  if   c < 0 then rebalance (add comparer k tn.Left) tn.Key tn.Right
                  elif c = 0 then t
                  else            rebalance tn.Left tn.Key (add comparer k tn.Right)
  
      let rec balance comparer (t1:SetTree<'T>) k (t2:SetTree<'T>) =
          // Given t1 < k < t2 where t1 and t2 are "balanced", 
  