anchor.diff:              // second traversal to remove the element once it's found.
               let n = create x l mid
               create a n right
  -            |> extractMax comparer
  +            |> extractMax
   
       /// Extracts the maximum (greatest) value from an AVL tree,
       /// returning the value along with the updated tree.
       /// No exception is thrown if the tree is empty.
  -    let tryExtractMax (comparer : IComparer<_>) (tree : AvlTree<'T>) =
  +    let tryExtractMax (tree : AvlTree<'T>) =
           // Is the tree empty?
           if isEmpty tree then
               None, tree
           else
  -            let maxElement, tree = extractMax comparer tree
  +            let maxElement, tree = extractMax tree
               Some maxElement, tree
   
       /// Merges two AVL trees and returns the result.
  -    let union (comparer : IComparer<_>) (tree1 : AvlTree<'T>) (tree2 : AvlTree<'T>) =
  +    let union (tree1 : AvlTree<'T>) (tree2 : AvlTree<'T>) =
           let tree1_count = count tree1
           let tree2_count = count tree2
   
  
positive.code:             #endif
  
              let head, stream' =
                  AvlTree.tryExtractMin charComparer stream
  
              let result, head', stream'' =
                  union' input None head stream'
  
negative.code:         if tree1_count < tree2_count then
              (tree2, tree1)
              ||> fold (fun tree el ->
                  insert el tree)
          else
              (tree1, tree2)
              ||> fold (fun tree el ->
                  insert el tree)
  
      /// Builds a new AVL tree from the elements of a sequence.
      let ofSeq (sequence : seq<_>) : AvlTree<'T> =
          (Empty, sequence)
          ||> Seq.fold (fun tree el ->
              insert el tree)
  
      /// Builds a new AVL tree from the elements of an F# list.
      let ofList (list : _ list) : AvlTree<'T> =
          (Empty, list)
          ||> List.fold (fun tree el ->
              insert el tree)
  
      /// Builds a new AVL tree from the elements of an array.
      let ofArray (array : _[]) : AvlTree<'T> =
          (Empty, array)
          ||> Array.fold (fun tree el ->
              insert el tree)
  
      /// Returns a sequence containing the elements stored
      /// in an AVL tree, ordered from least to greatest.
  