sig
  type 'a formatter = Format.formatter -> 'a -> unit
  val get : ('a, 'b) Hashtbl.t -> 'a -> 'b option
  module type QUEUE =
    sig
      type 'a t
      val empty : unit -> 'a Common.QUEUE.t
      val singleton : 'a -> 'a Common.QUEUE.t
      val push : 'a Common.QUEUE.t -> 'a -> unit
      val pop : 'a Common.QUEUE.t -> 'a option
      val fold : ('b -> 'a -> 'b) -> 'b -> 'a Common.QUEUE.t -> 'b
    end
  module IntSet : Sets.T
  type int_set = IntSet.t
  type 'a hval = 'a Hashcons.hash_consed
  type 'a hset = 'a Hset.t
  module Set :
    sig
      type 'a t
      val empty : 'a Common.Set.t
      val singleton : 'a -> 'a Common.Set.t
      val union : 'a Common.Set.t -> 'a Common.Set.t -> 'a Common.Set.t
      val inter : 'a Common.Set.t -> 'a Common.Set.t -> 'a Common.Set.t
      val diff : 'a Common.Set.t -> 'a Common.Set.t -> 'a Common.Set.t
      val mem : 'a -> 'a Common.Set.t -> bool
      val is_empty : 'a Common.Set.t -> bool
      val subset : 'a Common.Set.t -> 'a Common.Set.t -> bool
      val rem : 'a -> 'a Common.Set.t -> 'a Common.Set.t
      val add : 'a -> 'a Common.Set.t -> 'a Common.Set.t
      val map : ('a -> 'b) -> 'a Common.Set.t -> 'b Common.Set.t
      val iter : ('a -> unit) -> 'a Common.Set.t -> unit
      val fold : ('a -> 'b -> 'b) -> 'a Common.Set.t -> 'b -> 'b
      val filter : ('a -> bool) -> 'a Common.Set.t -> 'a Common.Set.t
      val exists : ('a -> bool) -> 'a Common.Set.t -> bool
      val for_all : ('a -> bool) -> 'a Common.Set.t -> bool
      val cardinal : 'a Common.Set.t -> int
      val print :
        ?sep:string ->
        'a Common.formatter -> 'a Common.Set.t Common.formatter
    end
  type 'a set = 'a Common.Set.t
  type ('v, 'k) gstring_ = ('v * ('k * bool) list) list
  type ('v, 'k) gstring = ('k * bool) list * ('v, 'k) Common.gstring_
  val print_gstring :
    'v Common.formatter ->
    'k Common.formatter -> ('v, 'k) Common.gstring Common.formatter
  val paren :
    int ->
    int ->
    ('b, 'c, 'd, 'e, 'f, 'g) Pervasives.format6 ->
    ('b, 'c, 'd, 'e, 'f, 'g) Pervasives.format6
  module Span :
    sig
      type ('v, 'a) t
      val empty : 'a -> ('v, 'a) Common.Span.t
      val single : 'v -> 'a -> 'a -> ('v, 'a) Common.Span.t
      val merge :
        ('a -> 'a -> 'a) ->
        ('v, 'a) Common.Span.t ->
        ('v, 'a) Common.Span.t -> ('v, 'a) Common.Span.t
      val map :
        ('a -> 'b) -> ('v, 'a) Common.Span.t -> ('v, 'b) Common.Span.t
      val iter : ('v -> 'a -> unit) -> ('v, 'a) Common.Span.t -> unit
      val iter2 :
        ('v -> 'a -> 'a -> unit) ->
        ('v, 'a) Common.Span.t -> ('v, 'a) Common.Span.t -> unit
      val get : ('v, 'a) Common.Span.t -> 'v -> 'a
    end
  type ('v, 's) span = ('v, 's) Common.Span.t
  val time : ('a -> 'b) -> 'a -> float * 'b
  val memo_rec : ?n:int -> (('a -> 'b) -> 'a -> 'b) -> 'a -> 'b
  val memo_rec1 :
    (('a Common.hval -> 'b) -> 'a Common.hval -> 'b) -> 'a Common.hval -> 'b
  val memo_rec2 :
    (('a Common.hval -> 'b Common.hval -> 'c) ->
     'a Common.hval -> 'b Common.hval -> 'c) ->
    'a Common.hval -> 'b Common.hval -> 'c
  val next_line : Lexing.lexbuf -> unit
  val unexpected_char : Lexing.lexbuf -> 'a
  val parse :
    ?msg:string -> ('a -> Lexing.lexbuf -> 'b) -> 'a -> Lexing.lexbuf -> 'b
end