HOME

;ELC
;;; Compiled
;;; in Emacs version 26.1
;;; 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)
#@406 Define a simple data structure called NAME.
Which contains data stored in FIELDS.  FIELDS is a list of symbols
which are field names or pairs (FIELD INITIAL-VALUE) where
INITIAL-VALUE is a constant used as the initial value of FIELD when
the data structure is created.  INITIAL-VALUE defaults to nil.

This defines a `make-NAME' constructor, get-able `NAME-FIELD' and
set-able `set-NAME-FIELD' accessors.
(defalias 'wisent-struct '(macro . #[(name &rest fields) "G\306\307\211\211\211\211W\203p@A\f:\2030\fA@	B\f@\2024\307	B\310\311\f#\312\310\313\"!\314\n\315\316\317\320FF
B\312\310\321\"!\314\n\322\316\323\320\324BBBBF
BT\211\202\325\314\312\310\326\"!\307\327\330\331	\237DEF
.BB\207" [fields ivals fun sufx field accors 0 nil format "%s-%s" intern "%s" defmacro (s) list 'aref s "set-%s" (s v) 'aset (v) progn "make-%s" cons 'vector quote i size name] 9 (#$ . 1860)]))
(put 'wisent-struct 'lisp-indent-function 1)
#@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 (#$ . 2833)])
(put 'wisent-pad-string 'byte-optimizer 'byte-compile-inline-expand)
(defconst wisent-BITS-PER-WORD (byte-code "\302\303\304!\203\305\202\f\306	!\307U\204	T\202	*\207" [do-shift i 1 boundp most-positive-fixnum #[(i) "\302	[\"\207" [most-positive-fixnum i lsh] 3] #[(i) "\301\302\"\207" [i lsh 1] 3] 0] 3))
#@42 (N + BITS-PER-WORD - 1) / BITS-PER-WORD.
(defalias 'wisent-WORDSIZE #[(n) "	\\S	\245\207" [n wisent-BITS-PER-WORD] 2 (#$ . 3479)])
(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 lsh 1] 8 (#$ . 3684)])
(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 lsh 1] 9 (#$ . 3939)])
(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 lsh 1 0] 6 (#$ . 4213)])
(put 'wisent-BITISSET 'byte-optimizer 'byte-compile-inline-expand)
#@57 Return non-nil if running without interactive terminal.
(defalias 'wisent-noninteractive #[nil "\207" [noninteractive] 1 (#$ . 4480)])
(put 'wisent-noninteractive 'byte-optimizer 'byte-compile-inline-expand)
#@40 Non-nil means enable some debug stuff.
(defvar wisent-debug-flag nil (#$ . 4695))
#@25 Name of the log buffer.
(defconst wisent-log-buffer-name "*wisent-log*" (#$ . 4783))
#@38 Non-nil means to start a new report.
(defvar wisent-new-log-flag nil (#$ . 4874))
#@66 Non-nil means to report verbose information on generated parser.
(custom-declare-variable 'wisent-verbose-flag nil '(#$ . 4962) :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 (#$ . 5127) 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 (#$ . 5420)]))
#@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 (#$ . 5625)]))
#@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 (#$ . 5808)])
#@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 (#$ . 6059)])
#@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 (#$ . 6389)])
(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" (#$ . 6832))
#@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 (#$ . 6955)])
#@30 The size of the state table.
(custom-declare-variable 'wisent-state-table-size 1009 '(#$ . 7300) :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 (#$ . 7434)]))
#@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 (#$ . 7619)]))
#@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 (#$ . 7799)])
(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 (#$ . 8100)])
(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 (#$ . 8409)])
(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 (#$ . 8667)])
(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 (#$ . 8914)])
(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 (#$ . 9224)])
(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 (#$ . 9459)])
(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 (#$ . 9757)])
(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 (#$ . 9992)])
(put 'wisent-set-prec 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'make-core '(macro . #[nil "\300\301B\207" [vector (nil nil 0 0 0 [0])] 2]))
(defalias 'set-core-items '(macro . #[(s v) "\302\303	F\207" [s v aset 5] 4]))
(defalias 'core-items '(macro . #[(s) "\301\302E\207" [s aref 5] 3]))
(defalias 'set-core-nitems '(macro . #[(s v) "\302\303	F\207" [s v aset 4] 4]))
(defalias 'core-nitems '(macro . #[(s) "\301\302E\207" [s aref 4] 3]))
(defalias 'set-core-accessing-symbol '(macro . #[(s v) "\302\303	F\207" [s v aset 3] 4]))
(defalias 'core-accessing-symbol '(macro . #[(s) "\301\302E\207" [s aref 3] 3]))
(defalias 'set-core-number '(macro . #[(s v) "\302\303	F\207" [s v aset 2] 4]))
(defalias 'core-number '(macro . #[(s) "\301\302E\207" [s aref 2] 3]))
(defalias 'set-core-link '(macro . #[(s v) "\302\303	F\207" [s v aset 1] 4]))
(defalias 'core-link '(macro . #[(s) "\301\302E\207" [s aref 1] 3]))
(defalias 'set-core-next '(macro . #[(s v) "\302\303	F\207" [s v aset 0] 4]))
(defalias 'core-next '(macro . #[(s) "\301\302E\207" [s aref 0] 3]))
(defalias 'make-shifts '(macro . #[nil "\300\301B\207" [vector (nil 0 0 [0])] 2]))
(defalias 'set-shifts-shifts '(macro . #[(s v) "\302\303	F\207" [s v aset 3] 4]))
(defalias 'shifts-shifts '(macro . #[(s) "\301\302E\207" [s aref 3] 3]))
(defalias 'set-shifts-nshifts '(macro . #[(s v) "\302\303	F\207" [s v aset 2] 4]))
(defalias 'shifts-nshifts '(macro . #[(s) "\301\302E\207" [s aref 2] 3]))
(defalias 'set-shifts-number '(macro . #[(s v) "\302\303	F\207" [s v aset 1] 4]))
(defalias 'shifts-number '(macro . #[(s) "\301\302E\207" [s aref 1] 3]))
(defalias 'set-shifts-next '(macro . #[(s v) "\302\303	F\207" [s v aset 0] 4]))
(defalias 'shifts-next '(macro . #[(s) "\301\302E\207" [s aref 0] 3]))
(defalias 'make-reductions '(macro . #[nil "\300\301B\207" [vector (nil 0 0 [0])] 2]))
(defalias 'set-reductions-rules '(macro . #[(s v) "\302\303	F\207" [s v aset 3] 4]))
(defalias 'reductions-rules '(macro . #[(s) "\301\302E\207" [s aref 3] 3]))
(defalias 'set-reductions-nreds '(macro . #[(s v) "\302\303	F\207" [s v aset 2] 4]))
(defalias 'reductions-nreds '(macro . #[(s) "\301\302E\207" [s aref 2] 3]))
(defalias 'set-reductions-number '(macro . #[(s v) "\302\303	F\207" [s v aset 1] 4]))
(defalias 'reductions-number '(macro . #[(s) "\301\302E\207" [s aref 1] 3]))
(defalias 'set-reductions-next '(macro . #[(s v) "\302\303	F\207" [s v aset 0] 4]))
(defalias 'reductions-next '(macro . #[(s) "\301\302E\207" [s aref 0] 3]))
(defalias 'make-errs '(macro . #[nil "\300\301B\207" [vector (0 [0])] 2]))
(defalias 'set-errs-errs '(macro . #[(s v) "\302\303	F\207" [s v aset 1] 4]))
(defalias 'errs-errs '(macro . #[(s) "\301\302E\207" [s aref 1] 3]))
(defalias 'set-errs-nerrs '(macro . #[(s v) "\302\303	F\207" [s v aset 0] 4]))
(defalias 'errs-nerrs '(macro . #[(s) "\301\302E\207" [s aref 0] 3]))
#@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 (#$ . 13129)])
#@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 (#$ . 13377)])
#@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 (#$ . 13551)])
#@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 lsh 1 ntokens N0 x wisent-BITS-PER-WORD] 6 (#$ . 13792)])
#@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 lsh wisent-useful-production logior wisent-bits-equal t wisent-BITS-PER-WORD N nrules P x rlhs ntokens k] 9 (#$ . 14118)])
#@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 lsh 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 (#$ . 14789)])
#@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 lsh x wisent-BITS-PER-WORD] 9 (#$ . 16246)])
#@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 lsh 1 nvars ntokens nsyms V x wisent-BITS-PER-WORD tags nrules rlhs ritem start-symbol nuseless-nonterminals] 7 (#$ . 16533)])
#@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 (#$ . 17311)])
#@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 lsh 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 (#$ . 17812)])
#@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 lsh 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 (#$ . 18718)])
#@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 (#$ . 20626)])
#@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 (#$ . 21228)])
#@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 (#$ . 21850)])
#@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 lsh 1 "   %d\n" ntokens nsyms s tags item wisent-escape-sequence-strings fderives nrules x wisent-BITS-PER-WORD] 7 (#$ . 22828)])
#@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 lsh 1 logior wisent-print-fderives ntokens nsyms firsts x wisent-BITS-PER-WORD derives wisent-debug-flag] 9 (#$ . 23602)])
#@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 lsh 1 "		%d (%s)\n" ntokens nsyms s tags item wisent-escape-sequence-strings firsts nvars x wisent-BITS-PER-WORD] 7 (#$ . 24504)])
#@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 lsh 1 logior wisent-BITS-PER-WORD] 9 (#$ . 25354)])
#@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 lsh 1] 9 (#$ . 25872)])
#@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 lsh 1 wisent-RTC wisent-print-firsts n wisent-BITS-PER-WORD varsetsize firsts ntokens nsyms derives ritem rrhs x k wisent-debug-flag] 9 (#$ . 26218)])
#@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 (#$ . 27115)])
#@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 (#$ . 27493)])
#@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 lsh 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 (#$ . 27887)])
#@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 (#$ . 29234)])
#@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 (#$ . 29674)])
#@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 (#$ . 29948)])
#@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\306\211\310\211\211\311&\312
\310\"\f\313I\210\f\314I\210\f\315
I\210\f\316I\210\310	W\203Z\nHI\210T\nT\202C\310\fI\210\fT\f.\207" [items iend isp2 isp1 p n nil vector 0 [0] make-vector 3 2 4 5 kernel-base symbol kernel-end nstates kernel-items last-state] 8 (#$ . 30713)])
#@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\262\306	\204\276\310HU\203\223\311H\312H\307	\203\223\fW\203\223H\n
HU\204\210\306T
T\202o	\204T\313H\203\244\313H\202T\313\314!I\311\211\202U\314!I\210\315H.\207" [n found sp2 sp iend isp2 nil 0 4 t 5 1 wisent-new-state 2 isp1 key kernel-base symbol kernel-end kernel-items wisent-state-table-size state-table] 9 (#$ . 31237)])
#@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 (#$ . 32038)])
#@20 Initialize states.
(defalias 'wisent-initialize-states #[nil "\305\306\211\307\211\211\310&\211\311\211)\207" [p first-state last-state this-state nstates vector nil 0 [0] 1] 8 (#$ . 32593)])
#@60 Save the NSHIFTS of SHIFTSET into the current linked list.
(defalias 'wisent-save-shifts #[nil "\306\211\211\307\306\310\211\311$\312\310\"\310\n\313\f\314HI\210\n\314I\210\n\315I\210	W\2039	
	HI\210	T\211\202&\203G\310\nI\210\202J\n\n\211+\207" [shifts i p nshifts this-state shiftset nil vector 0 [0] make-vector 1 2 3 last-shift first-shift] 6 (#$ . 32799)])
#@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\306\211\310\211\211\311&\211\312\nI\210	\313I\210\f\310	I\210	\307\306\310\211\314$\211\315\nI\210\nT\312\315I\210\313\307\n!I\210
\310I\210\211*\207" [sp statep nstates start-symbol last-state last-shift nil vector 0 [0] 2 3 [0] 1] 8 (#$ . 33192)])
#@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\203\257
\307H\310U\203\214
\311H\310H\211\312HW\203@\f\311H
W\203@\f\310H\211\202(\f\312HU\203\373\f\311H\203c\307H
W\203c\310H\211\204Q\203\316\307H
U\203\316\311H\313\306\310\211\314$\315T\310\"\n\307
I\210\n\311TI\210\n\312I\210\310I\210\310V\203\265\312HSHI\210S\211\202\233\n\310\310HI\210	\310\nI\210=\203\314
\n\202\314
\313\306\310\211\314$\211\307
I\210\n\311\307I\210\n\312\313!I\210\n\310I\210	\310\nI\210\204\314
\n\202\314
\313\306\310\211\314$\311H\315T\310\"\n\311TI\210\n\312I\210\310H\310\211\311HW\203b
\f\312HV\203I

U\203I

I\210
T
\312HHI\210\f\310HT
T\202'

U\203r

I\210
T\n\310\310HI\210\n=\203\206
\n\316 \210\202\314
\313\306\310\211\314$\211\311\307I\210\312\313!I\210\310I\210\316 \210\202\314
\313\306\310\211\314$\211\311\307I\210\312\313!I\210\316 \210\313\306\211\310\211\211\317&\211\311I\210\310\fI\210\f\313\306\310\211\314$\211\307I\210T\311\307I\210\312\313!I\210\310I\210\313\306\211\310\211\211\317&\211\311I\210T\310\fI\210\f\211.\207" [shifts sp1 sp2 sp statep k nil 1 0 2 3 vector [0] make-vector wisent-insert-start-shift [0] i first-shift first-state start-symbol nstates last-shift last-state final-state] 8 (#$ . 33673)])
#@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\203\310\306\307\211\311$\312\n\307\"	\313\314HI\210	\314\nI\210	\315I\210\307\211\nW\203n\f\fHI\210\fT\211\202Z\203|\307	I\210\202		\211-\207" [rules p count item i nitemset nil 0 vector [0] make-vector 1 2 3 ritem itemset redset this-state last-reduction first-reduction] 6 (#$ . 35454)])
#@69 Compute the nondeterministic finite state machine from the grammar.
(defalias 'wisent-generate-states #[nil "\303 \210\304!\210\305 \210	\2031\306	\307H	\310H\"\210\311 \210\312 \210\313 \210\n\314V\203)\315 \210	\314H\211\204\316 \207" [nitems this-state nshifts wisent-allocate-storage wisent-initialize-closure wisent-initialize-states wisent-closure 5 4 wisent-save-reductions wisent-new-itemsets wisent-append-states 0 wisent-save-shifts wisent-augment-automaton] 5 (#$ . 36110)])
#@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 (#$ . 36608)])
#@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 (#$ . 37179)])
#@20 Build state table.
(defalias 'wisent-set-state-table #[nil "\304\305	\304\"\211\205\n\306HI\210\307H\211\204
\304)\207" [sp nstates state-table first-state nil make-vector 2 0] 4 (#$ . 37496)])
#@31 Build accessing symbol table.
(defalias 'wisent-set-accessing-symbol #[nil "\304\305	\306\"\211\205\n\307H\310HI\210\306H\211\204
\304)\207" [sp nstates accessing-symbol first-state nil make-vector 0 2 3] 5 (#$ . 37707)])
#@20 Build shift table.
(defalias 'wisent-set-shift-table #[nil "\304\305	\304\"\211\205\n\306HI\210\307H\211\204
\304)\207" [sp nstates shift-table first-shift nil make-vector 1 0] 4 (#$ . 37946)])
#@24 Build reduction table.
(defalias 'wisent-set-reduction-table #[nil "\304\305	\304\"\211\205\n\306HI\210\307H\211\204
\304)\207" [rp nstates reduction-table first-reduction nil make-vector 1 0] 4 (#$ . 38157)])
#@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 (#$ . 38384)])
#@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\252\fI\210HH\203g\311H\312V\204^\n\203g\n\313H\310HHY\204g\f\311H\\\202n\314I\210\n\203\241\310\n\311H
\n\313H

W\203\241
HHU\203\232\306I\210

T\211\202~T\211\202'\fI\210\f\310U\203\314\307\312\306\"\307\312\310\"\307\312\306\"\202\336\307\f\306\"\307\f\310\"\307\f\306\"\310G

W\203
\307\310\"I\210T\211\202\350\310\211\310W\205P
H\204G
H\211\203G
\310
\311H\313H

W\203G
	
HI\210	T
T\211
\202-
T\211\202
.\207" [v np sp rp count k nil make-vector 0 2 1 3 t j i nstates consistent lookaheads reduction-table shift-table accessing-symbol ntokens error-token-number LA LAruleno lookback tokensetsize] 9 (#$ . 38599)])
#@18 Set up GOTO-MAP.
(defalias 'wisent-set-goto-map #[nil "\306\211\211\211\211\211\211\211\211\f
\307T\310\"\307T\310\"\310\211\203\311HS
\312H
\310Y\203u
HH\211W\203W\310
\202lT
Z
ZHTI\210
S\211
\202=\310H\211\204/\310
\310\f
W\203\253\f\fI\210\f\fH\\
T
\fT\f\202\210
\310\f
W\203\321\f\fHI\210
T
\fT\f\202\262\fI\210\fI\210\307\310\"\307\310\"\211\205T
\313H\312H\311HS\211
\310Y\203I

H	H\211W\203$
\310
\202@

ZH
Z\fTI\210\f\nI\210\f	I\210
S\211
\202
\310H\211\204\366\306.	\207" [v state2 state1 temp-map k symbol nil make-vector 0 2 3 1 j i sp nvars goto-map ngotos first-shift accessing-symbol ntokens nsyms from-state to-state] 10 (#$ . 39495)])
#@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 (#$ . 40311)])
#@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\203J
HH\211\203<
\311H\312H\310\306\204\323W\203\323	HH\211Y\203\244\313\211\202\204H\n !\245 \314 H\315\316!\246\"\"I+\210T\202\203W\203
	HH\"\nZH\203\371\f\317\n\"I\210\fTT\211\202\325\f\310V\203<
\307\fT\310\"\310
I\210\fW\2034
HI\210T\211\202
\f\320I\210\310TT\211\202]\321
!.
\207" [break v symbol stateno nedges reads nil make-vector 0 2 3 t logior lsh 1 wisent-map-goto -1 wisent-digraph rp rowp edge sp k j i ngotos F tokensetsize to-state shift-table accessing-symbol ntokens x wisent-BITS-PER-WORD nullable] 14 (#$ . 40716)])
#@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 (#$ . 41621)])
#@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 (#$ . 42025)])
#@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\"\307T\310\"\310\211W\203\215
\310H HH!\f\"ZH\211@\310V\203L
	\310I\210\311#@H$H\310V\203\334$H%
H\211\312H\313H\310\211W\203\311H
HU\203\300\211\202\244T\211\202\244	
I\210TT\202\200&
H\204\354\314
@#\210S\306\204C
\315S\211\310Y\203\364$H\"Y\203\364S	H\n\316
$H\"I\210T'$H\"ZH\203\364\306\211\203\371A\211\202f\310V\203\204
\307T\310\"\310I\210W\203~
\nHI\210T\211\202f
\317I\210T\211\202C\320\"\211.\207" [v states edge symbol2 symbol1 stateno nil make-vector 0 1 2 3 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 consistent nullable] 17 (#$ . 42815)])
#@18 Compute follows.
(defalias 'wisent-compute-FOLLOWS #[nil "\301!\207" [includes wisent-digraph] 2 (#$ . 43895)])
#@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 (#$ . 44014)])
#@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 (#$ . 44348)])
#@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 (#$ . 44882)])
(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@\307H\310H\311\211	W\205@\nH\311U\2049\n\nHHU\2039\n\311I\210\nT\211\202,\207" [v k i shiftp shift-table state nil 2 3 0 token accessing-symbol] 5 (#$ . 45664)])
#@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+,\236A*\"+#\311\312\313\"\314-\312\"\312\211$
\315\fI\210$-W\203\265%$H.(H$$)\316)$/\245H\317\315$/\246\"\"\312U*\204\2540$$)\316)$/\245H\317\315$/\246\"\"\312U*\204\254\n\211)\307*+\310+,\236A*\"+\211\203\254	#W\203P
1($\3202314\204\3225\205
\3211'3H\n6%6H7\3227!\203\37478\236A\206
\323\3247\"\202
\3257!*2\2579:\203
\326 \210r\327;!q\210\330\3319\"c*,\2100$$)$/\245<)<\316)<H\332\317\315$/\246\"!\"I+\210\3331$\"\210\202\254	#V\203\351
1($\3342314\204o
5\205\272
\3211'3H\n6%6H7\3227!\203\231
78\236A\206\235
\323\3247\"\202\235
\3257!*2\2579:\203\254
\326 \210r\327;!q\210\330\3319\"c*,\210.(H$$)$/\245<)<\316)<H\332\317\315$/\246\"!\"I+\210\202\254\n\211)\335*+\310+,\236A*\"+\211\336\267\20291($\3342314\2045\205g\3211'3H\n6%6H7\3227!\203F78\236A\206J\323\3247\"\202J\3257!*2\2579:\203Y\326 \210r\327;!q\210\330\3319\"c*,\210\20291($\3202314\204\2045\205\317\3211'3H\n6%6H7\3227!\203\25678\236A\206\262\323\3247\"\202\262\3257!*2\2579:\203\301\326 \210r\327;!q\210\330\3319\"c*,\210\20291($\3372314\204\3545\2057\3211'3H\n6%6H7\3227!\20378\236A\206\323\3247\"\202\3257!*2\2579:\203)\326 \210r\327;!q\210\330\3319\"c*,\210\340=\204m0$$)$/\245<)<\316)<H\332\317\315$/\246\"!\"I+\210\3331$\"\210\341=\204\235.(H$$)$/\245<)<\316)<H\332\317\315$/\246\"!\"I+\210\342=\203\254\f$I\210T$T\211$\202K\312V\205\306
\312I\210=1
I.\207" [sassoc sprec token nerrs errs errp nil wisent--prec plist-get vector 0 [0] make-vector 1 logand lsh "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 516 left 620 nonassoc 724)) "an error" right left nonassoc redprec i tags rprec LAruleno lookaheadnum x propname object ptable ntokens 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 err-table] 10 (#$ . 46066)])
#@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\203p	\311H	\312H\310\211W\203p\n
HH\211W\203p\n
H\310U\204i
\245\313H\314\315
\246\"\"I+\210
T\211\2020HTH
W\203\304
HH\203\275
H\310\211W\203\275\316\n\fH\fH\"\310U\203\260\fT\211\202\225\317
\"\210\211\202\225
T\211\202~H\211W\205

H\310\211W\203\372\316\n\fH\fH\"\310U\204\363\320I\210\fT\211\202\330\310\211W\203
\f\313\fH\n\fH\"I\210\fT\211\202\375
T\211\202\313.\207" [symbol shiftp v k j i nil fillarray 0 2 3 logior lsh 1 logand wisent-resolve-sr-conflict t consistent state lookaheadset shift-table accessing-symbol ntokens x wisent-BITS-PER-WORD lookaheads rprec LAruleno LA tokensetsize conflicts] 9 (#$ . 48967)])
#@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 (#$ . 49874)])
#@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\n\311H\n\312H\307\211W\203u
H\307U\204n
HH\211Y\203P\202n	
\245\313H\314\315
\246\"\"I+\210
T\211\2020THH\211W\203\262
H\307\211W\203\253\f\313\fH\fH\"I\210\fT\211\202\220
T\211\202\203\307\211W\203\321\316HH\"I\210T\211\202\265\307\211W\203

\316
\245H\314\315
\246\"\"\307U*\204\373T
T\211\202\324.\207" [v symbol shiftp k j i nil 0 fillarray 2 3 logior lsh 1 logand src-count shift-table state shiftset lookaheadset accessing-symbol ntokens x wisent-BITS-PER-WORD lookaheads LA tokensetsize] 9 (#$ . 50176)])
#@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 lsh 1 lookaheads state ntokens LA x wisent-BITS-PER-WORD] 7 (#$ . 50994)])
#@306 If non-nil suppress the warning about shift/reduce conflicts.
It is a decimal integer N that says there should be no warning if
there are N shift/reduce conflicts and no reduce/reduce conflicts.  A
warning is given if there are either more or fewer conflicts, or if
there are any reduce/reduce conflicts.
(custom-declare-variable 'wisent-expected-conflicts nil '(#$ . 51439) :group 'wisent :type '(choice (const nil) integer))
#@39 Report the total number of conflicts.
(defalias 'wisent-total-conflicts #[nil "\305U\205	\305U\206	\n\206\305U?\205n\306 \211\203$\307P\202%\310\311\312\"	\305V\203B\311\313\f	\211\314V\203?\315\202@\310$	\305V\203S\305V\203S\311\316\f\"\305V\203j\311\317\f\211\314V\203g\315\202h\310$\320\f!+\207" [rrc-total src-total wisent-expected-conflicts src msg 0 wisent-source " in " "" format "Grammar%s contains" "%s %d shift/reduce conflict%s" 1 "s" "%s and" "%s %d reduce/reduce conflict%s" message] 7 (#$ . 51872)])
#@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 (#$ . 52421)])
#@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 (#$ . 53424)])
#@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\252\n\311H$\n\312H#\307\211&$W\203\252#&H\307U\204\241*#&HH\211\"+Y\203r$&\202\241\",U\203|\313'\"&-&.\245$-$\314-$H\315\316&.\246\"\"I+\210&T\211&\202J/)H\211\203
	\307H$	\316H#\307\211&$W\203
#&H\211\"\307U\204\372'\"&-&.\245$-$\314-$H\315\316&.\246\"\"I+\210&T\211&\202\3020)H!0)TH\211 !Z\316U\203:\204:1!H2!H#\307\211$3W\203Q
4$\317#$H'$H\"I\210$T\211$\2020
\307\211&+W\203\362
4&&-\317-&.\245H\315\316&.\246\"\"\307U*\204\351
\320&565H7\3217!\203\237
78\236A\206\243
\322\3237\"\202\243
\3247!*
9
H565H7\3217!\203\312
78\236A\206\316
\322\3237\"\202\316
\3247!*F:;\203\332
\325 \210r\326<!q\210\327\330:\"c*\210&T\211&\202U
\331
9
H565H7\3217!\20378\236A\206\322\3237\"\202\3247!*E:;\203)\325 \210r\326<!q\210\327\330:\"c*\202\261 !Z\316Y\205\261\307\332\307\204!\211& W\2032&H#\307\211$\3073W\203\2124$\317#$H\333'$H!\"I\210$T\211$\202g\307\211%+W\203\3004%&-\317-&.\245H\315\316&.\246\"\"\307U*\204\267T%T\211%\202\216\fV\203\322&1&H\307\211$3W\203\367'$\314'$H4$H\"I\210$T\211$\202\326&T\211&\202T\310'\307\"\210\n\203n\n\311H$\n\312H#\307\211&$W\203n#&H\307U\204e*#&HH\211\"+Y\203@$&\202e'\"&-&.\245$-$\314-$H\315\316&.\246\"\"I+\210&T\211&\202\307\211&+W\203e\306'&&-\317-&.\245H\315\316&.\246\"\"\307U*\204\237\316\202\240\307!\211% W\203\\2%H&&-\317-&.\245H\315\316&.\246\"\"\307U*\204S\307U\203_%U\204V\334&565H7\3217!\203
78\236A\206\322\3237\"\202\3247!*1%H91%HH565H7\3217!\203478\236A\2068\322\3237\"\2028\3247!*F:;\203D\325 \210r\326<!q\210\327\330:\"c*\210\202Y\313T\202S\203\332\334&565H7\3217!\203\21078\236A\206\214\322\3237\"\202\214\3247!*1H91HH565H7\3217!\203\27378\236A\206\277\322\3237\"\202\277\3247!*F:;\203\313\325 \210r\326<!q\210\327\330:\"c*\210\306\320&565H7\3217!\203
78\236A\206\322\3237\"\202\3247!*1%H91%HH565H7\3217!\203478\236A\2068\322\3237\"\2028\3247!*F:;\203D\325 \210r\326<!q\210\327\330:\"c*\210%T\211%\202\246&T\211&\202r\307Y\205\261\335
9
H565H7\3217!\203\22378\236A\206\227\322\3237\"\202\227\3247!*E:;\203\243\325 \210r\326<!q\210\327\330:\"c*.\207" [nodefault errp shiftp count cmax default-rule nil 0 fillarray 2 3 t logior lsh 1 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 accessing-symbol ntokens error-token-number x wisent-BITS-PER-WORD err-table lookaheads LAruleno LA tokensetsize lookaheadset s tags item wisent-escape-sequence-strings rlhs args wisent-new-log-flag wisent-log-buffer-name] 16 (#$ . 56186)])
#@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\311)!q\210\312\313'\"c*\202\300\314C'(\203i\310 \210r\311)!q\210\312\313'\"c*\202\300
\204\207\315\211!\202:

\316H
\317H\315!\306\204
!W\203
!H\211\315U\203\267!T!\202\226*H\211+Y\203\313\320\211\202\227\321,-,H.\322.!\203\357./\236A\206\363\323\324.\"\202\363\325.!*E'(\203

\310 \210r\311)!q\210\312\313'\"c*\210!T!\202\226!\315V\203:
\326C'(\203+
\310 \210r\311)!q\210\312\313'\"c*\210\f\203\311
\f\315H\f\327H\315\211 	W\203\247
 H\203\236
\330 H,-,H.\322.!\203
./\236A\206\203
\323\324.\"\202\203
\325.!*D'(\203\217
\310 \210r\311)!q\210\312\313'\"c*\210 T\211 \202K
 \315V\203\311
\326C'(\203\272
\310 \210r\311)!q\210\312\313'\"c*\2100#H\203(\203(\317H\315H1\nH\331\n,-,H.\322.!\203./\236A\206\n\323\324.\"\202\n\325.!*E'(\203\310 \210r\311)!q\210\312\313'\"c*\210\2021\2031\332#!\210!W\205\300
\317H!W\203\246!H\211\203\235*H\333,-,H.\322.!\203|./\236A\206\200\323\324.\"\202\200\325.!*E'(\203\216\310 \210r\311)!q\210\312\313'\"c*\210!T\211!\202@\326C'(\203\262\310 \210r\311)!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 2 3 t "    %s	shift, and go to state %d\n" wisent-char-p format "'%c'" symbol-name "\n" 1 "    %s	error (nonassociative)\n" "    $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 accessing-symbol ntokens s tags item wisent-escape-sequence-strings consistent rlhs] 13 (#$ . 59507)])
#@19 Print STATE core.
(defalias 'wisent-print-core #[(state) "\306\211\211\211\211\211H\211\307H\211\310V\205\211
\310\211\fW\203o
\n\311H
H\211	H\310V\203;	T\202,	H[\312HH\313!\203g\236A\206k\314\315\"\202k\316!*D !\203w\317 \210r\320\"!q\210\321\322 \"c*\210#H\211W\203\335\323	HH\313!\203\267\236A\206\273\314\315\"\202\273\316!*D !\203\307\317 \210r\320\"!q\210\321\322 \"c*\210	T\211\202\214\324C !\203\351\317 \210r\320\"!q\210\321\322 \"c*\210	H\310V\203L
\325	HH\313!\203'
\236A\206+
\314\315\"\202+
\316!*D !\2037
\317 \210r\320\"!q\210\321\322 \"c*\210	T\202\370\326D !\203Y
\317 \210r\320\"!q\210\321\322 \"c*\210
T\211\202\327C !\203{
\317 \210r\320\"!q\210\321\322 \"c*.\207" [sp1 sp statep rule k i nil 4 0 5 "    %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 ritem rlhs s tags item wisent-escape-sequence-strings args wisent-new-log-flag wisent-log-buffer-name rrhs] 7 (#$ . 61503)])
#@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 (#$ . 62651)])
#@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 (#$ . 62986)])
#@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 (#$ . 63157)])
#@614 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\310H\211\203\273\311H\211\312Y\203\273HTH\211S\211Y\203\273\310\211W\203\262H \313 !\245H\314\312!\246\"\"\310U*\204\251\"H[I\210T\211\202tS\211\202j#H\211\203
\n\311H\n\315H\310\211W\203
H\211\310U\204
$
H\211Y\203\370\202
\f
I\210\f%U\203
\316T\211\202\323&H\211\203B
	\310H	\312H\310\211W\203B
H'I\210T\211\202(
\312Y\203\363
\204\363
(H\203`
\315H\310H[\202\363
\310\211W\203\276
\310\"H[\310\211W\203\245
H\247\203\234
HU\203\234
TT\211\202}
V\203\265
T\211\202h
\310V\203\363
\310\211W\203\363
H\247\203\352
HU\203\352
\306I\210T\211\202\311
\310U\2032)U\203	*\2022\310\211W\203.H'=\203%\306I\210T\211\202
'.\207" [nodefault errp shiftp redp symbol shift-state nil fillarray 0 2 1 logand lsh 3 t count max rule nreds default-rule v n m k j i actrow reduction-table state lookaheads ntokens LA x wisent-BITS-PER-WORD LAruleno shift-table accessing-symbol error-token-number err-table wisent-error-tag consistent final-state wisent-accept-tag] 18 (#$ . 63673)])
#@59 Tag used in an action table to indicate a default action.
(defconst wisent-default-tag 'default (#$ . 65695))
#@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 (#$ . 65811)])
#@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 (#$ . 66516)])
#@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 (#$ . 67026)])
(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 (#$ . 67290)])
(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 (#$ . 67571)])
#@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 (#$ . 68219)])
#@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\f,Z\313_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/\f\313_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 (#$ . 69143)])
#@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 (#$ . 70746)])
#@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) (#$ . 71281))
#@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) (#$ . 71503))
#@58 Main start symbol.
It gives the rules for start symbols.
(defconst wisent-starts-nonterm '$STARTS (#$ . 71682))
#@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 (#$ . 71801))
#@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 (#$ . 72050)])
(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 (#$ . 72350)])
(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 (#$ . 72686)])
#@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 (#$ . 73536)])
#@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 (#$ . 74139)])
#@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 (#$ . 75881)])
#@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 (#$ . 79327)])
(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 (#$ . 82476)])
(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 (#$ . 82852)])
(provide 'semantic/wisent/comp)