sig
  val iter : ('a -> 'b) -> 'a list -> unit
  val assocp : ('a -> bool) -> ('a * 'b) list -> 'b
  module StringSet :
    sig
      type elt = string
      type t
      val empty : t
      val is_empty : t -> bool
      val mem : elt -> t -> bool
      val add : elt -> t -> t
      val singleton : elt -> t
      val remove : elt -> t -> t
      val union : t -> t -> t
      val inter : t -> t -> t
      val diff : t -> t -> t
      val compare : t -> t -> int
      val equal : t -> t -> bool
      val subset : t -> t -> bool
      val iter : (elt -> unit) -> t -> unit
      val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
      val for_all : (elt -> bool) -> t -> bool
      val exists : (elt -> bool) -> t -> bool
      val filter : (elt -> bool) -> t -> t
      val partition : (elt -> bool) -> t -> t * t
      val cardinal : t -> int
      val elements : t -> elt list
      val min_elt : t -> elt
      val max_elt : t -> elt
      val choose : t -> elt
      val split : elt -> t -> t * bool * t
      val find : elt -> t -> elt
    end
  module StringMap :
    sig
      type key = string
      type +'a t
      val empty : 'a t
      val is_empty : 'a t -> bool
      val mem : key -> 'a t -> bool
      val add : key -> 'a -> 'a t -> 'a t
      val remove : key -> 'a t -> 'a t
      val merge :
        (key -> 'a option -> 'b option -> 'c option) -> 'a t -> 'b t -> 'c t
      val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
      val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
      val iter : (key -> 'a -> unit) -> 'a t -> unit
      val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
      val for_all : (key -> 'a -> bool) -> 'a t -> bool
      val exists : (key -> 'a -> bool) -> 'a t -> bool
      val filter : (key -> 'a -> bool) -> 'a t -> 'a t
      val partition : (key -> 'a -> bool) -> 'a t -> 'a t * 'a t
      val cardinal : 'a t -> int
      val bindings : 'a t -> (key * 'a) list
      val min_binding : 'a t -> key * 'a
      val max_binding : 'a t -> key * 'a
      val choose : 'a t -> key * 'a
      val split : key -> 'a t -> 'a t * 'a option * 'a t
      val find : key -> 'a t -> 'a
      val map : ('a -> 'b) -> 'a t -> 'b t
      val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
      val singleton : string -> 'a -> 'a t
      exception Strict of string
      val strict_add : key -> 'a -> 'a t -> 'a t
      val union : 'a t -> 'a t -> 'a t
      val strict_union : 'a t -> 'a t -> 'a t
    end
  val debug : bool Pervasives.ref
  val print_separated_list : string -> ('a -> string) -> 'a list -> string
  val make_indexes : 'a -> ('a -> int) * (int -> 'a) * ('a -> int)
  val last : 'a list -> 'a
  val curry : ('a -> 'b -> 'c) -> 'a * 'b -> 'c
  val switch_args : ('a -> 'b -> 'c) -> 'b -> 'a -> 'c
  val safe_find : 'a -> 'a
  val notf : ('a -> bool) -> 'a -> bool
  val eqf : 'a -> 'a -> bool
  val is_now : 'a option -> 'a option -> 'a option
  val itern : int -> (unit -> 'a) -> 'a list
  val update : 'a -> 'b -> ('a * 'b) list -> ('a * 'b) list
  val updatef : ('b -> 'b) -> 'a -> 'b -> ('a * 'b) list -> ('a * 'b) list
  val intersect : Misc.StringSet.t -> Misc.StringSet.t -> bool
  val set_of_list : string list -> Misc.StringSet.t
  val map_union :
    'a Misc.StringMap.t -> 'a Misc.StringMap.t -> 'a Misc.StringMap.t
  val twice : ('a -> 'b) -> 'a -> 'a -> 'b * 'b
  exception InvalidOptionUse
  val isNonef : ('a -> 'b option) -> 'a -> bool
  val default : 'a -> 'a option -> 'a
  val unSome : 'a option -> 'a
  val unSomef : ('a -> 'b option) -> 'a -> 'b
  val list_unionq : 'a list -> 'a list -> 'a list
  val list_removeq : 'a -> 'a list -> 'a list
  val pmapq : ('a * 'a) list -> 'a -> 'a
  val const : 'a -> 'b -> 'a
  val array_assoc : 'a -> ('a * 'b) array -> 'b
  val array_associ : 'a -> ('a * 'b) array -> int
  val assoc_proj1 : ('a * 'b) list -> 'a list
  val assoc_proj2 : ('a * 'b) list -> 'b list
  val proj1_3 : 'a * 'b * 'c -> 'a
  val proj2_3 : 'a * 'b * 'c -> 'b
  val proj3_3 : 'a * 'b * 'c -> 'c
  val proj1_4 : 'a * 'b * 'c * 'd -> 'a
  val proj2_4 : 'a * 'b * 'c * 'd -> 'b
  val proj3_4 : 'a * 'b * 'c * 'd -> 'c
  val proj4_4 : 'a * 'b * 'c * 'd -> 'd
  val proj1_5 : 'a * 'b * 'c * 'd * 'e -> 'a
  val proj2_5 : 'a * 'b * 'c * 'd * 'e -> 'b
  val proj3_5 : 'a * 'b * 'c * 'd * 'e -> 'c
  val proj4_5 : 'a * 'b * 'c * 'd * 'e -> 'd
  val proj5_5 : 'a * 'b * 'c * 'd * 'e -> 'e
  val split3 : ('a * 'b * 'c) list -> 'a list * 'b list * 'c list
  val split4 :
    ('a * 'b * 'c * 'd) list -> 'a list * 'b list * 'c list * 'd list
  val split5 :
    ('a * 'b * 'c * 'd * 'e) list ->
    'a list * 'b list * 'c list * 'd list * 'e list
  val transpose : 'a list list -> 'a list list
  val gcombine : 'a list -> 'b list -> ('a * 'b) list * 'a list * 'b list
  val list_map_array : ('a -> 'b) -> 'a list -> 'b array
  val list_iteri : (int -> 'a -> unit) -> 'a list -> unit
  val list_mapi : (int -> 'a -> 'b) -> 'a list -> 'b list
  exception NonDisjointCase
  exception Failure of exn list
  type ('a, 'b) either = Left of 'a | Right of 'b
  val one_of :
    (unit -> 'a) -> (unit -> 'b) -> ('a * exn, 'b * exn) Misc.either
  val reraise : (unit -> 'a) -> exn -> exn -> 'a
  val just_try : (unit -> 'a) -> 'a option
  val ( ^^ ) : string -> string -> string
  val opt_apply : ('a -> 'b) option -> 'a -> 'b option
  val list_foralli : (int -> 'a -> bool) -> 'a list -> bool
  val list_existsi : (int -> 'a -> bool) -> 'a list -> bool
  val list_mapi2 : (int -> 'a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list
  val are_distinct : 'a list -> 'a option
  val all_equal : 'a list -> bool * 'a option
end