anchor.diff:                  else
                       match right with
                       | Empty ->
  -                        CharDiet.Create ((x, value), left, Empty)
  +                        CharDiet.Create (left, Empty, (x, value))
                       | _ ->
                           let (u, v), r = CharDiet.DeleteMin right
                           if safePred u = value then
                               CharDiet.Join (comparer, left, r, (x, v))
                           else
  -                            CharDiet.Create ((x, value), left, right)
  +                            CharDiet.Create (left, right, (x, value))
   
               elif value < safePred x then
                   CharDiet.Join (comparer, add value left, right, (x, y))
               else
                   match left with
                   | Empty ->
  -                    CharDiet.Create ((value, y), Empty, right)
  +                    CharDiet.Create (Empty, right, (value, y))
                   | _ ->
                       let (u, v), l = CharDiet.DeleteMax left
                       if safeSucc v = value then
                           CharDiet.Join (comparer, l, right, (u, y))
                       else
  -                        CharDiet.Create ((value, y), left, right)
  +                        CharDiet.Create (left, right, (value, y))
   
       /// Returns a new set with the specified range of values added to the set.
       /// No exception is thrown if any of the values are already contained in the set.
  
positive.code:         // Preconditions
          //assert (AvlTree.AvlInvariant l)
          //assert (AvlTree.AvlInvariant r)
          //assert (AvlTree.HeightDiff (l, r) <= (balanceTolerance + 1u))
  
          let lh = AvlTree.Height l
          let rh = AvlTree.Height r
  
negative.code: 
              let result =
                  let result, head', stream'' =
                      let min, stream' = CharDiet.TryDeleteMin stream
                      
                      assert (dietInvariant stream')
                      assert (intervalsDisjoint stream')
                      
                      unionImpl input None min stream'
  
                  match head' with
                  | None ->
  