module Cduce_config :
  sig
    val init_all : unit -> unit
    val register : string -> string -> (unit -> unit) -> unit
    val descrs : unit -> (string * string) list
    val inhibit : string -> unit
  end
module Stats :
  sig
    type verbosity = Cduce_lib.Stats.verbosity = Quiet | Summary | Details
    val set_verbosity : verbosity -> unit
    val gettimeofday : (unit -> float) ref
    val register : verbosity -> (Format.formatter -> unit) -> unit
    val dump : Format.formatter -> unit
    module Counter :
      sig
        type t = Cduce_lib.Stats.Counter.t
        val create : string -> t
        val incr : t -> unit
        val add : t -> int -> unit
        val print : Format.formatter -> t -> unit
      end
    module Timer :
      sig
        type t = Cduce_lib.Stats.Timer.t
        val create : string -> t
        val start : t -> unit
        val stop : t -> 'a -> 'a
        val print : Format.formatter -> t -> unit
      end
    module InOut :
      sig
        val enter : string -> unit
        val leave : string -> unit
        val wrap : string -> ('a -> 'b) -> 'a -> 'b
      end
  end
module Custom :
  sig
    module type T =
      sig
        type t
        val dump : Format.formatter -> t -> unit
        val check : t -> unit
        val equal : t -> t -> bool
        val hash : t -> int
        val compare : t -> t -> int
      end
    module Dummy :
      sig
        val dump : 'a -> 'b -> 'c
        val check : 'a -> 'b
        val equal : 'a -> 'b -> 'c
        val hash : 'a -> 'b
        val compare : 'a -> 'b -> 'c
      end
    val dump_list :
      ?sep:string ->
      (Format.formatter -> 'a -> unit) -> Format.formatter -> 'a list -> unit
    val dump_array :
      ?sep:string ->
      (Format.formatter -> 'a -> unit) ->
      Format.formatter -> 'a array -> unit
    module String :
      sig
        type t = string
        val dump : Format.formatter -> t -> unit
        val check : t -> unit
        val equal : t -> t -> bool
        val hash : t -> int
        val compare : t -> t -> int
      end
    module Int :
      sig
        type t = int
        val dump : Format.formatter -> t -> unit
        val check : t -> unit
        val equal : t -> t -> bool
        val hash : t -> int
        val compare : t -> t -> int
      end
    module Bool :
      sig
        type t = bool
        val dump : Format.formatter -> t -> unit
        val check : t -> unit
        val equal : t -> t -> bool
        val hash : t -> int
        val compare : t -> t -> int
      end
    module Array :
      functor (X : T) ->
        sig
          module Elem :
            sig
              type t = X.t
              val dump : Format.formatter -> t -> unit
              val check : t -> unit
              val equal : t -> t -> bool
              val hash : t -> int
              val compare : t -> t -> int
            end
          type t = X.t array
          val dump : Format.formatter -> X.t array -> unit
          val check : X.t array -> unit
          val compare_elems : X.t array -> X.t array -> int -> int -> int
          val compare : X.t array -> X.t array -> int
          val equal : X.t array -> X.t array -> bool
          val hash : X.t array -> int
        end
    module List :
      functor (X : T) ->
        sig
          module Elem :
            sig
              type t = X.t
              val dump : Format.formatter -> t -> unit
              val check : t -> unit
              val equal : t -> t -> bool
              val hash : t -> int
              val compare : t -> t -> int
            end
          type t = X.t list
          val dump : Format.formatter -> X.t list -> unit
          val check : X.t list -> unit
          val equal : X.t list -> X.t list -> bool
          val hash : X.t list -> int
          val compare : X.t list -> X.t list -> int
        end
    module Pair :
      functor (X : T) ->
        functor (Y : T) ->
          sig
            module Fst :
              sig
                type t = X.t
                val dump : Format.formatter -> t -> unit
                val check : t -> unit
                val equal : t -> t -> bool
                val hash : t -> int
                val compare : t -> t -> int
              end
            module Snd :
              sig
                type t = Y.t
                val dump : Format.formatter -> t -> unit
                val check : t -> unit
                val equal : t -> t -> bool
                val hash : t -> int
                val compare : t -> t -> int
              end
            type t = X.t * Y.t
            val dump : Format.formatter -> X.t * Y.t -> unit
            val check : X.t * Y.t -> unit
            val compare : X.t * Y.t -> X.t * Y.t -> int
            val equal : X.t * Y.t -> X.t * Y.t -> bool
            val hash : X.t * Y.t -> int
          end
    type ('a, 'b) choice =
      ('a, 'b) Cduce_lib.Custom.choice =
        Left of 'a
      | Right of 'b
    module Sum :
      functor (X : T) ->
        functor (Y : T) ->
          sig
            type t = (X.t, Y.t) choice
            val equal : (X.t, Y.t) choice -> (X.t, Y.t) choice -> bool
            val hash : (X.t, Y.t) choice -> int
            val compare : (X.t, Y.t) choice -> (X.t, Y.t) choice -> int
            val check : 'a -> unit
            val dump : Format.formatter -> (X.t, Y.t) choice -> unit
          end
  end
module Encodings :
  sig
    type uchar = int
    module Utf8 :
      sig
        type t = Cduce_lib.Encodings.Utf8.t
        val dump : Format.formatter -> t -> unit
        val check : t -> unit
        val equal : t -> t -> bool
        val hash : t -> int
        val compare : t -> t -> int
        type uindex = Cduce_lib.Encodings.Utf8.uindex
        val mk_check : string -> t option
        val to_string : t -> string
        val print : Format.formatter -> t -> unit
        val empty : t
        val end_index : t -> uindex
        val start_index : t -> uindex
        val equal_index : uindex -> uindex -> bool
        val mk : string -> t
        val mk_latin1 : string -> t
        val mk_char : int -> t
        val mk_idx : int -> uindex
        val get_str : t -> string
        val get_idx : uindex -> int
        val get : t -> uindex -> uchar
        val advance : t -> uindex -> uindex
        val next : t -> uindex -> uchar * uindex
        val concat : t -> t -> t
        val store : Buffer.t -> uchar -> unit
        val copy : Buffer.t -> t -> uindex -> uindex -> unit
        val get_substr : t -> uindex -> uindex -> string
      end
  end
module Upool :
  sig
    type 'a typed_int = 'a Cduce_lib.Upool.typed_int
    external int : 'a typed_int -> int = "%identity"
    module type S =
      sig
        type token
        type value
        type t = token typed_int
        val dump : Format.formatter -> t -> unit
        val check : t -> unit
        val equal : t -> t -> bool
        val hash : t -> int
        val compare : t -> t -> int
        exception Not_unique of value * value
        val dummy : t
        val min : t -> t -> t
        val mk : value -> t
        val value : t -> value
        val extract : unit -> value array
        val intract : value array -> unit
        val from_int : int -> t
      end
    module Make :
      functor (X : Custom.T) ->
        sig
          type token = Cduce_lib.Upool.Make(X).token
          type value = X.t
          type t = token typed_int
          val dump : Format.formatter -> t -> unit
          val check : t -> unit
          val equal : t -> t -> bool
          val hash : t -> int
          val compare : t -> t -> int
          exception Not_unique of value * value
          val dummy : t
          val min : t -> t -> t
          val mk : value -> t
          val value : t -> value
          val extract : unit -> value array
          val intract : value array -> unit
          val from_int : int -> t
        end
  end
module Pretty :
  sig
    type 'a regexp =
      'a Cduce_lib.Pretty.regexp =
        Empty
      | Epsilon
      | Seq of 'a regexp * 'a regexp
      | Alt of 'a regexp * 'a regexp
      | Star of 'a regexp
      | Plus of 'a regexp
      | Trans of 'a
    module type S =
      sig
        type t
        val equal : t -> t -> bool
        val compare : t -> t -> int
        val hash : t -> int
      end
    module type TABLE =
      sig
        type key
        type 'a t
        val create : int -> 'a t
        val add : 'a t -> key -> 'a -> unit
        val find : 'a t -> key -> 'a
      end
    module Decompile :
      functor (X : TABLE) ->
        functor (S : S) ->
          sig
            val decompile :
              (X.key ->
               [ `Eps of S.t * X.key | `T of (S.t * X.key) list * bool ]) ->
              X.key -> S.t regexp
          end
  end
module Ns :
  sig
    module Uri :
      sig
        type token = Cduce_lib.Ns.Uri.token
        type value = Encodings.Utf8.t
        type t = token Upool.typed_int