;ELC   
;;; compiled by kwzh@nutrimat.gnu.ai.mit.edu on Thu Jun 15 18:22:53 1995
;;; from file /gd/gnu/emacs/19.0/lisp/cl-extra.el
;;; emacs version 19.28.94.3.
;;; bytecomp version FSF 2.10
;;; optimization is on.
;;; this file uses opcodes which do not exist in Emacs 18.

(if (and (boundp 'emacs-version)
	 (or (and (boundp 'epoch::version) epoch::version)
	     (string-lessp emacs-version "19.28.90")))
    (error "`cl-extra.el' was compiled for Emacs 19.29 or later"))


(byte-code "	>\n !" [cl-19 features error "Tried to load `cl-extra' before `cl'!"] 2)
(defalias 'cl-push '(macro . #[(x place) "		EE" [setq place cons x] 5]))
(defalias 'cl-pop '(macro . #[(place) "\n\n\nDEED" [car prog1 place setq cdr] 7]))
(byte-code "	B" [cl-emacs-type current-load-list] 2)
#@67 Coerce OBJECT to type TYPE.
TYPE is a Common Lisp type specifier.
(defalias 'coerce #[(x type) "= \n< \n\n\"=$ \n!  \n\n!=5 \n;1 \n\n=G \n!C \n\n!=] \n;] \nGU] \nH=o \n9o \n!\"=y \n!\n\" \n\n#" [type list x append nil vector vectorp vconcat string array arrayp character 1 0 coerce symbol-name float typep error "Can't coerce %s to type %s"] 4 (#$ . 798)])
#@218 T if two Lisp objects have similar structures and contents.
This is like `equal', except that it accepts numerically equal
numbers of different types (float vs. integer), and also compares
strings case-insensitively.
(defalias 'equalp #[(x y) "	= ;& 	; G	GU 	% 	4 	 	U:] :R 	:R A@	A@\"9 :? 	\"! 	! G	GU GSY H	H\"t W)	" [x y t equalp vectorp i 0] 4 (#$ . 1226)])
(defalias 'cl-mapcar-many #[(cl-func cl-seqs) "AAz \"\"	!\f!	Wu \f\fc \f@:N \f@@\f@AT \f@	H\fA\fA2 \"\nB	T	% \n.@A@GG^		T	W : A@ 	H: A@ 	H\"\nB *\n+" [cl-seqs nil cl-res apply min mapcar length cl-n 0 cl-i copy-sequence cl-args cl-p1 cl-p2 cl-func cl-y cl-x -1] 6])
#@164 Map a function across one or more sequences, returning a sequence.
TYPE is the sequence type to return, FUNC is the function, and SEQS
are the argument sequences.
(defalias 'map #[(cl-type cl-func cl-seq &rest cl-rest) "\n\f$ \")" [apply mapcar* cl-func cl-seq cl-rest cl-res cl-type coerce] 5 (#$ . 2065)])
#@139 Map FUNC to each sublist of LIST or LISTS.
Like `mapcar', except applies to lists and their cdr's rather than to
the elements themselves.
(defalias 'maplist #[(cl-func cl-list &rest cl-rest) "6 \n!B>1 \"B\f \fA@A! +\nM \n!B\nA= )" [cl-rest nil cl-list copy-sequence cl-p cl-args cl-res apply cl-func] 5 (#$ . 2393)])
#@73 Like `mapcar', but does not accumulate values returned by the function.
(defalias 'mapc #[(cl-func cl-seq &rest cl-rest) " \f% \f\"" [cl-rest apply map nil cl-func cl-seq mapcar] 6 (#$ . 2768)])
#@74 Like `maplist', but does not accumulate values returned by the function.
(defalias 'mapl #[(cl-func cl-list &rest cl-rest) " \f$  \f !A )\f" [cl-rest apply maplist cl-func cl-list cl-p] 6 (#$ . 2985)])
#@74 Like `mapcar', but nconc's together the values returned by the function.
(defalias 'mapcan #[(cl-func cl-seq &rest cl-rest) "\f$\"" [apply nconc mapcar* cl-func cl-seq cl-rest] 7 (#$ . 3215)])
#@75 Like `maplist', but nconc's together the values returned by the function.
(defalias 'mapcon #[(cl-func cl-list &rest cl-rest) "\f$\"" [apply nconc maplist cl-func cl-list cl-rest] 7 (#$ . 3421)])
#@127 Return true if PREDICATE is true of any element of SEQ or SEQs.
If so, return the true (non-nil) value returned by PREDICATE.
(defalias 'some #[(cl-pred cl-seq &rest cl-rest) "	 	< Í	  	A@! )" [cl-rest cl-seq cl-some (byte-code "\f%" [apply map nil #[(&rest cl-x) "	\n\" \")" [apply cl-pred cl-x cl-res throw cl-some] 4] cl-seq cl-rest] 6) nil cl-x cl-pred] 3 (#$ . 3631)])
#@67 Return true if PREDICATE is true of every element of SEQ or SEQs.
(defalias 'every #[(cl-pred cl-seq &rest cl-rest) "	 	< Í	 \f	@! 	A 	?" [cl-rest cl-seq cl-every (byte-code "\f%Ƈ" [apply map nil #[(&rest cl-x) "	\n\" \"" [apply cl-pred cl-x throw cl-every nil] 3] cl-seq cl-rest t] 6) cl-pred] 3 (#$ . 4048)])
#@68 Return true if PREDICATE is false of every element of SEQ or SEQs.
(defalias 'notany #[(cl-pred cl-seq &rest cl-rest) "\n\f$?" [apply some cl-pred cl-seq cl-rest] 5 (#$ . 4395)])
#@67 Return true if PREDICATE is false of some element of SEQ or SEQs.
(defalias 'notevery #[(cl-pred cl-seq &rest cl-rest) "\n\f$?" [apply every cl-pred cl-seq cl-rest] 5 (#$ . 4584)])
(defalias 'cl-map-keymap #[(cl-func cl-map) "9\f K 	= \f\"<W A:U @:8 \f@@@A\" @!H \f@\" @= ɉ )TGWy HZ \fH\"Z )" [cl-map cl-emacs-type lucid map-keymap cl-func cl-p vectorp cl-map-keymap keymap nil -1 cl-i] 5])
(defalias 'cl-map-keymap-recursively #[(cl-func-rec cl-map &optional cl-base) " \n= Ă !\"" [cl-base copy-sequence cl-emacs-type 18 "0" [0] cl-map-keymap #[(cl-key cl-bind) "GS	I!\" = Ȃ C\"#\"" [cl-base cl-key keymapp cl-bind cl-map-keymap-recursively cl-func-rec cl-emacs-type 18 concat vconcat 0] 6] cl-map] 3])
(defalias 'cl-map-intervals #[(cl-func &optional cl-what cl-prop cl-start cl-end) " p! q	! e!\n- \n!) A W ![ V #[ \"f qd)!\f \f^ \f\"0  ,	 	\n G\n	\nW !  	# 	\" \n	\n^\"	) " [cl-what bufferp nil t cl-next2 cl-next cl-mark2 cl-mark copy-marker cl-start cl-end fboundp next-property-change cl-prop next-single-property-change cl-func marker-position 0] 6])
(defalias 'cl-map-overlays #[(cl-func &optional cl-buffer cl-start cl-end cl-arg) " p!| q  !( !)\f@\fAg \f@!` I \f@!Y` V \f@!X` \n\f@\"g \fA3 p Éz É)q e!) q!)É\f!\f \f dW q\f!\f!Ó) \f \f@!\fU \n\f@\" É \fA  ÉÉ," [cl-buffer fboundp overlay-lists nil cl-ovl cl-start copy-marker cl-end overlay-start overlay-end cl-func cl-arg cl-pos cl-mark2 cl-mark marker-position overlays-at next-overlay-change] 5])
(defalias 'cl-set-frame-visible-p #[(frame val) " \n! = \n! \n!" [val make-frame-invisible frame icon iconify-frame make-frame-visible] 2])
(byte-code "	B" [cl-progv-save current-load-list] 2)
(defalias 'cl-progv-before #[(syms values) "7 @! @@JB @\nB, A@A@L  A@!  " [syms boundp cl-progv-save values makunbound] 3])
(defalias 'cl-progv-after #[nil "\" @: @@@AL @!A  " [cl-progv-save makunbound] 2])
#@54 Return the greatest common divisor of the arguments.
(defalias 'gcd #[(&rest args) "	A@\n !	, 	A@!V( \f )\f )" [abs args 0 a b] 4 (#$ . 6940)])
#@52 Return the least common multiple of the arguments.
(defalias 'lcm #[(&rest args) "	> 	A@ !	- 	A@!\f\f\"_) \f)" [0 args abs 1 a b gcd] 4 (#$ . 7115)])
#@49 Return the integer square root of the argument.
(defalias 'isqrt #[(a) "L VL Y Â* Y Ă* Y) ł* 		\\ʥ	WH 	0 	*=T \"" [a 0 1000000 10000 1000 100 10 nil g2 g 2 signal arith-error] 4 (#$ . 7296)])
#@71 Return X raised to the power of Y.  Works only for integer arguments.
(defalias 'cl-expt #[(x y) "X U > ŦU$ % _ť\"_" [y 0 1 x (-1 1) 2 cl-expt] 5 (#$ . 7545)])
(byte-code "! K! \"" [fboundp expt subrp defalias cl-expt] 3)
#@129 Return a list of the floor of X and the fractional part of X.
With two arguments, return floor and remainder of their quotient.
(defalias 'floor* #[(x &optional y) "	\n\"	\n \n_ Z)D" [floor x y q] 5 (#$ . 7819)])
#@133 Return a list of the ceiling of X and the fractional part of X.
With two arguments, return ceiling and remainder of their quotient.
(defalias 'ceiling* #[(x &optional y) "	\n\"A@U  @TA@\n ZD)" [floor* x y res 0 1] 4 (#$ . 8049)])
#@141 Return a list of the integer part of X and the fractional part of X.
With two arguments, return truncation and remainder of their quotient.
(defalias 'truncate* #[(x &optional y) "Y\n? \nY= \n\"\n\"" [x 0 y floor* ceiling*] 3 (#$ . 8301)])
#@139 Return a list of X rounded to the nearest integer and the remainder.
With two arguments, return rounding and remainder of their quotient.
(defalias 'round* #[(x &optional y) "U 	D D ¥	\\\"A@U: \\U: @¦U: @SDB @A@ZD*	!	_Z)D	^ 	D	!	Z)D" [y x 2 hy floor* res 0 round q] 5 (#$ . 8561)])
#@59 The remainder of X divided by Y, with the same sign as Y.
(defalias 'mod* #[(x y) "	\n\"A@" [floor* x y] 3 (#$ . 8902)])
#@59 The remainder of X divided by Y, with the same sign as X.
(defalias 'rem* #[(x y) "	\n\"A@" [truncate* x y] 3 (#$ . 9031)])
#@55 Return 1 if A is positive, -1 if negative, 0 if zero.
(defalias 'signum #[(a) "V W Ç" [a 0 1 -1] 2 (#$ . 9163)])
(byte-code "	B" [*random-state* current-load-list] 2)
#@124 Return a random nonnegative number less than LIM, an integer or float.
Optional second arg STATE is a random-state object.
(defalias 'random* #[(lim &optional state) " 	Hg !ǦZ\n\f\"I\fI\\ϦVS \fZ\fI1 TWf \"S ,HTϦIHTϦI\fH\fHZI\" X  V \"\"\\SW \\T \"W  \") ݥ_," [state *random-state* 3 vec 0 1357335 abs 1357333 1 nil ii k j i make-vector 55 21 200 random* 2 logand 8388607 n lim 512 lsh 9 1023 mask 8388608.0] 7 (#$ . 9354)])
#@143 Return a copy of random-state STATE, or of `*random-state*' if omitted.
If STATE is t, return a new state object seeded from the time of day.
(defalias 'make-random-state #[(&optional state) " \n!! \" $ !" [state make-random-state *random-state* vectorp cl-copy-tree t vector cl-random-state-tag -1 30 cl-random-time] 5 (#$ . 9955)])
#@46 Return t if OBJECT is a random-state object.
(defalias 'random-state-p #[(object) "	! 	GU 	H=" [vectorp object 4 0 cl-random-state-tag] 2 (#$ . 10321)])
(defalias 'cl-finite-do #[(func a b) "" [err (byte-code "	\n\" ĥU? )" [func a b res 2] 4) ((arith-error))] 3])
(byte-code "	B	B	B	B	B	B	B	B" [most-positive-float current-load-list most-negative-float least-positive-float least-negative-float least-positive-normalized-float least-negative-normalized-float float-epsilon float-negative-epsilon] 2)
(defalias 'cl-float-limits #[nil "  É#\" _ ɥ#8 ɥ_\" #J \\8 ɥ#r \\Ur \\ɥR [\f\f_Ϗ ɥɥ [\fԏ ɥ [\\U ɥ \\ZU ɥ \\+Ç" [most-positive-float 20.0 2.0 nil z y x cl-finite-do * 2 + most-negative-float 16 err (byte-code "_U \nV" [x 2 y 0] 3) ((arith-error)) least-positive-normalized-float least-negative-normalized-float 1 (byte-code "V" [x 2 0] 2) ((arith-error)) least-positive-float least-negative-float 1.0 1.0 1.0 float-epsilon 1.0 1.0 1.0 float-negative-epsilon] 6])
#@165 Return the subsequence of SEQ from START to END.
If END is omitted, it defaults to the length of the sequence.
If START or END is negative, it counts from the end.
(defalias 'subseq #[(seq start &optional end) ";\n 	\nO\n \nW \nG\\	W. 	\f, G\\<g 	V= 	\na \nS	YZ A@BD ) ! \nr \fq G\n	Z]\"		\nW 		HI	T		T *)" [seq start end nil len 0 res copy-sequence make-vector i] 5 (#$ . 11541)])
#@68 Concatenate, into a sequence of type TYPE, the argument SEQUENCES.
(defalias 'concatenate #[(type &rest seqs) "= \f\"= \f\"=$ ȉ\f\"\"\"" [type vector apply vconcat seqs string concat list append (nil) error "Not a sequence type name: %s"] 5 (#$ . 12009)])
#@39 Equivalent to (append (reverse X) Y).
(defalias 'revappend #[(x y) "	!\n" [reverse x y] 2 (#$ . 12296)])
#@39 Equivalent to (nconc (nreverse X) Y).
(defalias 'nreconc #[(x y) "	" [x y] 2 (#$ . 12410)])
#@63 Return the length of a list.  Return nil if list is circular.
(defalias 'list-length #[(x) "	A% \n= \fV% \f\\AA\nA 4 A?5 \fT5 \f+" [0 x slow fast n 2] 3 (#$ . 12512)])
#@43 Return true if SUBLIST is a tail of LIST.
(defalias 'tailp #[(sublist list) ": 	= A 	 		=" [list sublist] 3 (#$ . 12711)])
#@225 Make a copy of TREE.
If TREE is a cons cell, this recursively copies both its car and its cdr.
Constrast to copy-sequence, which copies only along the cdrs.  With second
argument VECP, this copies vectors as well as conses.
(defalias 'cl-copy-tree #[(tree &optional vecp) ":C !\n:? \n@:! ) \n@!) \n\n@\"\nA<7 \n\nA\"\nA )p p !p !GSYo H\"IU )" [tree copy-list p vecp vectorp cl-copy-tree copy-sequence i 0] 5 (#$ . 12860)])
(byte-code "! K! \"" [fboundp copy-tree subrp defalias cl-copy-tree] 3)
#@69 Return the value of SYMBOL's PROPNAME property, or DEFAULT if none.
(defalias 'get* #[(sym tag &optional def) "	N- \n- !! \f@	=! \fAA \f+ \fA@, \n)" [sym tag def symbol-plist plist] 3 (#$ . 13433)])
#@128 Search PROPLIST for property PROPNAME; return its value or DEFAULT.
PROPLIST is a list of the sort returned by `symbol-plist'.
(defalias 'getf #[(plist tag &optional def) "\n\"N \f \f#" [setplist --cl-getf-symbol-- plist tag def get*] 4 (#$ . 13655)])
(defalias 'cl-set-getf #[(plist tag val) " 	@\n= 	AA 	\" 	A' \n#)" [plist p tag val list*] 5])
(defalias 'cl-do-remf #[(plist tag) "AA 	A@\n= 	AA 	A% 	AAA)" [plist p tag t] 3])
#@61 Remove from SYMBOL's plist the property PROP and its value.
(defalias 'cl-remprop #[(sym tag) "	! \n@= 	\nAA\"ł \n\")" [symbol-plist sym plist tag setplist t cl-do-remf] 4 (#$ . 14141)])
(byte-code "! K! \"" [fboundp remprop subrp defalias cl-remprop] 3)
#@289 Make an empty Common Lisp-style hash-table.
If :test is `eq', this can use Lucid Emacs built-in hash-tables.
In non-Lucid Emacs, or with non-`eq' test, this internally uses a-lists.
Keywords supported:  :test :size
The Common Lisp keywords :rehash-size and :rehash-threshold are ignored.
(defalias 'make-hash-table #[(&rest cl-keys) "	>A@	 	>A@ =' !' !E V7 \"C !L)F*" [:test cl-keys eql :size 20 cl-size cl-test eq fboundp make-hashtable cl-hash-table-tag 1 make-vector 0 make-symbol "--hashsym--" sym nil] 6 (#$ . 14432)])
(byte-code "!  ! !! !H !	B	" [boundp cl-lucid-hash-tag fboundp make-hashtable vectorp 1 0 make-symbol "--cl-hash-tag--" current-load-list] 3)
#@37 Return t if OBJECT is a hash table.
(defalias 'hash-table-p #[(x) "=% ! GU H=% !% !" [x cl-hash-table-tag vectorp 4 0 cl-lucid-hash-tag fboundp hashtablep] 2 (#$ . 15169)])
(defalias 'cl-not-hash-table #[(x &optional y &rest z) " \fD\"" [signal wrong-type-argument hash-table-p y x] 4])
(defalias 'cl-hash-lookup #[(key table) "= !8A@	\f9) \fJ	 :> !H GVH ˜+ ;\\ =  9k !  V W  !\"H \f\"J		 = =  	 > 	\" 	$	E," [table cl-hash-table-tag cl-not-hash-table 2 array test key str nil sym vectorp 0 equalp symbol-name -8000000 8000000 truncate ["0" "1" "2" "3" "4" "5" "6" "7" "8" "9" "10" "11" "12" "13" "14" "15"] logand 15 "*" intern-soft eq eql (eql equal) assoc assoc* :test] 6])
(byte-code "! ! K! K B!; !8 K!8 K9 B!\\ !Y K!Y KZ 	B!} !z K!z K{ B" [boundp cl-builtin-gethash fboundp gethash subrp cl-not-hash-table current-load-list cl-builtin-remhash remhash cl-builtin-clrhash clrhash cl-builtin-maphash maphash] 2)
#@68 Look up KEY in HASH-TABLE; return corresponding value, or DEFAULT.
(defalias 'cl-gethash #[(key table &optional def) ": \n\"@ @A \f)\n\f#" [table cl-hash-lookup key found def cl-builtin-gethash] 5 (#$ . 16350)])
(defalias (quote gethash) (quote cl-gethash))
(defalias 'cl-puthash #[(key val table) ":o \n\"@ @\fk 8U 88G_VA 8\"	8\"AA	)88\"\n\fBA@BLa 8\n\fBA@BLAAA8T)u \n\f#\f" [table cl-hash-lookup key found val 2 3 make-vector 0 new-table mapatoms #[(sym) "\n!\"\nJL" [intern symbol-name sym new-table] 3] intern puthash] 5])
#@29 Remove KEY from HASH-TABLE.
(defalias 'cl-remhash #[(key table) ":? \n\"@= @A@\"AAA8S85 88\"L; 8L))\n\n#=?\f\n\"" [table cl-hash-lookup key found delq del 3 2 intern t cl-builtin-gethash --cl-- cl-builtin-remhash] 5 (#$ . 16960)])
(defalias (quote remhash) (quote cl-remhash))
#@19 Clear HASH-TABLE.
(defalias 'cl-clrhash #[(table) ":5 ! !89 8L+ AA8G\"AAAƠ: !ć" [table hash-table-p cl-not-hash-table 2 nil make-vector 0 cl-builtin-clrhash] 4 (#$ . 17284)])
(defalias (quote clrhash) (quote cl-clrhash))
#@51 Call FUNCTION on keys and values from HASH-TABLE.
(defalias 'cl-maphash #[(cl-func cl-table) "	!\n 	!	:% 	89  	8!# 	8\"	\"" [hash-table-p cl-table cl-not-hash-table mapatoms #[(cl-x) "J 	@@@A\"A " [cl-x cl-func nil] 4] 2 vector cl-builtin-maphash cl-func] 5 (#$ . 17545)])
(defalias (quote maphash) (quote cl-maphash))
#@45 Return the number of entries in HASH-TABLE.
(defalias 'hash-table-count #[(table) "	!\n 	!	: 	8	!" [hash-table-p table cl-not-hash-table 3 hashtable-fullness] 2 (#$ . 17904)])
#@69 Insert a pretty-printed rendition of a Lisp FORM in current buffer.
(defalias 'cl-prettyprint #[(form) "`!ñ`\nTb	#+ !c ! \nTb *" [nil last pt "\n" prin1-to-string form search-forward "(quote " t delete-backward-char 7 "'" forward-sexp delete-char 1 cl-do-prettyprint] 4 (#$ . 18096)])
(defalias 'cl-do-prettyprint #[nil "w! !% !% !% !% !!. !!7 !!W W  iY  u n !n  | !|  !  ? c  | u), " [" " nil looking-at "(" "((" "(prog" "(unwind-protect " "(function (" "(cl-block-wrapper " "(defun " "(defmacro " "(let\\*? " "(while " "(p?set[qf] " set let two skip forward-sexp 78 backward-sexp t nl 1 cl-do-prettyprint ")" "\n" lisp-indent-line] 6])
(byte-code "! B! B" [boundp cl-macroexpand-cmacs nil current-load-list cl-closure-vars] 2)
#@114 Expand all macro calls through a Lisp FORM.
This also does some trivial optimizations to make the form prettier.
(defalias 'cl-macroexpand-all #[(form &optional env) "\n\"=   !=  :  @> A@6 !B\n\"ɉ!\f @:l !\n\"9^ !\n\")B @\n\"9~  D)\fB\fAF  @= ͂ Ղ @\f!\n\"#+@= @A\"B@= @A@8\n\"!\"$@>A@=!\n\" !~@=~ !\"~!\"%!%\"'( @;1 @=B A @D(B(!!!@#E'(\"%!\"' \"#DE!\"$C#+@! #D)@>@A@!\n\"#@=!A@\n\"@=A\n\":;;@9;!;;:B!:B*@A\n\"B" [form macroexpand env cl-macroexpand-cmacs compiler-macroexpand (let let*) cl-macroexpand-all progn cddr nil cadr lets res letf caar exp t cl-macroexpand-body cdar list* let letf* cond mapcar #[(x) "	\n\"" [cl-macroexpand-body x env] 3] condition-case 2 #[(x) "@A\n\"B" [x cl-macroexpand-body env] 4] cdddr (quote function) lambda cddadr body cl-closure-vars function cl-expr-contains-any gensym new pairlis sub decls interactive quote put last used append list (quote lambda) (quote (&rest --cl-rest--)) sublis (quote apply) (quote quote) cadadr #[(x) "\nE" [list (quote quote) x] 3] ((quote --cl-rest--)) (defun defmacro) setq args p setf] 16 (#$ . 18985)])
(defalias 'cl-macroexpand-body #[(body &optional env) "\n\"" [mapcar #[(x) "	\n\"" [cl-macroexpand-all x env] 3] body] 3])
(defalias 'cl-prettyexpand #[(form &optional full) "!\n\n? \"!!!+" [message "Expanding..." full nil byte-compile-macro-environment cl-compiling-file cl-macroexpand-cmacs cl-macroexpand-all form ((block) (eval-when)) "Formatting..." cl-prettyprint ""] 3])
(run-hooks (quote cl-extra-load-hook))
