Current File : //proc/thread-self/root/kunden/usr/share/emacs/27.2/lisp/emacs-lisp/cl-seq.elc

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

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

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

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


(require 'cl-lib)
#@37 

(fn KWORDS OTHER-KEYS &rest BODY)
(defalias 'cl--parsing-keywords '(macro . #[642 "\300\301\302\"\303\304=?\205'\305\306\307\310\311\312\313\314\301\315\303\"\"DE\316\317F\320FEC\"BB\207" [let* mapcar #[257 "\211:\203\n\211@\202\211\300\301\302\303D\304BBDD
\305=\203(\306
\307\310E\311BBB\262

\312=\203:\306
\307\313E\314BBB\262
\315\316\317\320\321!\322\"\"!:\203T\323A@E\202U
D\207" [car cdr memq quote (cl-keys) :test-not and setq cl-test (t) :if-not cl-if (t) intern format "cl-%s" substring symbol-name 1 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\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)))] 19 (#$ . 426)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put cl--parsing-keywords lisp-indent-function 2 put edebug-form-spec (sexp sexp &rest form)] 5)
#@10 

(fn X)
(defalias 'cl--check-key '(macro . #[257 "\300\301\302\301EF\207" [if cl-key funcall] 6 (#$ . 1451)]))
(put 'cl--check-key 'edebug-form-spec 'edebug-forms)
#@15 

(fn ITEM X)
(defalias 'cl--check-test-nokey '(macro . #[514 "\300\301\302\303\304\301FD\305BBD\306\302\303\304\306ED\307BBD\310\311EDF\207" [cond cl-test eq not funcall (cl-test-not) cl-if (cl-if-not) t eql] 10 (#$ . 1624)]))
(put 'cl--check-test-nokey 'edebug-form-spec 'edebug-forms)
#@15 

(fn ITEM X)
(defalias 'cl--check-test '(macro . #[514 "\300\301DE\207" [cl--check-test-nokey cl--check-key] 6 (#$ . 1928)]))
(put 'cl--check-test 'edebug-form-spec 'edebug-forms)
#@12 

(fn X Y)
(defalias 'cl--check-match '(macro . #[514 "\300D\262\300
D\262
\301\302\303\304\305\302FD\306BB\307EF\207" [cl--check-key if cl-test eq not funcall (cl-test-not) eql] 10 (#$ . 2117)]))
(put 'cl--check-match 'edebug-form-spec 'edebug-forms)
#@104 Return true if X is the empty list; false if it is a cons.
Signal an error if X is not a list.

(fn X)
(defalias 'cl-endp #[257 "\211<\204
\300\301\302\303E\"\210\211?\207" [signal wrong-type-argument list x] 6 (#$ . 2384)])
#@861 Reduce two-argument FUNCTION across SEQ.

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

Return the result of calling FUNCTION with the first and the
second element of SEQ, then calling FUNCTION with that result and
the third element of SEQ, then with that result and the fourth
element of SEQ, etc.

If :INITIAL-VALUE is specified, it is logically added to the
front of SEQ (or the back if :FROM-END is non-nil).  If SEQ is
empty, return :INITIAL-VALUE and FUNCTION is not called.

If SEQ is empty and no :INITIAL-VALUE is specified, then return
the result of calling FUNCTION with zero arguments.  This is the
only case where FUNCTION is called with fewer than two arguments.

If SEQ contains exactly one element and no :INITIAL-VALUE is
specified, then return that element and FUNCTION is not called.


(fn FUNCTION SEQ [KEYWORD VALUE]...)
(defalias 'cl-reduce #[642 "\301
>A@\302>A@\206\303\304>A@\305>A@\306>A@\211\203A\211@\307>\2049\310>A@\2049\311\312@\"\210\211AA\262
\202\210<\204N\313\314\"\262\315#\262\203^\237\262\305>\203h\211\202\210\203\205\203|\211A\262\242!\202\210\211A\262\242\202\210 \203\261\203\326\203\243\211A\262\n\242!\202\252\211A\262	\242\"\262
\202\214\203\326
\203\311	\211A\262\242!\202\320\211A\262\n\242\"\262
\202\261\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] 13 (#$ . 2618)])
#@105 Fill the elements of SEQ with ITEM.

Keywords supported:  :start :end

(fn SEQ ITEM [KEYWORD VALUE]...)
(defalias 'cl-fill #[642 "\300
>A@\206	\301\302>A@\211\2030\211@\303>\204(\304>A@\204(\305\306@\"\210\211AA\262
\202\210<\203c
\233
\205@
Z
\203^\211\203R\211S\211\262\301Y\203^
\240\210
A\262\202@\266\202\222\211\204kG\262

\301U\203\200\211GU\203\200\307\"\210\202\222

W\203\222I\210
T\262\202\200\207" [:start 0 :end (:start :end) :allow-other-keys error "Bad keyword argument %s" fillarray] 9 (#$ . 4174)])
#@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 "\300
>A@\206	\301\302>A@\303>A@\206\301\304>A@\211\203?\211@\305>\2047\306>A@\2047\307\310@\"\210\211AA\262
\202\210=\203\240
X\203\240U\204\237
G\206\\\211Z\206c
Z^\211S\211\262\301Y\203\233\\
<\203\212\211\233\n\\\234\240\210\202\226

\\\234I\210\266\202f\266\202\237
<\203K
\233\205\261Z<\203
\233
\203\314\203\314
Z^\202\344
\203\330\204\330
\202\344
?\205\344\205\344Z\203\n

\203\n
\211\203\372\211S\211\262\301Y\203\n
@\240\210A\262
A\262\202\344\266\202F
\211\204
\206(
G\202(
\206$
G\\^\262
\203F
W\203F

H\240\210
A\262T\262\202*
\266\202\237
\206R
G\206Z
GZ\\^\262<\203\205

\233W\203\201
@I\210\211A\262
T\262\202i
\210\202\237
W\203\237
HI\210
T\262T\262\202\205
\207" [:start1 0 :end1 :start2 :end2 (:start1 :end1 :start2 :end2) :allow-other-keys error "Bad keyword argument %s"] 16 (#$ . 4737)])
#@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 "\305
>A@\306
>A@\205\306
>A@\211\205\307\310
>A@\311
>A@\312
>A@\2059\312
>A@\211\2059\307\313
>A@\314>A@\315>A@\206M\316\317>A@\211\203u\211@\320>\204m\321>A@\204m\322\323@\"\210\211AA\262
\202S\210G\206\200\211\211\262\316X\203\212\202-<\203\234\203\356
\324\245W\203\356\325%\211\203\347\326\327\n\330\331\"\330	\203\301\317TD\202\305\315D\f\"$<\203\323\211\202\342;\203\337\211\260
\202\342\332
!\262
\202\351\262
\202-
\206\363\211Z\262\316U\203m
\203m

\316V\203m
\203%
\n\203
\n	@!\202
@\"?	=\202S
\203@
\n\2036
\n@!\2029
@!?\f=\202S
\333\n\203O
\n	@!\202R
@\"\203m

S\262A\211\262\203m
S\211\262\316V\204\375\316V\203+
\316V\203+\316V\203\206
\233\202\215

S\262A\211\203\352
\316V\203\352
\203\262
	\n\203\251
\n@!\202\253
@\"?	=\202\334
\203\313
\n\203\302
\n@!\202\304

@!?\f=\202\334
\333	\n\203\331
\n@!\202\333
@\"\204\352
\211A\262
S\262\202\215
\211\203$\316V\203$\334\"\335U\203
A\202 
A\205 \326\327\336A!\315\316\317\nS\313S&\n\244\202&\262
\202-\262
-\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" 2 cl--position apply cl-delete append nil vconcat eql cl-ldiff 1 copy-sequence] 21 (#$ . 5920)])
#@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 "\300\301\302\303&\207" [apply cl-remove nil :if] 10 (#$ . 7663)])
#@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 "\300\301\302\303&\207" [apply cl-remove nil :if-not] 10 (#$ . 8024)])
#@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 "\305
>A@\306
>A@\205\306
>A@\211\205\307\310
>A@\311
>A@\312
>A@\2059\312
>A@\211\2059\307\313
>A@\314>A@\315>A@\206M\316\317>A@\211\203u\211@\320>\204m\321>A@\204m\322\323@\"\210\211AA\262
\202S\210G\206\200\211\211\262\316X\203\212\202<\203\372
\203\340
\324\245W\203\340\325S\211\262\316Y\203\331\326			%\211\262\203\331\211\316U\203\307A\262\202\323\211S\233\211
AA\241\266\211\262\202\235\262
\202
\206\345\211Z\262\316U\203f
\203_

\316V\203_
\203
\n\203

\n	@!\202
@\"?	=\202E
\2032
\n\203(
\n@!\202+
@!?\f=\202E
\327\n\203A
\n	@!\202D
@\"\203_

S\262A\211\262\203_
S\211\262\316V\204\357
S\262\202j
S\262\316V\203\365

\316V\203\365
\233\211A\203\364
\316V\203\364
\203\242
	\n\203\230
\nA@!\202\233
A@\"?	=\202\320
\203\275
\n\203\263
\nA@!\202\266

A@!?\f=\202\320
\327	\n\203\314
\nA@!\202\317
A@\"\203\351
\211
AA\241\210S\211\262\316U\203\355
\330\262\202\355
\211A\262
S\262\202z
\210\202\331\332			$\262
-\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" 2 nil cl--position eql 1 apply cl-remove] 15 (#$ . 8397)])
#@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 "\300\301\302\303&\207" [apply cl-delete nil :if] 10 (#$ . 9996)])
#@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 "\300\301\302\303&\207" [apply cl-delete nil :if-not] 10 (#$ . 10327)])
#@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 "\300\301#\207" [cl--delete-duplicates t] 6 (#$ . 10671)])
#@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 "\300\301#\207" [cl--delete-duplicates nil] 6 (#$ . 10929)])
#@31 

(fn CL-SEQ CL-KEYS CL-COPY)
(defalias 'cl--delete-duplicates #[771 "<\203\203
\304>A@\305>A@\205\305>A@\211\205\306\307>A@\310>A@\206.\311\312>A@\313>A@\314>A@\211\203a\211@\315>\204Y\316>A@\204Y\317\320@\"\210\211AA\262
\202?\210\211\203\324\233\321\206rGZ\262\322V\203\315\311\262
\323\n\203\213\n@!\202\215@AS$\211\262\203\276\203\255\324!\262\233\262\321\262\211\233\211
AA\241\266S\262\202
A\262S\262T\262\202v\266\202\202\201

\206\332GZ\262A\203
\311U\203

\322V\203
\323\n\203\374\n@!\202\377@A\311S$\203
A\262
S\262\202\336\311V\203\"
S\233\202*

S\262\322\262\211AA\203}
\322V\203}
\323\n\203C
\nA@!\202F

A@AA\311S$\203n
\203e
\324!\262S\233\262
\321\262\211
AA\241\210\202r
\211A\262
S\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] 13 (#$ . 11186)])
#@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 "\305
>A@\306
>A@\205\306
>A@\211\205\307\310
>A@\311
>A@\312
>A@\2059\312
>A@\211\2059\307\313
>A@\314>A@\206H\315\316>A@\317>A@\211\203u\211@\320>\204m\321>A@\204m\322\323@\"\210\211AA\262
\202S\210=\204\217\206\212\324\262
G\211\262\315X\203\223\202\344\325$\211\204\244\202\342\326!\262
\204\320

<\203\300\211\233\240\210\202\306

\fI\210\266\211T\262
S\262\327\330\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 cl--position copy-sequence apply cl-nsubstitute] 19 (#$ . 12374)])
#@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 "\300\301\302\303&\207" [apply cl-substitute nil :if] 12 (#$ . 13427)])
#@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 "\300\301\302\303&\207" [apply cl-substitute nil :if-not] 12 (#$ . 13814)])
#@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 "\305
>A@\306
>A@\205\306
>A@\211\205\307\310
>A@\311
>A@\312
>A@\2059\312
>A@\211\2059\307\313
>A@\314>A@\206H\315\316>A@\317>A@\211\203u\211@\320>\204m\321>A@\204m\322\323@\"\210\211AA\262
\202S\210G	=\204%\206\210\211\211\262\315X\204%<\203

\203\237
\324\245V\203
\233\206\250
Z\262\211\203
\315V\203
\315V\203
\203\327	\n\203\316\n@!\202\320@\"?	=\202

\203\360\n\203\347\n@!\202\351
@!?\f=\202

\325	\n\203\376\n@!\202
@\"\203

\211\n\240\210S\262\211A\262
S\262\202\254\210\202%\204#
\211\262
\203\256
W\203%\315V\203%S\262\203W
\n\203L
\n	\234!\202P
\234\"?	=\202\212
\203t
\n\203i
\n\234!\202m
\234!?\f=\202\212
\325\n\203\205
\n	\234!\202\211
\234\"\203'

<\203\237
\211\233\240\210\202\245


\fI\210\266S\262\202'
W\203%\315V\203%\203\333
\n\203\317
\n	H!\202\324
H\"?	=\202\203\371
\n\203\356
\nH!\202\362
H!?\f=\202\325\n\203\n\n	H!\202H\"\203\nI\210S\262T\262\202\256
\210-\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" 2 eql] 14 (#$ . 14213)])
#@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 "\300\301\302\303&\207" [apply cl-nsubstitute nil :if] 12 (#$ . 15789)])
#@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 "\300\301\302\303&\207" [apply cl-nsubstitute nil :if-not] 12 (#$ . 16148)])
#@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 "\300\301$\211\205

\234\207" [apply cl-position] 8 (#$ . 16519)])
#@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 "\300\301\302\303&\207" [apply cl-find nil :if] 10 (#$ . 16811)])
#@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 "\300\301\302\303&\207" [apply cl-find nil :if-not] 10 (#$ . 17102)])
#@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 "\305
>A@\306
>A@\205\306
>A@\211\205\307\310
>A@\311
>A@\312
>A@\2059\312
>A@\211\2059\307\313
>A@\206C\314\315>A@\316>A@\211\203o\211@\317>\204g\320>A@\204g\321\322@\"\210\211AA\262
\202N\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] 12 (#$ . 17405)])
#@61 

(fn CL-ITEM CL-SEQ CL-START &optional CL-END CL-FROM-END)
(defalias 'cl--position #[1283 "<\203v\233\305
\203u\203W\203u\211\203\203u\203:	\2031	@!\2023@\"?\n=\202d\203S	\203J	@!\202L@!?\f=\202d\306	\203a	@!\202c@\"\203j\262

A\262T\262\202	\207
\204~G\262\211\203\342
S\211\262Y\203\332\203\251	\203\237	H!\202\242H\"?\n=\202\327\203\304	\203\272	H!\202\275H!?\f=\202\327\306	\203\323	H!\202\326H\"\203\202
Y\205F

\207W\203?
\203
	\203\374	H!\202\377H\"?\n=\2025
\203!
	\203
	H!\202
H!?\f=\2025
\306	\2031
	H!\2024
H\"\204?
T\262\202\342W\205F
\207" [cl-test cl-key cl-test-not cl-if cl-if-not nil eql] 11 (#$ . 18118)])
#@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 "\300\301\302\303&\207" [apply cl-position nil :if] 10 (#$ . 18869)])
#@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 "\300\301\302\303&\207" [apply cl-position nil :if-not] 10 (#$ . 19181)])
#@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 "\305
>A@\306
>A@\205\306
>A@\211\205\307\310
>A@\311
>A@\312
>A@\2059\312
>A@\211\2059\307\313
>A@\206C\314\315>A@\211\203j\211@\316>\204b\317>A@\204b\320\321@\"\210\211AA\262
\202I\210\314\322\204uG\262:\203\200\233\262W\203\346:\203\224\211A\262\242\202\227H\262
\203\262\n\203\252\n!\202\253\"?	=\202\330\203\311\n\203\301\n!\202\302
!?\f=\202\330\323\n\203\326\n!\202\327\"\203\337
T\262T\262\202\200
\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] 11 (#$ . 19505)])
#@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 "\300\301\302\303&\207" [apply cl-count nil :if] 10 (#$ . 20383)])
#@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 "\300\301\302\303&\207" [apply cl-count nil :if-not] 10 (#$ . 20625)])
#@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 "\303
>A@\304
>A@\205\304
>A@\211\205\305\306
>A@\307
>A@\310>A@\206.\311\312>A@\313>A@\206<\311\314>A@\211\203d\211@\315>\204\\\316>A@\204\\\317\320@\"\210\211AA\262
\202B\210\204nG\262\211\204wG\262
\203
W\203\357

W\203\357\203\271\n\203\232\n	S\234!\202\237S\234\n\203\255\n	S\234!\202\262S\234\"?	=\202\341\321\n\203\310\n	S\234!\202\315S\234\n\203\333\n	S\234!\202\340S\234\"\203\357S\262\211S\262
\202{W\204\373

W\205\347
S\202\347
<\205\n
\233<\205
\233W\203\330
W\203\330
\203v
\n\203<
\n\2033
@\2028
H!\202J
\203E
@\202J
\nH\n\203a
\n\203X
@\202]
H!\202o
\203j
@\202o
\nH\"?	=\202\302
\321\n\203\216
\n\203\205
@\202\212
H!\202\234
\203\227
@\202\234
\nH\n\203\263
\n\203\252
@\202\257
H!\202\301
\203\274
@\202\301
\nH\"\203\330

A\262\211A\262
T\262T\262\202
W\204\344
W\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] 15 (#$ . 20879)])
#@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 "\304
>A@\305
>A@\205\305
>A@\211\205\306\307
>A@\310
>A@\311>A@\206.\312\313>A@\314>A@\206<\312\315>A@\211\203d\211@\316>\204\\\317>A@\204\\\320\321@\"\210\211AA\262
\202B\210\204nG\262\211\204wG\262
Y\203\211\203\205\211\202\372
\202\372Z\n\203\232\n	\234!\202\236\234\322\211SZ\262W\203\360\323\f%\211\262\203\360\324\325\f\f\311T\313\f\314	T\315\\\310\322&\203\360\203\351\211\262\202\247\211T\262\202\247W\205\367\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] 27 (#$ . 22416)])
#@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 "<\204\301\302\303\304\305\"$\"\207\306
>A@\211\211\203=\211@\306=\2045\307>A@\2045\310\311@\"\210\211AA\262
\202\210\312>\203K\313\"\202[\313\314\315\316\317\320!\321\"\322\323%\")\207" [cl-key cl-replace apply cl-sort append nil :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)"] 11 (#$ . 23499)])
#@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 "\300\301$\207" [apply cl-sort] 8 (#$ . 24153)])
#@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 "<\204\301\302\"\262<\204\301\302\"\262\303
>A@\211\211\203>\211@\303=\2046\304>A@\2046\305\306@\"\210\211AA\262
\202\210\302\203\203\203\203\203T@!\202V@\203b@!\202e@\"\203v\211A\262\242
B\262
\202@\211A\262\242
B\262
\202@\307
\237\244\244\"\262
)\207" [cl-key append nil :key :allow-other-keys error "Bad keyword argument %s" cl-coerce] 10 (#$ . 24437)])
#@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 "\211\203\265\305
>A@\306
>A@\205\306
>A@\211\205\307\310
>A@\311
>A@\312
>A@\205=\312
>A@\211\205=\307\211\211\203`\211@\313>\204X\314>A@\204X\315\316@\"\210\211AA\262
\202?\210
\203\262\203\n\203v\n@!\202x@\"?	=\202\250\203\230\n\203\217\n@!\202\221@!?\f=\202\250\317\n\203\245\n@!\202\247@\"\204\262
A\262\202a
-\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 memql] 7 (#$ . 25161)])
(byte-code "\300\301\302\303#\304\303\305\"\207" [function-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 "\300\301\302\303&\207" [apply cl-member nil :if] 10 (#$ . 26071)])
#@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 "\300\301\302\303&\207" [apply cl-member nil :if-not] 10 (#$ . 26345)])
#@38 

(fn CL-ITEM CL-LIST &rest CL-KEYS)
(defalias 'cl--adjoin #[642 "\301
>A@\302\303\203!\202$)\203
\207B\207" [cl-key :key apply cl-member] 8 (#$ . 26630)])
#@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 "\211\203\306\305
>A@\306
>A@\205\306
>A@\211\205\307\310
>A@\311
>A@\312
>A@\205=\312
>A@\211\205=\307\211\211\203`\211@\313>\204X\314>A@\204X\315\316@\"\210\211AA\262
\202?\210
\203\276
@:\203\267\203\207\n\203}\n@@!\202\200@@\"?	=\202\264\203\242\n\203\230\n@@!\202\233@@!?\f=\202\264\317\n\203\260\n@@!\202\263@@\"\204\276
A\262\202a
\205\304
@-\207\247\203\326\320!\204\326\321\"\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 fixnump assoc] 7 (#$ . 26808)])
(byte-code "\300\301\302\303#\304\303\305\"\207" [function-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 "\300\301\302\303&\207" [apply cl-assoc nil :if] 10 (#$ . 27760)])
#@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 "\300\301\302\303&\207" [apply cl-assoc nil :if-not] 10 (#$ . 27995)])
#@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 "\211\204	\247\203\313\305
>A@\306
>A@\205\"\306
>A@\211\205\"\307\310
>A@\311
>A@\312
>A@\205B\312
>A@\211\205B\307\211\211\203e\211@\313>\204]\314>A@\204]\315\316@\"\210\211AA\262
\202D\210
\203\303
@:\203\274\203\214\n\203\202\n@A!\202\205@A\"?	=\202\271\203\247\n\203\235\n@A!\202\240@A!?\f=\202\271\317\n\203\265\n@A!\202\270@A\"\204\303
A\262\202f
\205\311
@-\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] 7 (#$ . 28245)])
#@127 Find the first item whose cdr satisfies PREDICATE in LIST.

Keywords supported:  :key

(fn PREDICATE LIST [KEYWORD VALUE]...)
(defalias 'cl-rassoc-if #[642 "\300\301\302\303&\207" [apply cl-rassoc nil :if] 10 (#$ . 29032)])
#@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 "\300\301\302\303&\207" [apply cl-rassoc nil :if-not] 10 (#$ . 29269)])
#@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 "\204
\207
\204\f\207\211\204\232\203\207GGY\204&
\262\262
\203V\211\2044
@\247\203@\300\301@$\262\202M
@>\204M
@B\262
\211A\262\210\202&\207" [apply cl-adjoin] 8 (#$ . 29521)])
#@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 "\204
\207
\204\f\207\300\301$\207" [apply cl-union] 8 (#$ . 30101)])
#@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 "\205\206
\205\206\232\203\207\301
>A@\211\211\2038\211@\302>\2040\303>A@\2040\304\305@\"\210\211AA\262
\202\210\306GGY\204H\262\262\203\202
\204V@\247\203l\307\310\203c@!\202e@$\202p@>\203y@
B\262
\211A\262\210\202H\211\262
)\207" [cl-key :key (:key :test :test-not) :allow-other-keys error "Bad keyword argument %s" nil apply cl-member] 9 (#$ . 30514)])
#@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 "\205
\205\300\301$\207" [apply cl-intersection] 8 (#$ . 31297)])
#@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 "\203
\204\n\207\301
>A@\211\211\2032\211@\302>\204*\303>A@\204*\304\305@\"\210\211AA\262
\202\210\306\203n
\204B@\247\203X\307\310\203P@!\202R@$\202\\@>\204e@
B\262
\211A\262\210\2024\211\237\262
)\207" [cl-key :key (:key :test :test-not) :allow-other-keys error "Bad keyword argument %s" nil apply cl-member] 9 (#$ . 31719)])
#@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 "\203
\204\n\207\300\301$\207" [apply cl-set-difference] 8 (#$ . 32463)])
#@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 "\204
\207
\204\f\207\232\203\300\207\301\302\303$\302\303$\"\207" [nil append apply cl-set-difference] 10 (#$ . 32892)])
#@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 "\204
\207
\204\f\207\232\203\300\207\301\302$\301\302$\244\207" [nil apply cl-nset-difference] 9 (#$ . 33422)])
#@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 "\204\301\207
\204\f\302\207\232\203\301\207\303
>A@\211\211\203<\211@\304>\2044\305>A@\2044\306\307@\"\210\211AA\262
\202\210\203_\310\311\203N@!\202P@$\203_\211A\262\210\202=)?\207" [cl-key t nil :key (:key :test :test-not) :allow-other-keys error "Bad keyword argument %s" apply cl-member] 8 (#$ . 33908)])
#@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 "\300\301\302BC\303&\207" [apply cl-sublis nil :if] 11 (#$ . 34462)])
#@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 "\300\301\302BC\303&\207" [apply cl-sublis nil :if-not] 11 (#$ . 34789)])
#@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 "\300\301BC$\207" [apply cl-nsublis] 9 (#$ . 35128)])
#@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 "\300\301\302BC\303&\207" [apply cl-nsublis nil :if] 11 (#$ . 35447)])
#@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 "\300\301\302BC\303&\207" [apply cl-nsublis nil :if-not] 11 (#$ . 35784)])
#@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 "\306
>A@\307
>A@\205\307
>A@\211\205\310\311
>A@\312
>A@\313
>A@\2059\313
>A@\211\2059\310\211\211\203\\\211@\314>\204T\315>A@\204T\316\317@\"\210\211AA\262
\202;\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] 7 (#$ . 36133)])
#@16 

(fn CL-TREE)
(defalias 'cl--sublis-rec #[257 "\203\n
!\202\211	\211\203=\n\203 \n
@@\"?=\2023\f\203-\f!?
=\2023\306
@@\"\204=\211A\262
\202\f\211\203G\211@A\202o:\203n\307@!\307A!
@=\203f\211A=\203f\202i

B\266\202\202o\207" [cl-key cl--alist cl-test cl-test-not cl-if cl-if-not eql cl--sublis-rec] 7 (#$ . 36783)])
#@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 "\306
>A@\307
>A@\205\307
>A@\211\205\310\311
>A@\312
>A@\313
>A@\2059\313
>A@\211\2059\310\211\211\203\\\211@\314>\204T\315>A@\204T\316\317@\"\210\211AA\262
\202;\210
C\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] 7 (#$ . 37138)])
#@16 

(fn CL-TREE)
(defalias 'cl--nsublis-rec #[257 "\211:\205\270\203
@!\202\211@	\211\203D\n\203'\n
@@\"?=\202:\f\2034\f!?
=\202:\306
@@\"\204D\211A\262
\202\211\203Q
@A\240\210\202\\@:\203\\\307@!\210\203gA!\202iA\262	\262
\211\203\237\n\203\202\n
@@\"?=\202\225\f\203\217\f!?
=\202\225\306
@@\"\204\237\211A\262
\202n\211\203\257
@A\241\210\310\262\202\263A\262\266\202\207" [cl-key cl--alist cl-test cl-test-not cl-if cl-if-not eql cl--nsublis-rec nil] 6 (#$ . 37807)])
#@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 "\303
>A@\304
>A@\205\304
>A@\211\205\305\306
>A@\211\211\203B\211@\307>\204:\310>A@\204:\311\312@\"\210\211AA\262
\202!\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] 7 (#$ . 38337)])
#@18 

(fn CL-X CL-Y)
(defalias 'cl--tree-equal-rec #[514 "
:\203\211:\203\303@@\"\203
A\262\211A\262
\202
:?\205b\211:?\205b\203J	\2039	!\202:	\203D	!\202E\"?\n=\207\304	\203U	!\202V	\203`	!\202a\"\207" [cl-test cl-key cl-test-not cl--tree-equal-rec eql] 6 (#$ . 38887)])
(byte-code "\300\301!\210\302\303!\207" [run-hooks cl-seq-load-hook provide cl-seq] 2)