anchor.diff:          if count = 0 then
               None
           else
  -            //find the root with the minimum value a return it along with the remaining roots
  -            let (Root(rank, Node(_, aux, children)), roots') = SBHTreeRoot.extractMinRoot descending roots
  -
  -            //reverse the children a set their ranks based on the parent's rank
  -            let (_, reversed) = children |> List.fold (fun (rank, trees) tree -> rank - 1, Root(rank - 1, tree)::trees) (rank, [])
  -
  -            //merge the reversed children with the remaining trees
  -            let merged = SBHTreeRoot.mergeRoots descending reversed (SBHTreeRoot.normalize descending roots') 
  -
  -            //reinsert all "auxiliary" elements
  -            let newRoots = aux |> List.fold (fun roots value -> SBHTreeRoot.insert descending value roots) merged
  -
  -            Some (SkewBinomialHeap (count - 1, descending, newRoots))
  +            Some (SkewBinomialHeap (count - 1, descending, SBHTreeRoot.uncons descending roots |> snd))
   
       member this.Tail () =
           match this.TryTail () with
  
positive.code:     member this.ToList () =
          SBHTreeRoot.toListOrdered descending roots
  
      interface IEnumerable<'T> with
          member this.GetEnumerator () = (SBHTreeRoot.toListOrdered descending roots |> List.toSeq).GetEnumerator ()
          
  
negative.code:                 then this
                  else other
          | []                                    -> failwith "This should never happen"
  
      let uncons descending roots =
          //find the root with the minimum value a return it along with the remaining roots
          let (Root(rank, Node(x, aux, children)), roots') = extractMinRoot descending roots
          //reverse the children and set their ranks based on the parent's rank
          let (_, reversed) = children |> List.fold (fun (rank, trees) tree -> rank - 1, Root(rank - 1, tree)::trees) (rank, [])
          //merge the reversed children with the remaining trees
          let merged = mergeRoots descending reversed (normalize descending roots') 
          //reinsert all "auxiliary" elements
          let newRoots = aux |> List.fold (fun roots value -> insert descending value roots) merged
          x, newRoots
  
      let rec toListOrdered descending roots =
          let rec treeToList acc = function
  