sig
  module Stdlib :
    sig
      val compare : '-> '-> int
      val succ : int -> int
      val incr : int Pervasives.ref -> unit
      val min : '-> '-> 'a
      val max : '-> '-> 'a
      val min_int : int
      val max_int : int
      val flush : Pervasives.out_channel -> unit
      module Set :
        sig
          module type OrderedType =
            sig type t val compare : t -> t -> int end
          module type S =
            sig
              type elt
              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 map : (elt -> elt) -> t -> t
              val fold : (elt -> '-> 'a) -> t -> '-> '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 min_elt_opt : t -> elt option
              val max_elt : t -> elt
              val max_elt_opt : t -> elt option
              val choose : t -> elt
              val choose_opt : t -> elt option
              val split : elt -> t -> t * bool * t
              val find : elt -> t -> elt
              val find_opt : elt -> t -> elt option
              val find_first : (elt -> bool) -> t -> elt
              val find_first_opt : (elt -> bool) -> t -> elt option
              val find_last : (elt -> bool) -> t -> elt
              val find_last_opt : (elt -> bool) -> t -> elt option
              val of_list : elt list -> t
            end
          module Make :
            functor (Ord : OrderedType->
              sig
                type elt = Ord.t
                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 map : (elt -> elt) -> t -> t
                val fold : (elt -> '-> 'a) -> t -> '-> '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 min_elt_opt : t -> elt option
                val max_elt : t -> elt
                val max_elt_opt : t -> elt option
                val choose : t -> elt
                val choose_opt : t -> elt option
                val split : elt -> t -> t * bool * t
                val find : elt -> t -> elt
                val find_opt : elt -> t -> elt option
                val find_first : (elt -> bool) -> t -> elt
                val find_first_opt : (elt -> bool) -> t -> elt option
                val find_last : (elt -> bool) -> t -> elt
                val find_last_opt : (elt -> bool) -> t -> elt option
                val of_list : elt list -> t
              end
        end
      module Map :
        sig
          module type OrderedType =
            sig type t val compare : t -> t -> int end
          module type S =
            sig
              type key
              type +'a t
              val empty : 'a t
              val is_empty : 'a t -> bool
              val mem : key -> 'a t -> bool
              val add : key -> '-> 'a t -> 'a t
              val singleton : key -> '-> '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 union :
                (key -> '-> '-> 'a option) -> 'a t -> 'a t -> 'a t
              val compare : ('-> '-> int) -> 'a t -> 'a t -> int
              val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
              val iter : (key -> '-> unit) -> 'a t -> unit
              val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
              val for_all : (key -> '-> bool) -> 'a t -> bool
              val exists : (key -> '-> bool) -> 'a t -> bool
              val filter : (key -> '-> bool) -> 'a t -> 'a t
              val partition : (key -> '-> 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 min_binding_opt : 'a t -> (key * 'a) option
              val max_binding : 'a t -> key * 'a
              val max_binding_opt : 'a t -> (key * 'a) option
              val choose : 'a t -> key * 'a
              val choose_opt : 'a t -> (key * 'a) option
              val split : key -> 'a t -> 'a t * 'a option * 'a t
              val find : key -> 'a t -> 'a
              val find_opt : key -> 'a t -> 'a option
              val find_first : (key -> bool) -> 'a t -> key * 'a
              val find_first_opt : (key -> bool) -> 'a t -> (key * 'a) option
              val find_last : (key -> bool) -> 'a t -> key * 'a
              val find_last_opt : (key -> bool) -> 'a t -> (key * 'a) option
              val map : ('-> 'b) -> 'a t -> 'b t
              val mapi : (key -> '-> 'b) -> 'a t -> 'b t
            end
          module Make :
            functor (Ord : OrderedType->
              sig
                type key = Ord.t
                type +'a t
                val empty : 'a t
                val is_empty : 'a t -> bool
                val mem : key -> 'a t -> bool
                val add : key -> '-> 'a t -> 'a t
                val singleton : key -> '-> '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 union :
                  (key -> '-> '-> 'a option) -> 'a t -> 'a t -> 'a t
                val compare : ('-> '-> int) -> 'a t -> 'a t -> int
                val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                val iter : (key -> '-> unit) -> 'a t -> unit
                val fold : (key -> '-> '-> 'b) -> 'a t -> '-> 'b
                val for_all : (key -> '-> bool) -> 'a t -> bool
                val exists : (key -> '-> bool) -> 'a t -> bool
                val filter : (key -> '-> bool) -> 'a t -> 'a t
                val partition : (key -> '-> 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 min_binding_opt : 'a t -> (key * 'a) option
                val max_binding : 'a t -> key * 'a
                val max_binding_opt : 'a t -> (key * 'a) option
                val choose : 'a t -> key * 'a
                val choose_opt : 'a t -> (key * 'a) option
                val split : key -> 'a t -> 'a t * 'a option * 'a t
                val find : key -> 'a t -> 'a
                val find_opt : key -> 'a t -> 'a option
                val find_first : (key -> bool) -> 'a t -> key * 'a
                val find_first_opt :
                  (key -> bool) -> 'a t -> (key * 'a) option
                val find_last : (key -> bool) -> 'a t -> key * 'a
                val find_last_opt :
                  (key -> bool) -> 'a t -> (key * 'a) option
                val map : ('-> 'b) -> 'a t -> 'b t
                val mapi : (key -> '-> 'b) -> 'a t -> 'b t
              end
        end
    end
  module Dynlink : sig val init : unit -> unit end
  module Float : sig val max_float : float end
  module Format :
    sig
      type stag
      val string_of_stag : Transitioning.Format.stag -> string
      val stag_of_string : string -> Transitioning.Format.stag
      type formatter_stag_functions = {
        mark_open_stag : Transitioning.Format.stag -> string;
        mark_close_stag : Transitioning.Format.stag -> string;
        print_open_stag : Transitioning.Format.stag -> unit;
        print_close_stag : Transitioning.Format.stag -> unit;
      }
      val pp_set_formatter_stag_functions :
        Format.formatter ->
        Transitioning.Format.formatter_stag_functions -> unit
      val pp_get_formatter_stag_functions :
        Format.formatter ->
        unit -> Transitioning.Format.formatter_stag_functions
      val pp_open_stag :
        Format.formatter -> Transitioning.Format.stag -> unit
      val pp_close_stag : Format.formatter -> unit -> unit
      val pp_print_option :
        ?none:(Format.formatter -> unit -> unit) ->
        (Format.formatter -> '-> unit) ->
        Format.formatter -> 'a option -> unit
    end
  module Q : sig val to_float : Q.t -> float end
end