sig
  module Symbols :
    functor (T : sig type 'a terminal type 'a nonterminal end) ->
      sig
        type 'a symbol =
            T : 'a T.terminal -> 'a symbol
          | N : 'a T.nonterminal -> 'a symbol
        type xsymbol = X : 'a symbol -> xsymbol
      end
  module Make :
    functor
      (TT : TableFormat.TABLES) (IT : sig
                                        type 'a terminal
                                        type 'a nonterminal
                                        type 'a symbol =
                                            T : 'a terminal -> 'a symbol
                                          | N : 'a nonterminal -> 'a symbol
                                        type xsymbol =
                                            X : 'a symbol -> xsymbol
                                        type 'a lr1state = int
                                        val terminal : int -> xsymbol
                                        val nonterminal : int -> xsymbol
                                        val rhs :
                                          PackedIntArray.t * PackedIntArray.t
                                        val lr0_core : PackedIntArray.t
                                        val lr0_items :
                                          PackedIntArray.t * PackedIntArray.t
                                        val lr0_incoming : PackedIntArray.t
                                        val nullable : string
                                        val first : int * string
                                      end) (ET : sig
                                                   type state
                                                   val number : state -> int
                                                   type token
                                                   type terminal = int
                                                   type nonterminal = int
                                                   type semantic_value =
                                                       Obj.t
                                                   val token2terminal :
                                                     token -> terminal
                                                   val token2value :
                                                     token -> semantic_value
                                                   val error_terminal :
                                                     terminal
                                                   val error_value :
                                                     semantic_value
                                                   val foreach_terminal :
                                                     (terminal -> 'a -> 'a) ->
                                                     'a -> 'a
                                                   type production
                                                   val production_index :
                                                     production -> int
                                                   val find_production :
                                                     int -> production
                                                   val default_reduction :
                                                     state ->
                                                     ('env ->
                                                      production -> 'answer) ->
                                                     ('env -> 'answer) ->
                                                     'env -> 'answer
                                                   val action :
                                                     state ->
                                                     terminal ->
                                                     semantic_value ->
                                                     ('env ->
                                                      bool ->
                                                      terminal ->
                                                      semantic_value ->
                                                      state -> 'answer) ->
                                                     ('env ->
                                                      production -> 'answer) ->
                                                     ('env -> 'answer) ->
                                                     'env -> 'answer
                                                   val goto_nt :
                                                     state ->
                                                     nonterminal -> state
                                                   val goto_prod :
                                                     state ->
                                                     production -> state
                                                   val maybe_goto_nt :
                                                     state ->
                                                     nonterminal ->
                                                     state option
                                                   val is_start :
                                                     production -> bool
                                                   exception Error
                                                   type semantic_action =
                                                       (state,
                                                        semantic_value,
                                                        token)
                                                       EngineTypes.env ->
                                                       (state,
                                                        semantic_value)
                                                       EngineTypes.stack
                                                   val semantic_action :
                                                     production ->
                                                     semantic_action
                                                   val may_reduce :
                                                     state ->
                                                     production -> bool
                                                   val log : bool
                                                   module Log :
                                                     sig
                                                       val state :
                                                         state -> unit
                                                       val shift :
                                                         terminal ->
                                                         state -> unit
                                                       val reduce_or_accept :
                                                         production -> unit
                                                       val lookahead_token :
                                                         terminal ->
                                                         Lexing.position ->
                                                         Lexing.position ->
                                                         unit
                                                       val initiating_error_handling :
                                                         unit -> unit
                                                       val resuming_error_handling :
                                                         unit -> unit
                                                       val handling_error :
                                                         state -> unit
                                                     end
                                                 end) (E : sig
                                                             type 'a env =
                                                                 (ET.state,
                                                                  ET.semantic_value,
                                                                  ET.token)
                                                                 CamlinternalMenhirLib.EngineTypes.env
                                                           end) ->
      sig
        type 'a symbol =
            T : 'a IT.terminal -> 'a symbol
          | N : 'a IT.nonterminal -> 'a symbol
        type xsymbol = X : 'a symbol -> xsymbol
        type item = int * int
        val compare_terminals : 'a IT.terminal -> 'b IT.terminal -> int
        val compare_nonterminals :
          'a IT.nonterminal -> 'b IT.nonterminal -> int
        val compare_symbols : xsymbol -> xsymbol -> int
        val compare_productions : int -> int -> int
        val compare_items : item -> item -> int
        val incoming_symbol : 'a IT.lr1state -> 'a symbol
        val items : 'a IT.lr1state -> item list
        val lhs : int -> xsymbol
        val rhs : int -> xsymbol list
        val nullable : 'a IT.nonterminal -> bool
        val first : 'a IT.nonterminal -> 'b IT.terminal -> bool
        val xfirst : xsymbol -> 'a IT.terminal -> bool
        val foreach_terminal : (xsymbol -> 'a -> 'a) -> 'a -> 'a
        val foreach_terminal_but_error : (xsymbol -> 'a -> 'a) -> 'a -> 'a
        val feed :
          'a symbol ->
          IncrementalEngine.position ->
          'a -> IncrementalEngine.position -> 'b E.env -> 'b E.env
      end
end