WWWWWW

Current Directory: /usr/share/emacs/24.3/lisp/emacs-lisp
Viewing File: /usr/share/emacs/24.3/lisp/emacs-lisp/cl-seq.elc
;ELC
;;; Compiled by mockbuild@buildfarm01-new.corp.cloudlinux.com on Tue Nov 11 12:52:29 2025
;;; from file /builddir/build/BUILD/emacs-24.3/lisp/emacs-lisp/cl-seq.el
;;; in Emacs version 24.3.1
;;; with all optimizations.
;;; Function definitions are lazy-loaded.

;;; 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 'cl-lib)
(defalias 'cl--parsing-keywords '(macro . #[642 #@772 ("\300\301\302\"\303\304=?\205'0\305\306\307\310\311\312\313\314\301\315\303\"\"DE\316\317F\320FEC\"BB\207" . [let* mapcar #[257 "\211:\203\n0\211@\2020\211\300\301\302\303D\304BBDD\305=\203(0\306\307\310E\311BBB\262\312=\203:0\306\307\313E\314BBB\262\315\316\317\320!\321\322O\"!:\203S0\323A@E\202T0D\207" [car cdr memq quote (cl-keys) :test-not and setq cl-test (t) :if-not cl-if (t) intern format "cl-%s" symbol-name 1 nil or] 9 "\n\n(fn X)"] append t let ((cl-keys-temp cl-keys)) while cl-keys-temp or memq (car cl-keys-temp) quote #[257 "\211:\2030\211@\207\207" [] 2 "\n\n(fn X)"] (car (cdr (memq ':allow-other-keys cl-keys))) (error "Bad keyword argument %s" (car cl-keys-temp)) (setq cl-keys-temp (cdr (cdr cl-keys-temp)))])(#$ . 669) nil 19 "\n\n(fn KWORDS OTHER-KEYS &rest BODY)"]))
(byte-code "\300\301\302\303#\210\300\301\304\305#\207" [put cl--parsing-keywords lisp-indent-function 2 edebug-form-spec (sexp sexp &rest form)] 4)
(defalias 'cl--check-key '(macro . #[257 #@52 ("\300\301\302\301EF\207" . [if cl-key funcall])(#$ . 1696) nil 6 "\n\n(fn X)"]))
(put 'cl--check-key 'edebug-form-spec 'edebug-forms)
(defalias 'cl--check-test-nokey '(macro . #[514 #@163 ("\300\301\302\303\304\301FD\305BBD\306\302\303\304\306ED\307BBD\310\311EDF\207" . [cond cl-test eq not funcall (cl-test-not) cl-if (cl-if-not) t eql])(#$ . 1888) nil 10 "\n\n(fn ITEM X)"]))
(put 'cl--check-test-nokey 'edebug-form-spec 'edebug-forms)
(defalias 'cl--check-test '(macro . #[514 #@61 ("\300\301DE\207" . [cl--check-test-nokey cl--check-key])(#$ . 2197) nil 6 "\n\n(fn ITEM X)"]))
(put 'cl--check-test 'edebug-form-spec 'edebug-forms)
(defalias 'cl--check-match '(macro . #[514 #@140 ("\300D\262\300D\262\301\302\303\304\305\302FD\306BB\307EF\207" . [cl--check-key if cl-test eq not funcall (cl-test-not) eql])(#$ . 2399) nil 10 "\n\n(fn X Y)"]))
(put 'cl--check-match 'edebug-form-spec 'edebug-forms)
#@144 Reduce two-argument FUNCTION across SEQ.

Keywords supported:  :start :end :from-end :initial-value :key

(fn FUNCTION SEQ [KEYWORD VALUE]...)
(defalias 'cl-reduce #[642 #@661 ("\301>A@\302>A@\2060\303\304>A@\305>A@\306>A@\211\203A0\211@\307>\20490\310>A@\20490\311\312@\"\210\211AA\262\202_0\210<\204N0\313\314\"\262\315#\262\203^0\237\262\305>\203h0\211\202\2100\203\2050\203|0\211A\262@!\202\2100\211A\262@\202\2100 \203\2610\203\3260\203\2430\211A\262\n@!\202\2520\211A\262	@\"\262\202\2140\203\3260\203\3110	\211A\262@!\202\3200\211A\262\n@\"\262\202\2610\211\262)\207" . [cl-key :from-end :start 0 :end :initial-value :key (:from-end :start :end :initial-value :key) :allow-other-keys error "Bad keyword argument %s" append nil cl-subseq])(#$ . 2813) nil 13 (#$ . 2636)])
#@105 Fill the elements of SEQ with ITEM.

Keywords supported:  :start :end

(fn SEQ ITEM [KEYWORD VALUE]...)
(defalias 'cl-fill #[642 #@455 ("\300>A@\206	0\301\302>A@\211\20300\211@\303>\204(0\304>A@\204(0\305\306@\"\210\211AA\262\2020\210<\203c0\233\203C0Z\202D0\307\203^0\211S\211\262\301Y\203^0\240\210A\262\202D0\266\202\2220\211\204k0G\262\301U\203\2000\211GU\203\2000\310\"\210\202\2220W\203\2220I\210T\262\202\2000\207" . [:start 0 :end (:start :end) :allow-other-keys error "Bad keyword argument %s" 8000000 fillarray])(#$ . 3648) nil 9 (#$ . 3512)])
#@189 Replace the elements of SEQ1 with the elements of SEQ2.
SEQ1 is destructively modified, then returned.

Keywords supported:  :start1 :end1 :start2 :end2

(fn SEQ1 SEQ2 [KEYWORD VALUE]...)
(defalias 'cl-replace #[642 #@873 ("\300>A@\206	0\301\302>A@\303>A@\2060\301\304>A@\211\203?0\211@\305>\20470\306>A@\20470\307\310@\"\210\211AA\262\2020\210=\203\2100X\203\2100U\204^G\206\\0\211Z\206c0Z^\211S\211\262\301Y\203\2030\311	\\\n\\\234#\210\202f0\266\202^<\203\n\233\203\2340Z\202\2350\312<\203\3340\233\203\2630Z\202\2640\312^\203\3270\203\3270\211S\211\262\301Y\203\3270@\240\210A\262A\262\202\2650\266\202\206\3430G\\^\262\203W\203H\240\210A\262T\262\202\3510\266\202^\206G\206GZ\\^\262<\203D\233W\203@@I\210\211A\262T\262\202(\210\202^W\203^HI\210T\262T\262\202D\207" . [:start1 0 :end1 :start2 :end2 (:start1 :end1 :start2 :end2) :allow-other-keys error "Bad keyword argument %s" cl--set-elt 4000000])(#$ . 4363) nil 15 (#$ . 4140)])
#@256 Remove all occurrences of ITEM in SEQ.
This is a non-destructive function; it makes a copy of SEQ if necessary
to avoid corrupting the original SEQ.

Keywords supported:  :test :test-not :key :count :start :end :from-end

(fn ITEM SEQ [KEYWORD VALUE]...)
(defalias 'cl-remove #[642 #@1534 ("\305>A@\306>A@\2050\306>A@\211\2050\307\310>A@\311>A@\312>A@\20590\312>A@\211\20590\307\313>A@\314>A@\315>A@\206M0\316\317>A@\211\203u0\211@\320>\204m0\321>A@\204m0\322\323@\"\210\211AA\262\202S0\210\206~0\324\211\262\316X\203\2070\202\"<\203\2260\203\3500\325W\203\3500\326%\211\203\3410\327\330	\331\n\332\"\331\203\2730\317TD\202\2770\315D\"$<\203\3150\211\202\3340;\203\3310\211\260\202\3340\333!\262\202\3430\262\202\"\211\206\3550\324Z\262\316U\203e\203e\211\316V\203e\203\n\203\n@!\202@\"?	=\202L\2039\n\203/\n@!\2022@!?\f=\202L\334\n\203H\n@!\202K@\"\203e\211S\262A\211\262\203eS\211\262\316V\204\3670\316V\203!\211\316V\203!\316V\203~\233\202\204\211S\262A\211\203\341\316V\203\341\203\251\n\203\240\n@!\202\242@\"?	=\202\323\203\302\n\203\271\n@!\202\273@!?\f=\202\323\334\n\203\320\n@!\202\322@\"\204\341\211A\262S\262\202\204\211\203\316V\203\335\"\336U\203\373A\202A\205\327\330\n\337A!\315\316\317	S\313S&\n\244\202\262\202\"-\207" . [cl-test cl-test-not cl-key cl-if cl-if-not :test :test-not t :key :if :if-not :count :from-end :start 0 :end (:test :test-not :key :if :if-not :count :from-end :start :end) :allow-other-keys error "Bad keyword argument %s" 8000000 4000000 cl--position apply cl-delete append nil vconcat eql cl-ldiff 1 copy-sequence])(#$ . 5564) nil 20 (#$ . 5274)])
#@252 Remove all items satisfying PREDICATE in SEQ.
This is a non-destructive function; it makes a copy of SEQ if necessary
to avoid corrupting the original SEQ.

Keywords supported:  :key :count :start :end :from-end

(fn PREDICATE SEQ [KEYWORD VALUE]...)
(defalias 'cl-remove-if #[642 #@61 ("\300\301\302\303&\207" . [apply cl-remove nil :if])(#$ . 7423) nil 10 (#$ . 7136)])
#@256 Remove all items not satisfying PREDICATE in SEQ.
This is a non-destructive function; it makes a copy of SEQ if necessary
to avoid corrupting the original SEQ.

Keywords supported:  :key :count :start :end :from-end

(fn PREDICATE SEQ [KEYWORD VALUE]...)
(defalias 'cl-remove-if-not #[642 #@65 ("\300\301\302\303&\207" . [apply cl-remove nil :if-not])(#$ . 7817) nil 10 (#$ . 7522)])
#@226 Remove all occurrences of ITEM in SEQ.
This is a destructive function; it reuses the storage of SEQ whenever possible.

Keywords supported:  :test :test-not :key :count :start :end :from-end

(fn ITEM SEQ [KEYWORD VALUE]...)
(defalias 'cl-delete #[642 #@1427 ("\305>A@\306>A@\2050\306>A@\211\2050\307\310>A@\311>A@\312>A@\20590\312>A@\211\20590\307\313>A@\314>A@\315>A@\206M0\316\317>A@\211\203u0\211@\320>\204m0\321>A@\204m0\322\323@\"\210\211AA\262\202S0\210\206~0\324\211\262\316X\203\2070\202\370<\203\357\203\3300\325W\203\3300\326S\211\262\316Y\203\3210\327%\211\262\203\3210\211\316U\203\2770A\262\202\3130\211S\233\211AA\241\266\211\262\202\2270\262\202\370\211\206\3350\324Z\262\316U\203\\\203U\211\316V\203U\203\n\203\n@!\202@\"?	=\202<\203)\n\203_\n@!\202\"@!?\f=\202<\330\n\2038\n@!\202;@\"\203U\211S\262A\211\262\203US\211\262\316V\204\3470\211S\262\202`S\262\316V\203\353\211\316V\203\353\233\211A\203\352\316V\203\352\203\230\n\203\216\nA@!\202\221A@\"?	=\202\306\203\263\n\203\251\nA@!\202\254A@!?\f=\202\306\330\n\203\302\nA@!\202\305A@\"\203\337\211AA\241\210S\211\262\316U\203\343\331\262\202\343\211A\262S\262\202p\210\202\370\332\333$-\207" . [cl-test cl-test-not cl-key cl-if cl-if-not :test :test-not t :key :if :if-not :count :from-end :start 0 :end (:test :test-not :key :if :if-not :count :from-end :start :end) :allow-other-keys error "Bad keyword argument %s" 8000000 4000000 nil cl--position eql 1 apply cl-remove])(#$ . 8180) nil 14 (#$ . 7920)])
#@222 Remove all items satisfying PREDICATE in SEQ.
This is a destructive function; it reuses the storage of SEQ whenever possible.

Keywords supported:  :key :count :start :end :from-end

(fn PREDICATE SEQ [KEYWORD VALUE]...)
(defalias 'cl-delete-if #[642 #@61 ("\300\301\302\303&\207" . [apply cl-delete nil :if])(#$ . 9902) nil 10 (#$ . 9645)])
#@226 Remove all items not satisfying PREDICATE in SEQ.
This is a destructive function; it reuses the storage of SEQ whenever possible.

Keywords supported:  :key :count :start :end :from-end

(fn PREDICATE SEQ [KEYWORD VALUE]...)
(defalias 'cl-delete-if-not #[642 #@65 ("\300\301\302\303&\207" . [apply cl-delete nil :if-not])(#$ . 10266) nil 10 (#$ . 10001)])
#@153 Return a copy of SEQ with all duplicate elements removed.

Keywords supported:  :test :test-not :key :start :end :from-end

(fn SEQ [KEYWORD VALUE]...)
(defalias 'cl-remove-duplicates #[385 #@49 ("\300\301#\207" . [cl--delete-duplicates t])(#$ . 10567) nil 6 (#$ . 10371)])
#@151 Remove all duplicate elements from SEQ (destructively).

Keywords supported:  :test :test-not :key :start :end :from-end

(fn SEQ [KEYWORD VALUE]...)
(defalias 'cl-delete-duplicates #[385 #@51 ("\300\301#\207" . [cl--delete-duplicates nil])(#$ . 10849) nil 6 (#$ . 10655)])
(defalias 'cl--delete-duplicates #[771 #@1152 ("<\203\203\304>A@\305>A@\2050\305>A@\211\2050\306\307>A@\310>A@\206.0\311\312>A@\313>A@\314>A@\211\203a0\211@\315>\204Y0\316>A@\204Y0\317\320@\"\210\211AA\262\202?0\210\211\203\3240\233\321\206r0GZ\262\322V\203\3150\311\262\323\n\203\2130\n@!\202\2150@AS$\211\262\203\2760\203\2550\324!\262\233\262\321\262\211\233\211AA\241\266S\262\2020A\262S\262T\262\202v0\266\202\202\201\206\3320GZ\262A\203\311U\203\322V\203\323\n\203\3740\n@!\202\3770@A\311S$\203A\262S\262\202\3360\311V\203\"S\233\202*S\262\322\262\211AA\203}\322V\203}\323\n\203C\nA@!\202FA@AA\311S$\203n\203e\324!\262S\233\262\321\262\211AA\241\210\202r\211A\262S\262T\262\202*\262,\207\325\326\321\"\321#;\203\226\211\260\202\231\327!\207" . [cl-test cl-test-not cl-key cl-if :test :test-not t :key :start 0 :end :from-end :if (:test :test-not :key :start :end :from-end :if) :allow-other-keys error "Bad keyword argument %s" nil 1 cl--position copy-sequence cl--delete-duplicates append vconcat])(#$ . 10979) nil 13 "\n\n(fn CL-SEQ CL-KEYS CL-COPY)"])
#@251 Substitute NEW for OLD in SEQ.
This is a non-destructive function; it makes a copy of SEQ if necessary
to avoid corrupting the original SEQ.

Keywords supported:  :test :test-not :key :count :start :end :from-end

(fn NEW OLD SEQ [KEYWORD VALUE]...)
(defalias 'cl-substitute #[899 #@760 ("\305>A@\306>A@\2050\306>A@\211\2050\307\310>A@\311>A@\312>A@\20590\312>A@\211\20590\307\313>A@\314>A@\206H0\315\316>A@\317>A@\211\203u0\211@\320>\204m0\321>A@\204m0\322\323@\"\210\211AA\262\202S0\210=\204\2160\206\2110\324\262\325\211\262\315X\203\2220\202\3210\326$\211\204\2430\202\3170\327!\262\204\2750\330#\210\211T\262S\262\331\332\n\n\n\313\n\314&	\262-\207" . [cl-test cl-test-not cl-key cl-if cl-if-not :test :test-not t :key :if :if-not :count :start 0 :end :from-end (:test :test-not :key :if :if-not :count :start :end :from-end) :allow-other-keys error "Bad keyword argument %s" nil 8000000 cl--position copy-sequence cl--set-elt apply cl-nsubstitute])(#$ . 12480) nil 19 (#$ . 12192)])
#@268 Substitute NEW for all items satisfying PREDICATE in SEQ.
This is a non-destructive function; it makes a copy of SEQ if necessary
to avoid corrupting the original SEQ.

Keywords supported:  :key :count :start :end :from-end

(fn NEW PREDICATE SEQ [KEYWORD VALUE]...)
(defalias 'cl-substitute-if #[899 #@66 ("\300\301\302\303&\207" . [apply cl-substitute nil :if])(#$ . 13587) nil 12 (#$ . 13280)])
#@272 Substitute NEW for all items not satisfying PREDICATE in SEQ.
This is a non-destructive function; it makes a copy of SEQ if necessary
to avoid corrupting the original SEQ.

Keywords supported:  :key :count :start :end :from-end

(fn NEW PREDICATE SEQ [KEYWORD VALUE]...)
(defalias 'cl-substitute-if-not #[899 #@70 ("\300\301\302\303&\207" . [apply cl-substitute nil :if-not])(#$ . 14008) nil 12 (#$ . 13693)])
#@221 Substitute NEW for OLD in SEQ.
This is a destructive function; it reuses the storage of SEQ whenever possible.

Keywords supported:  :test :test-not :key :count :start :end :from-end

(fn NEW OLD SEQ [KEYWORD VALUE]...)
(defalias 'cl-nsubstitute #[899 #@1360 ("\305>A@\306>A@\2050\306>A@\211\2050\307\310>A@\311>A@\312>A@\20590\312>A@\211\20590\307\313>A@\314>A@\206H0\315\316>A@\317>A@\211\203u0\211@\320>\204m0\321>A@\204m0\322\323@\"\210\211AA\262\202S0\210=\204	\206\2060\324\211\262\315X\204	<\203\211\203\2320\325V\203\233\206\2430\324Z\262\211\203\315V\203\315V\203\203\3220\n\203\3110\n@!\202\3130@\"?	=\202\3740\203\3530\n\203\3420\n@!\202\3440@!?\f=\202\3740\326\n\203\3710\n@!\202\3730@\"\203\211	\240\210S\262\211A\262S\262\202\2470\210\202	\204_G\262\211\203\226W\203	\315V\203	S\262\203R\n\203G\n\234!\202K\234\"?	=\202\204\203o\n\203d\n\234!\202h\234!?\f=\202\204\326\n\203\n\234!\202\203\234\"\203#\327\n#\210S\262\202#W\203	\315V\203	\203\302\n\203\267\nH!\202\273H\"?	=\202\365\203\337\n\203\324\nH!\202\330H!?\f=\202\365\326\n\203\360\nH!\202\364H\"\203	I\210S\262T\262\202\226-\207" . [cl-test cl-test-not cl-key cl-if cl-if-not :test :test-not t :key :if :if-not :count :start 0 :end :from-end (:test :test-not :key :if :if-not :count :start :end :from-end) :allow-other-keys error "Bad keyword argument %s" 8000000 4000000 eql cl--set-elt])(#$ . 14378) nil 13 (#$ . 14118)])
#@238 Substitute NEW for all items satisfying PREDICATE in SEQ.
This is a destructive function; it reuses the storage of SEQ whenever possible.

Keywords supported:  :key :count :start :end :from-end

(fn NEW PREDICATE SEQ [KEYWORD VALUE]...)
(defalias 'cl-nsubstitute-if #[899 #@67 ("\300\301\302\303&\207" . [apply cl-nsubstitute nil :if])(#$ . 16056) nil 12 (#$ . 15778)])
#@242 Substitute NEW for all items not satisfying PREDICATE in SEQ.
This is a destructive function; it reuses the storage of SEQ whenever possible.

Keywords supported:  :key :count :start :end :from-end

(fn NEW PREDICATE SEQ [KEYWORD VALUE]...)
(defalias 'cl-nsubstitute-if-not #[899 #@71 ("\300\301\302\303&\207" . [apply cl-nsubstitute nil :if-not])(#$ . 16449) nil 12 (#$ . 16163)])
#@189 Find the first occurrence of ITEM in SEQ.
Return the matching ITEM, or nil if not found.

Keywords supported:  :test :test-not :key :start :end :from-end

(fn ITEM SEQ [KEYWORD VALUE]...)
(defalias 'cl-find #[642 #@62 ("\300\301$\211\205
0\234\207" . [apply cl-position])(#$ . 16779) nil 8 (#$ . 16560)])
#@185 Find the first item satisfying PREDICATE in SEQ.
Return the matching item, or nil if not found.

Keywords supported:  :key :start :end :from-end

(fn PREDICATE SEQ [KEYWORD VALUE]...)
(defalias 'cl-find-if #[642 #@59 ("\300\301\302\303&\207" . [apply cl-find nil :if])(#$ . 17098) nil 10 (#$ . 16880)])
#@189 Find the first item not satisfying PREDICATE in SEQ.
Return the matching item, or nil if not found.

Keywords supported:  :key :start :end :from-end

(fn PREDICATE SEQ [KEYWORD VALUE]...)
(defalias 'cl-find-if-not #[642 #@63 ("\300\301\302\303&\207" . [apply cl-find nil :if-not])(#$ . 17423) nil 10 (#$ . 17197)])
#@202 Find the first occurrence of ITEM in SEQ.
Return the index of the matching item, or nil if not found.

Keywords supported:  :test :test-not :key :start :end :from-end

(fn ITEM SEQ [KEYWORD VALUE]...)
(defalias 'cl-position #[642 #@482 ("\305>A@\306>A@\2050\306>A@\211\2050\307\310>A@\311>A@\312>A@\20590\312>A@\211\20590\307\313>A@\206C0\314\315>A@\316>A@\211\203o0\211@\317>\204g0\320>A@\204g0\321\322@\"\210\211AA\262\202N0\210\323%-\207" . [cl-test cl-test-not cl-key cl-if cl-if-not :test :test-not t :key :if :if-not :start 0 :end :from-end (:test :test-not :key :if :if-not :start :end :from-end) :allow-other-keys error "Bad keyword argument %s" cl--position])(#$ . 17763) nil 12 (#$ . 17526)])
(defalias 'cl--position #[1283 #@720 ("<\203|0\233\2040\305\262\306\203x0W\203x0\211\203\"0\203x0\203=0	\20340	@!\20260@\"?\n=\202g0\203V0	\203M0	@!\202O0@!?\f=\202g0\307	\203d0	@!\202f0@\"\203m0\262A\262T\262\2020\211\262\207\204\2040G\262\211\203\3500S\211\262Y\203\3400\203\2570	\203\2450	H!\202\2500H\"?\n=\202\3350\203\3120	\203\3000	H!\202\3030H!?\f=\202\3350\307	\203\3310	H!\202\3340H\"\203\2100Y\205L\207W\203E\203\f	\203	H!\202H\"?\n=\202;\203'	\203	H!\202 H!?\f=\202;\307	\2037	H!\202:H\"\204ET\262\202\3500W\205L\207" . [cl-test cl-key cl-test-not cl-if cl-if-not 8000000 nil eql])(#$ . 18316) nil 11 "\n\n(fn CL-ITEM CL-SEQ CL-START &optional CL-END CL-FROM-END)"])
#@198 Find the first item satisfying PREDICATE in SEQ.
Return the index of the matching item, or nil if not found.

Keywords supported:  :key :start :end :from-end

(fn PREDICATE SEQ [KEYWORD VALUE]...)
(defalias 'cl-position-if #[642 #@63 ("\300\301\302\303&\207" . [apply cl-position nil :if])(#$ . 19362) nil 10 (#$ . 19127)])
#@202 Find the first item not satisfying PREDICATE in SEQ.
Return the index of the matching item, or nil if not found.

Keywords supported:  :key :start :end :from-end

(fn PREDICATE SEQ [KEYWORD VALUE]...)
(defalias 'cl-position-if-not #[642 #@67 ("\300\301\302\303&\207" . [apply cl-position nil :if-not])(#$ . 19708) nil 10 (#$ . 19465)])
#@138 Count the number of occurrences of ITEM in SEQ.

Keywords supported:  :test :test-not :key :start :end

(fn ITEM SEQ [KEYWORD VALUE]...)
(defalias 'cl-count #[642 #@731 ("\305>A@\306>A@\2050\306>A@\211\2050\307\310>A@\311>A@\312>A@\20590\312>A@\211\20590\307\313>A@\206C0\314\315>A@\211\203j0\211@\316>\204b0\317>A@\204b0\320\321@\"\210\211AA\262\202I0\210\314\322\204u0G\262:\203\2000\233\262W\203\3460:\203\2240\211A\262@\202\2270H\262\203\2620\n\203\2520\n!\202\2530\"?	=\202\3300\203\3110\n\203\3010\n!\202\3020!?\f=\202\3300\323\n\203\3260\n!\202\3270\"\203\3370T\262T\262\202\2000\266\202-\207" . [cl-test cl-test-not cl-key cl-if cl-if-not :test :test-not t :key :if :if-not :start 0 :end (:test :test-not :key :if :if-not :start :end) :allow-other-keys error "Bad keyword argument %s" nil eql])(#$ . 19985) nil 11 (#$ . 19815)])
#@134 Count the number of items satisfying PREDICATE in SEQ.

Keywords supported:  :key :start :end

(fn PREDICATE SEQ [KEYWORD VALUE]...)
(defalias 'cl-count-if #[642 #@60 ("\300\301\302\303&\207" . [apply cl-count nil :if])(#$ . 20924) nil 10 (#$ . 20756)])
#@138 Count the number of items not satisfying PREDICATE in SEQ.

Keywords supported:  :key :start :end

(fn PREDICATE SEQ [KEYWORD VALUE]...)
(defalias 'cl-count-if-not #[642 #@64 ("\300\301\302\303&\207" . [apply cl-count nil :if-not])(#$ . 21200) nil 10 (#$ . 21024)])
#@322 Compare SEQ1 with SEQ2, return index of first mismatching element.
Return nil if the sequences match.  If one sequence is a prefix of the
other, the return value indicates the end of the shorter sequence.

Keywords supported:  :test :test-not :key :start1 :end1 :start2 :end2 :from-end

(fn SEQ1 SEQ2 [KEYWORD VALUE]...)
(defalias 'cl-mismatch #[642 #@1244 ("\303>A@\304>A@\2050\304>A@\211\2050\305\306>A@\307>A@\310>A@\206.0\311\312>A@\313>A@\206<0\311\314>A@\211\203d0\211@\315>\204\\0\316>A@\204\\0\317\320@\"\210\211AA\262\202B0\210\204n0G\262\211\204w0G\262\2030W\203\3570W\203\3570\203\2710\n\203\2320\n	S\234!\202\2370S\234\n\203\2550\n	S\234!\202\2620S\234\"?	=\202\3410\321\n\203\3100\n	S\234!\202\3150S\234\n\203\3330\n	S\234!\202\3400S\234\"\203\3570S\262\211S\262\202{0W\204\3730W\205\347S\202\347<\205\n\233<\205\233W\203\330W\203\330\203v\n\203<\n\2033@\2028H!\202J\203E@\202J\nH\n\203a\n\203X@\202]H!\202o\203j@\202o\nH\"?	=\202\302\321\n\203\216\n\203\205@\202\212H!\202\234\203\227@\202\234\nH\n\203\263\n\203\252@\202\257H!\202\301\203\274@\202\301\nH\"\203\330A\262\211A\262T\262T\262\202W\204\344W\205\345\266\202+\207" . [cl-test cl-test-not cl-key :test :test-not t :key :from-end :start1 0 :end1 :start2 :end2 (:test :test-not :key :from-end :start1 :end1 :start2 :end2) :allow-other-keys error "Bad keyword argument %s" eql])(#$ . 21662) nil 15 (#$ . 21304)])
#@262 Search for SEQ1 as a subsequence of SEQ2.
Return the index of the leftmost element of the first match found;
return nil if there are no matches.

Keywords supported:  :test :test-not :key :start1 :end1 :start2 :end2 :from-end

(fn SEQ1 SEQ2 [KEYWORD VALUE]...)
(defalias 'cl-search #[642 #@806 ("\304>A@\305>A@\2050\305>A@\211\2050\306\307>A@\310>A@\311>A@\206.0\312\313>A@\314>A@\206<0\312\315>A@\211\203d0\211@\316>\204\\0\317>A@\204\\0\320\321@\"\210\211AA\262\202B0\210\204n0G\262\211\204w0G\262Y\203\2110\203\2050\211\202\3720\202\3720Z\n\203\2320\n	\234!\202\2360\234\322\211SZ\262W\203\3600\323\f%\211\262\203\3600\324\325\f\f\311T\313\f\314	T\315\\\310\322&\203\3600\203\3510\211\262\202\2470\211T\262\202\2470W\205\3670\211)\266\203+\207" . [cl-test cl-test-not cl-key cl-if :test :test-not t :key :from-end :start1 0 :end1 :start2 :end2 (:test :test-not :key :from-end :start1 :end1 :start2 :end2) :allow-other-keys error "Bad keyword argument %s" nil cl--position apply cl-mismatch])(#$ . 23241) nil 27 (#$ . 22946)])
#@187 Sort the argument SEQ according to PREDICATE.
This is a destructive function; it reuses the storage of SEQ if possible.

Keywords supported:  :key

(fn SEQ PREDICATE [KEYWORD VALUE]...)
(defalias 'cl-sort #[642 #@439 ("<\2040\301\302\303\304\305\"$\"\207\306>A@\211\211\203=0\211@\307>\20450\310>A@\20450\311\312@\"\210\211AA\262\2020\210\313>\203K0\314\"\202[0\314\315\316\317\320\321!\322\"\323\324%\")\207" . [cl-key cl-replace apply cl-sort append nil :key (:key) :allow-other-keys error "Bad keyword argument %s" (nil identity) sort make-byte-code 514 "\300	!	!\"\207" vconcat vector [cl-key] 6 "\n\n(fn CL-X CL-Y)"])(#$ . 24305) nil 11 (#$ . 24087)])
#@194 Sort the argument SEQ stably according to PREDICATE.
This is a destructive function; it reuses the storage of SEQ if possible.

Keywords supported:  :key

(fn SEQ PREDICATE [KEYWORD VALUE]...)
(defalias 'cl-stable-sort #[642 #@40 ("\300\301$\207" . [apply cl-sort])(#$ . 25015) nil 8 (#$ . 24784)])
#@284 Destructively merge the two sequences to produce a new sequence.
TYPE is the sequence type to return, SEQ1 and SEQ2 are the two argument
sequences, and PREDICATE is a `less-than' predicate on the elements.

Keywords supported:  :key

(fn TYPE SEQ1 SEQ2 PREDICATE [KEYWORD VALUE]...)
(defalias 'cl-merge #[1156 #@418 ("<\2040\301\302\"\262<\2040\301\302\"\262\303>A@\211\211\203>0\211@\304>\20460\305>A@\20460\306\307@\"\210\211AA\262\2020\210\302\203\2030\203\2030\203T0@!\202V0@\203b0@!\202e0@\"\203v0\211A\262@B\262\202@0\211A\262@B\262\202@0\310\237\244\244\"\262)\207" . [cl-key append nil :key (:key) :allow-other-keys error "Bad keyword argument %s" cl-coerce])(#$ . 25411) nil 10 (#$ . 25094)])
#@168 Find the first occurrence of ITEM in LIST.
Return the sublist of LIST whose car is ITEM.

Keywords supported:  :test :test-not :key

(fn ITEM LIST [KEYWORD VALUE]...)
(defalias 'cl-member #[642 #@622 ("\211\203\2650\305>A@\306>A@\2050\306>A@\211\2050\307\310>A@\311>A@\312>A@\205=0\312>A@\211\205=0\307\211\211\203`0\211@\313>\204X0\314>A@\204X0\315\316@\"\210\211AA\262\202?0\210\203\2620\2030\n\203v0\n@!\202x0@\"?	=\202\2500\203\2300\n\203\2170\n@!\202\2210@!?\f=\202\2500\317\n\203\2450\n@!\202\2470@\"\204\2620A\262\202a0-\207\247\203\3030\250\204\3030\235\207>\207" . [cl-test cl-test-not cl-key cl-if cl-if-not :test :test-not t :key :if :if-not (:test :test-not :key :if :if-not) :allow-other-keys error "Bad keyword argument %s" eql])(#$ . 26070) nil 7 (#$ . 25869)])
(byte-code "\300\301\302\303#\210\304\303\305\"\207" [put cl-member compiler-macro cl--compiler-macro-member autoload "cl-macs"] 4)
#@164 Find the first item satisfying PREDICATE in LIST.
Return the sublist of LIST whose car matches.

Keywords supported:  :key

(fn PREDICATE LIST [KEYWORD VALUE]...)
(defalias 'cl-member-if #[642 #@61 ("\300\301\302\303&\207" . [apply cl-member nil :if])(#$ . 27062) nil 10 (#$ . 26863)])
#@168 Find the first item not satisfying PREDICATE in LIST.
Return the sublist of LIST whose car matches.

Keywords supported:  :key

(fn PREDICATE LIST [KEYWORD VALUE]...)
(defalias 'cl-member-if-not #[642 #@65 ("\300\301\302\303&\207" . [apply cl-member nil :if-not])(#$ . 27370) nil 10 (#$ . 27163)])
(defalias 'cl--adjoin #[642 #@99 ("\301>A@\302\303\2030!\2020$)\2030\207B\207" . [cl-key :key apply cl-member])(#$ . 27502) nil 8 "\n\n(fn CL-ITEM CL-LIST &rest CL-KEYS)"])
#@131 Find the first item whose car matches ITEM in LIST.

Keywords supported:  :test :test-not :key

(fn ITEM LIST [KEYWORD VALUE]...)
(defalias 'cl-assoc #[642 #@672 ("\211\203\3060\305>A@\306>A@\2050\306>A@\211\2050\307\310>A@\311>A@\312>A@\205=0\312>A@\211\205=0\307\211\211\203`0\211@\313>\204X0\314>A@\204X0\315\316@\"\210\211AA\262\202?0\210\203\2760@:\203\2670\203\2070\n\203}0\n@@!\202\2000@@\"?	=\202\2640\203\2420\n\203\2300\n@@!\202\2330@@!?\f=\202\2640\317\n\203\2600\n@@!\202\2630@@\"\204\2760A\262\202a0\205\3040@-\207\247\203\3250\250\204\3250\320\"\207\236\207" . [cl-test cl-test-not cl-key cl-if cl-if-not :test :test-not t :key :if :if-not (:test :test-not :key :if :if-not) :allow-other-keys error "Bad keyword argument %s" eql assoc])(#$ . 27831) nil 7 (#$ . 27668)])
(byte-code "\300\301\302\303#\210\304\303\305\"\207" [put cl-assoc compiler-macro cl--compiler-macro-assoc autoload "cl-macs"] 4)
#@127 Find the first item whose car satisfies PREDICATE in LIST.

Keywords supported:  :key

(fn PREDICATE LIST [KEYWORD VALUE]...)
(defalias 'cl-assoc-if #[642 #@60 ("\300\301\302\303&\207" . [apply cl-assoc nil :if])(#$ . 28833) nil 10 (#$ . 28672)])
#@134 Find the first item whose car does not satisfy PREDICATE in LIST.

Keywords supported:  :key

(fn PREDICATE LIST [KEYWORD VALUE]...)
(defalias 'cl-assoc-if-not #[642 #@64 ("\300\301\302\303&\207" . [apply cl-assoc nil :if-not])(#$ . 29105) nil 10 (#$ . 28933)])
#@131 Find the first item whose cdr matches ITEM in LIST.

Keywords supported:  :test :test-not :key

(fn ITEM LIST [KEYWORD VALUE]...)
(defalias 'cl-rassoc #[642 #@649 ("\211\204	0\247\203\3130\305>A@\306>A@\205\"0\306>A@\211\205\"0\307\310>A@\311>A@\312>A@\205B0\312>A@\211\205B0\307\211\211\203e0\211@\313>\204]0\314>A@\204]0\315\316@\"\210\211AA\262\202D0\210\203\3030@:\203\2740\203\2140\n\203\2020\n@A!\202\2050@A\"?	=\202\2710\203\2470\n\203\2350\n@A!\202\2400@A!?\f=\202\2710\317\n\203\2650\n@A!\202\2700@A\"\204\3030A\262\202f0\205\3110@-\207\320\"\207" . [cl-test cl-test-not cl-key cl-if cl-if-not :test :test-not t :key :if :if-not (:test :test-not :key :if :if-not) :allow-other-keys error "Bad keyword argument %s" eql rassq])(#$ . 29373) nil 7 (#$ . 29209)])
#@127 Find the first item whose cdr satisfies PREDICATE in LIST.

Keywords supported:  :key

(fn PREDICATE LIST [KEYWORD VALUE]...)
(defalias 'cl-rassoc-if #[642 #@61 ("\300\301\302\303&\207" . [apply cl-rassoc nil :if])(#$ . 30223) nil 10 (#$ . 30061)])
#@134 Find the first item whose cdr does not satisfy PREDICATE in LIST.

Keywords supported:  :key

(fn PREDICATE LIST [KEYWORD VALUE]...)
(defalias 'cl-rassoc-if-not #[642 #@65 ("\300\301\302\303&\207" . [apply cl-rassoc nil :if-not])(#$ . 30497) nil 10 (#$ . 30324)])
#@337 Combine LIST1 and LIST2 using a set-union operation.
The resulting list contains all items that appear in either LIST1 or LIST2.
This is a non-destructive function; it makes a copy of the data if necessary
to avoid corrupting the original LIST1 and LIST2.

Keywords supported:  :test :test-not :key

(fn LIST1 LIST2 [KEYWORD VALUE]...)
(defalias 'cl-union #[642 #@210 ("\2040\207\204\f0\207\232\2030\207GGY\204\"0\262\262\203S0\211\20400@\247\203<0\300\301@$\262\202I0@>\204I0@B\262\211A\262@\210\202\"0\207" . [apply cl-adjoin])(#$ . 30971) nil 8 (#$ . 30602)])
#@302 Combine LIST1 and LIST2 using a set-union operation.
The resulting list contains all items that appear in either LIST1 or LIST2.
This is a destructive function; it reuses the storage of LIST1 and LIST2
whenever possible.

Keywords supported:  :test :test-not :key

(fn LIST1 LIST2 [KEYWORD VALUE]...)
(defalias 'cl-nunion #[642 #@70 ("\2040\207\204\f0\207\300\301$\207" . [apply cl-union])(#$ . 31554) nil 8 (#$ . 31220)])
#@343 Combine LIST1 and LIST2 using a set-intersection operation.
The resulting list contains all items that appear in both LIST1 and LIST2.
This is a non-destructive function; it makes a copy of the data if necessary
to avoid corrupting the original LIST1 and LIST2.

Keywords supported:  :test :test-not :key

(fn LIST1 LIST2 [KEYWORD VALUE]...)
(defalias 'cl-intersection #[642 #@413 ("\205\2070\205\2070\232\2030\207\301>A@\211\211\20380\211@\302>\20400\303>A@\20400\304\305@\"\210\211AA\262\2020\210\306GGY\204H0\262\262\203\2030\204V0@\247\203l0\307\310\203c0@!\202e0@$\202p0@>\203y0@B\262\211A\262@\210\202H0\211\262)\207" . [cl-key :key (:key :test :test-not) :allow-other-keys error "Bad keyword argument %s" nil apply cl-member])(#$ . 32045) nil 9 (#$ . 31663)])
#@308 Combine LIST1 and LIST2 using a set-intersection operation.
The resulting list contains all items that appear in both LIST1 and LIST2.
This is a destructive function; it reuses the storage of LIST1 and LIST2
whenever possible.

Keywords supported:  :test :test-not :key

(fn LIST1 LIST2 [KEYWORD VALUE]...)
(defalias 'cl-nintersection #[642 #@65 ("\2050\2050\300\301$\207" . [apply cl-intersection])(#$ . 32844) nil 8 (#$ . 32497)])
#@340 Combine LIST1 and LIST2 using a set-difference operation.
The resulting list contains all items that appear in LIST1 but not LIST2.
This is a non-destructive function; it makes a copy of the data if necessary
to avoid corrupting the original LIST1 and LIST2.

Keywords supported:  :test :test-not :key

(fn LIST1 LIST2 [KEYWORD VALUE]...)
(defalias 'cl-set-difference #[642 #@369 ("\2030\204\n0\207\301>A@\211\211\20320\211@\302>\204*0\303>A@\204*0\304\305@\"\210\211AA\262\2020\210\306\203o0\204B0@\247\203X0\307\310\203P0@!\202R0@$\202\\0@>\204e0@B\262\211A\262@\210\20240\211\262)\207" . [cl-key :key (:key :test :test-not) :allow-other-keys error "Bad keyword argument %s" nil apply cl-member])(#$ . 33329) nil 9 (#$ . 32948)])
#@305 Combine LIST1 and LIST2 using a set-difference operation.
The resulting list contains all items that appear in LIST1 but not LIST2.
This is a destructive function; it reuses the storage of LIST1 and LIST2
whenever possible.

Keywords supported:  :test :test-not :key

(fn LIST1 LIST2 [KEYWORD VALUE]...)
(defalias 'cl-nset-difference #[642 #@73 ("\2030\204\n0\207\300\301$\207" . [apply cl-set-difference])(#$ . 34083) nil 8 (#$ . 33737)])
#@348 Combine LIST1 and LIST2 using a set-exclusive-or operation.
The resulting list contains all items appearing in exactly one of LIST1, LIST2.
This is a non-destructive function; it makes a copy of the data if necessary
to avoid corrupting the original LIST1 and LIST2.

Keywords supported:  :test :test-not :key

(fn LIST1 LIST2 [KEYWORD VALUE]...)
(defalias 'cl-set-exclusive-or #[642 #@131 ("\2040\207\204\f0\207\232\2030\300\207\301\302\303$\302\303$\"\207" . [nil append apply cl-set-difference])(#$ . 34586) nil 10 (#$ . 34195)])
#@313 Combine LIST1 and LIST2 using a set-exclusive-or operation.
The resulting list contains all items appearing in exactly one of LIST1, LIST2.
This is a destructive function; it reuses the storage of LIST1 and LIST2
whenever possible.

Keywords supported:  :test :test-not :key

(fn LIST1 LIST2 [KEYWORD VALUE]...)
(defalias 'cl-nset-exclusive-or #[642 #@122 ("\2040\207\204\f0\207\232\2030\300\207\301\302$\301\302$\244\207" . [nil apply cl-nset-difference])(#$ . 35114) nil 9 (#$ . 34757)])
#@179 Return true if LIST1 is a subset of LIST2.
I.e., if every element of LIST1 also appears in LIST2.

Keywords supported:  :test :test-not :key

(fn LIST1 LIST2 [KEYWORD VALUE]...)
(defalias 'cl-subsetp #[642 #@345 ("\2040\301\207\204\f0\302\207\232\2030\301\207\303>A@\211\211\203<0\211@\304>\20440\305>A@\20440\306\307@\"\210\211AA\262\2020\210\203`0\310\311\203N0@!\202P0@$\203`0\211A\262@\210\202=0)?\207" . [cl-key t nil :key (:key :test :test-not) :allow-other-keys error "Bad keyword argument %s" apply cl-member])(#$ . 35488) nil 8 (#$ . 35275)])
#@214 Substitute NEW for elements matching PREDICATE in TREE (non-destructively).
Return a copy of TREE with all matching elements replaced by NEW.

Keywords supported:  :key

(fn NEW PREDICATE TREE [KEYWORD VALUE]...)
(defalias 'cl-subst-if #[899 #@65 ("\300\301\302BC\303&\207" . [apply cl-sublis nil :if])(#$ . 36120) nil 11 (#$ . 35872)])
#@218 Substitute NEW for elts not matching PREDICATE in TREE (non-destructively).
Return a copy of TREE with all non-matching elements replaced by NEW.

Keywords supported:  :key

(fn NEW PREDICATE TREE [KEYWORD VALUE]...)
(defalias 'cl-subst-if-not #[899 #@69 ("\300\301\302BC\303&\207" . [apply cl-sublis nil :if-not])(#$ . 36481) nil 11 (#$ . 36225)])
#@227 Substitute NEW for OLD everywhere in TREE (destructively).
Any element of TREE which is `eql' to OLD is changed to NEW (via a call
to `setcar').

Keywords supported:  :test :test-not :key

(fn NEW OLD TREE [KEYWORD VALUE]...)
(defalias 'cl-nsubst #[899 #@47 ("\300\301BC$\207" . [apply cl-nsublis])(#$ . 36849) nil 9 (#$ . 36590)])
#@222 Substitute NEW for elements matching PREDICATE in TREE (destructively).
Any element of TREE which matches is changed to NEW (via a call to `setcar').

Keywords supported:  :key

(fn NEW PREDICATE TREE [KEYWORD VALUE]...)
(defalias 'cl-nsubst-if #[899 #@66 ("\300\301\302BC\303&\207" . [apply cl-nsublis nil :if])(#$ . 37192) nil 11 (#$ . 36935)])
#@226 Substitute NEW for elements not matching PREDICATE in TREE (destructively).
Any element of TREE which matches is changed to NEW (via a call to `setcar').

Keywords supported:  :key

(fn NEW PREDICATE TREE [KEYWORD VALUE]...)
(defalias 'cl-nsubst-if-not #[899 #@70 ("\300\301\302BC\303&\207" . [apply cl-nsublis nil :if-not])(#$ . 37563) nil 11 (#$ . 37298)])
#@209 Perform substitutions indicated by ALIST in TREE (non-destructively).
Return a copy of TREE with all matching elements replaced.

Keywords supported:  :test :test-not :key

(fn ALIST TREE [KEYWORD VALUE]...)
(defalias 'cl-sublis #[642 #@413 ("\306>A@\307>A@\2050\307>A@\211\2050\310\311>A@\312>A@\313>A@\20590\313>A@\211\20590\310\211\211\203\\0\211@\314>\204T0\315>A@\204T0\316\317@\"\210\211AA\262\202;0\210\320!.\207" . [cl-test cl-test-not cl-key cl-if cl-if-not cl--alist :test :test-not t :key :if :if-not (:test :test-not :key :if :if-not) :allow-other-keys error "Bad keyword argument %s" cl--sublis-rec])(#$ . 37915) nil 7 (#$ . 37673)])
(defalias 'cl--sublis-rec #[257 #@312 ("\203\n0!\2020\211	\211\203=0\n\203 0\n@@\"?=\20230\f\203-0\f!?
=\20230\306@@\"\204=0\211A\262\202\f0\211\203G0\211@A\202o0:\203n0\307@!\307A!@=\203f0\211A=\203f0\202i0B\266\202\202o0\207" . [cl-key cl--alist cl-test cl-test-not cl-if cl-if-not eql cl--sublis-rec])(#$ . 38399) nil 7 "\n\n(fn CL-TREE)"])
#@210 Perform substitutions indicated by ALIST in TREE (destructively).
Any matching element of TREE is changed via a call to `setcar'.

Keywords supported:  :test :test-not :key

(fn ALIST TREE [KEYWORD VALUE]...)
(defalias 'cl-nsublis #[642 #@433 ("\306>A@\307>A@\2050\307>A@\211\2050\310\311>A@\312>A@\313>A@\20590\313>A@\211\20590\310\211\211\203\\0\211@\314>\204T0\315>A@\204T0\316\317@\"\210\211AA\262\202;0\210C\320!\210\211@)\262-\207" . [cl-test cl-test-not cl-key cl-if cl-if-not cl--alist :test :test-not t :key :if :if-not (:test :test-not :key :if :if-not) :allow-other-keys error "Bad keyword argument %s" cl--nsublis-rec])(#$ . 39000) nil 7 (#$ . 38756)])
(defalias 'cl--nsublis-rec #[257 #@499 ("\211:\205\2700\2030@!\2020\211@	\211\203D0\n\203'0\n@@\"?=\202:0\f\20340\f!?
=\202:0\306@@\"\204D0\211A\262\2020\211\203Q0@A\240\210\202\\0@:\203\\0\307@!\210\203g0A!\202i0A\262	\262\211\203\2370\n\203\2020\n@@\"?=\202\2250\f\203\2170\f!?
=\202\2250\306@@\"\204\2370\211A\262\202n0\211\203\2570@A\241\210\310\262\202\2630A\262\266\20200\207" . [cl-key cl--alist cl-test cl-test-not cl-if cl-if-not eql cl--nsublis-rec nil])(#$ . 39505) nil 6 "\n\n(fn CL-TREE)"])
#@200 Return t if trees TREE1 and TREE2 have `eql' leaves.
Atoms are compared by `eql'; cons cells are compared recursively.

Keywords supported:  :test :test-not :key

(fn TREE1 TREE2 [KEYWORD VALUE]...)
(defalias 'cl-tree-equal #[642 #@313 ("\303>A@\304>A@\2050\304>A@\211\2050\305\306>A@\211\211\203B0\211@\307>\204:0\310>A@\204:0\311\312@\"\210\211AA\262\202!0\210\313\"+\207" . [cl-test cl-test-not cl-key :test :test-not t :key (:test :test-not :key) :allow-other-keys error "Bad keyword argument %s" cl--tree-equal-rec])(#$ . 40286) nil 7 (#$ . 40049)])
(defalias 'cl--tree-equal-rec #[514 #@255 (":\2030\211:\2030\303@@\"\2030A\262\211A\262\20200:?\205b0\211:?\205b0\203J0	\20390	!\202:0	\203D0	!\202E0\"?\n=\207\304	\203U0	!\202V0	\203`0	!\202a0\"\207" . [cl-test cl-key cl-test-not cl--tree-equal-rec eql])(#$ . 40674) nil 6 "\n\n(fn CL-X CL-Y)"])
(run-hooks 'cl-seq-load-hook)
F1l3 Manager
