sig
  module type ACCEPTOR_TYPE =
    sig
      type t
      val name : string
      val compare : t -> t -> int
      val pair : t -> t -> t
      val of_string : string -> t
      val to_string : t -> string
      val print : ?oc:out_channel -> t -> unit
      val print_ : ?oc:out_channel -> t -> unit
      type nodeSet
      type edgeSet
      val empty : t
      val make : nodeSet -> nodeSet -> edgeSet -> t
      val of_file : string -> t
      val to_file : string -> t -> unit
      val to_dotstring :
        ?size:string ->
        ?rd:string -> ?shape:string -> ?fs:string -> string -> t -> string
      val to_dotfile :
        ?size:string ->
        ?rd:string ->
        ?shape:string -> ?fs:string -> string -> string -> t -> unit
      val report : t -> unit
      val starts : t -> nodeSet
      val finals : t -> nodeSet
      val edges : t -> edgeSet
      val nodes : t -> nodeSet
      val is_cyclic : t -> bool
      val is_stripped : t -> bool
      val are_isomorphic : t -> t -> bool
      val equal : t -> t -> bool
      val reverse : t -> t
      val trim : t -> t
      val rename : t -> t
      val rename_n : int -> t -> t
      val inter : t -> t -> t
      val union : t -> t -> t
      type node
      type edge
      type label
      type word
      type wordSet
      type nodeSetSet
      val is_deterministic : t -> bool
      val complete_determinize : t -> t
      val determinize : t -> t
      val minimize : t -> t
      val complement : t -> t
      val print_edgeMap : t -> unit
      val concat : t -> t -> t
      val star : t -> t
      val is_nd : int -> int -> t -> bool
      val transform : t -> nodeSet -> Acceptors.ACCEPTOR_TYPE.word -> nodeSet
      val accepts : t -> string -> bool
      val accepts_wordSet :
        t ->
        Acceptors.ACCEPTOR_TYPE.wordSet ->
        Acceptors.ACCEPTOR_TYPE.wordSet * Acceptors.ACCEPTOR_TYPE.wordSet
      val generate : t -> int -> int -> Acceptors.ACCEPTOR_TYPE.wordSet
      val generate_p : t -> int -> int -> unit
      val k_followers :
        int -> nodeSet -> edgeSet -> Acceptors.ACCEPTOR_TYPE.wordSet
      val k_leaders :
        int -> nodeSet -> edgeSet -> Acceptors.ACCEPTOR_TYPE.wordSet
      val print_wordSet :
        ?oc:Pervasives.out_channel -> Acceptors.ACCEPTOR_TYPE.wordSet -> unit
      val extend_pt : t -> Acceptors.ACCEPTOR_TYPE.word -> t
      val pt : Acceptors.ACCEPTOR_TYPE.wordSet -> t
      val st : Acceptors.ACCEPTOR_TYPE.wordSet -> t
      val make_pt : string -> t
      val make_st : string -> t
      val extend : t -> Acceptors.ACCEPTOR_TYPE.word -> t
      val make_pt2 : string -> t
      val make_st2 : string -> t
      val wordSet_of_string : string -> Acceptors.ACCEPTOR_TYPE.wordSet
      val make_fin : Pervasives.in_channel -> t
      val range_fsa : Acceptors.ACCEPTOR_TYPE.wordSet -> t
      val make_range_fsa : string -> t
      val merge1 : t -> Acceptors.ACCEPTOR_TYPE.nodeSetSet -> t
      val merge1_ns : t -> nodeSet -> t
      val merge : t -> (t -> Acceptors.ACCEPTOR_TYPE.nodeSetSet) -> t
      val b_successors : t -> Acceptors.ACCEPTOR_TYPE.nodeSetSet
      val is_final_eqr : t -> Acceptors.ACCEPTOR_TYPE.nodeSetSet
      val is_nonfinal_eqr : t -> Acceptors.ACCEPTOR_TYPE.nodeSetSet
      val is_start_eqr : t -> Acceptors.ACCEPTOR_TYPE.nodeSetSet
      val is_nonstart_eqr : t -> Acceptors.ACCEPTOR_TYPE.nodeSetSet
      val k_leaders_eqr : int -> t -> Acceptors.ACCEPTOR_TYPE.nodeSetSet
      val k_followers_eqr : int -> t -> Acceptors.ACCEPTOR_TYPE.nodeSetSet
      val jk_nhoods_eqr :
        int -> int -> t -> Acceptors.ACCEPTOR_TYPE.nodeSetSet
    end
  module Make :
    functor (Vocab : Symbols.SYMBOL_SEED->
      functor
        (Word : sig
                  type elt = Vocab.t
                  type t
                  val name : string
                  val compare : t -> t -> int
                  val pair : t -> t -> t
                  val of_string : string -> t
                  val to_string : t -> string
                  val print : ?oc:out_channel -> t -> unit
                  val print_ : ?oc:out_channel -> t -> unit
                  val build : elt -> t -> t
                  val empty : t
                  val empty_string : string
                  val suffixes : t -> t list
                  val prefixes : t -> t list
                  val length : t -> int
                  val hd : t -> elt
                  val tl : t -> t
                  val nth : t -> int -> elt
                  val mem : elt -> t -> bool
                  val rev : t -> t
                  val append : t -> t -> t
                  val iter : (elt -> unit) -> t -> unit
                  val map : (elt -> 'a) -> t -> 'a list
                  val rev_map : (elt -> 'a) -> t -> 'a list
                  val fold_left : ('-> elt -> 'a) -> '-> t -> 'a
                  val fold_right : (elt -> '-> 'a) -> t -> '-> 'a
                end->
        functor
          (WordSet : sig
                       type t
                       val name : string
                       val compare : t -> t -> int
                       val pair : t -> t -> t
                       val of_string : string -> t
                       val to_string : t -> string
                       val print : ?oc:out_channel -> t -> unit
                       val print_ : ?oc:out_channel -> t -> unit
                       type elt = Word.t
                       val of_list : elt list -> t
                       val to_file : string -> t -> unit
                       val of_file : string -> t
                       val cross : t -> t -> 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 equal : t -> t -> bool
                       val subset : t -> t -> bool
                       val iter : (elt -> unit) -> t -> unit
                       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 max_elt : t -> elt
                       val choose : t -> elt
                       val split : elt -> t -> t * bool * t
                     end->
          functor
            (Symbol : sig
                        type t
                        val name : string
                        val compare : t -> t -> int
                        val pair : t -> t -> t
                        val of_string : string -> t
                        val to_string : t -> string
                        val print : ?oc:out_channel -> t -> unit
                        val print_ : ?oc:out_channel -> t -> unit
                        val are_unifiable : t -> t -> bool
                        val conform : t -> t -> t
                        type x = Vocab.t
                        val of_x : x -> t
                        val to_x : t -> x
                        val blank : t
                        val wild : t
                      end->
            functor (Node : X.X_TYPE->
              functor
                (NodeSet : sig
                             type t
                             val name : string
                             val compare : t -> t -> int
                             val pair : t -> t -> t
                             val of_string : string -> t
                             val to_string : t -> string
                             val print : ?oc:out_channel -> t -> unit
                             val print_ : ?oc:out_channel -> t -> unit
                             type elt = Node.t
                             val of_list : elt list -> t
                             val to_file : string -> t -> unit
                             val of_file : string -> t
                             val cross : t -> t -> 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 equal : t -> t -> bool
                             val subset : t -> t -> bool
                             val iter : (elt -> unit) -> t -> unit
                             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 max_elt : t -> elt
                             val choose : t -> elt
                             val split : elt -> t -> t * bool * t
                           end->
                functor
                  (NodeSetSet : sig
                                  type t
                                  val name : string
                                  val compare : t -> t -> int
                                  val pair : t -> t -> t
                                  val of_string : string -> t
                                  val to_string : t -> string
                                  val print : ?oc:out_channel -> t -> unit
                                  val print_ : ?oc:out_channel -> t -> unit
                                  type elt = NodeSet.t
                                  val of_list : elt list -> t
                                  val to_file : string -> t -> unit
                                  val of_file : string -> t
                                  val cross : t -> t -> 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 equal : t -> t -> bool
                                  val subset : t -> t -> bool
                                  val iter : (elt -> unit) -> t -> unit
                                  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 max_elt : t -> elt
                                  val choose : t -> elt
                                  val split : elt -> t -> t * bool * t
                                end->
                  functor
                    (Edge : sig
                              type t
                              val name : string
                              val compare : t -> t -> int
                              val pair : t -> t -> t
                              val of_string : string -> t
                              val to_string : t -> string
                              val print : ?oc:out_channel -> t -> unit
                              val print_ : ?oc:out_channel -> t -> unit
                              type node = Node.t
                              type label = Symbol.t
                              val origin : t -> node
                              val terminus : t -> node
                              val label : t -> label
                              val make : node -> node -> label -> t
                              val label_compare : label -> label -> int
                              val to_dotstring : t -> string
                            end->
                    functor
                      (EdgeSet : sig
                                   type t
                                   val name : string
                                   val compare : t -> t -> int
                                   val pair : t -> t -> t
                                   val of_string : string -> t
                                   val to_string : t -> string
                                   val print : ?oc:out_channel -> t -> unit
                                   val print_ : ?oc:out_channel -> t -> unit
                                   type elt = Edge.t
                                   val of_list : elt list -> t
                                   val to_file : string -> t -> unit
                                   val of_file : string -> t
                                   val cross : t -> t -> 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 equal : t -> t -> bool
                                   val subset : t -> t -> bool
                                   val iter : (elt -> unit) -> t -> unit
                                   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 max_elt : t -> elt
                                   val choose : t -> elt
                                   val split : elt -> t -> t * bool * t
                                 end->
                      functor (D : Delim.DELIM_TYPE->
                        sig
                          type t
                          val name : string
                          val compare : t -> t -> int
                          val pair : t -> t -> t
                          val of_string : string -> t
                          val to_string : t -> string
                          val print : ?oc:out_channel -> t -> unit
                          val print_ : ?oc:out_channel -> t -> unit
                          type nodeSet = NodeSet.t
                          type edgeSet = EdgeSet.t
                          val empty : t
                          val make : nodeSet -> nodeSet -> edgeSet -> t
                          val of_file : string -> t
                          val to_file : string -> t -> unit
                          val to_dotstring :
                            ?size:string ->
                            ?rd:string ->
                            ?shape:string ->
                            ?fs:string -> string -> t -> string
                          val to_dotfile :
                            ?size:string ->
                            ?rd:string ->
                            ?shape:string ->
                            ?fs:string -> string -> string -> t -> unit
                          val report : t -> unit
                          val starts : t -> nodeSet
                          val finals : t -> nodeSet
                          val edges : t -> edgeSet
                          val nodes : t -> nodeSet
                          val is_cyclic : t -> bool
                          val is_stripped : t -> bool
                          val are_isomorphic : t -> t -> bool
                          val equal : t -> t -> bool
                          val reverse : t -> t
                          val trim : t -> t
                          val rename : t -> t
                          val rename_n : int -> t -> t
                          val inter : t -> t -> t
                          val union : t -> t -> t
                          type node = Node.t
                          type edge = Edge.t
                          type label = Symbol.t
                          type word = Word.t
                          type wordSet = WordSet.t
                          type nodeSetSet
                          val is_deterministic : t -> bool
                          val complete_determinize : t -> t
                          val determinize : t -> t
                          val minimize : t -> t
                          val complement : t -> t
                          val print_edgeMap : t -> unit
                          val concat : t -> t -> t
                          val star : t -> t
                          val is_nd : int -> int -> t -> bool
                          val transform : t -> nodeSet -> word -> nodeSet
                          val accepts : t -> string -> bool
                          val accepts_wordSet :
                            t -> wordSet -> wordSet * wordSet
                          val generate : t -> int -> int -> wordSet
                          val generate_p : t -> int -> int -> unit
                          val k_followers :
                            int -> nodeSet -> edgeSet -> wordSet
                          val k_leaders :
                            int -> nodeSet -> edgeSet -> wordSet
                          val print_wordSet :
                            ?oc:out_channel -> wordSet -> unit
                          val extend_pt : t -> word -> t
                          val pt : wordSet -> t
                          val st : wordSet -> t
                          val make_pt : string -> t
                          val make_st : string -> t
                          val extend : t -> word -> t
                          val make_pt2 : string -> t
                          val make_st2 : string -> t
                          val wordSet_of_string : string -> wordSet
                          val make_fin : in_channel -> t
                          val range_fsa : wordSet -> t
                          val make_range_fsa : string -> t
                          val merge1 : t -> nodeSetSet -> t
                          val merge1_ns : t -> nodeSet -> t
                          val merge : t -> (t -> nodeSetSet) -> t
                          val b_successors : t -> nodeSetSet
                          val is_final_eqr : t -> nodeSetSet
                          val is_nonfinal_eqr : t -> nodeSetSet
                          val is_start_eqr : t -> nodeSetSet
                          val is_nonstart_eqr : t -> nodeSetSet
                          val k_leaders_eqr : int -> t -> nodeSetSet
                          val k_followers_eqr : int -> t -> nodeSetSet
                          val jk_nhoods_eqr : int -> int -> t -> nodeSetSet
                        end
  module Make_Q :
    functor (Vocab : Symbols.SYMBOL_SEED->
      functor (Node : X.X_TYPE->
        sig
          type t
          val name : string
          val compare : t -> t -> int
          val pair : t -> t -> t
          val of_string : string -> t
          val to_string : t -> string
          val print : ?oc:out_channel -> t -> unit
          val print_ : ?oc:out_channel -> t -> unit
          type nodeSet
          type edgeSet
          val empty : t
          val make : nodeSet -> nodeSet -> edgeSet -> t
          val of_file : string -> t
          val to_file : string -> t -> unit
          val to_dotstring :
            ?size:string ->
            ?rd:string ->
            ?shape:string -> ?fs:string -> string -> t -> string
          val to_dotfile :
            ?size:string ->
            ?rd:string ->
            ?shape:string -> ?fs:string -> string -> string -> t -> unit
          val report : t -> unit
          val starts : t -> nodeSet
          val finals : t -> nodeSet
          val edges : t -> edgeSet
          val nodes : t -> nodeSet
          val is_cyclic : t -> bool
          val is_stripped : t -> bool
          val are_isomorphic : t -> t -> bool
          val equal : t -> t -> bool
          val reverse : t -> t
          val trim : t -> t
          val rename : t -> t
          val rename_n : int -> t -> t
          val inter : t -> t -> t
          val union : t -> t -> t
          type node = Node.t
          type edge
          type label
          type word
          type wordSet
          type nodeSetSet
          val is_deterministic : t -> bool
          val complete_determinize : t -> t
          val determinize : t -> t
          val minimize : t -> t
          val complement : t -> t
          val print_edgeMap : t -> unit
          val concat : t -> t -> t
          val star : t -> t
          val is_nd : int -> int -> t -> bool
          val transform : t -> nodeSet -> word -> nodeSet
          val accepts : t -> string -> bool
          val accepts_wordSet : t -> wordSet -> wordSet * wordSet
          val generate : t -> int -> int -> wordSet
          val generate_p : t -> int -> int -> unit
          val k_followers : int -> nodeSet -> edgeSet -> wordSet
          val k_leaders : int -> nodeSet -> edgeSet -> wordSet
          val print_wordSet : ?oc:out_channel -> wordSet -> unit
          val extend_pt : t -> word -> t
          val pt : wordSet -> t
          val st : wordSet -> t
          val make_pt : string -> t
          val make_st : string -> t
          val extend : t -> word -> t
          val make_pt2 : string -> t
          val make_st2 : string -> t
          val wordSet_of_string : string -> wordSet
          val make_fin : in_channel -> t
          val range_fsa : wordSet -> t
          val make_range_fsa : string -> t
          val merge1 : t -> nodeSetSet -> t
          val merge1_ns : t -> nodeSet -> t
          val merge : t -> (t -> nodeSetSet) -> t
          val b_successors : t -> nodeSetSet
          val is_final_eqr : t -> nodeSetSet
          val is_nonfinal_eqr : t -> nodeSetSet
          val is_start_eqr : t -> nodeSetSet
          val is_nonstart_eqr : t -> nodeSetSet
          val k_leaders_eqr : int -> t -> nodeSetSet
          val k_followers_eqr : int -> t -> nodeSetSet
          val jk_nhoods_eqr : int -> int -> t -> nodeSetSet
        end
  module Make_DQ :
    functor (Vocab : Symbols.SYMBOL_SEED->
      functor (Node : X.X_TYPE->
        functor (WordD : Delim.DELIM_TYPE->
          functor (WordSetD : Delim.DELIM_TYPE->
            functor (EdgeD : Delim.DELIM_TYPE->
              functor (NodeSetD : Delim.DELIM_TYPE->
                functor (NodeSetSetD : Delim.DELIM_TYPE->
                  functor (EdgeSetD : Delim.DELIM_TYPE->
                    functor (D : Delim.DELIM_TYPE->
                      sig
                        type t
                        val name : string
                        val compare : t -> t -> int
                        val pair : t -> t -> t
                        val of_string : string -> t
                        val to_string : t -> string
                        val print : ?oc:out_channel -> t -> unit
                        val print_ : ?oc:out_channel -> t -> unit
                        type nodeSet
                        type edgeSet
                        val empty : t
                        val make : nodeSet -> nodeSet -> edgeSet -> t
                        val of_file : string -> t
                        val to_file : string -> t -> unit
                        val to_dotstring :
                          ?size:string ->
                          ?rd:string ->
                          ?shape:string ->
                          ?fs:string -> string -> t -> string
                        val to_dotfile :
                          ?size:string ->
                          ?rd:string ->
                          ?shape:string ->
                          ?fs:string -> string -> string -> t -> unit
                        val report : t -> unit
                        val starts : t -> nodeSet
                        val finals : t -> nodeSet
                        val edges : t -> edgeSet
                        val nodes : t -> nodeSet
                        val is_cyclic : t -> bool
                        val is_stripped : t -> bool
                        val are_isomorphic : t -> t -> bool
                        val equal : t -> t -> bool
                        val reverse : t -> t
                        val trim : t -> t
                        val rename : t -> t
                        val rename_n : int -> t -> t
                        val inter : t -> t -> t
                        val union : t -> t -> t
                        type node = Node.t
                        type edge
                        type label
                        type word
                        type wordSet
                        type nodeSetSet
                        val is_deterministic : t -> bool
                        val complete_determinize : t -> t
                        val determinize : t -> t
                        val minimize : t -> t
                        val complement : t -> t
                        val print_edgeMap : t -> unit
                        val concat : t -> t -> t
                        val star : t -> t
                        val is_nd : int -> int -> t -> bool
                        val transform : t -> nodeSet -> word -> nodeSet
                        val accepts : t -> string -> bool
                        val accepts_wordSet :
                          t -> wordSet -> wordSet * wordSet
                        val generate : t -> int -> int -> wordSet
                        val generate_p : t -> int -> int -> unit
                        val k_followers :
                          int -> nodeSet -> edgeSet -> wordSet
                        val k_leaders : int -> nodeSet -> edgeSet -> wordSet
                        val print_wordSet :
                          ?oc:out_channel -> wordSet -> unit
                        val extend_pt : t -> word -> t
                        val pt : wordSet -> t
                        val st : wordSet -> t
                        val make_pt : string -> t
                        val make_st : string -> t
                        val extend : t -> word -> t
                        val make_pt2 : string -> t
                        val make_st2 : string -> t
                        val wordSet_of_string : string -> wordSet
                        val make_fin : in_channel -> t
                        val range_fsa : wordSet -> t
                        val make_range_fsa : string -> t
                        val merge1 : t -> nodeSetSet -> t
                        val merge1_ns : t -> nodeSet -> t
                        val merge : t -> (t -> nodeSetSet) -> t
                        val b_successors : t -> nodeSetSet
                        val is_final_eqr : t -> nodeSetSet
                        val is_nonfinal_eqr : t -> nodeSetSet
                        val is_start_eqr : t -> nodeSetSet
                        val is_nonstart_eqr : t -> nodeSetSet
                        val k_leaders_eqr : int -> t -> nodeSetSet
                        val k_followers_eqr : int -> t -> nodeSetSet
                        val jk_nhoods_eqr : int -> int -> t -> nodeSetSet
                      end
end