Current File : //proc/thread-self/root/kunden/usr/share/emacs/27.2/lisp/emacs-lisp/cl-extra.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.

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


(byte-code "\300\301!\210\300\302!\207" [require cl-lib seq] 2)
#@85 Coerce OBJECT to type TYPE.
TYPE is a Common Lisp type specifier.

(fn OBJECT TYPE)
(defalias 'cl-coerce #[514 "\211\300\267\202E
<\203

\207\301\302\"\207\303!\203
\207\304!\207\305!\203&
\207\306\307\310\311\"\"\207
;\2035
\207
\260
\207\312!\203A
\207\304!\207\211\313=\203[
;\203[
G\314U\203[
\315H\207\211\313=\203m
9\203m\310\316!\"\207\211\317=\203w\317!\207\320\"\203\200
\207\321\322#\207" [#s(hash-table size 5 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (list 6 vector 18 bool-vector 30 string 46 array 57)) append nil vectorp vconcat bool-vector-p apply bool-vector cl-coerce list arrayp character 1 0 symbol-name float cl-typep error "Can't coerce %s to type %s"] 7 (#$ . 472)])
#@235 Return t if two Lisp objects have similar structures and contents.
This is like `equal', except that it accepts numerically equal
numbers of different types (float vs. integer), and also compares
strings case-insensitively.

(fn X Y)
(defalias 'cl-equalp #[514 "

=\203\300\207
;\203&\211;\205\224
G
GU\205\224

\230\206%
\227
\227\230\207
\247\2034\211\247\205\224

U\207
:\203b
:\203W\211:\203W\301@@\"\203W
A\262\211A\262
\2029
:?\205\224\301\"\207\302!\203\221\302
!\205\224
G
GU\205\224
G\211S\211\262\303Y\203\215\301HH\"\204x\211\303W\207

\232\207" [t cl-equalp vectorp 0] 7 (#$ . 1219)])
#@38 

(fn CL-FUNC CL-SEQS &optional ACC)
(defalias 'cl--mapcar-many #[770 "
AA\203w\300\301\302\303\304\"\"\305\306!\300\211\306!\262W\203o\262\262

\203P\211@:\203?@@\211@A\240\210\202C@H\240\210
A\262\211A\262
\202(\203b\301	\"B\262\202h\301	\"\210T\262\202\205v\237\207\300@A@
G
G^\307\211T\211\262W\203\301:\203\235\211A\262\242\202\240H:\203\256\211A\262\242\202\261H\"\203\275\211B\262\210\202\203\266\205\311\237\207" [nil apply min mapcar length 0 copy-sequence -1] 13 (#$ . 1852)])
#@137 Map a FUNCTION across one or more SEQUENCEs, returning a sequence.
TYPE is the sequence type to return.

(fn TYPE FUNCTION SEQUENCE...)
(defalias 'cl-map #[899 "\300\301$\205\302
\"\207" [apply cl-mapcar cl-coerce] 9 (#$ . 2421)])
#@169 Map FUNCTION to each sublist of LIST or LISTs.
Like `cl-mapcar', except applies to lists and their cdr's rather than to
the elements themselves.

(fn FUNCTION LIST...)
(defalias 'cl-maplist #[642 "\211\2031\300\301!B\300\300>\204.\302\"B\262
\262
\211\203\211
\211A\262\242A\240\210\202\237\207\300\203D!
B\262
A\262\2022\211\237\207" [nil copy-sequence apply] 9 (#$ . 2667)])
#@103 Like `cl-mapcar', but does not accumulate values returned by the function.

(fn FUNCTION SEQUENCE...)
(defalias 'cl-mapc #[642 "\211\203<\211A\204
<\203\211@<\204\300B\"\210
\207

@
\203:\211\203:\211A\262\242\211A\262\242\"\210\202 \207\301\"\207" [cl--mapcar-many mapc] 9 (#$ . 3074)])
#@100 Like `cl-maplist', but does not accumulate values returned by the function.

(fn FUNCTION LIST...)
(defalias 'cl-mapl #[642 "\211\203.
\300!B\301\301>\204)\302\"\210
\262
\211\203\n\211
\211A\262\242A\240\210\202\266\202?
\211\203>
!\210\211A\262
\202/\210
\207" [copy-sequence nil apply] 8 (#$ . 3390)])
#@104 Like `cl-mapcar', but nconc's together the values returned by the function.

(fn FUNCTION SEQUENCE...)
(defalias 'cl-mapcan #[642 "\211\203\300\301\300\302$\"\207\303\"\207" [apply nconc cl-mapcar mapcan] 10 (#$ . 3717)])
#@101 Like `cl-maplist', but nconc's together the values returned by the function.

(fn FUNCTION LIST...)
(defalias 'cl-mapcon #[642 "\300\301\300\302$\"\207" [apply nconc cl-maplist] 10 (#$ . 3956)])
#@150 Return true if PREDICATE is true of any element of SEQ or SEQs.
If so, return the true (non-nil) value returned by PREDICATE.

(fn PREDICATE SEQ...)
(defalias 'cl-some #[642 "\211\204	
<\204$\3002:\301\302\303\304\305\306\307\310\n!\311\"\312\313%%\210\3030\207\303\2037\211A\262\242!\211\262\203%\211\262
\207" [cl-some apply cl-map nil make-byte-code 128 "\301\300\"\211\205\f\302\303\"\207" vconcat vector [apply throw cl-some] 5 "\n\n(fn &rest CL-X)"] 12 (#$ . 4164)])
#@90 Return true if PREDICATE is true of every element of SEQ or SEQs.

(fn PREDICATE SEQ...)
(defalias 'cl-every #[642 "\211\204	
<\204$\30028\301\302\303\304\305\306\307\310\n!\311\"\312\313%%\210\3140\207
\2036@!\2036
A\262\202$
?\207" [cl-every apply cl-map nil make-byte-code 128 "\301\300\"\206\302\303\304\"\207" vconcat vector [apply throw cl-every nil] 4 "\n\n(fn &rest CL-X)" t] 12 (#$ . 4659)])
#@91 Return true if PREDICATE is false of every element of SEQ or SEQs.

(fn PREDICATE SEQ...)
(defalias 'cl-notany #[642 "\300\301$?\207" [apply cl-some] 8 (#$ . 5081)])
#@90 Return true if PREDICATE is false of some element of SEQ or SEQs.

(fn PREDICATE SEQ...)
(defalias 'cl-notevery #[642 "\300\301$?\207" [apply cl-every] 8 (#$ . 5256)])
#@45 

(fn CL-FUNC-REC CL-MAP &optional CL-BASE)
(defalias 'cl--map-keymap-recursively #[770 "\211C\211\242\204
\211\300\301!\240\210\302\303\304\305\306\307	\"\310\"\311\312%\"\207" [copy-sequence [0] map-keymap make-byte-code 514 "\301\242\301\242GSI\210\302
!\203\303\300\304\301\242\305C\"#\207\300\301\242\"\207" vconcat vector [keymapp cl--map-keymap-recursively vconcat 0] 8 "\n\n(fn CL-KEY CL-BIND)"] 12 (#$ . 5433)])
#@58 

(fn CL-FUNC &optional CL-WHAT CL-PROP CL-START CL-END)
(defalias 'cl--map-intervals #[1281 "\204p\262\300!\203\203\301\211\302\301rq\210\303\206e!\262\205'\303!\262)
\203u\2038W\203u\203G\304\n#\202L\305	\"\262
\206Yrq\210d)\262
\306!\301\223\210\203o^\202p\"\210\202*\301\211\223\210\205\202\301\211\223\207
\204\212\307\262\211\204\222G\262


W\205\271\203\245\304#\202\251\305\"\206\255\211^\"\210\262\202\222\207" [bufferp nil t copy-marker next-single-property-change next-property-change marker-position 0] 14 (#$ . 5870)])
#@59 

(fn CL-FUNC &optional CL-BUFFER CL-START CL-END CL-ARG)
(defalias 'cl--map-overlays #[1281 "\204p\262\300rq\210\301 \262
\203\302!\262\203\"\302!\262)\211@
A\244\262
\211\203^\303
@!\203W\203B\303
@!Y\204W\203O\304
@!X\204W
@\"\204^\211A\262
\202*\203g\300\211\223\210\205o\300\211\223\207" [nil overlay-lists copy-marker overlay-start overlay-end] 9 (#$ . 6482)])
#@18 

(fn FRAME VAL)
(defalias 'cl--set-frame-visible-p #[514 "\211\204\300!\210\202\211\301=\203\302!\210\202\303!\210\207" [make-frame-invisible icon iconify-frame make-frame-visible] 4 (#$ . 6889)])
#@71 Return the greatest common divisor of the arguments.

(fn &rest ARGS)
(defalias 'cl-gcd #[128 "\211
A\262\242\206\n\300
\211\203)\211@\211\300U\204\"
\211\262\246\262
\202
A\266\202\202\210\301
!\207" [0 abs] 7 (#$ . 7104)])
#@69 Return the least common multiple of the arguments.

(fn &rest ARGS)
(defalias 'cl-lcm #[128 "\300
>\203\300\207\211
A\262\242\206\301
\211\203*\211@\302\"\245
_\262
A\266\202\202\210\303
!\207" [0 1 cl-gcd abs] 8 (#$ . 7345)])
#@67 Return the integer square root of the (integer) argument.

(fn X)
(defalias 'cl-isqrt #[257 "\211\250\203+\211\300V\203+\301\302\303!\302\245\"\304
\245\\\302\245\211\262W\203)\211\262\202
\207\211\300=\2033\300\207\305\306\304\"\207" [0 ash 2 logb nil signal arith-error] 6 (#$ . 7590)])
#@149 Return a list of the floor of X and the fractional part of X.
With two arguments, return floor and remainder of their quotient.

(fn X &optional Y)
(defalias 'cl-floor #[513 "\300\"\211\203_\202ZD\207" [floor] 7 (#$ . 7898)])
#@153 Return a list of the ceiling of X and the fractional part of X.
With two arguments, return ceiling and remainder of their quotient.

(fn X &optional Y)
(defalias 'cl-ceiling #[513 "\300\"\211A@\301U\203\211\202\211@T
A@\206\302ZD\207" [cl-floor 0 1] 6 (#$ . 8142)])
#@161 Return a list of the integer part of X and the fractional part of X.
With two arguments, return truncation and remainder of their quotient.

(fn X &optional Y)
(defalias 'cl-truncate #[513 "
\300Y
?\206
\300Y=\203\301\"\207\302\"\207" [0 cl-floor cl-ceiling] 5 (#$ . 8424)])
#@159 Return a list of X rounded to the nearest integer and the remainder.
With two arguments, return rounding and remainder of their quotient.

(fn X &optional Y)
(defalias 'cl-round #[513 "\211\203N
\250\203A\211\250\203A\211\300\245\301\\\"\211A@\302U\2038
\211\\U\2038\211@\300\246\302U\2048\211@SD\202@\211@
A@ZD\207\303\245!\211_ZD\207
\250\203W
\302D\207\303!\211ZD\207" [2 cl-floor 0 round] 7 (#$ . 8714)])
#@69 The remainder of X divided by Y, with the same sign as Y.

(fn X Y)
(defalias 'cl-mod #[514 "\300\"A@\207" [cl-floor] 5 (#$ . 9151)])
#@69 The remainder of X divided by Y, with the same sign as X.

(fn X Y)
(defalias 'cl-rem #[514 "\300\"A@\207" [cl-truncate] 5 (#$ . 9293)])
#@63 Return 1 if X is positive, -1 if negative, 0 if zero.

(fn X)
(defalias 'cl-signum #[257 "\211\300V\203\301\207\211\300W\203\302\207\300\207" [0 1 -1] 3 (#$ . 9438)])
#@399 Parse integer from the substring of STRING from START to END.
STRING may be surrounded by whitespace chars (chars with syntax ` ').
Other non-digit chars are considered junk.
RADIX is an integer between 2 and 36, the default is 10.  Signal
an error if the substring between START and END cannot be parsed
as an integer unless JUNK-ALLOWED is non-nil.

(fn STRING &key START END RADIX JUNK-ALLOWED)
(defalias 'cl-parse-integer #[385 "\300
\301\"A@\300\302\"A@\300\303\"A@\300\304\"A@\211\203D\211@\305>\203,\211AA\262
\202\306>A@\203;\307\262
\202\310\311@\"\210\202\210;\204S\312\313\314\314E\"\210\206X\315CG\206a\211\206f\316\242X\203s
X\204z\310\317\242#\210\320\211#\210\242W\205\217\n\242H\211\321\267\202\251\211\242T\240\210\322\202\252\211\242T\240\210\323\202\252\322\262
\307\211\242W\203\334\324	\242H\"\211\262\203\334\211\206\314\315_\\\262
\211\242T\240\210\202\256	#\210\203\362\211\204\362\211\202
\203\375
_\202
\242U\203\n
\211\204
\310\325\"\202

_\266\203\262
\266\204\207" [plist-member :start :end :radix :junk-allowed (:start :end :radix :junk-allowed :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:start :end :radix :junk-allowed)" signal wrong-type-argument string 0 10 "Bad interval: [%d, %d)" #[771 "
\242
W\205\242Hz\300U\205
\211\242T\240\210\202\207" [32] 5 "\n\n(fn STRING START END)"] #s(hash-table size 2 test eql rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (43 149 45 159)) 1 -1 cl-digit-char-p "Not an integer string: `%s'"] 18 (#$ . 9616)])
(defalias 'cl--random-time #[0 "\300\301\302\"@\207" [time-convert nil t] 3])
#@74 compiler-macro for inlining `cl-random-state-p'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'cl-random-state-p--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block cl-random-state-p (and (memq (type-of cl-x) cl-struct-cl--random-state-tags) t)) nil] 9 (#$ . 11324)])
(put 'cl-random-state-p 'compiler-macro 'cl-random-state-p--cmacro)
#@13 

(fn CL-X)
(defalias 'cl-random-state-p #[257 "\301
!>\205	\302\207" [cl-struct-cl--random-state-tags type-of t] 3 (#$ . 11690)])
(byte-code "\300\301\302\303#\304\305\306\301#\207" [function-put cl-random-state-p side-effect-free error-free put cl--random-state cl-deftype-satisfies] 5)
#@75 compiler-macro for inlining `cl--random-state-i'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'cl--random-state-i--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block cl--random-state-i (progn (or (cl-random-state-p cl-x) (signal 'wrong-type-argument (list 'cl--random-state cl-x))) (aref cl-x 1))) nil] 9 (#$ . 11987)])
(put 'cl--random-state-i 'compiler-macro 'cl--random-state-i--cmacro)
#@63 Access slot "i" of `cl--random-state' struct CL-X.

(fn CL-X)
(defalias 'cl--random-state-i #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-cl--random-state-tags type-of signal wrong-type-argument cl--random-state 1] 5 (#$ . 12408)])
(byte-code "\300\301\302\303#\300\207" [function-put cl--random-state-i side-effect-free t] 4)
#@75 compiler-macro for inlining `cl--random-state-j'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'cl--random-state-j--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block cl--random-state-j (progn (or (cl-random-state-p cl-x) (signal 'wrong-type-argument (list 'cl--random-state cl-x))) (aref cl-x 2))) nil] 9 (#$ . 12762)])
(put 'cl--random-state-j 'compiler-macro 'cl--random-state-j--cmacro)
#@63 Access slot "j" of `cl--random-state' struct CL-X.

(fn CL-X)
(defalias 'cl--random-state-j #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-cl--random-state-tags type-of signal wrong-type-argument cl--random-state 2] 5 (#$ . 13183)])
(byte-code "\300\301\302\303#\300\207" [function-put cl--random-state-j side-effect-free t] 4)
#@77 compiler-macro for inlining `cl--random-state-vec'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'cl--random-state-vec--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block cl--random-state-vec (progn (or (cl-random-state-p cl-x) (signal 'wrong-type-argument (list 'cl--random-state cl-x))) (aref cl-x 3))) nil] 9 (#$ . 13537)])
(put 'cl--random-state-vec 'compiler-macro 'cl--random-state-vec--cmacro)
#@65 Access slot "vec" of `cl--random-state' struct CL-X.

(fn CL-X)
(defalias 'cl--random-state-vec #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-cl--random-state-tags type-of signal wrong-type-argument cl--random-state 3] 5 (#$ . 13968)])
(byte-code "\300\301\302\303#\300\207" [function-put cl--random-state-vec side-effect-free t] 4)
#@77 compiler-macro for inlining `cl--make-random-state'.

(fn CL-WHOLE-ARG VEC)
(defalias 'cl--make-random-state--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (vec) (cl-block cl--make-random-state (record 'cl--random-state -1 30 vec)) nil] 9 (#$ . 14328)])
(put 'cl--make-random-state 'compiler-macro 'cl--make-random-state--cmacro)
#@63 Constructor for objects of type `cl--random-state'.

(fn VEC)
(defalias 'cl--make-random-state #[257 "\300\301\302\303$\207" [record cl--random-state -1 30] 6 (#$ . 14687)])
(byte-code "\300\301\302\303#\304\305\306\307\310\306\311\312\305\303&	\207" [function-put cl--make-random-state side-effect-free t cl-struct-define cl--random-state nil cl-structure-object record ((cl-tag-slot) (i -1) (j 30) (vec)) cl-struct-cl--random-state-tags] 11)
(defvar cl--random-state (byte-code "\300 \301\302\303\304$\207" [cl--random-time record cl--random-state -1 30] 6))
#@150 Return a random nonnegative number less than LIM, an integer or float.
Optional second arg STATE is a random-state object.

(fn LIM &optional STATE)
(defalias 'cl-random #[513 "\211\204\262
\302
!	>\204\303\304\300D\"\210\211\305H\211\250\203{\306\307\310\311\246!Z\312\302!	>\2047\303\304\300D\"\210\211\305\313\314\315\"\211\262I\266\306I\210\316\\\314\246\211\262\306V\203fZ\262\211\262I\210\202IT\211\262\317W\203y\320\321\"\210\202f\266\302!	>\204\212\303\304\300D\"\210
\211\312\312H\211T\314\246\262
I\262
\302!	>\204\250\303\304\300D\"\210\211\321\321H\211T\314\246\262
I\262
\322\323HHZ\"I\250\203
\324X\203\332\211\246\202 
\323V\203\354\325
\326\"\320\324\"\\\262
\327\211SW\203\376\211
\\T\262
\202\355\322\"\211\262W\203

\202
\320\"\262
\202 
\211\330\245_\266\203\207" [cl--random-state cl-struct-cl--random-state-tags type-of signal wrong-type-argument 3 0 1357335 abs 1357333 1 make-vector 55 nil 21 200 cl-random 2 logand 8388607 512 ash 9 1023 8388608.0] 12 (#$ . 15257)])
#@167 Return a copy of random-state STATE, or of the internal state if omitted.
If STATE is t, return a new state object seeded from the time of day.

(fn &optional STATE)
(defalias 'cl-make-random-state #[256 "\211\204\262
\302
!	>\203\303
!\207\211\250\203\211\202\304 \305\300\306\307$\207" [cl--random-state cl-struct-cl--random-state-tags type-of copy-sequence cl--random-time record -1 30] 7 (#$ . 16337)])
#@17 

(fn FUNC A B)
(defalias 'cl--finite-do #[771 "\3001\"\211\247\205\211
\301\245U?\205\211\262
0\207\302\207" [(arith-error) 2 nil] 7 (#$ . 16760)])
#@315 Initialize the Common Lisp floating-point parameters.
This sets the values of: `cl-most-positive-float', `cl-most-negative-float',
`cl-least-positive-float', `cl-least-negative-float', `cl-float-epsilon',
`cl-float-negative-epsilon', `cl-least-positive-normalized-float', and
`cl-least-negative-normalized-float'.
(defalias 'cl-float-limits #[0 "\204
\306\247\203
\307\310\211\311\312\211#\203\211_\262\202\f\311\312\211\313\245#\2030\211\313\245_\262\202\311\314\211#\203@\211\\\262\2020\262
\313\245\262\311\314#\203e\\U\204e\\\262
\313\245\262\202H[
\245\262\315
\245\262_\262\3161\220\211\313\245\313_U\205\214
\313\245\317V0\202\223\310\262
\203\243\313\245\262
\313\245\262\202y

[\320
!\262\262\3211\275\313\245\317V0\202\300\310\262
\203\313\313\245\262\202\260[\322\262\323\\\324U\204\343\313\245\262\202\323\313_\325\262\326Z\327U\204\373\313\245\262\202\353\313_\266\310\207" [cl-most-positive-float cl-most-negative-float cl-least-positive-normalized-float cl-least-negative-normalized-float cl-least-positive-float cl-least-negative-float 20.0 2.0 nil cl--finite-do * 2 + 16 (arith-error) 0 / (arith-error) 1.0 1.0 1.0 1.0 1.0 1.0 cl-float-epsilon cl-float-negative-epsilon] 8 (#$ . 16925)])
#@309 Return the subsequence of SEQ from START to END.
If END is omitted, it defaults to the length of the sequence.
If START or END is negative, it counts from the end.
Signal an error if START or END are outside of the sequence (i.e
too large if positive or too small if negative).

(fn SEQ START &optional END)
(defalias 'cl-subseq #[770 "\300#\207" [seq-subseq] 7 (#$ . 18226)])
(byte-code "\300\301\302\303#\300\207" [function-put cl-subseq gv-expander #[385 "\300\301\302$\207" [gv--defsetter cl-subseq #[1027 "\300
!\203\211\202\301\302!\303\304\305\306	\257E
=\203'\211\202.\307DC\"\207" [macroexp-const-p make-symbol "new" progn cl-replace :start1 :end1 macroexp-let*] 14 "\n\n(fn NEW SEQ START &optional END)"]] 7 "\n\n(fn DO &rest ARGS)"]] 4)
#@91 Concatenate, into a sequence of type TYPE, the argument SEQUENCEs.

(fn TYPE SEQUENCE...)
(defalias 'cl-concatenate #[385 "\300\301#\207" [apply seq-concatenate] 6 (#$ . 19004)])
#@49 Equivalent to (append (reverse X) Y).

(fn X Y)
(defalias 'cl-revappend #[514 "\300!
\244\207" [reverse] 4 (#$ . 19191)])
#@49 Equivalent to (nconc (nreverse X) Y).

(fn X Y)
(defalias 'cl-nreconc #[514 "
\237
\244\207" [] 4 (#$ . 19320)])
#@71 Return the length of list X.  Return nil if list is circular.

(fn X)
(defalias 'cl-list-length #[257 "\211<\204
\300\301\302\303E\"\210\3041\211G0\207\210\305\207" [signal wrong-type-argument list x (circular-list) nil] 6 (#$ . 19439)])
#@62 Return true if SUBLIST is a tail of LIST.

(fn SUBLIST LIST)
(defalias 'cl-tailp #[514 "\211:\203

=\204\211A\262
\202
\247\203

\232\207

=\207" [] 4 (#$ . 19687)])
#@109 Return the value of SYMBOL's PROPNAME property, or DEFAULT if none.

(fn SYMBOL PROPNAME &optional DEFAULT)
(defalias 'cl-get #[770 "\300\301!#\207" [cl-getf symbol-plist] 7 (#$ . 19868)])
(byte-code "\300\301\302\303#\300\301\304\305#\306\303\307\"\207" [function-put cl-get compiler-macro cl--compiler-macro-get gv-expander #[385 "\300\301\302$\207" [gv--defsetter cl-get #[1027 "\300F\207" [put] 8 "\n\n(fn STORE SYM TAG &optional DEF)"]] 7 "\n\n(fn DO &rest ARGS)"] autoload "cl-macs"] 5)
#@170 Search PROPLIST for property PROPNAME; return its value or DEFAULT.
PROPLIST is a list of the sort returned by `symbol-plist'.

(fn PROPLIST PROPNAME &optional DEFAULT)
(defalias 'cl-getf #[770 "\300\"\243\211\203\211@\202
\207" [plist-member] 6 (#$ . 20377)])
(byte-code "\300\301\302\303#\300\207" [function-put cl-getf gv-expander #[1027 "\300\301\302\303\304\305\n		#\306\"\307\310%\"\207" [gv-get make-byte-code 514 "\301\303
!\203\211\202\304\305!\302\303
!\203\211\202\304\306!\300\307F\310\311\312\313\314\f\f#\315\"\316\317%\"
=\203?\211\202F\320DC\"\266\203
=\203R\211\202Y\320DC\"\207" vconcat vector [macroexp-const-p make-symbol "k" "d" cl-getf make-byte-code 257 "\211\303
!\203\211\202\304\305!\306\301\307\300\302F!E
=\203\"\211\202)\310DC\"\207" vconcat vector [macroexp-const-p make-symbol "val" progn cl--set-getf macroexp-let*] 9 "\n\n(fn V)" macroexp-let*] 16 "\n\n(fn GETTER SETTER)"] 14 "\n\n(fn DO PLIST TAG &optional DEF)"]] 4)
#@22 

(fn PLIST TAG VAL)
(defalias 'cl--set-getf #[771 "\300\"\243\211\203\211\240\210\202BB\207" [plist-member] 7 (#$ . 21386)])
#@18 

(fn PLIST TAG)
(defalias 'cl--do-remf #[514 "
A\211A\203\211A@=\204\211AA\262
\202\211A\205$\211
AAA\241\210\300\207" [t] 5 (#$ . 21529)])
#@87 Remove from SYMBOL's plist the property PROPNAME and its value.

(fn SYMBOL PROPNAME)
(defalias 'cl-remprop #[514 "\300!\211\203

@=\203\301AA\"\210\302\202\303
\"\207" [symbol-plist setplist t cl--do-remf] 6 (#$ . 21684)])
#@84 Output a newline unless already at the beginning of a line.

(fn &optional STREAM)
(defalias 'cl-fresh-line #[256 "\300
\301\"\207" [terpri ensure] 4 (#$ . 21924)])
#@80 Insert a pretty-printed rendition of a Lisp FORM in current buffer.

(fn FORM)
(defalias 'cl-prettyprint #[257 "`\300\301\302!\301\261\210`\262

Tb\210\303\304\305#\203*\306\307!\210\310c\210\311 \210\306\312!\210\202
Tb\210\313 \207" [nil "\n" prin1-to-string search-forward "(quote " t delete-char -7 "'" forward-sexp 1 cl--do-prettyprint] 7 (#$ . 22095)])
(defalias 'cl--do-prettyprint #[0 "\300\301w\210\302\303!\203\222\302\304!\206%\302\305!\206%\302\306!\206%\302\307!\206%\302\310!\302\311!\206.\302\312!\302\313!\2067\302\314!\302\315!\204N
\204N\316 \210i\317Y\205\221\320 \210\321\322u\210\323 \210\204b\302\324!\204b\323 \210\203o\302\324!\204o\323 \210\302\324!\204\215
\203}\211?\262
\211\203\204\325c\210\326 \210\323 \210\202o\322u\262
\207\316 \207" [" " nil looking-at "(" "((" "(prog" "(unwind-protect " "(function (" "(cl--block-wrapper " "(defun " "(defmacro " "(let\\*? " "(while " "(p?set[qf] " forward-sexp 78 backward-sexp t 1 cl--do-prettyprint ")" "\n" lisp-indent-line] 7])
#@87 Expand macros in FORM and insert the pretty-printed result.

(fn FORM &optional FULL)
(defalias 'cl-prettyexpand #[513 "\301\302!\210\303\304!\262\301\305!\210\306!\301\307!\210)\207" [byte-compile-macro-environment message "Expanding..." nil macroexpand-all "Formatting..." cl-prettyprint ""] 5 (#$ . 23130)])
(byte-code "\300\301\302\303#\210\304\305!\210\306\307\310\311\312E\"\207" [set-advertised-calling-convention cl-prettyexpand (form) "27.1" require help-mode add-to-list describe-symbol-backends nil cl-find-class #[771 "\300!\207" [cl-describe-type] 5 "\n\n(fn S B F)"]] 5)
(defconst cl--typedef-regexp "(\\(?:cl-def\\(?:struct\\|type\\)\\|def\\(?:class\\|struct\\|type\\)\\)[ 	
\n]+%s[ 	
\n]+")
(byte-code "\300\301\302\"\210\303\304\305\306\307\310\311\312\313!&\210\303\314\305\306\311\312\315!%\207" [eval-after-load find-func #[0 "\301\235\203\207\301B\211\207" [find-function-regexp-alist (define-type . cl--typedef-regexp)] 2] define-button-type cl-help-type :supertype help-function-def help-function cl-describe-type help-echo purecopy "mouse-2, RET: describe this type" cl-type-definition "mouse-2, RET: find type definition"] 9)
#@13 

(fn TYPE)
(defalias 'cl-find-class #[257 "\211\300N\207" [cl--class] 3 (#$ . 24299)])
#@64 Display the documentation for type TYPE (a symbol).

(fn TYPE)
(defalias 'cl-describe-type #[257 "\305\306D\307\310!\"\210\212\311\211\223\210\312	B\313\nB\314 \315 \316
!\211\311\211r\fq\210\317!\211\2037\320\"\210\202=\321\322\"\210\210)r\fq\210\323 )\262
rq\210\324\311\"\262)\325\326!\203`\326\"\202a\211)\266\204+\207" [help-window-point-marker temp-buffer-window-setup-hook temp-buffer-window-show-hook help-window-old-frame standard-output help-setup-xref cl-describe-type called-interactively-p interactive nil help-mode-setup help-mode-finish selected-frame help-buffer temp-buffer-window-setup cl-find-class cl--describe-class user-error "Unknown type %S" buffer-string temp-buffer-window-show functionp help-window-setup] 9 (#$ . 24393) (byte-code "\301\302\303\304$\211G\305X\203\306\307!\202\310
!C\207" [obarray completing-read "Describe type: " cl-find-class t 0 user-error "Abort!" intern] 5)])
#@29 

(fn TYPE &optional CLASS)
(defalias 'cl--describe-class #[513 "\211\204	
\301N\262
\302\303\"\304!\305!\306\307!\261\210\310\305!\311#\210\306\312!c\210
\203?\306\313!c\210\310\314!\315\303%\210\306\316!c\210\317c\210\304!>\204Q\320\321\301D\"\210\322H\323
\203\234\324c\210
\211A\262\242\211\262\203\231\304
!>\204w\320\321\301D\"\210\211\325H\262
\306\326!c\210\310\305!\311#\210\306\203\222\327\202\223\316!c\210\202\\\317c\210\266\3301\313\331\"\204\260\320\321D\"\210\332
!\333=\203\301\334
\335\"8\202\307\334\335\"H0\202\315\210\323\323
\203

\336c\210
\211A\262\242\211\262\203\376\306\326!c\210\310\305!\311#\210\306\203\367\327\202\370\316!c\210\202\325\317c\210\266\304!>\204
\320\321\301D\"\210\337H\211\203
\340
\341\261\210\210\342!\210\343!\211\205\210
\344\345\346\347#c\210\211\211\205\206
\211@\306\326!c\210\310\305!\350#\210\306\316!c\210\351
\"\211\203{
\211@\211@
A\211@
A\211@
A
\352\353#\206p
\354\261\266\n
A\266\202\202P
\210\341c\210
A\266\202\2023
\262
\262
\207" [cl-struct-cl--class-tags cl--class find-lisp-object-file-name define-type type-of symbol-name substitute-command-keys " is a type (of kind `" help-insert-xref-button cl-help-type "')" " in `" help-fns-short-filename cl-type-definition "'" ".\n" signal wrong-type-argument 3 nil " Inherits from " 1 "`" "', " (cl-struct-unknown-slot) cl-typep cl-struct-sequence-type list cl-struct-slot-offset children " Children " 2 "\n" "\n\n" cl--describe-class-slots cl-generic-all-functions propertize "Specialized Methods:\n\n" face bold help-function cl--generic-method-documentation format " %s%S\n" ""] 22 (#$ . 25336)])
#@13 

(fn SLOT)
(defalias 'cl--describe-class-slot #[257 "\301\302\303\304#\305\306!>\204\307\310\311D\"\210\312H!\306!>\204(\307\310\311D\"\210\313H\314=?\205H\315\305\306!>\204C\307\310\311D\"\210\313H!P\316\305\306!>\204[\307\310\311D\"\210\317H!P\320\321\306!>\204s\307\310\311	D\"\210\322H\"\205\227\323\305\320\321\306	!>\204\220\307\310\311D\"\210\322H\"!P\320\324\306!>\204\252\307\310\311\nD\"\210\322H\"\205\317\325\326\320\324\306\n!>\204\307\307\310\311\fD\"\210	\322H\"!\327Q\260\327\261\207" [cl-struct-cl-slot-descriptor-tags propertize "Slot: " face bold prin1-to-string type-of signal wrong-type-argument cl-slot-descriptor 1 3 t "    type = " "    default = " 2 alist-get :printer 4 "    printer = " :documentation "\n  " substitute-command-keys "\n"] 14 (#$ . 27023)])
#@20 

(fn HEADER ROWS)
(defalias 'cl--print-table #[514 "\300\301\302\303\"\"\304\211\203O\211@G\305\211W\203F\211\211A\262\242H
\203-\303!\202.\305\211V\203=	

I\266\266\211T\262
\202\266
A\266\202\202	\210\306\305G\305\211W\203\201\211\307\310\311\312\313\\E#\314PB\262H\\\\\262\210\211T\262
\202U\266\315\316\237\317#\300\320\302\321\"#\322\261\210\300\320\302\323\"#\322\261\210\211\205\272\211@\300\320#\322\261\210
A\266\202\202\244\262
\262
\266\202\207" [apply vector mapcar string-width 2 0 nil propertize "	" display space :align-to "%s" mapconcat identity "" format #[257 "\300
\301\302#\207" [propertize face italic] 5 "\n\n(fn STR)"] "\n" #[257 "\300\301!\302\"\207" [make-string string-width 8212] 4 "\n\n(fn STR)"]] 17 (#$ . 27868)])
#@91 Print help description for the slots in CLASS.
Outputs to the current buffer.

(fn CLASS)
(defalias 'cl--describe-class-slots #[257 "\301
!>\204\302\303\304D\"\210\211\305H\301!\3061B\307\"\204'\302\303D\"\210\310
!\311=\2038\312
\313\"8\202>\312\313\"H0\202D\210\314\315\316\317\320#c\210\314C\321\322\323\324\325\326!\327\"\330\331%\"\332\333\334\335\242\205g\336BBB\"\266\337c\210\211G\340V\205\203\315\341\317\320#c\210\342\343\"\207" [cl-struct-cl--class-tags type-of signal wrong-type-argument cl--class 4 (cl-struct-unknown-slot) cl-typep cl-struct-sequence-type list cl-struct-slot-offset class-slots nil propertize "Instance Allocated Slots:\n\n" face bold mapcar make-byte-code 257 "\302\303!	>\204\304\305\306D\"\210
\307H!\302\303!	>\204$\304\305\306D\"\210\310H!\302\303!	>\2049\304\305\306D\"\210\311H!\312\313\303!	>\204P\304\305\306D\"\210\314H\"\211\204\\\315\202c\300\316\240\210\317
!\262
F\207" vconcat vector [cl-struct-cl-slot-descriptor-tags cl-prin1-to-string type-of signal wrong-type-argument cl-slot-descriptor 1 3 2 alist-get :documentation 4 "" t substitute-command-keys] 10 "\n\n(fn SLOT)" cl--print-table "Name" "Type" "Default" ("Doc") "\n" 0 "\nClass Allocated Slots:\n\n" mapc cl--describe-class-slot] 12 (#$ . 28678)])
(byte-code "\300\301!\210\302\303!\207" [run-hooks cl-extra-load-hook provide cl-extra] 2)