anchor.diff:          | [p] -> (p, [])
           | (Root(_, tree) as root)::roots ->
               let (Root(_, tree') as root', roots') = extractMinRoot descending roots
  -            if xor (SBHTree.item tree <= SBHTree.item tree') descending
  +            if (SBHTree.item tree <= SBHTree.item tree') <> descending
                   then root, roots
                   else root', root::roots'
           | [] -> failwith "This should never happen"
  
positive.code:         | Root(_, node)::roots'                 -> 
              let this = item node
              let other = findMinRootItem descending roots'
              if xor (this <= other) descending
                  then this
                  else other
          | []                                    -> failwith "This should never happen"
  
negative.code: 
  type private 'T SBHTreeRoot = Root of int * 'T SBHTree
  
  module private SBHTree =
      let item (Node (x, _, _)) = x
  
      let link descending (Node (x, auxX, childrenX) as treeX) (Node (y, auxY, childrenY) as treeY) =
          if x <= y <> descending
              then Node (x, auxX, treeY::childrenX)
              else Node (y, auxY, treeX::childrenY)
  
      let skewLink descending v treeX treeY =
          let (Node (w, aux, children)) = link descending treeX treeY
          if v <= w <> descending
              then Node (v, w::aux, children)
              else Node (w, v::aux, children)
  
  