anchor.diff:              && avl r
   
       /// Determines if an AVL tree contains a specified value.
  -    let rec contains (comparer : IComparer<_>) value (tree : AvlTree<'T>) =
  +    let rec contains value (tree : AvlTree<'T>) =
           match tree with
           | Empty ->
               false
           | Node (n, l, r, _) ->
  -            let comparison = comparer.Compare (value, n)
  +            let comparison = compare value n
               if comparison = 0 then      // value = n
                   true
               elif comparison < 0 then    // value < n
  -                contains comparer value l
  +                contains value l
               else                        // value > n
  -                contains comparer value r
  +                contains value r
   
       /// Removes the specified value from the tree.
       /// If the tree doesn't contain the value, no exception is thrown;
       /// the tree will be returned without modification.
  -    let rec delete (comparer : IComparer<_>) x (tree : AvlTree<'T>) =
  +    let rec delete x (tree : AvlTree<'T>) =
           match tree with
           | Empty ->
               Empty
           | Node (n, l, r, _) as tree ->
  -            let comparison = comparer.Compare (x, n)
  +            let comparison = compare x n
               if comparison = 0 then      // x = n
                   delete_root tree
               elif comparison < 0 then    // x < n
  -                let la = delete comparer x l
  +                let la = delete x l
                   mkt_bal_r n la r
               else                        // x > n
  -                let a = delete comparer x r
  +                let a = delete x r
                   mkt_bal_l n l a
   
       /// Adds a value to an AVL tree.
       /// If the tree already contains the value, no exception is thrown;
       /// the tree will be returned without modification.
  -    let rec insert (comparer : IComparer<_>) x (tree : AvlTree<'T>) =
  +    let rec insert x (tree : AvlTree<'T>) =
           match tree with
           | Empty ->
               Node (x, Empty, Empty, 1u)
           | Node (n, l, r, _) as tree ->
  -            let comparison = comparer.Compare (x, n)
  +            let comparison = compare x n
               if comparison = 0 then      // x = n
                   tree
               elif comparison < 0 then    // x < n
  -                mkt_bal_l n (insert comparer x l) r
  +                mkt_bal_l n (insert x l) r
               else                        // x > n
  -                mkt_bal_r n l (insert comparer x r)
  +                mkt_bal_r n l (insert x r)
   
       /// Gets the maximum (greatest) value stored in the AVL tree.
       let rec maxElement (tree : AvlTree<'T>) =
  
positive.code:         elif AvlTree.isEmpty stream then
              AvlTree.Empty
          else
              let head, stream = AvlTree.extractMin charComparer stream
              let result, _, _ = inter' input (Some head) stream
              result
  
  
negative.code:                 elif compare y b < 0 then
                      // [a, b] and [x, y] overlap
                      // y < b
                      let head, stream = AvlTree.tryExtractMin stream
                      diff_helper (succ y, b) right left head stream
                  else
                      // [a, b] and [x, y] overlap
  