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