;ELC
;;; Compiled by mockbuild@buildfarm06-new.corp.cloudlinux.com on Fri Oct 11 10:08:59 2024
;;; from file /builddir/build/BUILD/emacs-24.3/lisp/emacs-lisp/cl-extra.el
;;; in Emacs version 24.3.1
;;; with all optimizations.
;;; Function definitions are lazy-loaded.

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

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

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


(require 'cl-lib)
#@85 Coerce OBJECT to type TYPE.
TYPE is a Common Lisp type specifier.

(fn OBJECT TYPE)
(defalias 'cl-coerce #[514 #@496 ("\211\300=\203
0

<\203

0

\207\301\302\"\207\211\303=\203$
0\304!\203 
0

\207\305!\207\211\306=\2035
0

;\2031
0

\207

\260

\207\211\307=\203G
0\310!\203C
0

\207\305!\207\211\311=\203]
0

;\203]
0

G\312U\203]
0

\313H\207\211\311=\203o
0

9\203o
0\314\315!\"\207\211\316=\203y
0\316!\207\317\"\203\202
0

\207\320\321#\207" . [list append nil vector vectorp vconcat string array arrayp character 1 0 cl-coerce symbol-name float cl-typep error "Can't coerce %s to type %s"])(#$ . 740) nil 6 (#$ . 622)])
#@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 #@396 ("



=\203
0\300\207

;\203&
0\211;\205\224
0

G

GU\205\224
0



\230\206%
0

\227

\227\230\207

\247\2034
0\211\247\205\224
0



U\207

:\203b
0

:\203W
0\211:\203W
0\301@@\"\203W
0

A\262\211A\262

\2029
0

:?\205\224
0\301\"\207\302!\203\221
0\302

!\205\224
0

G

GU\205\224
0

G\211S\211\262\303Y\203\215
0\301HH\"\204x
0\211\303W\207



\232\207" . [t cl-equalp vectorp 0])(#$ . 1539) nil 7 (#$ . 1271)])
(defalias 'cl--mapcar-many #[514 #@428 ("\211AA\203c
0\300\301\302\303\304\"\"\305\306!\300\211\306!\262W\203`
0\262\262



\203O
0\211@:\203>
0@@\211@A\240\210\202B
0@H\240\210

A\262\211A\262

\202'
0\301\"B\262T\262\202
0\237\207\300

@A@

G

G^\307\211T\211\262W\203\245
0:\203\211
0\211A\262@\202\214
0H:\203\232
0\211A\262@\202\235
0H\"B\262\202o
0\266\237\207" . [nil apply min mapcar length 0 copy-sequence -1])(#$ . 2005) nil 12 "\n\n(fn CL-FUNC CL-SEQS)"])
#@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 #@70 ("\300\301$\205
0\302

\"\207" . [apply cl-mapcar cl-coerce])(#$ . 2652) nil 9 (#$ . 2486)])
#@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 #@201 ("\211\2031
0\300\301!B\300\300>\204.
0\302\"B\262

\262

\211\203
0\211

\211A\262@A\240\210\202
0\237\207\300\203D
0!

B\262

A\262\2022
0\211\237\207" . [nil copy-sequence apply])(#$ . 2962) nil 9 (#$ . 2759)])
#@103 Like `cl-mapcar', but does not accumulate values returned by the function.

(fn FUNCTION SEQUENCE...)
(defalias 'cl-mapc #[642 #@81 ("\211\203
0\300\301\302%\210

\207\303\"\207" . [apply cl-map nil mapc])(#$ . 3333) nil 9 (#$ . 3200)])
#@100 Like `cl-maplist', but does not accumulate values returned by the function.

(fn FUNCTION LIST...)
(defalias 'cl-mapl #[642 #@111 ("\211\203
0\300\301$\210\202
_
0

\211\203
0

!\210\211A\262

\202
0\210

\207" . [apply cl-maplist])(#$ . 3582) nil 8 (#$ . 3451)])
#@104 Like `cl-mapcar', but nconc's together the values returned by the function.

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

(fn FUNCTION LIST...)
(defalias 'cl-mapcon #[642 #@62 ("\300\301\300\302$\"\207" . [apply nconc cl-maplist])(#$ . 4098) nil 10 (#$ . 3965)])
#@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 #@446 ("

C

\204\f
0\211@<\204$
0\300\301\302\303\304\305\306\n\n#\307\"\310\311%D\215\202>
0\312

@\203;
0@\211@A\240\210@!\211\262\203%
0\211\262

\207" . [cl-some funcall make-byte-code 0 "\303\304\305\306\307\310\311\312\300!\313\"\314\315%\301@\302%\210\305\207" vconcat vector [apply cl-map nil make-byte-code 128 "\301\300\"\211\205\f
0\302\303\"\207" vconcat vector [apply throw cl-some] 5 "\n\n(fn &rest CL-X)"] 9 "\n\n(fn)" nil])(#$ . 4379) nil 14 (#$ . 4198)])
#@90 Return true if PREDICATE is true of every element of SEQ or SEQs.

(fn PREDICATE SEQ...)
(defalias 'cl-every #[642 #@442 ("

C

\204\f
0\211@<\204$
0\300\301\302\303\304\305\306\n\n#\307\"\310\311%D\215\202=
0\211@\203:
0

@@!\203:
0\211

@A\240\210\202$
0\211@?\207" . [cl-every funcall make-byte-code 0 "\303\304\305\306\307\310\311\312\300!\313\"\314\315%\301@\302%\210\316\207" vconcat vector [apply cl-map nil make-byte-code 128 "\301\300\"\206
0\302\303\304\"\207" vconcat vector [apply throw cl-every nil] 4 "\n\n(fn &rest CL-X)" t] 9 "\n\n(fn)"])(#$ . 4984) nil 14 (#$ . 4862)])
#@91 Return true if PREDICATE is false of every element of SEQ or SEQs.

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

(fn PREDICATE SEQ...)
(defalias 'cl-notevery #[642 #@42 ("\300\301$?\207" . [apply cl-every])(#$ . 5787) nil 8 (#$ . 5663)])
(defalias 'cl--map-keymap-recursively #[770 #@319 ("\211C\211@\204

0\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@\301@GSI\210\302

!\203
0\303\300\304\301@\305C\"#\207\300\301@\"\207" vconcat vector [keymapp cl--map-keymap-recursively vconcat 0] 8 "\n\n(fn CL-KEY CL-BIND)"])(#$ . 5910) nil 12 "\n\n(fn CL-FUNC-REC CL-MAP &optional CL-BASE)"])
(defalias 'cl--map-intervals #[1281 #@529 ("\204
0p\262\300!\203\203
0\301\211\302\301rq\210\303\206
0e!\262\205'
0\303!\262)

\203u
0\2038
0W\203u
0\203G
0\304\n#\202L
0\305	\"\262

\206Y
0rq\210d)\262

\306!\301\223\210\203o
0^\202p
0\"\210\202*
0\301\211\223\210\205\202
0\301\211\223\207

\204\212
0\307\262\211\204\222
0G\262





W\205\271
0\203\245
0\304#\202\251
0\305\"\206\255
0\211^\"\210\262\202\222
0\207" . [bufferp nil t copy-marker next-single-property-change next-property-change marker-position 0])(#$ . 6339) nil 14 "\n\n(fn CL-FUNC &optional CL-WHAT CL-PROP CL-START CL-END)"])
(defalias 'cl--map-overlays #[1281 #@689 ("\204
0p\262\300\301!\203v
0\302rq\210\301 \262

\203
_
0\303!\262\203(
0\303!\262)\211@

A\244\262

\211\203d
0\304

@!\203]
0\203H
0\304

@!Y\204]
0\203U
0\305

@!X\204]
0

@\"\204d
0\211A\262

\2020
0\203m
0\302\211\223\210\205u
0\302\211\223\207rq\210\303\206\200
0e!)\205\216
0rq\210\303!)\302\211\212\306!\211\262\205\263
0

\206\240
0dW\205\263
0q\210\307!\262

\310!\302\223)\203\334
0\211\203\220
0\304

@!U\203\325
0

@\"\203\325
0\302\211\223\204\220
0\211A\262

\202\267
0\302\211\223\210\205\351
0\302\211\223\207" . [fboundp overlay-lists nil copy-marker overlay-start overlay-end marker-position overlays-at next-overlay-change])(#$ . 6990) nil 12 "\n\n(fn CL-FUNC &optional CL-BUFFER CL-START CL-END CL-ARG)"])
(defalias 'cl--set-frame-visible-p #[514 #@144 ("\211\204
0\300!\210\202
0\211\301=\203
0\302!\210\202
0\303!\210\207" . [make-frame-invisible icon iconify-frame make-frame-visible])(#$ . 7808) nil 4 "\n\n(fn FRAME VAL)"])
#@71 Return the greatest common divisor of the arguments.

(fn &rest ARGS)
(defalias 'cl-gcd #[128 #@137 ("\300

\211A\262@\206
0\301!

\203-
0\300\211A\262@!\211\301V\203)
0



\211\262\246\262

\202
0\210\202\f
0\211\207" . [abs 0])(#$ . 8098) nil 6 (#$ . 7997)])
#@69 Return the least common multiple of the arguments.

(fn &rest ARGS)
(defalias 'cl-lcm #[128 #@142 ("\300

>\203
0\300\207\301

\211A\262@\206
0\302!

\203-
0\301\211A\262@!

\303\"\245

_\266\202\202
0\211\207" . [0 abs 1 cl-gcd])(#$ . 8370) nil 7 (#$ . 8271)])
#@57 Return the integer square root of the argument.

(fn X)
(defalias 'cl-isqrt #[257 #@284 ("\211\250\203B
0\211\300V\203B
0\211\301X\203
0\302\202*
0\211\303X\203
_
0\301\202*
0\211\304X\203)
0\305\202*
0\211\306

\245\\\307\245\211\262W\203@
0\211\262\202+
0

\207\211\300=\203J
0\300\207\310\311\306\"\207" . [0 100 10 10000 1000000 1000 nil 2 signal arith-error])(#$ . 8637) nil 6 (#$ . 8548)])
#@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 #@54 ("\300\"\211\203
0_\202
0ZD\207" . [floor])(#$ . 9138) nil 7 (#$ . 8958)])
#@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 #@88 ("\300\"\211A@\301U\203
0\211\202
0\211@T

A@\206
0\302ZD\207" . [cl-floor 0 1])(#$ . 9415) nil 6 (#$ . 9229)])
#@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 #@88 ("

\300Y

?\206
0

\300Y=\203
0\301\"\207\302\"\207" . [0 cl-floor cl-ceiling])(#$ . 9735) nil 5 (#$ . 9540)])
#@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 #@249 ("\211\203N
0

\250\203A
0\211\250\203A
0\211\300\245\301\\\"\211A@\302U\2038
0

\211\\U\2038
0\211@\300\246\302U\2048
0\211@SD\202@
0\211@

A@ZD\207\303\245!\211_ZD\207

\250\203W
0

\302D\207\303!\211ZD\207" . [2 cl-floor 0 round])(#$ . 10051) nil 7 (#$ . 9860)])
#@69 The remainder of X divided by Y, with the same sign as Y.

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

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

(fn X)
(defalias 'cl-signum #[257 #@73 ("\211\300V\203
0\301\207\211\300W\203
0\302\207\300\207" . [0 1 -1])(#$ . 10773) nil 3 (#$ . 10678)])
#@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 #@668 ("\211\204
0\262

\211\301H\211\250\203Z
0\302\303\304!\305\246Z\306\301\307\310\311\"\211\262I\210\302I\210\312\\\310\246\211\262\302V\203E
0Z\262\211\262I\210\202(
0T\211\262\313W\203X
0\314\315\"\210\202E
0\266

\306\306HT\310\246I\315\315HT\310\246I\316HHZI\317\"\250\203\314
0\320X\203\214
0\211\246\202\322
0\317V\203\236
0\321

\322\"\314\320\"\\\262

\323\211SW\203\260
0\211

\\T\262

\202\237
0\316\"\211\262W\203\301
0

\202\307
0\314\"\262

\202\322
0\211\324\245_\266\203\207" . [cl--random-state 3 0 1357335 abs 1357333 1 make-vector 55 nil 21 200 cl-random 2 logand 8388607 512 lsh 9 1023 8388608.0])(#$ . 11068) nil 11 (#$ . 10885)])
#@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 #@219 ("\211\204
0\301!\207\302

!\203
0\303

\304\"\207\211\250\203
_
0\305\306\307\310$\207\301\311 !\207" . [cl--random-state cl-make-random-state vectorp copy-tree t vector cl-random-state-tag -1 30 cl-random-time])(#$ . 11987) nil 6 (#$ . 11776)])
#@59 Return t if OBJECT is a random-state object.

(fn OBJECT)
(defalias 'cl-random-state-p #[257 #@91 ("\300

!\205
0\211G\301U\205
0\211\302H\303=\207" . [vectorp 4 0 cl-random-state-tag])(#$ . 12343) nil 3 (#$ . 12244)])
(defalias 'cl--finite-do #[771 #@269 ("\300\301\302\303\304\305\306			#\307\"\310\311%D\312\301\313\300EDC\217\207" . [#1=#:err funcall make-byte-code 0 "\300\301\302\"\211\247\205
0\211

\303\245U?\205
0\211\207" vconcat vector [2] 4 "\n\n(fn)" arith-error #[257 "\300\207" [nil] 2 "\n\n(fn ##)"]])(#$ . 12504) nil 13 "\n\n(fn FUNC A B)"])
#@321 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'.

(fn)
(defalias 'cl-float-limits #[0 #@1350 ("\204G

\306\247\203G

\307C\310C\310\311\312@@#\203#
0\211@@_\240\210\202
0\311\312@@\313\245#\203<
0\211@@\313\245_\240\210\202#
0\311\314@@#\203Q
0\211@@\\\240\210\202<
0@\262



@\313\245\240\210\311\314@@#\203\203
0@@\\@U\204\203
0\211@@\\\240\210

\211@\313\245\240\210\202\\
0@@[\211@\245\240\210

\315\245\240\210\211@@_\240\210\316\317\320\321\322\323\324		\"\325\"\326\327%D\330\317\331\316EDC\217\203\315
0\211@\313\245\240\210

\211@\313\245\240\210\202\237
0

@

@[\332\245\240\210

@\240\210\333\317\320\321\334\323\324	!\335\"\313\327%D\330\317\336\333EDC\217\203

\211@\313\245\240\210\202\337
0@@[\337\240\210\340@\\\341U\204\"

\211@\313\245\240\210\202

@\313_%\342\240\210\343@Z\344U\204?

\211@\313\245\240\210\202,

@\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 #1=#:err funcall make-byte-code 0 "\300@\300@\302\245\302_U\205
0\301@\302\245\303V\207" vconcat vector [2 0] 3 "\n\n(fn)" arith-error #[257 "\300\207" [nil] 2 "\n\n(fn ##)"] 1 #2=#:err "\300@\301\245\302V\207" [2 0] #[257 "\300\207" [nil] 2 "\n\n(fn ##)"] 1.0 1.0 1.0 1.0 1.0 1.0 cl-float-epsilon cl-float-negative-epsilon])(#$ . 13179) nil 12 (#$ . 12820)])
#@195 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.

(fn SEQ START &optional END)
(defalias 'cl-subseq #[770 #@397 (";\203\n
0O\207\300

\203
0

\301W\203
0

G\211\262\\\262\301W\2031
0

\206.
0G\211\262\\\262<\203j
0\301V\203A
0\233\262

\203d
0\300S\211\262Y\203]
0\211A\262@

B\262

\202F
0\211\237\262

\202\234
0\302!\202\234
0

\204v
0\211\206t
0G\262\303Z\301]\300\"\301W\203\231
0



HI\210\211T\262

T\262\202
0

\266\202\207" . [nil 0 copy-sequence make-vector])(#$ . 14797) nil 10 (#$ . 14569)])
(put 'cl-subseq 'gv-expander #[385 "\300\301\302$\207" [gv--defsetter cl-subseq #[1027 "\300\301\302\303\257E\207" [progn cl-replace :start1 :end1] 12 "\n\n(fn NEW SEQ START &optional END)"]] 7 "\n\n(fn DO &rest ARGS)"])
#@91 Concatenate, into a sequence of type TYPE, the argument SEQUENCEs.

(fn TYPE SEQUENCE...)
(defalias 'cl-concatenate #[385 #@212 ("

\300=\203
0\301\302\"\207

\303=\203
0\301\304\"\207

\305=\203$
0\301\306\211\307\"\"\207\310\311\"\207" . [vector apply vconcat string concat list append (nil) error "Not a sequence type name: %s"])(#$ . 15594) nil 7 (#$ . 15465)])
#@49 Equivalent to (append (reverse X) Y).

(fn X Y)
(defalias 'cl-revappend #[514 #@34 ("\300!

\244\207" . [reverse])(#$ . 15928) nil 4 (#$ . 15844)])
#@49 Equivalent to (nconc (nreverse X) Y).

(fn X Y)
(defalias 'cl-nreconc #[514 #@27 ("

\237

\244\207" . [])(#$ . 16082) nil 4 (#$ . 16000)])
#@71 Return the length of list X.  Return nil if list is circular.

(fn X)
(defalias 'cl-list-length #[257 #@132 ("\300

\211

A\203%
0



=\203
0\300V\204%
0\301\\\262

AA\262\211A\262

\202
0

\2034
0

A?\2055
0T\2025
0\207" . [0 2])(#$ . 16256) nil 6 (#$ . 16147)])
#@62 Return true if SUBLIST is a tail of LIST.

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



=\204
0\211A\262

\202
0
0

\247\203
0



\232\207



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

(fn SYMBOL PROPNAME &optional DEFAULT)
(defalias 'cl-get #[770 #@130 ("N\206-
0\211\205-
0\300!\211\203 
0\211@=\204 
0\211AA\262

\202

0\211\203*
0\211A@\202+
0

\262

\207" . [symbol-plist])(#$ . 16785) nil 6 (#$ . 16646)])
(byte-code "\300\301\302\303#\210\300\301\304\305#\210\306\303\307\"\207" [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"] 4)
#@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 #@136 ("\300\301\"\210\301N\206+
0\211\205+
0\203\"
0@=\204\"
0AA\262\202
0\203*
0A@\207\211\207" . [setplist --cl-getf-symbol--])(#$ . 17464) nil 6 (#$ . 17263)])
(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 "\301\303\300\302F!\207" vconcat vector [cl--set-getf] 6 "\n\n(fn V)" macroexp-let*] 16 "\n\n(fn GETTER SETTER)"] 14 "\n\n(fn DO PLIST TAG &optional DEF)"])
(defalias 'cl--set-getf #[771 #@99 ("\211\203
0\211@=\204
0\211AA\262

\202


0\211\203!
0\211A\240\210\202&
0BB\207" . [])(#$ . 18228) nil 7 "\n\n(fn PLIST TAG VAL)"])
(defalias 'cl--do-remf #[514 #@98 ("

A\211A\203
0\211A@=\204
0\211AA\262

\202
0\211A\205$
0\211

AAA\241\210\300\207" . [t])(#$ . 18406) nil 5 "\n\n(fn PLIST TAG)"])
#@87 Remove from SYMBOL's plist the property PROPNAME and its value.

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



@=\203
0\301AA\"\210\302\202
0\303

\"\207" . [symbol-plist setplist t cl--do-remf])(#$ . 18671) nil 6 (#$ . 18550)])
#@80 Insert a pretty-printed rendition of a Lisp FORM in current buffer.

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



Tb\210\303\304\305#\203*
0\306\307!\210\310c\210\311 \210\306\312!\210\202
0

Tb\210\313 \207" . [nil "\n" prin1-to-string search-forward "(quote " t delete-char -7 "'" forward-sexp 1 cl--do-prettyprint])(#$ . 18941) nil 7 (#$ . 18823)])
(defalias 'cl--do-prettyprint #[0 #@653 ("\300\301w\210\302\303!\203\222
0\302\304!\206%
0\302\305!\206%
0\302\306!\206%
0\302\307!\206%
0\302\310!\302\311!\206.
0\302\312!\302\313!\2067
0\302\314!\302\315!\204N
0

\204N
0\316 \210i\317Y\205\221
0\320 \210\321\322u\210\323 \210\204b
0\302\324!\204b
0\323 \210\203o
0\302\324!\204o
0\323 \210\302\324!\204\215
0

\203}
0\211?\262

\211\203\204
0\325c\210\326 \210\323 \210\202o
0\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])(#$ . 19261) nil 7 "\n\n(fn)"])
#@187 Expand macros in FORM and insert the pretty-printed result.
Optional argument FULL non-nil means to expand all macros,
including `cl-block' and `cl-eval-when'.

(fn FORM &optional FULL)
(defalias 'cl-prettyexpand #[513 #@250 ("\302\303!\210\211\304\305?\205
0\306\"\262\302\307!\210\310!\302\311!\210*\207" . [byte-compile-macro-environment cl--compiling-file message "Expanding..." nil macroexpand-all ((cl-block) (cl-eval-when)) "Formatting..." cl-prettyprint ""])(#$ . 20177) nil 5 (#$ . 19951)])
(run-hooks 'cl-extra-load-hook)