Current File : //proc/self/root/kunden/usr/share/emacs/27.2/lisp/cedet/semantic/wisent/comp.elc

;ELC
;;; Compiled
;;; in Emacs version 27.2
;;; with all optimizations.

;;; This file uses dynamic docstrings, first added in Emacs 19.29.

;;; This file does not contain utf-8 non-ASCII characters,
;;; and so can be loaded in Emacs versions earlier than 23.

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;


(require 'semantic/wisent)
#@36 Return the context name from NAME.
(defalias 'wisent-context-name '(macro . #[(name) "\301\302\303DE\304\305\306ED\307\310EF\207" [name if and symbolp intern format "wisent-context-%s" error "Invalid context name: %S"] 6 (#$ . 435)]))
#@39 Return the variables in context NAME.
(defalias 'wisent-context-bindings '(macro . #[(name) "\301\302DD\207" [name symbol-value wisent-context-name] 3 (#$ . 680)]))
#@54 Define a context NAME that will bind variables VARS.
(defalias 'wisent-defcontext '(macro . #[(name &rest vars) "\2039\203\304\305\306\"!\202\307\310\"\311\312\n\"\313\314\315\316	\317\nDEDC\"*B\207" [name context vars declarations intern format "wisent-context-%s" error "Invalid context name: %S" mapcar #[(v) "\301D\207" [v defvar] 2] progn append eval-when-compile defvar quote] 8 (#$ . 852)]))
(byte-code "\300\301\302\303#\300\207" [function-put wisent-defcontext lisp-indent-function 1] 4)
#@48 Bind variables in context NAME then eval BODY.
(defalias 'wisent-with-context '(macro . #[(name &rest body) "\2039\203\303\304\305\"!\202\306\307\"J\310\311\312\313	\"\314	\nBBC\")B\207" [name bindings body intern format "wisent-context-%s" error "Invalid context name: %S" progn append mapcar #[(binding) "\301\242\206D\207" [binding defvar] 2] let*] 6 (#$ . 1369)]))
(byte-code "\300\301\302\303#\300\207" [function-put wisent-with-context lisp-indent-function 1] 4)
#@150 Fill string S with spaces.
Return a new string of at least N characters.  Insert spaces on right.
If optional LEFT is non-nil insert spaces on left.
(defalias 'wisent-pad-string #[(s n &optional left) "G\211\nW\203#\203\304\n	Z\305\"P\202$\304\n	Z\305\"P\202$)\207" [s i n left make-string 32] 5 (#$ . 1860)])
(put 'wisent-pad-string 'byte-optimizer 'byte-compile-inline-expand)
(defconst wisent-BITS-PER-WORD (logcount most-positive-fixnum))
#@42 (N + BITS-PER-WORD - 1) / BITS-PER-WORD.
(defalias 'wisent-WORDSIZE #[(n) "	\\S	\245\207" [n wisent-BITS-PER-WORD] 2 (#$ . 2320)])
(put 'wisent-WORDSIZE 'byte-optimizer 'byte-compile-inline-expand)
#@49 X[I/BITS-PER-WORD] |= 1 << (I % BITS-PER-WORD).
(defalias 'wisent-SETBIT #[(x i) "	\245\n\304\nH\305\306	\246\"\"I)\207" [i wisent-BITS-PER-WORD k x logior ash 1] 8 (#$ . 2525)])
(put 'wisent-SETBIT 'byte-optimizer 'byte-compile-inline-expand)
#@52 X[I/BITS-PER-WORD] &= ~(1 << (I % BITS-PER-WORD)).
(defalias 'wisent-RESETBIT #[(x i) "	\245\n\304\nH\305\306\307	\246\"!\"I)\207" [i wisent-BITS-PER-WORD k x logand lognot ash 1] 9 (#$ . 2780)])
(put 'wisent-RESETBIT 'byte-optimizer 'byte-compile-inline-expand)
#@57 (X[I/BITS-PER-WORD] & (1 << (I % BITS-PER-WORD))) != 0.
(defalias 'wisent-BITISSET #[(x i) "\303	\n\245H\304\305	\n\246\"\"\306U?\207" [x i wisent-BITS-PER-WORD logand ash 1 0] 6 (#$ . 3054)])
(put 'wisent-BITISSET 'byte-optimizer 'byte-compile-inline-expand)
#@40 Non-nil means enable some debug stuff.
(defvar wisent-debug-flag nil (#$ . 3321))
#@25 Name of the log buffer.
(defconst wisent-log-buffer-name "*wisent-log*" (#$ . 3409))
#@38 Non-nil means to start a new report.
(defvar wisent-new-log-flag nil (#$ . 3500))
#@66 Non-nil means to report verbose information on generated parser.
(custom-declare-variable 'wisent-verbose-flag nil '(#$ . 3588) :group 'wisent :type 'boolean)
#@67 Toggle whether to report verbose information on generated parser.
(defalias 'wisent-toggle-verbose-flag #[nil "?\301\302!\205\303\304\203\305\202\306\"\207" [wisent-verbose-flag called-interactively-p interactive message "Verbose report %sabled" "en" "dis"] 3 (#$ . 3753) nil])
#@82 Return the log buffer.
Its name is defined in constant `wisent-log-buffer-name'.
(defalias 'wisent-log-buffer '(macro . #[nil "\300\207" [(get-buffer-create wisent-log-buffer-name)] 1 (#$ . 4046)]))
#@47 Delete the entire contents of the log buffer.
(defalias 'wisent-clear-log '(macro . #[nil "\300\207" [(with-current-buffer (wisent-log-buffer) (erase-buffer))] 1 (#$ . 4251)]))
#@45 Return the current source file name or nil.
(defalias 'wisent-source #[nil "\303\300!\203\n\206	\206\304 \211\205\305\n!)\207" [byte-compile-current-file load-file-name source boundp buffer-file-name file-relative-name] 3 (#$ . 4434)])
#@40 Start a new entry into the log buffer.
(defalias 'wisent-new-log #[nil "\303\304\305\306 \206\307 \310\311!#r\312\n!q\210db\210	c*\207" [wisent-new-log-flag text wisent-log-buffer-name nil format "\n\n*** Wisent %s - %s\n\n" wisent-source buffer-name format-time-string "%Y-%m-%d %R" get-buffer-create] 5 (#$ . 4685)])
#@170 Insert text into the log buffer.
`format-message' is applied to ARGS and the result string is inserted into the
log buffer returned by the function `wisent-log-buffer'.
(defalias 'wisent-log #[(&rest args) "\203\303 \210r\304	!q\210\305\306\n\"c)\207" [wisent-new-log-flag wisent-log-buffer-name args wisent-new-log get-buffer-create apply format-message] 3 (#$ . 5015)])
(put 'wisent-log 'byte-optimizer 'byte-compile-inline-expand)
#@63 The log file.
Used when running without interactive terminal.
(defconst wisent-log-file "wisent.output" (#$ . 5458))
#@57 Append contents of logging buffer to `wisent-log-file'.
(defalias 'wisent-append-to-log-file #[nil "\303!\205)\3041!r\305!q\210~\210deV\205\306ed	\307$)0\207\310\311\312\n!\")\207" [wisent-log-buffer-name wisent-log-file err get-buffer (error) get-buffer-create write-region t message "*** %s" error-message-string] 5 (#$ . 5581)])
#@30 The size of the state table.
(custom-declare-variable 'wisent-state-table-size 1009 '(#$ . 5926) :type 'integer :group 'wisent)
#@87 Return non-nil if item number S defines a token (terminal).
That is if S < `ntokens'.
(defalias 'wisent-ISTOKEN '(macro . #[(s) "\301\302BB\207" [s < (ntokens)] 3 (#$ . 6060)]))
#@83 Return non-nil if item number S defines a nonterminal.
That is if S >= `ntokens'.
(defalias 'wisent-ISVAR '(macro . #[(s) "\301\302BB\207" [s >= (ntokens)] 3 (#$ . 6245)]))
#@41 Return printable form of item number S.
(defalias 'wisent-tag #[(s) "	H\304\n!\203\n\236A\206\305\306\n\"\202\307\n!)\207" [tags s item wisent-escape-sequence-strings wisent-char-p format "'%c'" symbol-name] 3 (#$ . 6425)])
(put 'wisent-tag 'byte-optimizer 'byte-compile-inline-expand)
#@79 Store OBJECT's PROPNAME property with value VALUE.
Use `eq' to locate OBJECT.
(defalias 'wisent-put #[(object propname value) "	\236\211\204C\211	B\n\305\nA\f#\241)\207" [object ptable entry propname value plist-put] 6 (#$ . 6726)])
(put 'wisent-put 'byte-optimizer 'byte-compile-inline-expand)
#@76 Return the value of OBJECT's PROPNAME property.
Use `eq' to locate OBJECT.
(defalias 'wisent-get #[(object propname) "\303	\236A\n\"\207" [object ptable propname plist-get] 3 (#$ . 7035)])
(put 'wisent-get 'byte-optimizer 'byte-compile-inline-expand)
#@37 Return the item number of symbol X.
(defalias 'wisent-item-number #[(x) "\304\305\n\236A	\"*\207" [x propname object ptable wisent--item-no plist-get] 3 (#$ . 7293)])
(put 'wisent-item-number 'byte-optimizer 'byte-compile-inline-expand)
#@39 Set the item number of symbol X to N.
(defalias 'wisent-set-item-number #[(x n) "\306	\211
\236\211\204\fC\211
B\307A\n#\241,\207" [x n value propname object ptable wisent--item-no plist-put entry] 6 (#$ . 7540)])
(put 'wisent-set-item-number 'byte-optimizer 'byte-compile-inline-expand)
#@39 Return the associativity of symbol X.
(defalias 'wisent-assoc #[(x) "\304\305\n\236A	\"*\207" [x propname object ptable wisent--assoc plist-get] 3 (#$ . 7850)])
(put 'wisent-assoc 'byte-optimizer 'byte-compile-inline-expand)
#@41 Set the associativity of symbol X to A.
(defalias 'wisent-set-assoc #[(x a) "\306	\211
\236\211\204\fC\211
B\307A\n#\241,\207" [x a value propname object ptable wisent--assoc plist-put entry] 6 (#$ . 8085)])
(put 'wisent-set-assoc 'byte-optimizer 'byte-compile-inline-expand)
#@42 Return the precedence level of symbol X.
(defalias 'wisent-prec #[(x) "\304\305\n\236A	\"*\207" [x propname object ptable wisent--prec plist-get] 3 (#$ . 8383)])
(put 'wisent-prec 'byte-optimizer 'byte-compile-inline-expand)
#@44 Set the precedence level of symbol X to P.
(defalias 'wisent-set-prec #[(x p) "\306	\211
\236\211\204\fC\211
B\307A\n#\241,\207" [x p value propname object ptable wisent--prec plist-put entry] 6 (#$ . 8618)])
(put 'wisent-set-prec 'byte-optimizer 'byte-compile-inline-expand)
#@39 compiler-macro for inlining `core-p'.
(defalias 'core-p--cmacro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block core-p (and (memq (type-of cl-x) cl-struct-core-tags) t)) nil] 7 (#$ . 8916)])
(put 'core-p 'compiler-macro 'core-p--cmacro)
(defalias 'core-p #[(cl-x) "\302!	>\205	\303\207" [cl-x cl-struct-core-tags type-of t] 2])
(byte-code "\300\301\302\303#\304\305\306\301#\207" [function-put core-p side-effect-free error-free put core cl-deftype-satisfies] 5)
#@42 compiler-macro for inlining `core-next'.
(defalias 'core-next--cmacro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block core-next (progn (or (core-p cl-x) (signal 'wrong-type-argument (list 'core cl-x))) (aref cl-x 1))) nil] 7 (#$ . 9439)])
(put 'core-next 'compiler-macro 'core-next--cmacro)
#@43 Access slot "next" of `core' struct CL-X.
(defalias 'core-next #[(cl-x) "\302!	>\204\303\304\305D\"\210\306H\207" [cl-x cl-struct-core-tags type-of signal wrong-type-argument core 1] 4 (#$ . 9788)])
(byte-code "\300\301\302\303#\300\207" [function-put core-next side-effect-free t] 4)
#@42 compiler-macro for inlining `core-link'.
(defalias 'core-link--cmacro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block core-link (progn (or (core-p cl-x) (signal 'wrong-type-argument (list 'core cl-x))) (aref cl-x 2))) nil] 7 (#$ . 10084)])
(put 'core-link 'compiler-macro 'core-link--cmacro)
#@43 Access slot "link" of `core' struct CL-X.
(defalias 'core-link #[(cl-x) "\302!	>\204\303\304\305D\"\210\306H\207" [cl-x cl-struct-core-tags type-of signal wrong-type-argument core 2] 4 (#$ . 10434)])
(byte-code "\300\301\302\303#\300\207" [function-put core-link side-effect-free t] 4)
#@44 compiler-macro for inlining `core-number'.
(defalias 'core-number--cmacro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block core-number (progn (or (core-p cl-x) (signal 'wrong-type-argument (list 'core cl-x))) (aref cl-x 3))) nil] 7 (#$ . 10731)])
(put 'core-number 'compiler-macro 'core-number--cmacro)
#@45 Access slot "number" of `core' struct CL-X.
(defalias 'core-number #[(cl-x) "\302!	>\204\303\304\305D\"\210\306H\207" [cl-x cl-struct-core-tags type-of signal wrong-type-argument core 3] 4 (#$ . 11091)])
(byte-code "\300\301\302\303#\300\207" [function-put core-number side-effect-free t] 4)
#@54 compiler-macro for inlining `core-accessing-symbol'.
(defalias 'core-accessing-symbol--cmacro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block core-accessing-symbol (progn (or (core-p cl-x) (signal 'wrong-type-argument (list 'core cl-x))) (aref cl-x 4))) nil] 7 (#$ . 11394)])
(put 'core-accessing-symbol 'compiler-macro 'core-accessing-symbol--cmacro)
#@55 Access slot "accessing-symbol" of `core' struct CL-X.
(defalias 'core-accessing-symbol #[(cl-x) "\302!	>\204\303\304\305D\"\210\306H\207" [cl-x cl-struct-core-tags type-of signal wrong-type-argument core 4] 4 (#$ . 11804)])
(byte-code "\300\301\302\303#\300\207" [function-put core-accessing-symbol side-effect-free t] 4)
#@44 compiler-macro for inlining `core-nitems'.
(defalias 'core-nitems--cmacro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block core-nitems (progn (or (core-p cl-x) (signal 'wrong-type-argument (list 'core cl-x))) (aref cl-x 5))) nil] 7 (#$ . 12137)])
(put 'core-nitems 'compiler-macro 'core-nitems--cmacro)
#@45 Access slot "nitems" of `core' struct CL-X.
(defalias 'core-nitems #[(cl-x) "\302!	>\204\303\304\305D\"\210\306H\207" [cl-x cl-struct-core-tags type-of signal wrong-type-argument core 5] 4 (#$ . 12497)])
(byte-code "\300\301\302\303#\300\207" [function-put core-nitems side-effect-free t] 4)
#@43 compiler-macro for inlining `core-items'.
(defalias 'core-items--cmacro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block core-items (progn (or (core-p cl-x) (signal 'wrong-type-argument (list 'core cl-x))) (aref cl-x 6))) nil] 7 (#$ . 12800)])
(put 'core-items 'compiler-macro 'core-items--cmacro)
#@44 Access slot "items" of `core' struct CL-X.
(defalias 'core-items #[(cl-x) "\302!	>\204\303\304\305D\"\210\306H\207" [cl-x cl-struct-core-tags type-of signal wrong-type-argument core 6] 4 (#$ . 13155)])
(byte-code "\300\301\302\303#\304\305\306\"\207" [function-put core-items side-effect-free t defalias copy-core copy-sequence] 4)
#@42 compiler-macro for inlining `make-core'.
(defalias 'make-core--cmacro #[(_cl-whole-arg) "\300\301\302\301\211\211%\207" [cl--defsubst-expand nil (cl-block make-core (record 'core nil nil 0 0 0 [0]))] 6 (#$ . 13498)])
(put 'make-core 'compiler-macro 'make-core--cmacro)
#@41 Constructor for objects of type `core'.
(defalias 'make-core #[nil "\300\301\302\211\303\211\211\304&\207" [record core nil 0 [0]] 8 (#$ . 13773)])
(byte-code "\300\301\302\303#\304\305\306\307\310\306\311\312\305\303&	\207" [function-put make-core side-effect-free t cl-struct-define core nil cl-structure-object record ((cl-tag-slot) (next) (link) (number 0) (accessing-symbol 0) (nitems 0) (items [0])) cl-struct-core-tags] 11)
#@41 compiler-macro for inlining `shifts-p'.
(defalias 'shifts-p--cmacro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block shifts-p (and (memq (type-of cl-x) cl-struct-shifts-tags) t)) nil] 7 (#$ . 14211)])
(put 'shifts-p 'compiler-macro 'shifts-p--cmacro)
(defalias 'shifts-p #[(cl-x) "\302!	>\205	\303\207" [cl-x cl-struct-shifts-tags type-of t] 2])
(byte-code "\300\301\302\303#\304\305\306\301#\207" [function-put shifts-p side-effect-free error-free put shifts cl-deftype-satisfies] 5)
#@44 compiler-macro for inlining `shifts-next'.
(defalias 'shifts-next--cmacro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block shifts-next (progn (or (shifts-p cl-x) (signal 'wrong-type-argument (list 'shifts cl-x))) (aref cl-x 1))) nil] 7 (#$ . 14755)])
(put 'shifts-next 'compiler-macro 'shifts-next--cmacro)
#@45 Access slot "next" of `shifts' struct CL-X.
(defalias 'shifts-next #[(cl-x) "\302!	>\204\303\304\305D\"\210\306H\207" [cl-x cl-struct-shifts-tags type-of signal wrong-type-argument shifts 1] 4 (#$ . 15119)])
(byte-code "\300\301\302\303#\300\207" [function-put shifts-next side-effect-free t] 4)
#@46 compiler-macro for inlining `shifts-number'.
(defalias 'shifts-number--cmacro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block shifts-number (progn (or (shifts-p cl-x) (signal 'wrong-type-argument (list 'shifts cl-x))) (aref cl-x 2))) nil] 7 (#$ . 15426)])
(put 'shifts-number 'compiler-macro 'shifts-number--cmacro)
#@47 Access slot "number" of `shifts' struct CL-X.
(defalias 'shifts-number #[(cl-x) "\302!	>\204\303\304\305D\"\210\306H\207" [cl-x cl-struct-shifts-tags type-of signal wrong-type-argument shifts 2] 4 (#$ . 15800)])
(byte-code "\300\301\302\303#\300\207" [function-put shifts-number side-effect-free t] 4)
#@47 compiler-macro for inlining `shifts-nshifts'.
(defalias 'shifts-nshifts--cmacro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block shifts-nshifts (progn (or (shifts-p cl-x) (signal 'wrong-type-argument (list 'shifts cl-x))) (aref cl-x 3))) nil] 7 (#$ . 16113)])
(put 'shifts-nshifts 'compiler-macro 'shifts-nshifts--cmacro)
#@48 Access slot "nshifts" of `shifts' struct CL-X.
(defalias 'shifts-nshifts #[(cl-x) "\302!	>\204\303\304\305D\"\210\306H\207" [cl-x cl-struct-shifts-tags type-of signal wrong-type-argument shifts 3] 4 (#$ . 16492)])
(byte-code "\300\301\302\303#\300\207" [function-put shifts-nshifts side-effect-free t] 4)
#@46 compiler-macro for inlining `shifts-shifts'.
(defalias 'shifts-shifts--cmacro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block shifts-shifts (progn (or (shifts-p cl-x) (signal 'wrong-type-argument (list 'shifts cl-x))) (aref cl-x 4))) nil] 7 (#$ . 16808)])
(put 'shifts-shifts 'compiler-macro 'shifts-shifts--cmacro)
#@47 Access slot "shifts" of `shifts' struct CL-X.
(defalias 'shifts-shifts #[(cl-x) "\302!	>\204\303\304\305D\"\210\306H\207" [cl-x cl-struct-shifts-tags type-of signal wrong-type-argument shifts 4] 4 (#$ . 17182)])
(byte-code "\300\301\302\303#\304\305\306\"\207" [function-put shifts-shifts side-effect-free t defalias copy-shifts copy-sequence] 4)
#@44 compiler-macro for inlining `make-shifts'.
(defalias 'make-shifts--cmacro #[(_cl-whole-arg) "\300\301\302\301\211\211%\207" [cl--defsubst-expand nil (cl-block make-shifts (record 'shifts nil 0 0 [0]))] 6 (#$ . 17540)])
(put 'make-shifts 'compiler-macro 'make-shifts--cmacro)
#@43 Constructor for objects of type `shifts'.
(defalias 'make-shifts #[nil "\300\301\302\303\211\304%\207" [record shifts nil 0 [0]] 6 (#$ . 17821)])
(byte-code "\300\301\302\303#\304\305\306\307\310\306\311\312\305\303&	\207" [function-put make-shifts side-effect-free t cl-struct-define shifts nil cl-structure-object record ((cl-tag-slot) (next) (number 0) (nshifts 0) (shifts [0])) cl-struct-shifts-tags] 11)
#@45 compiler-macro for inlining `reductions-p'.
(defalias 'reductions-p--cmacro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block reductions-p (and (memq (type-of cl-x) cl-struct-reductions-tags) t)) nil] 7 (#$ . 18236)])
(put 'reductions-p 'compiler-macro 'reductions-p--cmacro)
(defalias 'reductions-p #[(cl-x) "\302!	>\205	\303\207" [cl-x cl-struct-reductions-tags type-of t] 2])
(byte-code "\300\301\302\303#\304\305\306\301#\207" [function-put reductions-p side-effect-free error-free put reductions cl-deftype-satisfies] 5)
#@48 compiler-macro for inlining `reductions-next'.
(defalias 'reductions-next--cmacro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block reductions-next (progn (or (reductions-p cl-x) (signal 'wrong-type-argument (list 'reductions cl-x))) (aref cl-x 1))) nil] 7 (#$ . 18820)])
(put 'reductions-next 'compiler-macro 'reductions-next--cmacro)
#@49 Access slot "next" of `reductions' struct CL-X.
(defalias 'reductions-next #[(cl-x) "\302!	>\204\303\304\305D\"\210\306H\207" [cl-x cl-struct-reductions-tags type-of signal wrong-type-argument reductions 1] 4 (#$ . 19212)])
(byte-code "\300\301\302\303#\300\207" [function-put reductions-next side-effect-free t] 4)
#@50 compiler-macro for inlining `reductions-number'.
(defalias 'reductions-number--cmacro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block reductions-number (progn (or (reductions-p cl-x) (signal 'wrong-type-argument (list 'reductions cl-x))) (aref cl-x 2))) nil] 7 (#$ . 19539)])
(put 'reductions-number 'compiler-macro 'reductions-number--cmacro)
#@51 Access slot "number" of `reductions' struct CL-X.
(defalias 'reductions-number #[(cl-x) "\302!	>\204\303\304\305D\"\210\306H\207" [cl-x cl-struct-reductions-tags type-of signal wrong-type-argument reductions 2] 4 (#$ . 19941)])
(byte-code "\300\301\302\303#\300\207" [function-put reductions-number side-effect-free t] 4)
#@49 compiler-macro for inlining `reductions-nreds'.
(defalias 'reductions-nreds--cmacro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block reductions-nreds (progn (or (reductions-p cl-x) (signal 'wrong-type-argument (list 'reductions cl-x))) (aref cl-x 3))) nil] 7 (#$ . 20274)])
(put 'reductions-nreds 'compiler-macro 'reductions-nreds--cmacro)
#@50 Access slot "nreds" of `reductions' struct CL-X.
(defalias 'reductions-nreds #[(cl-x) "\302!	>\204\303\304\305D\"\210\306H\207" [cl-x cl-struct-reductions-tags type-of signal wrong-type-argument reductions 3] 4 (#$ . 20671)])
(byte-code "\300\301\302\303#\300\207" [function-put reductions-nreds side-effect-free t] 4)
#@49 compiler-macro for inlining `reductions-rules'.
(defalias 'reductions-rules--cmacro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block reductions-rules (progn (or (reductions-p cl-x) (signal 'wrong-type-argument (list 'reductions cl-x))) (aref cl-x 4))) nil] 7 (#$ . 21001)])
(put 'reductions-rules 'compiler-macro 'reductions-rules--cmacro)
#@50 Access slot "rules" of `reductions' struct CL-X.
(defalias 'reductions-rules #[(cl-x) "\302!	>\204\303\304\305D\"\210\306H\207" [cl-x cl-struct-reductions-tags type-of signal wrong-type-argument reductions 4] 4 (#$ . 21398)])
(byte-code "\300\301\302\303#\304\305\306\"\207" [function-put reductions-rules side-effect-free t defalias copy-reductions copy-sequence] 4)
#@48 compiler-macro for inlining `make-reductions'.
(defalias 'make-reductions--cmacro #[(_cl-whole-arg) "\300\301\302\301\211\211%\207" [cl--defsubst-expand nil (cl-block make-reductions (record 'reductions nil 0 0 [0]))] 6 (#$ . 21777)])
(put 'make-reductions 'compiler-macro 'make-reductions--cmacro)
#@47 Constructor for objects of type `reductions'.
(defalias 'make-reductions #[nil "\300\301\302\303\211\304%\207" [record reductions nil 0 [0]] 6 (#$ . 22082)])
(byte-code "\300\301\302\303#\304\305\306\307\310\306\311\312\305\303&	\207" [function-put make-reductions side-effect-free t cl-struct-define reductions nil cl-structure-object record ((cl-tag-slot) (next) (number 0) (nreds 0) (rules [0])) cl-struct-reductions-tags] 11)
#@39 compiler-macro for inlining `errs-p'.
(defalias 'errs-p--cmacro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block errs-p (and (memq (type-of cl-x) cl-struct-errs-tags) t)) nil] 7 (#$ . 22518)])
(put 'errs-p 'compiler-macro 'errs-p--cmacro)
(defalias 'errs-p #[(cl-x) "\302!	>\205	\303\207" [cl-x cl-struct-errs-tags type-of t] 2])
(byte-code "\300\301\302\303#\304\305\306\301#\207" [function-put errs-p side-effect-free error-free put errs cl-deftype-satisfies] 5)
#@43 compiler-macro for inlining `errs-nerrs'.
(defalias 'errs-nerrs--cmacro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block errs-nerrs (progn (or (errs-p cl-x) (signal 'wrong-type-argument (list 'errs cl-x))) (aref cl-x 1))) nil] 7 (#$ . 23042)])
(put 'errs-nerrs 'compiler-macro 'errs-nerrs--cmacro)
#@44 Access slot "nerrs" of `errs' struct CL-X.
(defalias 'errs-nerrs #[(cl-x) "\302!	>\204\303\304\305D\"\210\306H\207" [cl-x cl-struct-errs-tags type-of signal wrong-type-argument errs 1] 4 (#$ . 23397)])
(byte-code "\300\301\302\303#\300\207" [function-put errs-nerrs side-effect-free t] 4)
#@42 compiler-macro for inlining `errs-errs'.
(defalias 'errs-errs--cmacro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block errs-errs (progn (or (errs-p cl-x) (signal 'wrong-type-argument (list 'errs cl-x))) (aref cl-x 2))) nil] 7 (#$ . 23697)])
(put 'errs-errs 'compiler-macro 'errs-errs--cmacro)
#@43 Access slot "errs" of `errs' struct CL-X.
(defalias 'errs-errs #[(cl-x) "\302!	>\204\303\304\305D\"\210\306H\207" [cl-x cl-struct-errs-tags type-of signal wrong-type-argument errs 2] 4 (#$ . 24047)])
(byte-code "\300\301\302\303#\304\305\306\"\207" [function-put errs-errs side-effect-free t defalias copy-errs copy-sequence] 4)
#@42 compiler-macro for inlining `make-errs'.
(defalias 'make-errs--cmacro #[(_cl-whole-arg) "\300\301\302\301\211\211%\207" [cl--defsubst-expand nil (cl-block make-errs (record 'errs 0 [0]))] 6 (#$ . 24387)])
(put 'make-errs 'compiler-macro 'make-errs--cmacro)
#@41 Constructor for objects of type `errs'.
(defalias 'make-errs #[nil "\300\301\302\303#\207" [record errs 0 [0]] 4 (#$ . 24650)])
(byte-code "\300\301\302\303#\304\305\306\307\310\306\311\312\305\303&	\207" [function-put make-errs side-effect-free t cl-struct-define errs nil cl-structure-object record ((cl-tag-slot) (nerrs 0) (errs [0])) cl-struct-errs-tags] 11)
#@106 Visit L and R and return non-nil if their first N elements are `='.
L and R must be vectors of integers.
(defalias 'wisent-bits-equal #[(L R n) "S\305\n\203\306	!\203	H\f	HU	S\202\n*\207" [n i iseq L R t natnump] 3 (#$ . 25020)])
#@41 Return number of bits set in integer I.
(defalias 'wisent-nbits #[(i) "\302	\302U\204\303	\304	\211[\"\"T\202)\207" [count i 0 logxor logand] 5 (#$ . 25268)])
#@94 In vector S count the total of bits set in first N elements.
S must be a vector of integers.
(defalias 'wisent-bits-size #[(S n) "S\304\305	!\203\n\306	H!\\	S\202\n*\207" [n i count S 0 natnump wisent-nbits] 4 (#$ . 25442)])
#@53 Return non-nil if production I is in useful set N0.
(defalias 'wisent-useful-production #[(i N0) "\306	\nH\307\203A
H\211\310V\203A\f\fY\203;
\f\fZ\311\n\245H\312\313\n\246\"\"\310U*?T\202+\207" [useful rrhs i r n ritem t nil 0 logand ash 1 ntokens N0 x wisent-BITS-PER-WORD] 6 (#$ . 25683)])
#@39 Find out which nonterminals are used.
(defalias 'wisent-useless-nonterminals #[nil "\306\211\211\211\211
\211\\S\245)\307	\310\"\204\313	S\311\n!\2036\f\n\nHI\210\nS\202\"\312\211X\203\261\n\313\n\245H\314\312\n\246\"\"\310U*\203\252\315\n\"\203\252\f\nHZ\n\245\316H\314\312\n\246\"\"I+\210\n\n\245\316H\314\312\n\246\"\"I+\210\nT\211\2029\317\f	#\203\300\320\211\202\f\202\f\211-\207" [break n i Ns Np nvars nil make-vector 0 natnump 1 logand ash wisent-useful-production logior wisent-bits-equal t wisent-BITS-PER-WORD N nrules P x rlhs ntokens k] 9 (#$ . 26009)])
#@70 Find out which productions are reachable and which symbols are used.
(defalias 'wisent-inaccessible-symbols #[nil "\306\211\211\211\211\211\211\211\211\211\\S\245)T\211\\S\245)\307\n\310\"\307	\310\"Z\311
\245H\312\313
\246\"\"\310U*\204\236

\245\314H\312\313
\246\"\"I+\210\204\236
\nS\315
!\203\232

HI\210
S\202\205\313\211X\203

\311
\245H\312\313
\246\"\"\310U*\203x

\311
\245H\312\313
\246\"\"\310U*\204x

H\311
\245H\312\313
\246\"\"\310U*\204x

H\315 H\211!\203W
\fW\2040
\fZ\311
\245H\312\313
\246\"\"\310U*\204Q
\f
\245\314H\312\313
\246\"\"I+\210T\202\377

\245\314H\312\313
\246\"\"I+\210
T\211\202\235\316\n#\203\217
\317\211\202\202~\211\310
\245\314H\312\313
\246\"\"I+\210\313
\245\314H\312\313
\246\"\"I+\210\320	\"Z!\"#\211W\203'
\311
\245H\312\313
\246\"\"\310U*\204 #S#
T\211\202\371
\313\211X\205b$
H\203[%$
H
\245\314H\312\313
\246\"\"I+\210
T\211\202*.	\207" [break m n r tt i nil make-vector 0 logand ash 1 logior natnump wisent-bits-equal t wisent-bits-size Pp Vs Vp nsyms wisent-BITS-PER-WORD nrules N start-symbol ntokens x V k P rlhs rrhs ritem nuseless-productions nvars nuseless-nonterminals rprec V1] 10 (#$ . 26680)])
#@30 Disable useless productions.
(defalias 'wisent-reduce-grammar-tables #[nil "\306V\2053\307\211\nX\2052	\f	\n\310\n
\245H\311\307
\246\"\"\306U*?I\210	T\211\202	)\207" [nuseless-productions pn nrules ruseful P i 0 1 logand ash x wisent-BITS-PER-WORD] 9 (#$ . 28137)])
#@30 Remove useless nonterminals.
(defalias 'wisent-nonterminals-reduce #[nil "\306\211\211\211\211\211\307\f\310\"

\211W\203M
\311
\245H\312\313
\246\"\"\310U*\204F	

Z\fI\210\fT
T\211\202
\211W\203\205
\311
\245H\312\313
\246\"\"\310U*\203~	

Z\fI\210\fT
T\211\202Q\307\f\306\"
\211W\203\256	

ZH\f
Z
HI\210
T\211\202\217
\211W\203\312


ZHI\210
T\211\202\262\313\211X\203\350
	
H
ZHI\210
T\211\202\315\310H\211\203
\n
Y\203
	\n
ZHI\210T\202\352	
ZHZ\fZ\211\f.\207" [tags-sorted nontermmap item r n i nil make-vector 0 logand ash 1 nvars ntokens nsyms V x wisent-BITS-PER-WORD tags nrules rlhs ritem start-symbol nuseless-nonterminals] 7 (#$ . 28424)])
#@56 Report number of useless nonterminals and productions.
(defalias 'wisent-total-useless #[nil "\304 \211\203
\305P\202\306\307\310\"\n\311V\203+\307\312	\n\211\311V\203(\313\202)\306$\n\311V\203<\311V\203<\307\314	\"\311V\203S\307\315	\211\311V\203P\313\202Q\306$\316	!+\207" [src msg nuseless-nonterminals nuseless-productions wisent-source " in " "" format "Grammar%s contains" 0 "%s %d useless nonterminal%s" "s" "%s and" "%s %d useless rule%s" message] 7 (#$ . 29202)])
#@59 Find unreachable terminals, nonterminals and productions.
(defalias 'wisent-reduce-grammar #[nil "\306\211\n\\S\n\245)\307\"\306\fT\211\n\\S\n\245)\307\"\306\211\n\\S\n\245)\307\"\306\211\n\\S\n\245)\307\"\307\211\310 \210\311 \210\\\307V\205\252\312 \210Z\313\n\245H\314\315\n\246\"\"\307U*\203\236\316\317 H!\320!!\203\227!\"\236A\206\233\321\322!\"\202\233\323!!*\"\210\324 \210\307V\205\252\325 \207" [nvars n wisent-BITS-PER-WORD N nrules P make-vector 0 wisent-useless-nonterminals wisent-inaccessible-symbols wisent-total-useless logand ash 1 error "Start symbol `%s' does not derive any sentence" wisent-char-p format "'%c'" symbol-name wisent-reduce-grammar-tables wisent-nonterminals-reduce nsyms V V1 nuseless-nonterminals nuseless-productions start-symbol ntokens i x s tags item wisent-escape-sequence-strings] 7 (#$ . 29703)])
#@48 Output the detailed results of the reductions.
(defalias 'wisent-print-useless #[nil "\306\211\211\307V\203u\310C
\203\311 \210r\312\"!q\210\313\314\f\"c*\210\307\211W\203u\315#\n\\$%$H&\316&!\203R&'\236A\206V\317\320&\"\202V\321&!*D
\203`\311 \210r\312\"!q\210\313\314\f\"c*\210\nT\211\202'\306\307\211(W\203
)\n*\322*\n+\245H\323\324\n+\246\"\"\307U*\203
,\n*\322*\n+\245H\323\324\n+\246\"\"\307U*\203
	\204\324\325C
\203\306\311 \210r\312\"!q\210\313\314\f\"c*\210\326\315\n$%$H&\316&!\203\371&'\236A\206\375\317\320&\"\202\375\321&!*D
\203
\311 \210r\312\"!q\210\313\314\f\"c*\210\nT\211\202z-\307V\203R\327C
\203-
\311 \210r\312\"!q\210\313\314\f\"c*\210\324\211.X\203R/\nH\204K\330\317\331\n\"\332\30601\211$G\2111W\203\201
0\203t
\3331\nZ\334\"$P\202\203
$\3331\nZ\334\"P\202\203
$,D
\203\215
\311 \210r\312\"!q\210\313\314\f\"c*\210\3352\nH$%$H&\316&!\203\301
&'\236A\206\305
\317\320&\"\202\305
\321&!*D
\203\317
\311 \210r\312\"!q\210\313\314\f\"c*\2103\nH\3364H!\2033\3374H$%$H&\316&!\203&'\236A\206\317\320&\"\202\321&!*D
\203\311 \210r\312\"!q\210\313\314\f\"c*\210T\202\342
\340C
\203=\311 \210r\312\"!q\210\313\314\f\"c*\210\nT\211\202>
	\204c\307V\204c-\307V\205z\341C
\203m\311 \210r\312\"!q\210\313\314\f\"c*+\207" [r b i nuseless-nonterminals args wisent-new-log-flag nil 0 "\n\nUseless nonterminals:\n\n" wisent-new-log get-buffer-create apply format-message "   %s\n" wisent-char-p format "'%c'" symbol-name logand ash 1 "\n\nTerminals which are not used:\n\n" t "\n\nUseless rules:\n\n" "#%s  " "%d" 4 make-string 32 "%s:" natnump " %s" ";\n" "\n\n" wisent-log-buffer-name nsyms s tags item wisent-escape-sequence-strings ntokens V x wisent-BITS-PER-WORD V1 nuseless-productions nrules ruseful left n rlhs rrhs ritem] 7 (#$ . 30609)])
#@182 Find, for each variable (nonterminal), which rules can derive it.
It sets up the value of DERIVES so that DERIVES[i - NTOKENS] points to
a list of rule numbers, terminated with -1.
(defalias 'wisent-set-derives #[nil "\306\211\211\211\211\211\307\n\306\"\307T\310\"\310\211\310V\203N\f
H\203G

H
	\fZHBI\210	\fZI\210T
S\211\202\307\n\306\"\211W\205\221\306	
ZH\211\203|H\211@\nBA\211\204l\311\nB\237
Z\nI\210
T\211\202Y.\207" [delts dset q p lhs i nil make-vector 0 -1 nvars nrules ruseful rlhs ntokens derives nsyms] 7 (#$ . 32517)])
#@17 Print NULLABLE.
(defalias 'wisent-print-nullable #[nil "\306\307C\n\203\f\310 \210r\311!q\210\312\313	\"c*\210\f\211
W\203t\314H\315!\203D\236A\206H\316\317\"\202H\320!*\fZH\203V\321\202W\322E\n\203`\310 \210r\311!q\210\312\313	\"c*\210T\211\202\323C\n\203~\310 \210r\311!q\210\312\313	\"c+\207" [i args wisent-new-log-flag wisent-log-buffer-name ntokens nsyms nil "NULLABLE\n" wisent-new-log get-buffer-create apply format-message "	%s: %s\n" wisent-char-p format "'%c'" symbol-name "yes" "no" "\n\n" s tags item wisent-escape-sequence-strings nullable] 6 (#$ . 33119)])
#@138 Set up NULLABLE.
A vector saying which nonterminals can expand into the null string.
NULLABLE[i - NTOKENS] is nil if symbol I can do so.
(defalias 'wisent-set-nullable #[nil "\306\211\211\211\211\211\211\211\211\211\211
\307\310\"\307T\310\"\307\306\"\307\311\312#\306\"\307\306\"\310\211\310\312\211X\203
H\203
HH\310V\203\325\306H

H\310V\203\220
HW\203\210\313
T
\202q\204
H

H\211\310V\203
\f\fHTI\210\n	ZHBI\210	ZI\210T
T
\202\233H\203
H\211\203
	ZH\204
	Z\313I\210
	I\210TT\211\202MW\203e

HZHT\203
\nH\211@A\f\fHSI\310U\203&
H	Z\313I\210
	I\210T\202&
\205l
\314 .\207" [any-tokens item relts rsets rcount squeue nil make-vector 0 + 1 t wisent-print-nullable r p s2 s1 ruleno nvars nrules nitems nullable ruseful ritem rrhs ntokens rlhs wisent-debug-flag] 12 (#$ . 33741)])
#@17 Print FDERIVES.
(defalias 'wisent-print-fderives #[nil "\306\211\211\307C\f\203\310 \210r\311
!q\210\312\313\"c*\210\211W\205\267\314\nH\315!\203J\236A\206N\316\317\"\202N\320!*D\f\203X\310 \210r\311
!q\210\312\313\"c*\210\nZH\321\211X\203\260	\322\n\245H\323\324\n\246\"\"\321U*\204\251\325	D\f\203\234\310 \210r\311
!q\210\312\313\"c*\210	T\211\202p\nT\211\202!+\207" [rp j i args wisent-new-log-flag wisent-log-buffer-name nil "\n\n\nFDERIVES\n" wisent-new-log get-buffer-create apply format-message "\n\n%s derives\n\n" wisent-char-p format "'%c'" symbol-name 0 logand ash 1 "   %d\n" ntokens nsyms s tags item wisent-escape-sequence-strings fderives nrules x wisent-BITS-PER-WORD] 7 (#$ . 34719)])
#@319 Set up FDERIVES.
An NVARS by NRULES matrix of bits indicating which rules can help
derive the beginning of the data for each nonterminal.  For example,
if symbol 5 can be derived as the sequence of symbols 8 3 20, and one
of the rules for deriving symbol 8 is rule 4, then the
[5 - NTOKENS, 4] bit in FDERIVES is set.
(defalias 'wisent-set-fderives #[nil "\306\211\211\307\306\"\310\211W\203\"\f\n\307
\310\"I\210\nT\211\202\311 \210\211W\203\244\211W\203\235\nZH	Z\312\n\245H\313\314\n\246\"\"\310U*\204\226	ZH\211@\310V\203\226\f\nZH@\n\245\315H\313\314\n\246\"\"I+\210A\211\202f	T\211\2023\nT\211\202)\205\253\316 +\207" [k j i nvars fderives rulesetsize nil make-vector 0 wisent-set-firsts logand ash 1 logior wisent-print-fderives ntokens nsyms firsts x wisent-BITS-PER-WORD derives wisent-debug-flag] 9 (#$ . 35493)])
#@15 Print FIRSTS.
(defalias 'wisent-print-firsts #[nil "\306\211\211\307C\f\203\310 \210r\311
!q\210\312\313\"c*\210\211W\205\344\314\nH\315!\203J\236A\206N\316\317\"\202N\320!*D\f\203X\310 \210r\311
!q\210\312\313\"c*\210\nZH\321\211W\203\335	\322\n\245H\323\324\n\246\"\"\321U*\204\326\325	\\	\\H\315!\203\273\236A\206\277\316\317\"\202\277\320!*E\f\203\311\310 \210r\311
!q\210\312\313\"c*\210	T\211\202p\nT\211\202!+\207" [v j i args wisent-new-log-flag wisent-log-buffer-name nil "\n\n\nFIRSTS\n\n" wisent-new-log get-buffer-create apply format-message "\n\n%s firsts\n\n" wisent-char-p format "'%c'" symbol-name 0 logand ash 1 "		%d (%s)\n" ntokens nsyms s tags item wisent-escape-sequence-strings firsts nvars x wisent-BITS-PER-WORD] 7 (#$ . 36395)])
#@123 Transitive closure.
Given R an N by N matrix of bits, modify its contents to be the
transitive closure of what was given.
(defalias 'wisent-TC #[(R n) "\306\211\211\307\211W\205\205\307\211W\203~\f	H\n\310
\n\f\245H\311\312\n\f\246\"\"\307U*\204w\307\211W\203w\f\nH\310
\n\f\245H\311\312\n\f\246\"\"\307U*\204p\f	H\n\f\245
\313
H\311\312\n\f\246\"\"I+\210T\211\2024	T\211\202\nT\211\202	+\207" [k j i n R x nil 0 logand ash 1 logior wisent-BITS-PER-WORD] 9 (#$ . 37245)])
#@125 Reflexive Transitive Closure.
Same as `wisent-TC' and then set all the bits on the diagonal of R, an
N by N matrix of bits.
(defalias 'wisent-RTC #[(R n) "\306\307	\n\"\210\310\211\nW\2050	H\f\245
\311
H\312\313\f\246\"\"I+\210T\211\202\n)\207" [i R n x wisent-BITS-PER-WORD k nil wisent-TC 0 logior ash 1] 9 (#$ . 37763)])
#@342 Set up FIRSTS.
An NVARS by NVARS bit matrix indicating which items can represent the
beginning of the input corresponding to which other items.  For
example, if some rule expands symbol 5 into the sequence of symbols 8
3 20, the symbol 8 can be the beginning of the data for symbol 5, so
the bit [8 - NTOKENS, 5 - NTOKENS] in FIRSTS is set.
(defalias 'wisent-set-firsts #[nil "\306\211\211\211\211
\211\\S\245)\211\307
\306\"\310\211
W\2038\307	\310\"I\210T\211\202#\310\211W\203\233ZH\n@\310Y\203\221\n@HH\nAY\203LZ\fH\245\311H\312\313\246\"\"I+\210\202L\fTT\211\202>\314
\"\210\205\250\315 -\207" [i rowsize sp symbol row nvars nil make-vector 0 logior ash 1 wisent-RTC wisent-print-firsts n wisent-BITS-PER-WORD varsetsize firsts ntokens nsyms derives ritem rrhs x k wisent-debug-flag] 9 (#$ . 38109)])
#@163 Allocate the ITEMSET and RULESET vectors.
And precompute useful data so that `wisent-closure' can be called.
N is the number of elements to allocate for ITEMSET.
(defalias 'wisent-initialize-closure #[(n) "\306\307\"\nT\211\\S\245)\306\f\307\"\310 \207" [n itemset nrules wisent-BITS-PER-WORD rulesetsize ruleset make-vector 0 wisent-set-fderives] 4 (#$ . 39006)])
#@16 Print ITEMSET.
(defalias 'wisent-print-closure #[nil "\306\307	D\203
\310 \210r\311\f!q\210\312\313\n\"c*\210\314\211	W\205C\315
HD\203/\310 \210r\311\f!q\210\312\313\n\"c*\210T\211\202)\207" [i nitemset args wisent-new-log-flag wisent-log-buffer-name itemset nil "\n\nclosure n = %d\n\n" wisent-new-log get-buffer-create apply format-message 0 "   %d\n"] 4 (#$ . 39384)])
#@591 Set up RULESET and ITEMSET for the transitions out of CORE state.
Given a vector of item numbers items, of length N, set up RULESET and
ITEMSET to indicate what rules could be run and which items could be
accepted when those items are the active ones.

RULESET contains a bit for each rule.  `wisent-closure' sets the bits
for all rules which could potentially describe the next input to be
read.

ITEMSET is a vector of item numbers; NITEMSET is the number of items
in ITEMSET.  `wisent-closure' places there the indices of all items
which represent units of input that could arrive next.
(defalias 'wisent-closure #[(core n) "\306\211\211\211\211\211\307U\2034\307ZH\fW\203\f\fHI\210\fT\211\202\310\307\"\210\307\211W\203
HH\211Y\203x\307\nZH\fW\203x\f\311\fH\fH\"I\210\fT\211\202]
T\211\202=\307\211\307_	\fW\203\357	\312\245H\313\314\246\"\"\307U*\204\350	H
W\203\334
HW\203\334
HI\210T
T\211\202\267I\210T	T\211\202\215
W\203\f

HI\210T
T\211\202\360\205
\315 .\207" [itemno ruleno symbol v r c nil 0 fillarray logior logand ash 1 wisent-print-closure n fderives start-symbol ntokens rulesetsize ruleset ritem core nitemset wisent-BITS-PER-WORD i x rrhs itemset wisent-debug-flag] 7 (#$ . 39778)])
#@32 Allocate storage for itemsets.
(defalias 'wisent-allocate-itemsets #[nil "\306\211\211\211\307\310\f
\\\307\"\307	\nH\211\2033\307V\203-	THTI\210\nT\202\310\f\306\"\n\310	\307\"\307\211\307\fW\203\\\n\n	I\210	\nH\\\nT\211\202D\f\310\f\306\"\211
,\207" [symbol-count count i symbol nsyms nuseless-nonterminals nil 0 make-vector ritem kernel-base kernel-items shift-symbol kernel-end] 5 (#$ . 41125)])
#@41 Allocate storage for the state machine.
(defalias 'wisent-allocate-storage #[nil "\306 \210\307\310\"\307\nT\310\"\307\f\311\"\211\207" [nsyms shiftset nrules redset wisent-state-table-size state-table wisent-allocate-itemsets make-vector 0 nil] 3 (#$ . 41565)])
#@411 Find which symbols can be shifted in the current state.
And for each one record which items would be active after that shift.
Uses the contents of ITEMSET.  SHIFT-SYMBOL is set to a vector of the
symbols that can be shifted.  For each symbol in the grammar,
KERNEL-BASE[symbol] points to a vector of item numbers activated if
that symbol is shifted, and KERNEL-END[symbol] points after the end of
that vector.
(defalias 'wisent-new-itemsets #[nil "\306\211\211\211\211\307
\306\"\210\310\211\n	W\203U\n\nH\nT\fH\211\310V\203
H\211\204C\fI\210T
H	\fTI\210	T
	I\210\202\211-\207" [symbol ksp isp shiftcount i kernel-end nil fillarray 0 nitemset itemset ritem shift-symbol kernel-base kernel-items nshifts] 6 (#$ . 41839)])
#@122 Create a new state for those items, if necessary.
SYMBOL is the core accessing-symbol.
Subroutine of `wisent-get-state'.
(defalias 'wisent-new-state #[(symbol) "\306\211\211\211\211\211HH\211Z\307\310\306\211\311\211\211\312&\313
\311\"\314\f!>\204<\315\316\310\fD\"\210\f\211\317I\210)\314\f!>\204V\315\316\310\fD\"\210\f\211\320I\210)\314\f!>\204p\315\316\310\fD\"\210\f\211\321
I\210)\314\f!>\204\211\315\316\310\fD\"\210\f\211\322I\210)\311	W\203\253\nHI\210T\nT\202\224\314!>\204\275\315\316\310D\"\210\211\323\fI\210)\fT\f.\207" [items iend isp2 isp1 p n nil record core 0 [0] make-vector type-of signal wrong-type-argument 4 3 5 6 1 kernel-base symbol kernel-end cl-struct-core-tags #1=#:v #2=#:v nstates #3=#:v #4=#:v kernel-items last-state #5=#:v] 9 (#$ . 42604)])
#@241 Find the state we would get to by shifting SYMBOL.
Return the state number for the state we would get to (from the
current state) by shifting SYMBOL.  Create a new state if no
equivalent one exists already.  Used by `wisent-append-states'.
(defalias 'wisent-get-state #[(symbol) "\306\211\211\211\211\211\211\211HH\211Z\307\fW\203AH\\T\211\202)\246H\211\203
\306	\204
\310!>\204h\311\312\313D\"\210\314HU\203\263\315H\310!>\204\211\311\312\313D\"\210\316H\307	\203\263\fW\203\263H\n
HU\204\250\306T
T\202\217	\204T\310!>\204\307\311\312\313D\"\210\317H\203\344\310!>\204\335\311\312\313D\"\210\317H\202T\310!>\204\364\311\312\313D\"\210\211\317\320!I)\315\211\202U\320!I\210\310!>\204\"
\311\312\313D\"\210\321H.\207" [n found sp2 sp iend isp2 nil 0 type-of signal wrong-type-argument core 5 t 6 2 wisent-new-state 3 isp1 key kernel-base symbol kernel-end kernel-items wisent-state-table-size state-table cl-struct-core-tags #1=#:v] 9 (#$ . 43461)])
#@250 Find or create the core structures for states.
Use the information computed by `wisent-new-itemsets' to find the
state numbers reached by each shift transition from the current state.
SHIFTSET is set up as a vector of state numbers of those states.
(defalias 'wisent-append-states #[nil "\306\211\211\307\211W\203>\f\nH\n\211\310V\2032\f	SHV\2032\f	\f	SHI\210	S\211\202\f	I\210\nT\211\202	\310\211W\205X\f\nH
\n\311!I\210\nT\211\202A+\207" [symbol j i nshifts shift-symbol shiftset nil 1 0 wisent-get-state] 5 (#$ . 44556)])
#@20 Initialize states.
(defalias 'wisent-initialize-states #[nil "\305\306\307\211\310\211\211\311&\211\312\211)\207" [p first-state last-state this-state nstates record core nil 0 [0] 1] 9 (#$ . 45111)])
#@60 Save the NSHIFTS of SHIFTSET into the current linked list.
(defalias 'wisent-save-shifts #[nil "\306\211\211\307\300\306\310\211\311%\312\310\"\310\313\n!\f>\204$\314\315\300\nD\"\210\n\211\316\313!>\204:\314\315\317D\"\210\320HI\210)\313\n!\f>\204P\314\315\300\nD\"\210\n\211\320I\210)\313\n!\f>\204h\314\315\300\nD\"\210\n\211\321I\210)	W\203\206		HI\210	T\211\202r\203\251\313!\f>\204\234\314\315\300D\"\210\211\322\nI\210)\202\254\n\n\211+\207" [shifts i p nshifts cl-struct-shifts-tags #1=#:v nil record 0 [0] make-vector type-of signal wrong-type-argument 2 core 3 4 1 this-state cl-struct-core-tags #2=#:v #3=#:v shiftset last-shift #4=#:v first-shift] 7 (#$ . 45326)])
#@155 Create the next-to-final state.
That is the state to which a shift has already been made in the
initial state.  Subroutine of `wisent-augment-automaton'.
(defalias 'wisent-insert-start-shift #[nil "\306\211\307\310\306\211\311\211\211\312&\313	!\n>\204\314\315\310	D\"\210	\211\316\fI\210)\313	!\n>\2045\314\315\310	D\"\210	\211\317I\210)\313!\n>\204O\314\315\310D\"\210\211\320	I\210)	\307\321\306\311\211\322%\313!>\204t\314\315\321D\"\210\211\323\fI\210)\fT\313!>\204\220\314\315\321D\"\210\211\316\320I\210)\313!>\204\251\314\315\321D\"\210\211\317\324\f!I\210)\313!>\204\306\314\315\321D\"\210\211\320I\210)\211*\207" [sp statep cl-struct-core-tags #1=#:v nstates #2=#:v nil record core 0 [0] type-of signal wrong-type-argument 3 4 1 shifts [0] 2 vector start-symbol last-state #3=#:v cl-struct-shifts-tags #4=#:v #5=#:v #6=#:v last-shift #7=#:v] 9 (#$ . 46060)])
#@335 Set up initial and final states as parser wants them.
Make sure that the initial state has a shift that accepts the
grammar's start symbol and goes to the next-to-final state, which has
a shift going to the final state, which has a shift to the termination
state.  Create such states and shifts if they don't happen to exist
already.
(defalias 'wisent-augment-automaton #[nil "\306\211\211\211\211\211\211\211\203F\307!>\204&\310\311\300D\"\210\312H\313U\203\346\307!>\204>\310\311\300D\"\210\314H\307!>\204T\310\311\315D\"\210\316H\307\f!>\204i\310\311\315\fD\"\210\f\317HW\203\241\307\f!>\204\202\310\311\315\fD\"\210\f\314H
W\203\241\307\f!>\204\232\310\311\315\fD\"\210\f\316H\202Y\307\f!>\204\261\310\311\315\fD\"\210\f\317HU\203\246\307\f!>\204\312\310\311\315\fD\"\210\f\314H\203
\307!>\204\342\310\311\300D\"\210\312H
W\203
\307!>\204\374\310\311\300D\"\210\316H\211\204\322\203\307!>\204
\310\311\300D\"\210\312H
U\203\307!>\2040
\310\311\300D\"\210\314H\320\300\306\313\211\321%\322T\313\"\307\n!>\204T
\310\311\300\nD\"\210\n\211\312
I\210)\307\n!>\204m
\310\311\300\nD\"\210\n\211\314TI\210)\307\n!>\204\210
\310\311\300\nD\"\210\n\211\317I\210)\313I\210\313V\203\303
\307!>\204\261
\310\311\300D\"\210\317HSHI\210S\211\202\231
\307\n!>\204\323
\310\311\300\nD\"\210\n\211 \316\307!>\204\350
\310\311\300D\"\210\316HI\210)\307	!>\204\376
\310\311\300	D\"\210	\211!\316\nI\210)\"=\203\214\n\"\202\214\320\300\306\313\211\321%\307\n!>\204,\310\311\300\nD\"\210\n\211#\312
I\210)\307\n!>\204E\310\311\300\nD\"\210\n\211$\314\316I\210)\307\n!>\204^\310\311\300\nD\"\210\n\211%\317\323!I\210)\307\n!>\204z\310\311\300\nD\"\210\n\211&\316I\210)\307	!>\204\223\310\311\300	D\"\210	\211'\316\nI\210)\204\214\n\"\202\214\320\300\306\313\211\321%\307!>\204\301\310\311\300D\"\210\314H\322T\313\"\307\n!>\204\335\310\311\300\nD\"\210\n\211(\314TI\210)\307\n!>\204\370\310\311\300\nD\"\210\n\211)\317I\210)\307!>\204\310\311\315D\"\210\316H\313\211\307!>\204/\310\311\300D\"\210\314HW\203\230\307\f!>\204F\310\311\315\fD\"\210\f\317HV\203_
U\203_
I\210
T
\307!>\204q\310\311\300D\"\210\317HHI\210\307\f!>\204\211\310\311\315\fD\"\210\f\316HT
T\202
U\203\250
I\210
T\307\n!>\204\270\310\311\300\nD\"\210\n\211*\316\307!>\204\315\310\311\300D\"\210\316HI\210)\n\"=\203\340\n\"\324 \210\202\214\320\300\306\313\211\321%\307!>\204\376\310\311\300D\"\210\211+\314\316I\210)\307!>\204\310\311\300D\"\210\211,\317\323!I\210)\307!>\2043\310\311\300D\"\210\211-\316I\210)\324 \210\202\214\320\300\306\313\211\321%\307!>\204^\310\311\300D\"\210\211.\314\316I\210)\307!>\204w\310\311\300D\"\210\211/\317\323!I\210)\"\324 \210\320\315\306\211\313\211\211\325&\307\f!>\204\247\310\311\315\fD\"\210\f\2110\314I\210)\3071!>\204\303\310\311\3151D\"\2101\2112\316\fI\210)\f1\320\300\306\313\211\321%\307!>\204\350\310\311\300D\"\210\2113\312I\210)T\307!>\204\310\311\300D\"\210\2114\314\316I\210)\307!>\204 \310\311\300D\"\210\2115\317\323!I\210)\307\"!>\204>\310\311\300\"D\"\210\"\2116\316I\210)\"7\320\315\306\211\313\211\211\325&\307\f!>\204j\310\311\315\fD\"\210\f\2118\314I\210)T\3071!>\204\213\310\311\3151D\"\2101\2119\316\fI\210)\f\2111.\207" [shifts sp1 sp2 sp statep k nil type-of signal wrong-type-argument 2 0 3 core 1 4 record [0] make-vector vector wisent-insert-start-shift [0] i first-shift cl-struct-shifts-tags first-state cl-struct-core-tags start-symbol #1=#:v #2=#:v #3=#:v nstates #4=#:v #5=#:v last-shift #6=#:v #7=#:v #8=#:v #9=#:v #10=#:v #11=#:v #12=#:v #13=#:v #14=#:v #15=#:v #16=#:v #17=#:v #18=#:v #19=#:v last-state #20=#:v #21=#:v #22=#:v #23=#:v #24=#:v final-state #25=#:v #26=#:v] 9 (#$ . 46999)])
#@184 Make a reductions structure.
Find which rules can be used for reduction transitions from the
current state and make a reductions structure for the state to record
their rule numbers.
(defalias 'wisent-save-reductions #[nil "\306\211\211\211\211\307\211\307
W\2033\fHH\211\307W\203,\n[I\210\nT\fT\211\202\n\307V\205\350\310\311\306\307\211\312%\313\n\307\"\314	!>\204V\315\316\311	D\"\210	\211\317\314!>\204m\315\316\320D\"\210\321HI\210)\314	!>\204\204\315\316\311	D\"\210	\211\321\nI\210)\314	!>\204\235\315\316\311	D\"\210	\211\322I\210)\307\211\nW\203\275\f\fHI\210\fT\211\202\251\203\341\314!>\204\324\315\316\311D\"\210\211\323	I\210)\202\344		\211-\207" [rules p count item i nitemset nil 0 record reductions [0] make-vector type-of signal wrong-type-argument 2 core 3 4 1 ritem itemset redset cl-struct-reductions-tags #1=#:v this-state cl-struct-core-tags #2=#:v #3=#:v last-reduction #4=#:v first-reduction] 7 (#$ . 51043)])
#@69 Compute the nondeterministic finite state machine from the grammar.
(defalias 'wisent-generate-states #[nil "\304 \210\305!\210\306 \210	\203^\307\310	!\n>\204\311\312\313	D\"\210	\314H\310	!\n>\2040\311\312\313	D\"\210	\315H\"\210\316 \210\317 \210\320 \210\321V\203G\322 \210\310	!\n>\204V\311\312\313	D\"\210	\323H\211\204\324 \207" [nitems this-state cl-struct-core-tags nshifts wisent-allocate-storage wisent-initialize-closure wisent-initialize-states wisent-closure type-of signal wrong-type-argument core 6 5 wisent-save-reductions wisent-new-itemsets wisent-append-states 0 wisent-save-shifts 1 wisent-augment-automaton] 7 (#$ . 52058)])
#@13 Traverse I.
(defalias 'wisent-traverse #[(i) "\306\211\211\211\211\211T\211\f
I\210
I\210
H\211\203\220\307\n
H\307Y\203\220\n
HH\307U\203H\310\n
H!\210
H\n
HHV\203c
\n
HHI\210
H\307\211W\203\212	\f\311	\fH\n
HH\fH\"I\210\fT\211\202l
T\202/
HU\205\336\306?\205\336\fHS
I\210

U\203\300\312\211\202\235\307\211W\203\234
H\f
H\fHI\210\fT\211\202\303.\207" [break Fi Ri height k j nil 0 wisent-traverse logior t top VERTICES i INDEX R F tokensetsize infinity] 8 (#$ . 52722)])
#@19 Digraph RELATION.
(defalias 'wisent-digraph #[(relation) "\306\211\306\211\306
\307\\\310
T\311\"\310
T\311\"\311\311\211\f
W\205F\fH\311U\203=	\fH\203=\312\f!\210\fT\211\f\202#.\207" [INDEX R VERTICES infinity top ngotos nil 2 make-vector 0 wisent-traverse relation i] 4 (#$ . 53293)])
#@20 Build state table.
(defalias 'wisent-set-state-table #[nil "\305\306	\305\"\211\205;\n\307!\f>\204\310\311\312D\"\210\313HI\210\307!\f>\2042\310\311\312D\"\210\314H\211\204
\305)\207" [sp nstates state-table first-state cl-struct-core-tags nil make-vector type-of signal wrong-type-argument core 3 1] 6 (#$ . 53610)])
#@31 Build accessing symbol table.
(defalias 'wisent-set-accessing-symbol #[nil "\305\306	\307\"\211\205L\n\310!\f>\204\311\312\313D\"\210\314H\310!\f>\204/\311\312\313D\"\210\315HI\210\310!\f>\204C\311\312\313D\"\210\316H\211\204
\305)\207" [sp nstates accessing-symbol first-state cl-struct-core-tags nil make-vector 0 type-of signal wrong-type-argument core 3 4 1] 7 (#$ . 53951)])
#@20 Build shift table.
(defalias 'wisent-set-shift-table #[nil "\305\306	\305\"\211\205;\n\307!\f>\204\310\311\312D\"\210\313HI\210\307!\f>\2042\310\311\312D\"\210\314H\211\204
\305)\207" [sp nstates shift-table first-shift cl-struct-shifts-tags nil make-vector type-of signal wrong-type-argument shifts 2 1] 6 (#$ . 54357)])
#@24 Build reduction table.
(defalias 'wisent-set-reduction-table #[nil "\305\306	\305\"\211\205;\n\307!\f>\204\310\311\312D\"\210\313HI\210\307!\f>\2042\310\311\312D\"\210\314H\211\204
\305)\207" [rp nstates reduction-table first-reduction cl-struct-reductions-tags nil make-vector type-of signal wrong-type-argument reductions 2 1] 6 (#$ . 54702)])
#@22 Setup MAXRHS length.
(defalias 'wisent-set-maxrhs #[nil "\305\211\211\306\211\306\nH\2030\nH\306V\203 	T\202*	V\203(	\306\nT\202\f\211+\207" [max len i ritem maxrhs nil 0] 4 (#$ . 55071)])
#@12 Set up LA.
(defalias 'wisent-initialize-LA #[nil "\306\211\211\211\211\211\211\211\307\306\"\307T\310\"\310\211\310W\203\372\fI\210HH\203\227\311!>\204T\312\313\314D\"\210\315H\316V\204~\n\203\227\311\n!>\204r\312\313\317\nD\"\210\n\320H\310HHY\204\227\f\311!>\204\217\312\313\314D\"\210\315H\\\202\236\321I\210\n\203\361\310\311\n!>\204\264\312\313\317\nD\"\210\n\315H\311\n!>\204\311\312\313\317\nD\"\210\n\320H
W\203\361
HHU\203\352\306I\210
T\211\202\316T\211\202'\fI\210\f\310U\203
\307\316\306\"\307\316\310\"\307\316\306\" \202.
\307\f\306\"\307\f\310\"\307\f\306\" \310GW\203R
\307!\310\"I\210T\211\2028
\310\211\310W\205\300
H\204\267
H\211\203\267
\310\311!>\204\203
\312\313\314D\"\210\315H\311!>\204\227
\312\313\314D\"\210\320H
W\203\267
	HI\210	TT\211\202\235
T\211\202X
.\207" [v np sp rp count k nil make-vector 0 type-of signal wrong-type-argument reductions 3 1 shifts 4 t j i nstates consistent lookaheads reduction-table shift-table cl-struct-reductions-tags accessing-symbol cl-struct-shifts-tags ntokens error-token-number LA LAruleno lookback tokensetsize] 9 (#$ . 55286)])
#@18 Set up GOTO-MAP.
(defalias 'wisent-set-goto-map #[nil "\306\211\211\211\211\211\211\211\211\307T\310\"\307T\310\"\310\211\203\265\311!>\204A\312\313\314D\"\210\315HS\311!>\204Z\312\313\314D\"\210\316H\310Y\203\231HH\211W\203{\310\202\220T
Z
ZHTI\210S\211\202a\311!>\204\253\312\313\314D\"\210\317H\211\204/\310\310W\203\341\fI\210\fH\\TT\202\276\310W\203
HI\210TT\202\350I\210I\210\307\310\"\307\310\"\211\205\322
\311!>\204>
\312\313\314D\"\210\320H\311!>\204U
\312\313\314D\"\210\316H\311!>\204l
\312\313\314D\"\210\315HS\211\310Y\203\265
H	H\211W\203\220
\310\202\254

ZH
Z\fTI\210\f\nI\210\f	I\210S\211\202t
\311!>\204\307
\312\313\314D\"\210\317H\211\204,
\306.	\207" [v state2 state1 temp-map k symbol nil make-vector 0 type-of signal wrong-type-argument shifts 3 4 1 2 j i sp nvars goto-map ngotos first-shift cl-struct-shifts-tags accessing-symbol ntokens nsyms from-state to-state] 10 (#$ . 56570)])
#@58 Map a STATE/SYMBOL pair into its numeric representation.
(defalias 'wisent-map-goto #[(state symbol) "\306\211\211\211\211
\nZH
\nTZHS\204Q\fX\203Q\f\\\307\245\f\nH\211
U\203>\n\211\202	
W\203K\nT\202\nS\202\206X\310\311!-\207" [result s middle low high goto-map nil 2 error "Internal error in `wisent-map-goto'" symbol ntokens from-state state] 6 (#$ . 57719)])
#@11 Set up F.
(defalias 'wisent-initialize-F #[nil "\306\211\211\211\211\211\211\211\211\211\211\211\211\307\306\"\310\211W\203F\307\310\"I\210T\211\202,\307\306\"\307T\310\"\310\211\310\211W\203n
 H!H\211\203`
\311!\">\204\205\312\313\314D\"\210\315H\311!\">\204\235\312\313\314D\"\210\316H\310\306\204\367W\203\367#	HH\211$Y\203\310\317\211\202\250H\n%&\245%\320%H\321\322&\246\"\"I+\210T\202\247W\203&
#	HH'\n$ZH\203
\f\323\n\"I\210\fTT\211\202\371\f\310V\203`
\307\fT\310\"\310
I\210\fW\203X
HI\210T\211\202?
\f\324I\210\310TT\211\202]\325
!.
\207" [break v symbol stateno nedges reads nil make-vector 0 type-of signal wrong-type-argument shifts 3 4 t logior ash 1 wisent-map-goto -1 wisent-digraph rp rowp edge sp k j i ngotos F tokensetsize to-state shift-table cl-struct-shifts-tags accessing-symbol ntokens x wisent-BITS-PER-WORD nullable] 14 (#$ . 58124)])
#@68 Add a lookback edge.
STATENO, RULENO, GOTONO are self-explanatory.
(defalias 'wisent-add-lookback-edge #[(stateno ruleno gotono) "\306\211\211\fH\fTH\306\2040\n	W\2030
\nH\nU\203*\307\211\202\nT\202\2048\310\311!\210\n\f\nHBI+\207" [found k i lookaheads stateno LAruleno nil t error "Internal error in `wisent-add-lookback-edge'" ruleno lookback gotono] 6 (#$ . 59171)])
#@229 Return the transpose of R-ARG, of size N.
Destroy R-ARG, as it is replaced with the result.  R-ARG[I] is nil or
a -1 terminated list of numbers.  RESULT[NUM] is nil or the -1
terminated list of the I such as NUM is in R-ARG[I].
(defalias 'wisent-transpose #[(R-arg n) "\306\211\211\211\211\211\211\n\307\306\"\307\306\"\307\310\"\310\211\nW\203Z\f\nH\211\203Q\310	
H\310Y\203Q\n	
H\n	
HHTI\210
T\2027\nT\211\n\202%\310\211\nW\203\223\n\nH\310V\203\212\307\n\nHT\310\"\211\n\nH\311I\210\f\nI\210\n\310I\210\nT\211\n\202^\310\211\nW\203\332\f\nH\211\203\321\310	
H\310Y\203\321\f	
HH	
HH\nI\210	
H	
HHTI\210
T\202\251\nT\211\n\202\227\f.\207" [sp v nedges end-R new-R j nil make-vector 0 -1 i n R-arg] 8 (#$ . 59575)])
#@18 Build relations.
(defalias 'wisent-build-relations #[nil "\306\211\211\211\211\211\211\211\211\211\211\211\211\211\211\211\307\306\" \307T\310\"\307!T\310\"\310\211W\203\262
\310\"H#$HH%\f&ZH\211@\310V\203q
	\310I\210\311'@H(H\310V\203

(H)
H\312!*>\204\250\313\314\315D\"\210\316H\312!*>\204\300\313\314\315D\"\210\317H\310\211W\203\356H#
HU\203\345\211\202\311T\211\202\311	
I\210TT\202\200+
H\204
\320
@#\210S\306\204h
\321S\211\310Y\203
(H&Y\203
S	H\n\322
(H\"I\210T,(H&ZH\203
\306\211\203
A\211\202f\310V\203\251
\307T\310\"\310 I\210W\203\243
\nHI\210T\211\202\213
\323I\210T\211\202C\324 \"\211 .\207" [v states edge symbol2 symbol1 stateno nil make-vector 0 1 type-of signal wrong-type-argument shifts 3 4 wisent-add-lookback-edge t wisent-map-goto -1 wisent-transpose state1 done nedges length sp rp rulep k j i ngotos includes maxrhs from-state accessing-symbol to-state derives ntokens rrhs ritem shift-table cl-struct-shifts-tags consistent nullable] 17 (#$ . 60365)])
#@18 Compute follows.
(defalias 'wisent-compute-FOLLOWS #[nil "\301!\207" [includes wisent-digraph] 2 (#$ . 61573)])
#@21 Compute lookaheads.
(defalias 'wisent-compute-lookaheads #[nil "\306\211\211\211\211\211	\nH\307\211W\205X
H\211\203Q\f
H
@H\307\211W\203J\n\f\310\n\fH	\fH\"I\210\fT\211\2021A\211\204#
T\211\202.\207" [sp v2 v1 n j i nil 0 logior lookaheads nstates lookback LA F tokensetsize] 7 (#$ . 61692)])
#@63 Make the nondeterministic finite state machine deterministic.
(defalias 'wisent-lalr #[nil "\211\n\\S\n\245)\304 \210\305 \210\306 \210\307 \210\310 \210\311 \210\312 \210\313 \210\314 \210\315 \210\316 \207" [ntokens n wisent-BITS-PER-WORD tokensetsize wisent-set-state-table wisent-set-accessing-symbol wisent-set-shift-table wisent-set-reduction-table wisent-set-maxrhs wisent-initialize-LA wisent-set-goto-map wisent-initialize-F wisent-build-relations wisent-compute-FOLLOWS wisent-compute-lookaheads] 3 (#$ . 62026)])
#@141 Log a shift-reduce conflict resolution.
In specified STATE between rule pointed by lookahead number LANO and
TOKEN, resolved as RESOLUTION.
(defalias 'wisent-log-resolution #[(state LAno token resolution) "\204	\205P\306\n\fH
H\307!\203/\236A\2063\310\311\"\2023\312!*\257\203B\313 \210r\314!q\210\315\316\"c*\207" [wisent-verbose-flag wisent-debug-flag state LAruleno LAno token "Conflict in state %d between rule %d and token %s resolved as %s.\n" wisent-char-p format "'%c'" symbol-name wisent-new-log get-buffer-create apply format-message s tags item wisent-escape-sequence-strings resolution args wisent-new-log-flag wisent-log-buffer-name] 6 (#$ . 62560)])
(put 'wisent-log-resolution 'byte-optimizer 'byte-compile-inline-expand)
#@135 Turn off the shift recorded in the specified STATE for TOKEN.
Used when we resolve a shift-reduce conflict in favor of the reduction.
(defalias 'wisent-flush-shift #[(state token) "\306\211\211\211\f
H\211\205`\307!>\204 \310\311\312D\"\210\313H\307!>\2044\310\311\312D\"\210\314H\315\211	W\205`\nH\315U\204Y\nHHU\203Y\n\315I\210\nT\211\202;,\207" [v k i shiftp shift-table state nil type-of signal wrong-type-argument shifts 3 4 0 cl-struct-shifts-tags token accessing-symbol] 5 (#$ . 63342)])
#@366 Attempt to resolve shift-reduce conflict for one rule.
Resolve by means of precedence declarations.  The conflict occurred in
specified STATE for the rule pointed by the lookahead symbol
LOOKAHEADNUM.  It has already been checked that the rule has a
precedence.  A conflict is resolved by modifying the shift or reduce
tables so that there is no longer a conflict.
(defalias 'wisent-resolve-sr-conflict #[(state lookaheadnum) "\306\211\211\211\211\211\211\211'()*+,HHH\211\211-\307./\310/0\236A.\"+'\311\304\312\313#\3141\312\"\312\211(\315
!2>\204U\316\317\304
D\"\210
\2113\320\fI\210)(1W\203\312)(H4,H((-\321-(5\245H\322\323(5\246\"\"\312U*\204\3016((-\321-(5\245H\322\323(5\246\"\"\312U*\204\301\n\211-\307./\310/0\236A.\"+\211\203\301	'W\203e
7,(\324897:\204\347;\2052
\3257+9H\n<)<H=\326=!\203
=>\236A\206
\327\330=\"\202
\331=!*8\257?@\203$
\332 \210r\333A!q\210\334\335?\"c*,\2106((-(5\245B-B\321-BH\336\322\323(5\246\"!\"I+\210\3377(\"\210\202\301	'V\203\376
7,(\340897:\204\204
;\205\317
\3257+9H\n<)<H=\326=!\203\256
=>\236A\206\262
\327\330=\"\202\262
\331=!*8\257?@\203\301
\332 \210r\333A!q\210\334\335?\"c*,\2104,H((-(5\245B-B\321-BH\336\322\323(5\246\"!\"I+\210\202\301\n\211-\341./\310/0\236A.\"+\211\342\267\202N7,(\340897:\2041;\205|\3257+9H\n<)<H=\326=!\203[=>\236A\206_\327\330=\"\202_\331=!*8\257?@\203n\332 \210r\333A!q\210\334\335?\"c*,\210\202N7,(\324897:\204\231;\205\344\3257+9H\n<)<H=\326=!\203\303=>\236A\206\307\327\330=\"\202\307\331=!*8\257?@\203\326\332 \210r\333A!q\210\334\335?\"c*,\210\202N7,(\343897:\204
;\205L\3257+9H\n<)<H=\326=!\203+=>\236A\206/\327\330=\"\202/\331=!*8\257?@\203>\332 \210r\333A!q\210\334\335?\"c*,\210\344=\204\2026((-(5\245B-B\321-BH\336\322\323(5\246\"!\"I+\210\3377(\"\210\345=\204\2624,H((-(5\245B-B\321-BH\336\322\323(5\246\"!\"I+\210\346=\203\301\f(I\210T(T\211(\202`\312V\205\357\315
!2>\204\340\316\317\304
D\"\210
\211C\323I\210)D7
I.\207" [sassoc sprec token nerrs errs errp nil wisent--prec plist-get record 0 [0] make-vector type-of signal wrong-type-argument 2 logand ash 1 "reduce" "Conflict in state %d between rule %d and token %s resolved as %s.\n" wisent-char-p format "'%c'" symbol-name wisent-new-log get-buffer-create apply format-message lognot wisent-flush-shift "shift" wisent--assoc #s(hash-table size 3 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (right 537 left 641 nonassoc 745)) "an error" right left nonassoc redprec i tags rprec LAruleno lookaheadnum x propname object ptable ntokens cl-struct-errs-tags #1=#:v LA wisent-BITS-PER-WORD lookaheadset state resolution LAno wisent-verbose-flag wisent-debug-flag s item wisent-escape-sequence-strings args wisent-new-log-flag wisent-log-buffer-name k #2=#:v err-table] 10 (#$ . 63877)])
#@59 Find and attempt to resolve conflicts in specified STATE.
(defalias 'wisent-set-conflicts #[(state) "\306\211\211\211\211\211H?\205?
\307\310\"\210H\211\203\220\311	!>\2045\312\313\314	D\"\210	\315H\311	!>\204I\312\313\314	D\"\210	\316H\310\211W\203\220\n
HH\211W\203\220\n
H\310U\204\211
\245\317H\320\321
\246\"\"I+\210
T\211\202PHTH
W\203\344 
HH\203\335!
H\310\211\"W\203\335\322\n\fH\fH\"\310U\203\320\fT\211\202\265\323
\"\210\"\211\202\265
T\211\202\236H\211W\205?
!
H\310\211\"W\203
\322\n\fH\fH\"\310U\204
#\324I\210\fT\211\202\370\310\211\"W\2038
\f\317\fH\n\fH\"I\210\fT\211\202

T\211\202\353.\207" [symbol shiftp v k j i nil fillarray 0 type-of signal wrong-type-argument shifts 3 4 logior ash 1 logand wisent-resolve-sr-conflict t consistent state lookaheadset shift-table cl-struct-shifts-tags accessing-symbol ntokens x wisent-BITS-PER-WORD lookaheads rprec LAruleno LA tokensetsize conflicts] 9 (#$ . 66939)])
#@29 Find and resolve conflicts.
(defalias 'wisent-resolve-conflicts #[nil "\306\307	\306\"\307\310\"\307\310\"\307	\306\"\n\310\211	W\205*\311!\210T\211\202)\207" [i nstates conflicts tokensetsize shiftset lookaheadset nil make-vector 0 wisent-set-conflicts err-table] 4 (#$ . 67990)])
#@64 Count the number of shift/reduce conflicts in specified STATE.
(defalias 'wisent-count-sr-conflicts #[(state) "\306\211\211\211\211\211\307H\211\203\"
\310\307\"\210\310\307\"\210\311\n!>\2045\312\313\314\nD\"\210\n\315H\311\n!>\204I\312\313\314\nD\"\210\n\316H\307\211W\203\225
H\307U\204\216
HH\211Y\203p\202\216	
\245\317H\320\321
\246\"\"I+\210
T\211\202PTHH\211W\203\322
H\307\211W\203\313\f\317\fH\fH\"I\210\fT\211\202\260
T\211\202\243\307\211W\203\361\322HH\"I\210T\211\202\325\307\211W\203\"

\322
\245H\320\321
\246\"\"\307U*\204
T
T\211\202\364.\207" [v symbol shiftp k j i nil 0 fillarray type-of signal wrong-type-argument shifts 3 4 logior ash 1 logand src-count shift-table state shiftset lookaheadset cl-struct-shifts-tags accessing-symbol ntokens x wisent-BITS-PER-WORD lookaheads LA tokensetsize] 9 (#$ . 68292)])
#@65 Count the number of reduce/reduce conflicts in specified STATE.
(defalias 'wisent-count-rr-conflicts #[(state) "\306\211\211\211\211\307\f
H\f
TH\211Z\310Y\203l\307\211W\203l\307\211	W\203\\H\f\311\f\245H\312\313\f\246\"\"\307U*\204U\nTT\211\202/\n\310Y\203e
T\fT\211\202$
-\207" [m n count j i rrc-count nil 0 2 logand ash 1 lookaheads state ntokens LA x wisent-BITS-PER-WORD] 7 (#$ . 69256)])
(byte-code "\300\301\302\303\304\305\306\307&\210\310\301\311\312#\207" [custom-declare-variable wisent-expected-conflicts nil "If non-nil suppress the warning about shift/reduce conflicts.\nIt is a decimal integer N that says there should be no warning if\nthere are N shift/reduce conflicts and no reduce/reduce conflicts.  A\nwarning is given if there are either more or fewer conflicts, or if\nthere are any reduce/reduce conflicts." :group wisent :type (choice (const nil) integer) make-obsolete-variable "use %expectedconflicts in the .wy file instead" "27.1"] 8)
#@39 Report the total number of conflicts.
(defalias 'wisent-total-conflicts #[nil "\306 \211\205\307\310\311\312\313\314#\"!\n\315U\203<\315U?\205\220\f\206%\315U?\205\220	\203<\316	!\203<	J\232?\205\220\203F\317P\202G\314\310\320\"\315V\203d\310\321
\211\322V\203a\323\202b\314$\315V\203u\n\315V\203u\310\324
\"\n\315V\203\214\310\325
\n\211\322V\203\211\323\202\212\314$\326
!**\207" [src symbol rrc-total src-total wisent-expected-conflicts msg wisent-source intern format "wisent-%s--expected-conflicts" replace-regexp-in-string "\\.el$" "" 0 boundp " in " "Grammar%s contains" "%s %d shift/reduce conflict%s" 1 "s" "%s and" "%s %d reduce/reduce conflict%s" message] 8 (#$ . 70271)])
#@19 Report conflicts.
(defalias 'wisent-print-conflicts #[nil "\306\307\211\307\211W\203\361\fH\203\352\310!\210\311!\210	
\\\n\\\204/\203\352\312D\203<\313 \210r\314!q\210\315\316\"c*\210
\307V\203x\317
\211\320V\203]\321\202^\322E\203i\313 \210r\314!q\210\315\316\"c*\210
\307V\203\240\307V\203\240\323C\203\221\313 \210r\314!q\210\315\316\"c*\210\307V\203\317\324\211\320V\203\264\321\202\265\322E\203\300\313 \210r\314!q\210\315\316\"c*\210\325C\203\333\313 \210r\314!q\210\315\316\"c*\210T\211\202	\326 )\207" [i src-total rrc-total nstates conflicts src-count nil 0 wisent-count-sr-conflicts wisent-count-rr-conflicts "State %d contains" wisent-new-log get-buffer-create apply format-message " %d shift/reduce conflict%s" 1 "s" "" " and" " %d reduce/reduce conflict%s" ".\n" wisent-total-conflicts rrc-count wisent-verbose-flag wisent-debug-flag args wisent-new-log-flag wisent-log-buffer-name] 5 (#$ . 70997)])
#@16 Print grammar.
(defalias 'wisent-print-grammar #[nil "\306\211\211\211\211\211\307C$%\203\310 \210r\311&!q\210\312\313$\"c*\210\314\211'X\203R
(
H\203K
\315\316
!\317\306)*\211+G\211*W\203l)\203_\320*
Z\321\"+P\202n+\320*
Z\321\"P\202n+,,
H+-+H.\322.!\203\224./\236A\206\230\323\324.\"\202\230\325.!*E$%\203\244\310 \210r\311&!q\210\312\313$\"c*\2100
H1H\326V\203
1H\326V\2030
\3271H+-+H.\322.!\203\360./\236A\206\364\323\324.\"\202\364\325.!*D$%\203
\310 \210r\311&!q\210\312\313$\"c*\210T\202\301\330C$%\203!
\310 \210r\311&!q\210\312\313$\"c*\210\331C$%\203<
\310 \210r\311&!q\210\312\313$\"c*\210
T\211\202*\332C$%\203^
\310 \210r\311&!q\210\312\313$\"c*\210\333\326+-+H.\322.!\203\220
./\236A\206\224
\323\324.\"\202\224
\325.!*D$%\203\240
\310 \210r\311&!q\210\312\313$\"c*\210\314\2112W\203q\334
+-+H.\322.!\203\333
./\236A\206\337
\323\324.\"\202\337
\325.!*
E$%\203\354
\310 \210r\311&!q\210\312\313$\"c*\210\314\211'X\203O0\fH\306\n\204H1H\326V\203H1H
U\211\203B\335\fD$%\2030\310 \210r\311&!q\210\312\313$\"c*\210\202T\202\fT\211\202\376
\331C$%\203[\310 \210r\311&!q\210\312\313$\"c*\210
T\211\202\262
\336C$%\203}\310 \210r\311&!q\210\312\313$\"c*\2102\2113W\2053\326\211\314\211'X\203\342,\fH
U\203\257	T0\fH\306\n\204\3331H\326V\203\3331H
U\203\325T\337\211\202\267T\202\266\fT\211\202\235\340
+-+H.\322.!\203./\236A\206	\323\324.\"\202	\325.!*
E$%\203\310 \210r\311&!q\210\312\313$\"c*\210	\326V\203{\341C$%\2037\310 \210r\311&!q\210\312\313$\"c*\210\314\211'X\203{,\fH
U\203t\335\fD$%\203e\310 \210r\311&!q\210\312\313$\"c*\210\fT\211\202I\326V\203	\326V\203\242\342C$%\203\223\310 \210r\311&!q\210\312\313$\"c*\210\343C$%\203\256\310 \210r\311&!q\210\312\313$\"c*\210\314\211'X\2030\fH\306\n\204\n1H\326V\203\n1H
U\211\203\335\fD$%\203\362\310 \210r\311&!q\210\312\313$\"c*\210\202\315T\202\315\fT\211\202\300\331C$%\203\310 \210r\311&!q\210\312\313$\"c*\210
T\211\202\220.\207" [right-count left-count break r j i nil "\n\nGrammar\n\n  Number, Rule\n" wisent-new-log get-buffer-create apply format-message 1 "  %s  %s ->" number-to-string 6 make-string 32 wisent-char-p format "'%c'" symbol-name 0 " %s" " /* empty */" "\n" "\n\nTerminals, with rules where they appear\n\n" "%s (-1)\n" "%s (%d)" " %d" "\n\nNonterminals, with rules where they appear\n\n" t "%s (%d)\n   " " on left:" "," " on right:" args wisent-new-log-flag wisent-log-buffer-name nrules ruseful left n s rlhs tags item wisent-escape-sequence-strings rrhs ritem ntokens nsyms] 7 (#$ . 72000)])
#@28 Print reductions on STATE.
(defalias 'wisent-print-reductions #[(state) "\306\211\211\211\211\211\211\211\211\211\211\211\211\211\211$%&'()*+,\306\307,\310-\307\"\210./H\211\203\312\311\n!0>\204L\312\313\314\nD\"\210\n\315H*\311\n!0>\204a\312\313\314\nD\"\210\n\316H)\307\211,*W\203\312),H\307U\204\3011),HH\211(2Y\203\222*,\202\301(3U\203\234\317-(,4,5\245*4*\3204*H\321\322,5\246\"\"I+\210,T\211,\202j6/H\211\203C
\311	!7>\204\344\312\313\323	D\"\210	\322H*\311	!7>\204\371\312\313\323	D\"\210	\324H)\307\211,*W\203C
),H\211(\307U\204:
-(,4,5\245*4*\3204*H\321\322,5\246\"\"I+\210,T\211,\202
8/H'8/TH\211&'Z\322U\203z\204z9'H:'H)\307\211*;W\203\221
<*\325)*H-*H\"I\210*T\211*\202p
\307\211,2W\2032<,,4\3254,5\245H\321\322,5\246\"\"\307U*\204)\326,=>=H?\327?!\203\337
?@\236A\206\343
\330\331?\"\202\343
\332?!*
A
H=>=H?\327?!\203\n?@\236A\206\330\331?\"\202\332?!*FBC\203\333 \210r\334D!q\210\335\336B\"c*\210,T\211,\202\225
\337
A
H=>=H?\327?!\203Y?@\236A\206]\330\331?\"\202]\332?!*EBC\203i\333 \210r\334D!q\210\335\336B\"c*\202&'Z\322Y\205\307\340$\307\204@'\211,&W\203@:,H)\307\211*\307;W\203\312<*\325)*H\341-*H!\"I\210*T\211*\202\247\307\211+2W\203<+,4\3254,5\245H\321\322,5\246\"\"\307U*\204\367T+T\211+\202\316\fV\203,$9,H\307\211*;W\2037-*\320-*H<*H\"I\210*T\211*\202,T\211,\202\224\310-\307\"\210\n\203\316\311\n!0>\204Z\312\313\314\nD\"\210\n\315H*\311\n!0>\204o\312\313\314\nD\"\210\n\316H)\307\211,*W\203\316),H\307U\204\3051),HH\211(2Y\203\240*,\202\305-(,4,5\245*4*\3204*H\321\322,5\246\"\"I+\210,T\211,\202x\307\211,2W\203\305\306%-,,4\3254,5\245H\321\322,5\246\"\"\307U*\204\377\322\202\307'\211+&W\203\274:+H,,4\3254,5\245H\321\322,5\246\"\"\307U*\204\263\307U\203\277+$U\204\266\342,=>=H?\327?!\203a?@\236A\206e\330\331?\"\202e\332?!*9+HA9+HH=>=H?\327?!\203\224?@\236A\206\230\330\331?\"\202\230\332?!*FBC\203\244\333 \210r\334D!q\210\335\336B\"c*\210\202\271\317%T\202\263%\203:\342,=>=H?\327?!\203\350?@\236A\206\354\330\331?\"\202\354\332?!*9$HA9$HH=>=H?\327?!\203?@\236A\206\330\331?\"\202\332?!*FBC\203+\333 \210r\334D!q\210\335\336B\"c*\210\306%\326,=>=H?\327?!\203a?@\236A\206e\330\331?\"\202e\332?!*9+HA9+HH=>=H?\327?!\203\224?@\236A\206\230\330\331?\"\202\230\332?!*FBC\203\244\333 \210r\334D!q\210\335\336B\"c*\210+T\211+\202,T\211,\202\322$\307Y\205\343
A
H=>=H?\327?!\203\363?@\236A\206\367\330\331?\"\202\367\332?!*EBC\203\333 \210r\334D!q\210\335\336B\"c*.\207" [nodefault errp shiftp count cmax default-rule nil 0 fillarray type-of signal wrong-type-argument shifts 3 4 t logior ash 1 errs 2 logand "    %s	[reduce using rule %d (%s)]\n" wisent-char-p format "'%c'" symbol-name wisent-new-log get-buffer-create apply format-message "    $default	reduce using rule %d (%s)\n\n" -1 lognot "    %s	reduce using rule %d (%s)\n" "    $default	reduce using rule %d (%s)\n" default-LA defaulted n m symbol v k j i shiftset shift-table state cl-struct-shifts-tags accessing-symbol ntokens error-token-number x wisent-BITS-PER-WORD err-table cl-struct-errs-tags lookaheads LAruleno LA tokensetsize lookaheadset s tags item wisent-escape-sequence-strings rlhs args wisent-new-log-flag wisent-log-buffer-name] 16 (#$ . 74762)])
#@25 Print actions on STATE.
(defalias 'wisent-print-actions #[(state) "\306\211\211\211\211\211\211\211\211\211\211\211#$%&'()*H+*H,*H
\204z\204z-*U\203]\307C./\203L\310 \210r\3110!q\210\312\313.\"c*\202 \314C./\203i\310 \210r\3110!q\210\312\313.\"c*\202 
\204\207\315\211(&\202Z
\316
!1>\204\227\317\320\321
D\"\210
\322H&\316
!1>\204\254\317\320\321
D\"\210
\323H%\315(\306\2048
(&W\2038
%(H\211$\315U\203\327(T(\202\2662$H\211#3Y\203\353\324\211\202\267\325#454H6\3266!\203
67\236A\206
\327\3306\"\202
\3316!*$E./\203!
\310 \210r\3110!q\210\312\313.\"c*\210(T(\202\266(\315V\203Z
\332C./\203K
\310 \210r\3110!q\210\312\313.\"c*\210\f\203	\316\f!8>\204n
\317\320\333\fD\"\210\f\334H\316\f!8>\204\202
\317\320\333\fD\"\210\f\335H%\315\211'	W\203\347
%'H\203\336
\336%'H454H6\3266!\203\277
67\236A\206\303
\327\3306\"\202\303
\3316!*D./\203\317
\310 \210r\3110!q\210\312\313.\"c*\210'T\211'\202\213
'\315V\203	\332C./\203\372
\310 \210r\3110!q\210\312\313.\"c*\2109*H\203x\203x\316!:>\204%\317\320\337D\"\210\323H\315H;\nH#\340\n#454H6\3266!\203V67\236A\206Z\327\3306\"\202Z\3316!*E./\203f\310 \210r\3110!q\210\312\313.\"c*\210\202\201\203\201\341*!\210(&W\205 \316
!1>\204\231\317\320\321
D\"\210
\323H%(&W\203%(H\211$\203\3752$H#\342#454H6\3266!\203\33467\236A\206\340\327\3306\"\202\340\3316!*$E./\203\356\310 \210r\3110!q\210\312\313.\"c*\210(T\211(\202\240\332C./\203\310 \210r\3110!q\210\312\313.\"c*.\f\207" [break nerrs rule redp errp shiftp nil "    $default	accept\n" wisent-new-log get-buffer-create apply format-message "    NO ACTIONS\n" 0 type-of signal wrong-type-argument shifts 3 4 t "    %s	shift, and go to state %d\n" wisent-char-p format "'%c'" symbol-name "\n" errs 1 2 "    %s	error (nonassociative)\n" reductions "    $default	reduce using rule %d (%s)\n\n" wisent-print-reductions "    %s	go to state %d\n" symbol state1 v k j i shift-table state reduction-table err-table final-state args wisent-new-log-flag wisent-log-buffer-name cl-struct-shifts-tags accessing-symbol ntokens s tags item wisent-escape-sequence-strings cl-struct-errs-tags consistent cl-struct-reductions-tags rlhs] 13 (#$ . 78402)])
#@19 Print STATE core.
(defalias 'wisent-print-core #[(state) "\306\211\211\211\211\211H\307\n!>\204\"\310\311\312\nD\"\210\n\313H\211\314V\205\251
\314\211\fW\203\217
\307\n!>\204D\310\311\312\nD\"\210\n\315H
H\211	H\314V\203[	T\202L	H[\316 H!\"!H#\317#!\203\207#$\236A\206\213\320\321#\"\202\213\322#!*D%&\203\227\323 \210r\324'!q\210\325\326%\"c*\210(H\211W\203\375\327	H!\"!H#\317#!\203\327#$\236A\206\333\320\321#\"\202\333\322#!*D%&\203\347\323 \210r\324'!q\210\325\326%\"c*\210	T\211\202\254\330C%&\203	
\323 \210r\324'!q\210\325\326%\"c*\210	H\314V\203l
\331	H!\"!H#\317#!\203G
#$\236A\206K
\320\321#\"\202K
\322#!*D%&\203W
\323 \210r\324'!q\210\325\326%\"c*\210	T\202
\332D%&\203y
\323 \210r\324'!q\210\325\326%\"c*\210
T\211\202/\333C%&\203\233
\323 \210r\324'!q\210\325\326%\"c*.\207" [sp1 sp statep rule k i nil type-of signal wrong-type-argument core 5 0 6 "    %s  ->  " wisent-char-p format "'%c'" symbol-name wisent-new-log get-buffer-create apply format-message "%s " "." " %s" "   (rule %d)\n" "\n" state-table state cl-struct-core-tags ritem rlhs s tags item wisent-escape-sequence-strings args wisent-new-log-flag wisent-log-buffer-name rrhs] 7 (#$ . 80737)])
#@29 Print information on STATE.
(defalias 'wisent-print-state #[(state) "\304D\n\203\305 \210r\306!q\210\307\310	\"c*\210\311!\210\312!\207" [state args wisent-new-log-flag wisent-log-buffer-name "\n\nstate %d\n\n" wisent-new-log get-buffer-create apply format-message wisent-print-core wisent-print-actions] 3 (#$ . 82027)])
#@30 Print information on states.
(defalias 'wisent-print-states #[nil "\302\211	W\205\303!\210T\211\202)\207" [i nstates 0 wisent-print-state] 3 (#$ . 82362)])
#@129 Print information on generated parser.
Report detailed information if `wisent-verbose-flag' or
`wisent-debug-flag' are non-nil.
(defalias 'wisent-print-results #[nil "\204	\203\304 \210\305 \210\204	\203\306 \210\307 \210\n\205,\310 \210r\311!q\210\312 )\207" [wisent-verbose-flag wisent-debug-flag noninteractive wisent-log-buffer-name wisent-print-useless wisent-print-conflicts wisent-print-grammar wisent-print-states wisent-append-to-log-file get-buffer-create erase-buffer] 2 (#$ . 82533)])
#@615 Figure out the actions for the specified STATE.
Decide what to do for each type of token if seen as the lookahead
token in specified state.  The value returned is used as the default
action for the state.  In addition, ACTROW is filled with what to do
for each kind of token, index by symbol number, with nil meaning do
the default action.  The value `error', means this situation is an
error.  The parser recognizes this value specially.

This is where conflicts are resolved.  The loop over lookahead rules
considered lower-numbered rules last, and the last rule considered
that likes a token gets to handle it.
(defalias 'wisent-action-row #[(state actrow) "\306\211\211\211\211\211\211\211\211\211\211\211\211\211\211\211\211 \307!\306\"\210\310\306\310\211\310\"#H\211\203\313\311!$>\204[\312\313\314D\"\210\315H\211\316Y\203\313%#H%#TH\211S\211 Y\203\313\310\211&W\203\302' H (\317( )\245H\320\316 )\246\"\"\310U*\204\271!* H[I\210T\211\202\204 S\211 \202z+#H\211\203@
\311\n!,>\204\345\312\313\321\nD\"\210\n\315H\311\n!,>\204\372\312\313\321\nD\"\210\n\322H\310\211 W\203@
 H\211\310U\2047
-
H\211&Y\203(
 \2027
!\f
I\210\f.U\2037
\323 T\211 \202
/#H\211\203\222
\311	!0>\204Z
\312\313\324	D\"\210	\316H\311	!0>\204o
\312\313\324	D\"\210	\325H\310\211 W\203\222
! H1I\210 T\211 \202x
\316Y\203S\204S2#H\203\300
\311!$>\204\265
\312\313\314D\"\210\322H\310H[\202S\310\211 W\203\310* H[\310\211&W\203!H\247\203\374
!HU\203\374
TT\211\202\335
V\203 T\211 \202\310
\310V\203S\310\211&W\203S!H\247\203J!HU\203J!\306I\210T\211\202)\310U\203\2223#U\203i4\202\222\310\211&W\203\216!H1=\203\205!\306I\210T\211\202m1.\207" [nodefault errp shiftp redp symbol shift-state nil fillarray 0 type-of signal wrong-type-argument reductions 3 1 logand ash shifts 4 t errs 2 count max rule nreds default-rule v n m k j i actrow reduction-table state cl-struct-reductions-tags lookaheads ntokens LA x wisent-BITS-PER-WORD LAruleno shift-table cl-struct-shifts-tags accessing-symbol error-token-number err-table cl-struct-errs-tags wisent-error-tag consistent final-state wisent-accept-tag] 18 (#$ . 83049)])
#@59 Tag used in an action table to indicate a default action.
(defconst wisent-default-tag 'default (#$ . 85413))
#@66 Figure out the actions for every state.
Return the action table.
(defalias 'wisent-state-actions #[nil "\306\307\310\306\"I\210\311\211\211\211\211\307\311\"\307\311\"\306\311\211\311\211\311\312\313!\312\314!\312\315!\312\316!
W\203\255\317
\n\"\211\250\203_	\306W\203_\320	[!
	BCI\210\306\211W\203\236\n\fH\211\203\227	\250\203\211	\306W\203\211\320	[!
\fH	B
HBI\210\fT\211\202k

H\237I\210
T\211\202D.\n\207" [rcode action actrow action-table j i 0 make-vector 13 nil make-symbol "stack" "sp" "gotos" "state" wisent-action-row wisent-semantic-action nstates ntokens stack sp gotos state NAME wisent-default-tag tags] 6 (#$ . 85529)])
#@177 Figure out what to do after reducing with each rule.
Depending on the saved state from before the beginning of parsing the
data that matched this rule.  Return the goto table.
(defalias 'wisent-goto-actions #[nil "\306\211\211\211\211\211\211\307	\306\"\n\211W\203`\nZ\f\nH\f\nTH\f\211W\203W

H	H
HB	HBI\210
T\211\2024T\211\202.\207" [goto-table state symbol n m j nil make-vector i nstates ntokens nsyms goto-map from-state tags to-state] 8 (#$ . 86234)])
#@57 Return non-nil if SYM is bound to the `quote' function.
(defalias 'wisent-quote-p #[(sym) "\3011
\302!\302\303!=0\207\210\304\207" [sym (error) indirect-function quote nil] 3 (#$ . 86744)])
(put 'wisent-quote-p 'byte-optimizer 'byte-compile-inline-expand)
#@61 Return non-nil if SYM is bound to the `backquote' function.
(defalias 'wisent-backquote-p #[(sym) "\3011
\302!\302\303!=0\207\210\304\207" [sym (error) indirect-function backquote nil] 3 (#$ . 87008)])
(put 'wisent-backquote-p 'byte-optimizer 'byte-compile-inline-expand)
#@182 Return non-nil if X is a valid $N or $regionN symbol.
That is if X is a $N or $regionN symbol with N >= 1 and N <= M.
Also warn if X is a $N or $regionN symbol with N < 1 or N > M.
(defalias 'wisent-check-$N #[(x m) "9\205K\305!\306\307	\"\205\310\311\312	\"!\211\205J\n\313Y\203+\nX\203+\314\202J\315\316\f\317\313W\203:\320\202E\313U\203D\321\202E\322\"$\210\323*\207" [x n i m NAME symbol-name string-match "\\`\\$\\(region\\)?\\([0-9]+\\)\\'" string-to-number match-string 2 1 t message "*** In %s, %s might be a free variable (rule has %s)" format "no component" "%d component" "%d components" nil] 8 (#$ . 87289)])
#@382 Parse BODY of semantic action.
N is the maximum number of $N variables that can be referenced in
BODY.  Warn on references out of permitted range.
Optional argument FOUND is the accumulated list of $N references
encountered so far.
Return a cons (FOUND . XBODY), where FOUND is the list of $N
references found in BODY, and XBODY is BODY expression with
`backquote' forms expanded.
(defalias 'wisent-semantic-action-expand-body #[(body n &optional found) "<\204\306	\"\203\n\235\203\n\202\nB\nB\207\307\211@\31014\311
!\311\312!=0\2026\210\307)\203>\313!\203\221@A:\203t@\3141_\311
!\311\315!=0\202a\210\307)\204t\316	\n#\211@A\202\211\306	\"\203\211\n\235\203\205\n\202\210\nB\fC\244\202>\n\f*B\207" [body n found sexpr xbody sym wisent-check-$N nil (error) indirect-function backquote macroexpand (error) quote wisent-semantic-action-expand-body] 5 (#$ . 87937)])
#@553 Set up the Elisp function for semantic action at rule R.
On entry RCODE[R] contains a vector [BODY N (NTERM I)] where BODY is the
body of the semantic action, N is the maximum number of values
available in the parser's stack, NTERM is the nonterminal the semantic
action belongs to, and I is the index of the semantic action inside
NTERM definition.  Return the semantic action symbol.
The semantic action function accepts three arguments:

- the state/value stack
- the top-of-stack index
- the goto table

And returns the updated top-of-stack index.
(defalias 'wisent-semantic-action #[(r) "	H\204\n	\306I\207\n	H\211\307H\310\311\312\313H#\314\315H\f\"\211&@'&A&(	H)\306\211*+\306\211,-\f\211,\315V\203\241\313\f,Z_T-\316\311\317,\"!\211+'>\203t+\320\321.\322/-EEDD*B*\316\311\323,\"!\211+'>\203\230+\324\321.\322/-EEDD*B*,S\211,\202B0	H,\315-1,H\315V\203\301-T-,T,\202\252\316
\n\315H\"\211\325./2E\326\327*\330\f\307U\203\364\331*\236\203\347\331\202\n
\320\321.\332/DED\202\n
\f\307V\205\n
\333.\322/\313\f_SE\332/DFD\334
D\335\3363)HDDE-\315V\205+
/\322/-\313_EDC4\320\337\335\3212\321./EEEDDC$\340/\341/\342BBE\343.\332/D\344&\345BBF\343./4F/\257EM\210.\207" [ruseful r rcode actn n NAME nil 1 apply format "%s:%d" 2 wisent-semantic-action-expand-body 0 intern "$region%d" cdr aref - "$%d" car lambda let* append $region $region1 1- wisent-production-bounds $action $nterm quote assq setq + (2) aset cons ($region) form $l rlhs nt bl $v i j stack sp rrhs ritem gotos tags state] 18 (#$ . 88861)])
#@167 Compute and return LALR(1) automaton from GRAMMAR.
GRAMMAR is in internal format.  GRAM/ACTS are grammar rules
in internal format.  STARTS defines the start symbols.
(defalias 'wisent-parser-automaton #[nil "\302 \210\303 \210\304 \210\305 \210\306 \210\307 \210\310 \210\311\312 \313 	\314H$\207" [start-table rcode wisent-reduce-grammar wisent-set-derives wisent-set-nullable wisent-generate-states wisent-lalr wisent-resolve-conflicts wisent-print-results vector wisent-state-actions wisent-goto-actions 0] 6 (#$ . 90464)])
#@143 The list of reserved symbols.
Also all symbols starting with a character defined in
`wisent-reserved-capitals' are reserved for internal use.
(defconst wisent-reserved-symbols (list wisent-error-term) (#$ . 90999))
#@116 The list of reserved capital letters.
All symbol starting with one of these letters are reserved for
internal use.
(defconst wisent-reserved-capitals '(36 64) (#$ . 91221))
#@58 Main start symbol.
It gives the rules for start symbols.
(defconst wisent-starts-nonterm '$STARTS (#$ . 91400))
#@193 Non-nil means allows only one start symbol like in Bison.
That is don't add extra start rules to the grammar.  This is
useful to compare the Wisent's generated automaton with the Bison's
one.
(defvar wisent-single-start-flag nil (#$ . 91519))
#@58 Return non-nil if X is a character or an allowed symbol.
(defalias 'wisent-ISVALID-VAR #[(x) "\2059\205\303!\304H	>?\205\n>?\207" [x wisent-reserved-capitals wisent-reserved-symbols symbol-name 0] 2 (#$ . 91768)])
(put 'wisent-ISVALID-VAR 'byte-optimizer 'byte-compile-inline-expand)
#@58 Return non-nil if X is a character or an allowed symbol.
(defalias 'wisent-ISVALID-TOKEN #[(x) "\303!\206!\211\205 9\205 \304!\305H	>?\205 \n>?)\207" [x wisent-reserved-capitals wisent-reserved-symbols wisent-char-p symbol-name 0] 3 (#$ . 92068)])
(put 'wisent-ISVALID-TOKEN 'byte-optimizer 'byte-compile-inline-expand)
#@81 Push a new SYMBOL in the list of tokens.
Bypass checking if NOCHECK is non-nil.
(defalias 'wisent-push-token #[(symbol &optional nocheck) "\2040	\306\n!\206'\n\211\205&\n9\205&\307\n!\310H>?\205&\n\f>?))\2040\311\312	\"\210	
>\203;\313\314	\"\207	\315\211\316\211\236\211\204_C\211B\317A#\241.\210	\315\211\320\211\236\211\204\222C\211B\317A#\241.\210	\211\321\211\236\211\204\306C\211B\317A#\241.\210T	
B\211\207" [nocheck symbol x wisent-reserved-capitals wisent-reserved-symbols token-list wisent-char-p symbol-name 0 error "Invalid terminal symbol: %S" message "*** duplicate terminal `%s' ignored" nil wisent--prec plist-put wisent--assoc wisent--item-no p value propname object ptable entry a ntokens n] 6 (#$ . 92404)])
#@87 Push a new SYMBOL in the list of nonterminals.
Bypass checking if NOCHECK is non-nil.
(defalias 'wisent-push-var #[(symbol &optional nocheck) "\2042	\211\205\n9\205\306\n!\307H>?\205\n\f>?)\204'\310\311	\"\210	
>\2032\310\312	\"\210	
\211\313\211\236\211\204WC\211B\314A#\241.\210
T
	
B\211\207" [nocheck symbol x wisent-reserved-capitals wisent-reserved-symbols var-list symbol-name 0 error "Invalid nonterminal symbol: %S" "Nonterminal `%s' already defined" wisent--item-no plist-put nvars n value propname object ptable entry] 6 (#$ . 93254)])
#@322 Parse nonterminal definitions in DEFS.
Fill in each element of the global arrays RPREC, RCODE, RUSEFUL with
respectively rule precedence level, semantic action code and
usefulness flag.  Return a list of rules of the form (LHS . RHS) where
LHS and RHS are respectively the Left Hand Side and Right Hand Side of
the rule.
(defalias 'wisent-parse-nonterminals #[(defs) "\306\211\307\211\306\211\211\211\211\211\211\211\211\211\211\211\211\211\211 !\"#$%&'()\307*\203\263
*@)*A*)@()A'\307':\204\\\310\311)\"\210'\2035'@&'A'&@!&A#\307 \306$\nT!\203\f
!@\"!A!\nT\"<\203\327
T\312\313\314
\"!\315\316\"\210\317\" (\fD#\fT\306	BB\211\"C%B%\nTT\202\375\"+>\204\375\",>\204\375\320\"!\203\367\321\"\316\"\210\202\375\310\322\"\"\210 T \"$B$\202~\323#@!\205i
#@\"#A#\"G\324U\203d
\"\307H+>\203d
\"\307H\211-\325./\326/0\236A.\"+\203d
\"\307H\211-\327./\326/0\236A.\"+\202i
\310\330\"\"\211B\317#\203\211
#A\203\203
\310\331#\"\202\221
#@\202\221
 \307V\205\221
\332 (\fD#\fT	B($\237B%B%T\202\\\333T\316\"1\334\306\237B!\334\306	\237B!%\237.\207" [rprec rcode nitems nrules iactn @count nil 0 error "Invalid nonterminal definition syntax: %S" intern format "@%d" wisent-push-var t vector wisent-char-p wisent-push-token "Symbol `%s' is used, but is not defined as a token and has no rules" vectorp 1 wisent--prec plist-get wisent--item-no "Invalid rule precedence level syntax: %S" "Invalid semantic action syntax: %S" $1 make-vector vconcat @n semact plevel rhl items item rest rhs rules rule rlist nonterm def defs token-list var-list x propname object ptable ruseful] 16 (#$ . 93857)])
#@669 Parse GRAMMAR and build a suitable internal representation.
Optional argument START-LIST defines the start symbols.
GRAMMAR is a list of form: (TOKENS ASSOCS . NONTERMS)

TOKENS is a list of terminal symbols (tokens).

ASSOCS is nil or an alist of (ASSOC-TYPE . ASSOC-VALUE) elements
describing the associativity of TOKENS.  ASSOC-TYPE must be one of the
`default-prec' `nonassoc', `left' or `right' symbols.  When ASSOC-TYPE
is `default-prec', ASSOC-VALUE must be nil or t (the default).
Otherwise it is a list of tokens which must have been previously
declared in TOKENS.

NONTERMS is the list of non terminal definitions (see function
`wisent-parse-nonterminals').
(defalias 'wisent-parse-grammar #[(grammar &optional start-list) ":\203\fG\306V\204\307\310!\210\311\211\211\211\211\211\211\211\211\211\211\211\211\211\211\211\211\211)*+,-./012345\312\21167\3138\314\"\210\3139\314\"\210@\2110\203j\3130@!\2100A\2110\204[A@0\3122\311\2111\314
0\203i
0@\211)@.)A0A0.\315=\203\276
A\203\251
@\316>\204\251\307\317
\"\210
@
1\203\270\320\321
\"\210\3141\202z.\322>\204\313\307\323.\"\2102T2
\203z
@+
A+\f>\203\350\320\324+\"\210+:>\204\365\313+!\210+\fB+2;\211<\325;=>\211?@\236\211A\204!
?C\211A@B@A\326AA>=#\241.\210+.B\211<\327B=>\211?@\236\211A\204W
?C\211A@B@A\326AA>=#\241.\210\202\320AA0\3110\203\251
0@)0A0):\204\213
\307\330)\"\210)@:>\203\233
\307\331)@\"\210\332)@!\210)\fB\202p
\f\204\261
\307\333!\210\f\237\311CD\204\304
\f@@/\202[E\204\317
DA\204\343
D@\211/\f\236\204[\307\334/\"\210\202[E\204[F/D\23700\203N0@*0A0*G>\204\307\334*\"\210*C\236\204\361
\335\336\337*\"!\335\336\340*\"!\313\314\"\210\332\n\314\"\210*BCBC\n*D\341DD\fB\nC\342D	B\202\361
\332/\314\"\210/	B\fB\343\f!-67\\H:\237:G0\311G0\203\3300@*0A0*GBG*6*\211<\344>?\345?@\236A>\"+\\I\211<\344I=>\211?@\236\211A\204\306?C\211A@B@A\326AA>=#\241.\210\202s9\211<\344>?\345?@\236A>\"+J/\211<\344>?\345?@\236A>\"+K\346:G\"L\347MT\311\"N\347MT\311\"O\347PT\311\"Q\3125\3504-\205\357N4-@@\211<\344>?\345?@\236A>\"+I\210O45I\210-@A3\31123\203\2423@\211<\344>?\345?@\236A>\"+\211,6W\203\214
\203\214,2Q5,I\2105T53A\2113\204dR4H\204\3222\203\322L2H\211<\325>?\345?@\236A>\"+\203\322R42I\210Q54[I\2105T54T4-A\211-\2041\311.\207" [grammar ep-def ep-var ep-token defs tokens 2 error "Bad input grammar" nil 0 wisent-push-token t default-prec (t nil) "Invalid default-prec value: %S" message "*** redefining default-prec to %s" (left right nonassoc) "Invalid associativity syntax: %S" "*** redefining precedence of `%s'" wisent--prec plist-put wisent--assoc "Invalid nonterminal definition: %S" "Nonterminal `%s' already defined as token" wisent-push-var "No input grammar" "Start symbol `%s' has no rule" intern format "$%s" "$$%s" $2 $1 wisent-parse-nonterminals wisent--item-no plist-get vconcat make-vector 1 def var token item rules assoc start-var lst dpre pre rhs r i ntokens nvars wisent-eoi-term wisent-error-term token-list p x value propname object ptable entry a start-table start-list wisent-single-start-flag wisent-starts-nonterm var-list nsyms n error-token-number start-symbol tags nrules rlhs rrhs nitems ritem rprec] 19 (#$ . 95599)])
#@1655 Compile the LALR(1) GRAMMAR.

GRAMMAR is a list (TOKENS ASSOCS . NONTERMS) where:

- TOKENS is a list of terminal symbols (tokens).

- ASSOCS is nil, or an alist of (ASSOC-TYPE . ASSOC-VALUE) elements
  describing the associativity of TOKENS.  ASSOC-TYPE must be one of
  the `default-prec' `nonassoc', `left' or `right' symbols.  When
  ASSOC-TYPE is `default-prec', ASSOC-VALUE must be nil or t (the
  default).  Otherwise it is a list of tokens which must have been
  previously declared in TOKENS.

- NONTERMS is a list of nonterminal definitions.

Optional argument START-LIST specify the possible grammar start
symbols.  This is a list of nonterminals which must have been
previously declared in GRAMMAR's NONTERMS form.  By default, the start
symbol is the first nonterminal defined.  When START-LIST contains
only one element, it is the start symbol.  Otherwise, all elements are
possible start symbols, unless `wisent-single-start-flag' is non-nil.
In that case, the first element is the start symbol, and others are
ignored.

Return an automaton as a vector: [ACTIONS GOTOS STARTS FUNCTIONS]
where:

- ACTIONS is a state/token matrix telling the parser what to do at
  every state based on the current lookahead token.  That is shift,
  reduce, accept or error.

- GOTOS is a state/nonterminal matrix telling the parser the next
  state to go to after reducing with each rule.

- STARTS is an alist which maps the allowed start nonterminal symbols
  to tokens that will be first shifted into the parser stack.

- FUNCTIONS is an obarray of semantic action symbols.  Each symbol's
  function definition is the semantic action lambda expression.
(defalias 'wisent-compile-grammar #[(grammar &optional start-list) "\306!\203\207\307\211\307\211\307\211
\307\211\307\211\307\211\307\211\307\211\307\211\307\211\307\211\307\211\307\211 !\307\211\"#\307\211$%\307\211&'\307\211()\307\211*+\307\211,-\307\211./\307\21101\307\21123\307\21145\307\21167\307\21189\307\211:;\307\211<=\307\211>?\307\211@A\307\211BC\307\211DE\307\211FG\307\211HI\307\211JK\307\211LM\307\211NO\307\211PQ\307R\310S\311 \210\312T\313U\"\210\314 .L\207" [grammar F LA LAruleno accessing-symbol conflicts wisent-automaton-p nil 1000000 garbage-collect t wisent-parse-grammar wisent-parser-automaton consistent default-prec derives err-table fderives final-state first-reduction first-shift first-state firsts from-state goto-map includes itemset nitemset kernel-base kernel-end kernel-items last-reduction last-shift last-state lookaheads lookaheadset lookback maxrhs ngotos nitems nrules nshifts nstates nsyms ntokens nullable nvars rassoc redset reduction-table ritem rlhs rprec rrc-count rrc-total rrhs ruseful rcode ruleset rulesetsize shift-symbol shift-table shiftset src-count src-total start-table state-table tags this-state to-state tokensetsize varsetsize error-token-number start-symbol token-list var-list N P V V1 nuseless-nonterminals nuseless-productions ptable gc-cons-threshold wisent-new-log-flag start-list] 4 (#$ . 99045)])
(require 'bytecomp)
#@131 Byte compile the `wisent-compile-grammar' FORM.
Automatically called by the Emacs Lisp byte compiler as a
`byte-compile' handler.
(defalias 'wisent-byte-compile-grammar #[(form) "\301\302\303\304!!!!\207" [form byte-compile-form macroexpand-all wisent-automaton-lisp-form eval] 5 (#$ . 102194)])
(put 'wisent-compile-grammar 'byte-compile 'wisent-byte-compile-grammar)
#@110 Return a Lisp form that produces AUTOMATON.
See also `wisent-compile-grammar' for more details on AUTOMATON.
(defalias 'wisent-automaton-lisp-form #[(automaton) "\304!\204
\305\306\304D\"\210\307\310!\311H\312\n\313BC\314\315\316\317	\"\210)\320\211\321\322\323H\"B\324H\325\326HD\n\257C\"*BB\207" [automaton obv obn obcode wisent-automaton-p signal wrong-type-argument make-symbol "ob" 3 let ((make-vector 13 0)) append nil mapatoms #[(s) "\303\304\305!	E\306KDE\nB\211\207" [s obn obcode fset intern symbol-name function] 4] vector mapcar #[(state) "\301\302\303\"B\207" [state list mapcar #[(tr) "@A	9\203+\305\306	!\"\203+\307\n9\203 \310\nD\202!\n\305\306	!\fEE\202.\310D*\207" [tr a k obv obn intern-soft symbol-name cons quote] 5]] 4] 0 1 quote 2] 10 (#$ . 102571)])
(provide 'semantic/wisent/comp)