;ELC ;;; Compiled by pot@pot.cnuce.cnr.it on Tue Mar 18 15:39:03 2003 ;;; from file /home/pot/gnu/emacs-pretest.new/lisp/emacs-lisp/cl-seq.el ;;; in Emacs version 21.3 ;;; with bytecomp version 2.85.4.1 ;;; with all optimizations. ;;; Function definitions are lazy-loaded. ;;; This file uses dynamic docstrings, first added in Emacs 19.29. (if (and (boundp 'emacs-version) (< (aref emacs-version (1- (length emacs-version))) ?A) (or (and (boundp 'epoch::version) epoch::version) (string-lessp emacs-version "19.29"))) (error "`cl-seq.el' was compiled for Emacs 19.29 or later")) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; (byte-code "\301>\204\n\302\303!\210\301\207" [features cl-19 error "Tried to load `cl-seq' before `cl'!"] 2) (defalias 'cl-push '(macro . #[(x place) #@45 ("\302\303 EE\207" . [place x setq cons])(#$ . 820) nil 5])) (defalias 'cl-pop '(macro . #[(place) #@62 ("\301\302\303\304DEED\207" . [place car prog1 setq cdr])(#$ . 927) nil 7])) (defalias 'cl-parsing-keywords '(macro . #[(kwords other-keys &rest body) #@746 ("\303\304\305\"\306 \307=?\205%0\310\311\312\313\314\315\316\317\304\320\306 \"\"DE\321\322F\323FEC\n\"BB\207" . [kwords other-keys body let* mapcar #[(x) ":\203\n0@\202 0\303\304\305\306 D\307EDD \310=\203&0\311\n\312\313\nE\314F \315=\20350\311\n\312\316\nE\314F\317\320\321\322 !\323\324O\"!:\203N0\325\nA@E\202O0\n*D\207" [x var mem car cdr memq quote cl-keys :test-not and setq cl-test t :if-not cl-if intern format "cl-%s" symbol-name 1 nil or] 6] append t let ((cl-keys-temp cl-keys)) while cl-keys-temp or memq (car cl-keys-temp) quote #[(x) ":\2030@\207\207" [x] 1] (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)))])(#$ . 1088) nil 16])) (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 . #[(x) #@54 ("\301\302\303\302EF\207" . [x if cl-key funcall])(#$ . 2048) nil 5])) (defalias 'cl-check-test-nokey '(macro . #[(item x) #@190 ("\302\303\304\305\306\303 FD\307ED\310\304\305\306\310 ED\311ED\312\313\314D\315 E\304 EFDF\207" . [item x cond cl-test eq not funcall cl-test-not cl-if cl-if-not t if numberp equal])(#$ . 2180) nil 10])) (defalias 'cl-check-test '(macro . #[(item x) #@66 ("\302\303 DE\207" . [item x cl-check-test-nokey cl-check-key])(#$ . 2442) nil 4])) (defalias 'cl-check-match '(macro . #[(x y) #@156 ("\302D\302 D\303\304\305\306\307\304 FD\310E\303\311D\312 E\305 EFF\207" . [x y cl-check-key if cl-test eq not funcall cl-test-not numberp equal])(#$ . 2578) nil 9])) (byte-code "\301\302\303\304#\210\301\305\303\304#\210\301\306\303\304#\210\301\307\303\304#\210\310B\311B\312B\313B\314B\301\207" [current-load-list put cl-check-key edebug-form-spec edebug-forms cl-check-test cl-check-test-nokey cl-check-match cl-test cl-test-not cl-if cl-if-not cl-key] 4) #@110 Reduce two-argument FUNCTION across SEQUENCE. Keywords supported: :start :end :from-end :initial-value :key (defalias 'reduce #[(cl-func cl-seq &rest cl-keys) #@710 ("\306>A@\307>A@\2060\310\311>A@\312>A@\313>A@\211\203J0@\314>\204@0\315>A@\204@0\316\317@\"\210AA\211\204)0)<\204X0\320\321\"\322\n # \203i0\237\312>\203s0\f\202\2250\203\2220 \203\2100 \211A@!\202\2250\211A@\202\2250  \203\3010\203\3470 \203\2620 \211A@!\202\2710\211A@\"\202\2330\203\3470 \203\3320 \211A@!\202\3410\211A@\"\202\3010.\207" . [cl-keys cl-from-end cl-start cl-end cl-initial-value 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 subseq cl-keys-temp cl-seq cl-func cl-accum])(#$ . 3230) nil 6 (#$ . 3063)]) #@70 Fill the elements of SEQ with ITEM. Keywords supported: :start :end (defalias 'fill #[(seq item &rest cl-keys) #@489 ("\306>A@\206 0\307\310>A@\211\20330 @\311>\204+0\312>A@\204+0\313\314 @\"\210 AA\211\2040)\f<\203j0 \f\233\n\203F0\n Z\202G0\315\211\203f0 S\211\307Y\203f0\240\210A\211\204N0*\202\2320\n\204q0\fG \307U\203\2070\n\fGU\203\2070\316\f\"\210\202\2320 \nW\203\2320\f I\210 T\211\202\2100\f*\207" . [cl-keys cl-start cl-end cl-keys-temp seq n :start 0 :end (:start :end) :allow-other-keys error "Bad keyword argument %s" 8000000 fillarray p item])(#$ . 4095) nil 4 (#$ . 3976)]) #@153 Replace the elements of SEQ1 with the elements of SEQ2. SEQ1 is destructively modified, then returned. Keywords supported: :start1 :end1 :start2 :end2 (defalias 'replace #[(cl-seq1 cl-seq2 &rest cl-keys) #@985 ("\306>A@\206 0\307\310>A@\311>A@\2060\307\312>A@\211\203C0 @\313>\204;0\314>A@\204;0\315\316 @\"\210 AA\211\204&0)=\203\2570 X\203\2570 U\204\227G\n\206c0 Z\f\206k0 Z^S\211\307Y\203\2530 \\ \\\234\211<\203\2370\233\240\210\202\2470I\210+\202p0*\202\227<\203@ \233\n\203\3030\n Z\202\3040\317<\203 \233\f\203\3360\f Z\202\3370\317^\203 \203 S\211\307Y\203 @\240\210AA\202\3440*\202<\f\206G \\^\203< \fW\203< H\240\210A T\202*\202\227\n\206GG \f\206OG Z\\^<\203~ \233 \nW\203z @I\210A T\211\202a)\202\227 \nW\203\227  HI\210 T T\211\202,\207" . [cl-keys cl-start1 cl-end1 cl-start2 cl-end2 cl-keys-temp :start1 0 :end1 :start2 :end2 (:start1 :end1 :start2 :end2) :allow-other-keys error "Bad keyword argument %s" 4000000 cl-seq1 cl-seq2 cl-len cl-n val n seq cl-n1 cl-p1 cl-p2])(#$ . 4833) nil 6 (#$ . 4621)]) #@221 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 (defalias 'remove* #[(cl-item cl-seq &rest cl-keys) #@1664 ("\306>A@\307>A@\2050\307>A@\211\2050\310\311>A@\312>A@\313>A@\20590\313>A@\211\20590\310\314>A@ \315>A@!\316>A@\206Q0\317\"\320>A@#\211$\203\2020$@\321>\204x0\322>A@\204x0\323\324$@\"\210$AA\211$\204a0) \206\2140\325\211 \317X\203\2260%\202\216%<\203\2500!\2030 \326W\2030\327&%\"#!%\211'\203\3720\330\331&\332%\333\"\332!\203\3210\320'TD\202\3250\316'D\"$(%<\203\3450(\202\3660%;\203\3620(\260\202\3660\334(!)\202\3740%)\202\216#\206\325\"Z#\"\317U\203\237%\203\237#\317V\203\237 \203; & \2031 %@!\2024%@\"?\n=\202\203\f\203V\f \203L %@!\202O%@!? =\202\203&\247\203q& \203j %@!\202m%@\232\202\203& \203 %@!\202\202%@=\203\237#S#%A\211%\203\237 S\211 \317V\204 \317V\203\214#\317V\203\214\"\317V\203\274\"%\233\202\304#S#%A))\203G#\317V\203G \203\357 & \203\345 )@!\202\350)@\"?\n=\2027\f\203\n\f \2030 )@!\202)@!? =\2027&\247\203%& \203 )@!\202!)@\232\2027& \2033 )@!\2026)@=\204G)A)#S#\202\306)\203\206#\317V\203\206\335%)\" \336U\203f)A\202\202)A\205\202\330\331&\337)A!\316\317\320#S\314 S&\n\244\202\210%)\202\216%. \207" . [cl-keys 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 delete* append nil vconcat ldiff 1 copy-sequence cl-count cl-from-end cl-start cl-end cl-keys-temp cl-seq cl-item cl-i cl-res cl-p])(#$ . 6135) nil 13 (#$ . 5855)]) #@212 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 (defalias 'remove-if #[(cl-pred cl-list &rest cl-keys) #@82 ("\303\304\305\306 \n&\207" . [cl-list cl-pred cl-keys apply remove* nil :if])(#$ . 8109) nil 7 (#$ . 7837)]) #@216 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 (defalias 'remove-if-not #[(cl-pred cl-list &rest cl-keys) #@86 ("\303\304\305\306 \n&\207" . [cl-list cl-pred cl-keys apply remove* nil :if-not])(#$ . 8508) nil 7 (#$ . 8228)]) #@191 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 (defalias 'delete* #[(cl-item cl-seq &rest cl-keys) #@1517 ("\306>A@\307>A@\2050\307>A@\211\2050\310\311>A@\312>A@\313>A@\20590\313>A@\211\20590\310\314>A@\315>A@\316>A@\206Q0\317\320>A@_\211 \203\2020 @\321>\204x0\322>A@\204x0\323\324 @\"\210 AA\211 \204a0)\206\2140\325\211\317X\203\2260!\202d!<\203\\\203\3630\326W\203\3630\327\"S\211\317Y\203\3550\330#!_%\211\"\203\3550\"\317U\203\3270!A!\202\3460\"S!\233\211$\211AA\241\210)\"_\202\2530!)\202d_\206\3710\325Z_\317U\203\232!\203\222_\317V\203\222 \203. # \203$ !@!\202'!@\"?\n=\202v\f\203I\f \203? !@!\202B!@!? =\202v#\247\203d# \203] !@!\202`!@\232\202v# \203r !@!\202u!@=\203\222_S_!A\211!\203\222S\211\317V\204_S_\202\237S\317V\203W_\317V\203W!\233%%A\203V_\317V\203V \203\340 # \203\325 %A@!\202\331%A@\"?\n=\202.\f\203\375\f \203\362 %A@!\202\366%A@!? =\202.#\247\203# \203 %A@!\202%A@\232\202.# \203) %A@!\202-%A@=\203I%\211AA\241\210S\211\317U\203N\331_\202N%A%_S_\202\264)!\202d\332\333#!$. \207" . [cl-keys 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 1 apply remove* cl-count cl-from-end cl-start cl-end cl-keys-temp cl-seq cl-i cl-item cl-tail cl-p])(#$ . 8881) nil 7 (#$ . 8631)]) #@182 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 (defalias 'delete-if #[(cl-pred cl-list &rest cl-keys) #@82 ("\303\304\305\306 \n&\207" . [cl-list cl-pred cl-keys apply delete* nil :if])(#$ . 10677) nil 7 (#$ . 10435)]) #@186 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 (defalias 'delete-if-not #[(cl-pred cl-list &rest cl-keys) #@86 ("\303\304\305\306 \n&\207" . [cl-list cl-pred cl-keys apply delete* nil :if-not])(#$ . 11048) nil 7 (#$ . 10798)]) #@123 Return a copy of SEQ with all duplicate elements removed. Keywords supported: :test :test-not :key :start :end :from-end (defalias 'remove-duplicates #[(cl-seq &rest cl-keys) #@63 ("\302 \303#\207" . [cl-seq cl-keys cl-delete-duplicates t])(#$ . 11355) nil 4 (#$ . 11173)]) #@121 Remove all duplicate elements from SEQ (destructively). Keywords supported: :test :test-not :key :start :end :from-end (defalias 'delete-duplicates #[(cl-seq &rest cl-keys) #@65 ("\302 \303#\207" . [cl-seq cl-keys cl-delete-duplicates nil])(#$ . 11637) nil 4 (#$ . 11457)]) (defalias 'cl-delete-duplicates #[(cl-seq cl-keys cl-copy) #@1198 ("<\203\236\306 >A@\307 >A@\2050\307 >A@\211\2050\310\311 >A@\312 >A@\206.0\313\314 >A@\315 >A@\316 >A@ \211\203l0@\317>\204b0\320 >A@\204b0\321\322@\"\210AA\211\204K0)\203\3520 \233\323_\206\2010G Z\324V\203\3450\313\325\f\203\2340\f_@!\202\2370_@_AS$\211\203\3250 \203\2770\326! \233_\323 _\233\211!\211AA\241\210)S\202\2170_A_S T\202\2050*\202\233\206\3610G ZA\203* \313U\203*\324V\203*\325\f\203\f@!\202@A\313S$\203*AS\202\3650 \313V\2037 S\233\202?S\324__AA\203\231\324V\203\231\325\f\203]\f_A@!\202a_A@_AA\313S$\203\211 \203\326! S\233_\323 _\211AA\241\210\202\216_A_S T\202A).\207\327\330\323\" \323#\";\203\264\"\260\202\270\331\"!)\207" . [cl-seq cl-keys cl-test cl-test-not cl-key cl-start :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 cl-end cl-from-end cl-if cl-keys-temp cl-i cl-p cl-copy cl-tail cl-res])(#$ . 11801) nil 6]) #@213 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 (defalias 'substitute #[(cl-new cl-old cl-seq &rest cl-keys) #@874 ("\306>A@\307>A@\2050\307>A@\211\2050\310\311>A@\312>A@\313>A@\20590\313>A@\211\20590\310\314>A@\315>A@\206J0\316\317>A@\320>A@\211_\203\2020_@\321>\204x0\322>A@\204x0\323\324_@\"\210_AA\211_\204a0) !=\204\2340\206\2270\325\326\211\316X\203\2410\"\202\327 \"$\211#\204\2660\"\202\330\"!\"\204\3610\"#!$%\211&<\203\3360%&\233$\240\210\202\3460&%$I\210+#T#S\331\332! \"\314\315#& ). \207" . [cl-keys 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 apply nsubstitute cl-count cl-start cl-end cl-from-end cl-keys-temp cl-old cl-new cl-seq cl-i val n seq])(#$ . 13305) nil 11 (#$ . 13025)]) #@224 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 (defalias 'substitute-if #[(cl-new cl-pred cl-list &rest cl-keys) #@93 ("\304\305\306 \307\n &\207" . [cl-new cl-list cl-pred cl-keys apply substitute nil :if])(#$ . 14514) nil 8 (#$ . 14219)]) #@228 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 (defalias 'substitute-if-not #[(cl-new cl-pred cl-list &rest cl-keys) #@97 ("\304\305\306 \307\n &\207" . [cl-new cl-list cl-pred cl-keys apply substitute nil :if-not])(#$ . 14949) nil 8 (#$ . 14646)]) #@183 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 (defalias 'nsubstitute #[(cl-new cl-old cl-seq &rest cl-keys) #@1645 ("\306>A@\307>A@\2050\307>A@\211\2050\310\311>A@\312>A@\313>A@\20590\313>A@\211\20590\310\314>A@\315>A@\206J0\316\317>A@\320>A@\211\203\2020@\321>\204x0\322>A@\204x0\323\324@\"\210AA\211\204a0)=\204\272\206\2240\325\211\316X\204\272<\203T\203\2530\326V\203T\233_\206\2700\325Z_\203P\316V\203P\316V\203P \203\3550  \203\3430 _@!\202\3460_@\"?\n=\2025\f\203\f \203\3760 _@!\202_@!? =\2025\247\203# \203 _@!\202__@\232\2025 \2031 _@!\2024_@=\203C_\240\210S_A_S\202\2750)\202\272\204^G\203W\203\272\316V\203\272S \203\230  \203\214 \234!\202\221\234\"?\n=\202\354\f\203\267\f \203\253 \234!\202\260\234!? =\202\354\247\203\326 \203\315 \234!\202\322\234\232\202\354 \203\346 \234!\202\353\234=\203c !\211\"<\203\f!\"\233 \240\210\202\"! I\210+S\202cW\203\272\316V\203\272 \203M  \203A H!\202FH\"?\n=\202\241\f\203l\f \203` H!\202eH!? =\202\241\247\203\213 \203\202 H!\202\207H\232\202\241 \203\233 H!\202\240H=\203\261I\210ST\211\202_. \207" . [cl-keys 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 cl-count cl-start cl-end cl-from-end cl-keys-temp cl-old cl-new cl-seq cl-p val n seq])(#$ . 15337) nil 6 (#$ . 15085)]) #@194 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 (defalias 'nsubstitute-if #[(cl-new cl-pred cl-list &rest cl-keys) #@94 ("\304\305\306 \307\n &\207" . [cl-new cl-list cl-pred cl-keys apply nsubstitute nil :if])(#$ . 17287) nil 8 (#$ . 17021)]) #@198 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 (defalias 'nsubstitute-if-not #[(cl-new cl-pred cl-list &rest cl-keys) #@98 ("\304\305\306 \307\n &\207" . [cl-new cl-list cl-pred cl-keys apply nsubstitute nil :if-not])(#$ . 17694) nil 8 (#$ . 17420)]) #@155 Find the first occurrence of ITEM in LIST. Return the matching ITEM, or nil if not found. Keywords supported: :test :test-not :key :start :end :from-end (defalias 'find #[(cl-item cl-seq &rest cl-keys) #@91 ("\304\305 \n$\211\2050 \234)\207" . [cl-item cl-seq cl-keys cl-pos apply position])(#$ . 18040) nil 6 (#$ . 17831)]) #@146 Find the first item satisfying PREDICATE in LIST. Return the matching ITEM, or nil if not found. Keywords supported: :key :start :end :from-end (defalias 'find-if #[(cl-pred cl-list &rest cl-keys) #@79 ("\303\304\305\306 \n&\207" . [cl-list cl-pred cl-keys apply find nil :if])(#$ . 18374) nil 7 (#$ . 18170)]) #@150 Find the first item not satisfying PREDICATE in LIST. Return the matching ITEM, or nil if not found. Keywords supported: :key :start :end :from-end (defalias 'find-if-not #[(cl-pred cl-list &rest cl-keys) #@83 ("\303\304\305\306 \n&\207" . [cl-list cl-pred cl-keys apply find nil :if-not])(#$ . 18704) nil 7 (#$ . 18492)]) #@168 Find the first occurrence of ITEM in LIST. Return the index of the matching item, or nil if not found. Keywords supported: :test :test-not :key :start :end :from-end (defalias 'position #[(cl-item cl-seq &rest cl-keys) #@543 ("\306>A@\307>A@\2050\307>A@\211\2050\310\311>A@\312>A@\313>A@\20590\313>A@\211\20590\310\314>A@\206C0\315\316>A@\317>A@\211\203{0@\320>\204q0\321>A@\204q0\322\323@\"\210AA\211\204Z0)\324%.\207" . [cl-keys 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 cl-start cl-end cl-from-end cl-keys-temp cl-item cl-seq])(#$ . 19053) nil 7 (#$ . 18826)]) (defalias 'cl-position #[(cl-item cl-seq cl-start &optional cl-end cl-from-end) #@978 ("<\203\2370 \233 \2040\306\307\n\203\2340 W\203\2340\f\203#0 \203\2340\203C0 \n\20390\n\n@!\202;0\n@\"? =\202\2160\f\203a0\f\n\203W0\n\n@!\202Y0\n@!? =\202\2160 \247\203|0 \n\203v0\n\n@!\202x0\n@\232\202\2160 \n\203\2130\n\n@!\202\2150\n@=\203\2230 \nA T\2020\f*\207 \204\2460G \2031 S\211 Y\203)\203\3250 \n\203\3120\n H!\202\3150 H\"? =\202&\f\203\3650\f\n\203\3520\n H!\202\3550 H!? =\202& \247\203 \n\203 \n H!\202 H\232\202& \n\203\"\n H!\202% H=\203\2520 Y\205\273 \207 W\203\264\203Y \n\203N\n H!\202Q H\"? =\202\252\f\203y\f\n\203n\n H!\202q H!? =\202\252 \247\203\226 \n\203\217\n H!\202\222 H\232\202\252 \n\203\246\n H!\202\251 H=\204\264 T\211\2022 W\205\273 \207" . [cl-seq cl-start cl-p cl-end cl-res cl-from-end 8000000 nil cl-test cl-item cl-key cl-test-not cl-if cl-if-not])(#$ . 19715) nil 6]) #@159 Find the first item satisfying PREDICATE in LIST. Return the index of the matching item, or nil if not found. Keywords supported: :key :start :end :from-end (defalias 'position-if #[(cl-pred cl-list &rest cl-keys) #@83 ("\303\304\305\306 \n&\207" . [cl-list cl-pred cl-keys apply position nil :if])(#$ . 20940) nil 7 (#$ . 20719)]) #@163 Find the first item not satisfying PREDICATE in LIST. Return the index of the matching item, or nil if not found. Keywords supported: :key :start :end :from-end (defalias 'position-if-not #[(cl-pred cl-list &rest cl-keys) #@87 ("\303\304\305\306 \n&\207" . [cl-list cl-pred cl-keys apply position nil :if-not])(#$ . 21291) nil 7 (#$ . 21062)]) #@104 Count the number of occurrences of ITEM in LIST. Keywords supported: :test :test-not :key :start :end (defalias 'count #[(cl-item cl-seq &rest cl-keys) #@816 ("\306>A@\307>A@\2050\307>A@\211\2050\310\311>A@\312>A@\313>A@\20590\313>A@\211\20590\310\314>A@\206C0\315\316>A@\211\203t0@\317>\204j0\320>A@\204j0\321\322@\"\210AA\211\204S0)\315\323\204\2050G:\203\2220\233W\203_:\203\2520\211A@\202\2570H \203\3140  \203\3030 !\202\3050\"?\n=\202\f\203\3450\f \203\3340 !\202\3360!? =\202\247\203\3760 \203\3700 !\202\3720\232\202 \203  !\202 =\203TT\211\202\2240. \207" . [cl-keys 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 cl-start cl-end cl-keys-temp cl-x cl-count cl-seq cl-item])(#$ . 21577) nil 5 (#$ . 21417)]) #@95 Count the number of items satisfying PREDICATE in LIST. Keywords supported: :key :start :end (defalias 'count-if #[(cl-pred cl-list &rest cl-keys) #@80 ("\303\304\305\306 \n&\207" . [cl-list cl-pred cl-keys apply count nil :if])(#$ . 22585) nil 7 (#$ . 22431)]) #@99 Count the number of items not satisfying PREDICATE in LIST. Keywords supported: :key :start :end (defalias 'count-if-not #[(cl-pred cl-list &rest cl-keys) #@84 ("\303\304\305\306 \n&\207" . [cl-list cl-pred cl-keys apply count nil :if-not])(#$ . 22865) nil 7 (#$ . 22703)]) #@286 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 (defalias 'mismatch #[(cl-seq1 cl-seq2 &rest cl-keys) #@1637 ("\306>A@\307>A@\2050\307>A@\211\2050\310\311>A@\312>A@\313>A@\206/0\314\315>A@\316>A@\206@0\314\317>A@\211\203q0@\320>\204g0\321>A@\204g0\322\323@\"\210AA\211\204P0)\204|0G\204\2060G\f\203f W\203QW\203Q \203\3170 \203\2550 S\234!\202\2630S\234 \203\3020 S\234!\202\3100S\234\"?\n=\202A \203\3360 S\234!\202\3440S\234\247\203 \203\3670 S\234!\202\3750S\234 \203\f S\234!\202S\234\232\202A \203% S\234!\202+S\234 \203: S\234!\202@S\234=\203QSS\202\2120 W\204`W\205\343S\202\343<\205p \233<\205{\233 W\203\322W\203\322 \203\352 \203\253 \203\243@\202\247 H!\202\272\203\266@\202\272 H \203\323 \203\312@\202\317H!\202\343\203\336@\202\343H\"?\n=\202\272 \203 \203\372@\202\376 H!\202\203 @\202 H\247\203i \203- \203%@\202) H!\202<\2038@\202< H \203U \203L@\202QH!\202e\203`@\202eH\232\202\272 \203\201 \203y@\202} H!\202\220\203\214@\202\220 H \203\251 \203\240@\202\245H!\202\271\203\264@\202\271H=\203\322AA TT\202 W\204\341W\205\342 *.\207" . [cl-keys cl-test cl-test-not cl-key cl-from-end cl-start1 :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" cl-end1 cl-start2 cl-end2 cl-keys-temp cl-seq1 cl-seq2 cl-p2 cl-p1])(#$ . 23335) nil 6 (#$ . 22988)]) #@226 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 (defalias 'search #[(cl-seq1 cl-seq2 &rest cl-keys) #@867 ("\306>A@\307>A@\2050\307>A@\211\2050\310\311>A@\312>A@\313>A@\206/0\314\315>A@\316>A@\206@0\314\317>A@\211\203q0@\320>\204g0\321>A@\204g0\322\323@\"\210AA\211\204P0)\204|0G\204\2060G Y\203\2330\f\203\2260\202\202 Z \203\2560  \234!\202\2620 \234_\324 \324!SZW\203 \325_\f%\211!\203 \326\327\313 T\315\316!T\317!\\\312\324&\203 \f\203!\202\3020!T\211\202\3040W\205!,.\207" . [cl-keys cl-test cl-test-not cl-key cl-from-end cl-start1 :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 mismatch cl-end1 cl-start2 cl-end2 cl-keys-temp cl-seq1 cl-seq2 cl-len cl-first cl-if cl-pos])(#$ . 25295) nil 16 (#$ . 25011)]) #@157 Sort the argument SEQUENCE according to PREDICATE. This is a destructive function; it reuses the storage of SEQUENCE if possible. Keywords supported: :key (defalias 'sort* #[(cl-seq cl-pred &rest cl-keys) #@403 ("<\2040\305\306\307\310\311\" \n$\"\207\312\n>A@\n\211\203;0\f@\313>\20430\314\n>A@\20430\315\316\f@\"\210\fAA\211\2040) \317>\203I0\320 \"\202M0\320\321\")\207" . [cl-seq cl-pred cl-keys cl-key cl-keys-temp replace apply sort* append nil :key (:key) :allow-other-keys error "Bad keyword argument %s" (nil identity) sort #[(cl-x cl-y) " \n! !\"\207" [cl-pred cl-key cl-x cl-y] 4]])(#$ . 26415) nil 8 (#$ . 26202)]) #@164 Sort the argument SEQUENCE stably according to PREDICATE. This is a destructive function; it reuses the storage of SEQUENCE if possible. Keywords supported: :key (defalias 'stable-sort #[(cl-seq cl-pred &rest cl-keys) #@62 ("\303\304 \n$\207" . [cl-seq cl-pred cl-keys apply sort*])(#$ . 27082) nil 5 (#$ . 26857)]) #@228 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 PRED is a `less-than' predicate on the elements. Keywords supported: :key (defalias 'merge #[(cl-type cl-seq1 cl-seq2 cl-pred &rest cl-keys) #@427 ("<\204\n0\306\307\" <\2040\306 \307\"\310\n>A@\n\211\203=0\f@\311>\20450\312\n>A@\20450\313\314\f@\"\210\fAA\211\204 0)\307\203~0 \203~0 \203U0 @!\202W0 @ \203b0 @!\202d0@\"\203s0 \211A@ B\202@0\211A@ B\202@0\315 \237\244 \244\"*\207" . [cl-seq1 cl-seq2 cl-keys cl-key cl-keys-temp cl-res append nil :key (:key) :allow-other-keys error "Bad keyword argument %s" coerce cl-pred cl-type])(#$ . 27484) nil 5 (#$ . 27183)]) #@132 Find the first occurrence of ITEM in LIST. Return the sublist of LIST whose car is ITEM. Keywords supported: :test :test-not :key (defalias 'member* #[(cl-item cl-list &rest cl-keys) #@713 ("\203\3410\306>A@\307>A@\2050\307>A@\211\2050\310\311>A@\312>A@\313>A@\205=0\313>A@\211\205=0\310\211\203f0@\314>\204\\0\315>A@\204\\0\316\317@\"\210AA\211\204E0)\203\3350 \203\2110  \2030 @!\202\2020@\"?\n=\202\3210\f\203\2440\f \203\2320 @!\202\2350@!? =\202\3210\247\203\2770 \203\2700 @!\202\2730@\232\202\3210 \203\3150 @!\202\3200@=\204\3350A\211\204l0-\207\247\203\3630\250\204\3630\235\207>\207" . [cl-keys 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" cl-keys-temp cl-list cl-item])(#$ . 28141) nil 5 (#$ . 27950)]) #@123 Find the first item satisfying PREDICATE in LIST. Return the sublist of LIST whose car matches. Keywords supported: :key (defalias 'member-if #[(cl-pred cl-list &rest cl-keys) #@82 ("\303\304\305\306 \n&\207" . [cl-list cl-pred cl-keys apply member* nil :if])(#$ . 29076) nil 7 (#$ . 28893)]) #@127 Find the first item not satisfying PREDICATE in LIST. Return the sublist of LIST whose car matches. Keywords supported: :key (defalias 'member-if-not #[(cl-pred cl-list &rest cl-keys) #@86 ("\303\304\305\306 \n&\207" . [cl-list cl-pred cl-keys apply member* nil :if-not])(#$ . 29388) nil 7 (#$ . 29197)]) (defalias 'cl-adjoin #[(cl-item cl-list &rest cl-keys) #@122 ("\304>A@\305\306 \2030 \n!\2020\n $)\2030 \207\n B\207" . [cl-keys cl-key cl-item cl-list :key apply member*])(#$ . 29568) nil 5]) #@95 Find the first item whose car matches ITEM in LIST. Keywords supported: :test :test-not :key (defalias 'assoc* #[(cl-item cl-alist &rest cl-keys) #@757 ("\203\3660\306>A@\307>A@\2050\307>A@\211\2050\310\311>A@\312>A@\313>A@\205=0\313>A@\211\205=0\310\211\203f0@\314>\204\\0\315>A@\204\\0\316\317@\"\210AA\211\204E0)\203\3540@:\203\3430 \203\2220  \203\2070 @@!\202\2130@@\"?\n=\202\3400\f\203\2570\f \203\2440 @@!\202\2500@@!? =\202\3400\247\203\3140 \203\3040 @@!\202\3100@@\232\202\3400 \203\3330 @@!\202\3370@@=\204\3540A\211\204l0\205\3640@-\207\247\203 \250\204 \320\"\207\236\207" . [cl-keys 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" assoc cl-keys-temp cl-alist cl-item])(#$ . 29869) nil 5 (#$ . 29715)]) #@86 Find the first item whose car satisfies PREDICATE in LIST. Keywords supported: :key (defalias 'assoc-if #[(cl-pred cl-list &rest cl-keys) #@81 ("\303\304\305\306 \n&\207" . [cl-list cl-pred cl-keys apply assoc* nil :if])(#$ . 30809) nil 7 (#$ . 30664)]) #@93 Find the first item whose car does not satisfy PREDICATE in LIST. Keywords supported: :key (defalias 'assoc-if-not #[(cl-pred cl-list &rest cl-keys) #@85 ("\303\304\305\306 \n&\207" . [cl-list cl-pred cl-keys apply assoc* nil :if-not])(#$ . 31084) nil 7 (#$ . 30928)]) #@95 Find the first item whose cdr matches ITEM in LIST. Keywords supported: :test :test-not :key (defalias 'rassoc* #[(cl-item cl-alist &rest cl-keys) #@735 ("\204 0 \247\203\3710\306>A@\307>A@\205\"0\307>A@\211\205\"0\310\311>A@\312>A@\313>A@\205B0\313>A@\211\205B0\310\211\203l0@\314>\204b0\315>A@\204b0\316\317@\"\210AA\211\204K0)\203\3570@:\203\3460\n\203\2270\n \f\203\2140\f@A!\202\2200@A\"? =\202\3430 \203\2650 \f\203\2510\f@A!\202\2550@A!?=\202\3430 \247\203\3200 \f\203\3100\f@A!\202\3140@A\232\202\3430 \f\203\3360\f@A!\202\3420@A=\204\3570A\211\204r0\205\3670@-\207\320 \"\207" . [cl-keys cl-item cl-test cl-test-not cl-key cl-if :test :test-not t :key :if :if-not (:test :test-not :key :if :if-not) :allow-other-keys error "Bad keyword argument %s" rassq cl-if-not cl-keys-temp cl-alist])(#$ . 31362) nil 5 (#$ . 31207)]) #@86 Find the first item whose cdr satisfies PREDICATE in LIST. Keywords supported: :key (defalias 'rassoc-if #[(cl-pred cl-list &rest cl-keys) #@82 ("\303\304\305\306 \n&\207" . [cl-list cl-pred cl-keys apply rassoc* nil :if])(#$ . 32281) nil 7 (#$ . 32135)]) #@93 Find the first item whose cdr does not satisfy PREDICATE in LIST. Keywords supported: :key (defalias 'rassoc-if-not #[(cl-pred cl-list &rest cl-keys) #@86 ("\303\304\305\306 \n&\207" . [cl-list cl-pred cl-keys apply rassoc* nil :if-not])(#$ . 32558) nil 7 (#$ . 32401)]) #@296 Combine LIST1 and LIST2 using a set-union operation. The result 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 (defalias 'union #[(cl-list1 cl-list2 &rest cl-keys) #@202 ("\2040 \207 \204\f0\207 \232\2030\207G GY\204 0  \203N0\n\204.0 @\247\20390\303\304 @\n$\202E0 @>\204E0 @B \211A@\210\202 0\207" . [cl-list1 cl-list2 cl-keys apply adjoin])(#$ . 33038) nil 5 (#$ . 32683)]) #@261 Combine LIST1 and LIST2 using a set-union operation. The result 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 (defalias 'nunion #[(cl-list1 cl-list2 &rest cl-keys) #@92 ("\2040 \207 \204\f0\207\303\304 \n$\207" . [cl-list1 cl-list2 cl-keys apply union])(#$ . 33599) nil 5 (#$ . 33279)]) #@302 Combine LIST1 and LIST2 using a set-intersection operation. The result 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 (defalias 'intersection #[(cl-list1 cl-list2 &rest cl-keys) #@423 ("\205\2020 \205\2020 \232\2030\207\306\n>A@\n\211\20390\f@\307>\20410\310\n>A@\20410\311\312\f@\"\210\fAA\211\2040)\313G GY\204H0  \203\2000\n\204V0 @\247\203k0\314\315 \203c0 @!\202e0 @\n$\202o0 @>\203w0 @ B \211A@\210\202H0 *\207" . [cl-list1 cl-list2 cl-keys cl-key cl-keys-temp cl-res :key (:key :test :test-not) :allow-other-keys error "Bad keyword argument %s" nil apply member*])(#$ . 34098) nil 6 (#$ . 33730)]) #@267 Combine LIST1 and LIST2 using a set-intersection operation. The result 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 (defalias 'nintersection #[(cl-list1 cl-list2 &rest cl-keys) #@88 ("\2050 \2050\303\304 \n$\207" . [cl-list1 cl-list2 cl-keys apply intersection])(#$ . 34893) nil 5 (#$ . 34560)]) #@299 Combine LIST1 and LIST2 using a set-difference operation. The result 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 (defalias 'set-difference #[(cl-list1 cl-list2 &rest cl-keys) #@386 ("\2030 \204\n0\207\306\n>A@\n\211\20330\f@\307>\204+0\310\n>A@\204+0\311\312\f@\"\210\fAA\211\2040)\313\203n0\n\204D0@\247\203Y0\314\315 \203Q0 @!\202S0@ \n$\202]0@ >\204e0@ B\211A@\210\20260 *\207" . [cl-list1 cl-list2 cl-keys cl-key cl-keys-temp cl-res :key (:key :test :test-not) :allow-other-keys error "Bad keyword argument %s" nil apply member*])(#$ . 35387) nil 6 (#$ . 35020)]) #@264 Combine LIST1 and LIST2 using a set-difference operation. The result 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 (defalias 'nset-difference #[(cl-list1 cl-list2 &rest cl-keys) #@96 ("\2030 \204\n0\207\303\304 \n$\207" . [cl-list1 cl-list2 cl-keys apply set-difference])(#$ . 36144) nil 5 (#$ . 35812)]) #@309 Combine LIST1 and LIST2 using a set-exclusive-or operation. The result list contains all items that appear 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 (defalias 'set-exclusive-or #[(cl-list1 cl-list2 &rest cl-keys) #@152 ("\2040 \207 \204\f0\207 \232\2030\303\207\304\305\306 \n$\305\306 \n$\"\207" . [cl-list1 cl-list2 cl-keys nil append apply set-difference])(#$ . 36658) nil 7 (#$ . 36279)]) #@274 Combine LIST1 and LIST2 using a set-exclusive-or operation. The result list contains all items that appear 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 (defalias 'nset-exclusive-or #[(cl-list1 cl-list2 &rest cl-keys) #@144 ("\2040 \207 \204\f0\207 \232\2030\303\207\304\305 \n$\304\305 \n$\244\207" . [cl-list1 cl-list2 cl-keys nil apply nset-difference])(#$ . 37194) nil 6 (#$ . 36849)]) #@134 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 (defalias 'subsetp #[(cl-list1 cl-list2 &rest cl-keys) #@371 ("\2040\305\207 \204\f0\306\207 \232\2030\305\207\307\n>A@\n\211\203=0\f@\310>\20450\311\n>A@\20450\312\313\f@\"\210\fAA\211\204 0)\203`0\314\315 \203O0 @!\202Q0@ \n$\203`0\211A@\210\202>0)?\207" . [cl-list1 cl-list2 cl-keys cl-key cl-keys-temp t nil :key (:key :test :test-not) :allow-other-keys error "Bad keyword argument %s" apply member*])(#$ . 37572) nil 6 (#$ . 37377)]) #@169 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 (defalias 'subst-if #[(cl-new cl-pred cl-tree &rest cl-keys) #@91 ("\304\305\306BC \307\n &\207" . [cl-new cl-tree cl-pred cl-keys apply sublis nil :if])(#$ . 38217) nil 7 (#$ . 37982)]) #@173 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 (defalias 'subst-if-not #[(cl-new cl-pred cl-tree &rest cl-keys) #@95 ("\304\305\306BC \307\n &\207" . [cl-new cl-tree cl-pred cl-keys apply sublis nil :if-not])(#$ . 38590) nil 7 (#$ . 38347)]) #@188 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 (defalias 'nsubst #[(cl-new cl-old cl-tree &rest cl-keys) #@74 ("\304\305 BC\n $\207" . [cl-old cl-new cl-tree cl-keys apply nsublis])(#$ . 38975) nil 5 (#$ . 38724)]) #@177 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 (defalias 'nsubst-if #[(cl-new cl-pred cl-tree &rest cl-keys) #@92 ("\304\305\306BC \307\n &\207" . [cl-new cl-tree cl-pred cl-keys apply nsublis nil :if])(#$ . 39332) nil 7 (#$ . 39088)]) #@181 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 (defalias 'nsubst-if-not #[(cl-new cl-pred cl-tree &rest cl-keys) #@96 ("\304\305\306BC \307\n &\207" . [cl-new cl-tree cl-pred cl-keys apply nsublis nil :if-not])(#$ . 39715) nil 7 (#$ . 39463)]) #@172 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 (defalias 'sublis #[(cl-alist cl-tree &rest cl-keys) #@414 ("\306>A@\307>A@\2050\307>A@\211\2050\310\311>A@\312>A@\313>A@\20590\313>A@\211\20590\310\211\203b0@\314>\204X0\315>A@\204X0\316\317@\"\210AA\211\204A0)\320!-\207" . [cl-keys 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" cl-sublis-rec cl-keys-temp cl-tree])(#$ . 40081) nil 4 (#$ . 39850)]) (byte-code "\301B\301\207" [current-load-list cl-alist] 2) (defalias 'cl-sublis-rec #[(cl-tree) #@361 ("\203\n0 !\202 0 \n \203Q0 \203#0 @@\f\"?=\202G0\20330\f!? =\202G0 @@\247\203B0 @@\f\232\202G0 @@\f=\204Q0 A\211\2040 \203[0 @A\202\2110 :\203\2100\306 @!\306 A!\n\211 @=\2030\n A=\2030 \202\2040 \nB*\202\2110 *\207" . [cl-key cl-tree cl-alist cl-p cl-temp cl-test cl-sublis-rec cl-test-not cl-if cl-if-not cl-d cl-a])(#$ . 40632) nil 4]) #@173 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 (defalias 'nsublis #[(cl-alist cl-tree &rest cl-keys) #@436 ("\306>A@\307>A@\2050\307>A@\211\2050\310\311>A@\312>A@\313>A@\20590\313>A@\211\20590\310\211\203b0@\314>\204X0\315>A@\204X0\316\317@\"\210AA\211\204A0)C\320!\210@.\207" . [cl-keys 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" cl-nsublis-rec cl-keys-temp cl-tree cl-hold])(#$ . 41252) nil 4 (#$ . 41019)]) (defalias 'cl-nsublis-rec #[(cl-tree) #@532 (":\205\3310 \2030 @!\2020@\n \203X0 \203*0 @@\f\"?=\202N0 \203:0 \f!?\n=\202N0 @@\247\203I0 @@\f\232\202N0 @@\f=\204X0 A\211\2040 \203e0 @A\240\210\202p0@:\203p0\306@!\210 \203{0 A!\202}0A\n\211\203\3030 \203\2250 @@\f\"?=\202\2710 \203\2450 \f!?\n=\202\2710 @@\247\203\2640 @@\f\232\202\2710 @@\f=\204\3030 A\211\204\2040 \203\3220 @A\241\210\307\202\3250A*\20200\207" . [cl-tree cl-key cl-alist cl-p cl-temp cl-test cl-nsublis-rec nil cl-test-not cl-if cl-if-not])(#$ . 41765) nil 4]) #@147 T if trees X and Y have `eql' leaves. Atoms are compared by `eql'; cons cells are compared recursively. Keywords supported: :test :test-not :key (defalias 'tree-equal #[(cl-x cl-y &rest cl-keys) #@331 ("\306>A@\307>A@\2050\307>A@\211\2050\310\311>A@\211\203C0\f@\312>\204;0\313>A@\204;0\314\315\f@\"\210\fAA\211\204&0)\316 \"+\207" . [cl-keys cl-test cl-test-not cl-key cl-keys-temp cl-x :test :test-not t :key (:test :test-not :key) :allow-other-keys error "Bad keyword argument %s" cl-tree-equal-rec cl-y])(#$ . 42526) nil 4 (#$ . 42323)]) (defalias 'cl-tree-equal-rec #[(cl-x cl-y) #@324 (":\2030 :\2030\305@ @\"\2030A A\20200:?\205\2060 :?\205\2060\n\203H0\n \20370 !\20280 \203B0 !\202C0 \"?\f=\207 \203R0 !\202S0\247\203o0 \203a0 !\202b0 \203l0 !\202m0 \232\207 \203y0 !\202z0 \203\2040 !\202\2050 =\207" . [cl-x cl-y cl-test cl-key cl-test-not cl-tree-equal-rec])(#$ . 42939) nil 4]) (run-hooks 'cl-seq-load-hook)