anchor.diff:  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)
  +  String.compare s1 s2
   
   (** * (Pairing) min-heaps * **)
   
  
positive.code:     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> =
  
negative.code: 
  (** * High level interface * **)
  
  type symbol =
  | Lid of Ident.lid
  
  