anchor.diff:  
   [<NoEquality; NoComparison>]
   [<AllowNullLiteral>]
  -type internal SetTree<'T>(k: 'T) =
  +type internal SetTree<'T>(k: 'T, h: int) =
  +    member _.Height = h
       member _.Key = k
  -
  +    new(k: 'T) = SetTree(k,1)
  +    
   [<NoEquality; NoComparison>]
   [<Sealed>]
   [<AllowNullLiteral>]
   type internal SetTreeNode<'T>(v:'T, left:SetTree<'T>, right: SetTree<'T>, h: int) =
  -    inherit SetTree<'T>(v)
  -
  +    inherit SetTree<'T>(v,h)
       member _.Left = left
       member _.Right = right
  -    member _.Height = h
  -
  +    
   [<CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix)>]
   module internal SetTree = 
       
  
positive.code: 
      let inline height (t:SetTree<'T>) = 
          if isEmpty t then 0
          else
              match t with 
              | :? SetTreeNode<'T> as tn -> tn.Height
              | _ -> 1
  
  #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  ->
                  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>]
  
negative.code:         if isEmpty t1 then t2
          elif isEmpty t2 then t1
          else
              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.
  