anchor.diff:      let lists = add_priorities 0 [] lists in
       aux (heap_from_list cmp lists) []
   
  -let test_merge () =
  -  let l1 = List.rev [("And", 7); ("admitP", 5); ("2", 2); ("1", 1)] in
  -  let l2 = List.rev [("And", 77); ("admitP", 66); ("5", 55); ("3", 3); ("1", 1)] in
  -  let l3 = List.rev [("And", 777); ("admitP", 555); ("4", 4); ("1", 1)] in
  -  merge_increasing_lists_rev (fun (k, _) -> k) [l1;l2;l3]
  -
   (** * Binary trees * **)
   
   type btree<'a> =
  
positive.code: open FStar.All
  module BU = FStar.Util
  
  module String = begin
    let compare = compare
    let uppercase (s: string) = s.ToUpperInvariant ()
  end
  
  module List = begin
    let filter_map f l =
        (let rec filter_map acc l =
           match l with
           | [] ->
               List.rev acc
           | hd :: tl ->
               match f hd with
               | Some hd ->
                   filter_map (hd :: acc) tl
               | None ->
                   filter_map acc tl
         in
         filter_map [] l)
  
    let rev_map_onto f l acc = List.fold (fun acc x -> f x :: acc) acc l
  
    let fold_left = List.fold
  
    let hd = List.head
  
    let rec rev_acc = (fun ( l  :  'a list ) ( acc  :  'a list ) ->
                       (match (l) with
                        | [] -> begin
                                   acc
                               end
                        | hd::tl -> begin
                                      (rev_acc tl ((hd)::acc))
                                  end))
  
    let rev_append l a = rev_acc l a
  end
  module All = begin end
  module BU = begin
      let bind_opt opt f =
          match opt with
          | None -> None
          | Some x -> f x
      let dflt x = function
          | None   -> x
          | Some x -> x
      let format1 msg arg = msg ^ arg
      let starts_with = fun (s: string) pref -> s.StartsWith pref
  end
  
  let string_compare s1 s2 =
    String.compare s1 s2 // (String.uppercase s1) (String.uppercase s2)
  
  (** * (Pairing) min-heaps * **)
  
  
negative.code: 
  (** * High level interface * **)
  
  type symbol =
  | Lid of Ident.lid
  
  