Current File : //proc/self/root/kunden/usr/share/emacs/27.2/lisp/emacs-lisp/cl-preloaded.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\302\303!\"\207" [define-error cl-assertion-failed purecopy "Assertion failed"] 4)
#@41 

(fn FORM &optional STRING SARGS ARGS)
(defalias 'cl--assertion-failed #[1025 "\203	\302\303BBD\"\207\203\304\302\305\"#\207\306\303B\"\207" [debug-on-error debugger error cl-assertion-failed apply append signal] 10 (#$ . 511)])
#@211 Alist of supertypes.
Each element has the form (TYPE . SUPERTYPES) where TYPE is one of
the symbols returned by `type-of', and SUPERTYPES is the list of its
supertypes from the most specific to least specific.
(defconst cl--typeof-types '((integer number number-or-marker atom) (symbol atom) (string array sequence atom) (cons list sequence) (marker number-or-marker atom) (overlay atom) (float number atom) (window-configuration atom) (process atom) (window atom) (subr atom) (compiled-function function atom) (module-function function atom) (buffer atom) (char-table array sequence atom) (bool-vector array sequence atom) (frame atom) (hash-table atom) (terminal atom) (thread atom) (mutex atom) (condvar atom) (font-spec atom) (font-entity atom) (font-object atom) (vector array sequence atom) (user-ptr atom) (null symbol list sequence atom)) (#$ . 765))
(defconst cl--all-builtin-types (byte-code "\301\302\303\304\"!!\207" [cl--typeof-types delete-dups copy-sequence apply append] 5))
#@75 Return t if NAME is a valid structure name for `cl-defstruct'.

(fn NAME)
(defalias 'cl--struct-name-p #[257 "\211\205\2119\205\301
!?\205\211>?\207" [cl--all-builtin-types keywordp] 3 (#$ . 1763)])
(defvar cl-struct-cl-structure-object-tags nil)
(byte-code "\300\301N\204\f\302\300\301\303#\210\304\305M\207" [cl-structure-object cl--class put dummy cl--make-slot-desc #[1025 "\300\301%\207" [record cl-slot-descriptor] 10 "\n\n(fn NAME &optional INITFORM TYPE PROPS)"]] 4)
#@13 

(fn NAME)
(defalias 'cl--struct-get-class #[257 "\2119\204	\211\206_\211\300N\206_\211\301N\204\302\303\"\207\304\305\306\"!
\301N\307N\310\311\312N@\313=\205>A@?\205>\314\236?\205D@A@\304\305\315
\"!\n\f\316N&	\210\300N\266\203\207" [cl--class cl-struct-type error "%S is not a struct name" intern format "cl-struct-%s" cl-struct-slots cl-struct-define nil cl-struct-include vector cl-tag-slot "cl-struct-%s-tags" cl-struct-print] 15 (#$ . 2256)])
#@21 

(fn PLIST MEMBER)
(defalias 'cl--plist-remove #[514 "
\204\300\207\211\204\f
\207

=\203
AA\207
@A@\301AA\"BB\207" [nil cl--plist-remove] 7 (#$ . 2739)])
#@19 

(fn PARENT TAG)
(defalias 'cl--struct-register-child #[514 "\301!\2054\302\303!>\204\304\305\306D\"\210\307H\"\210\303!>\204+\304\305\306D\"\210
\310H@\262\202\207" [cl-struct-cl-structure-class-tags recordp add-to-list type-of signal wrong-type-argument cl-structure-class 10 3] 7 (#$ . 2909)])
#@70 

(fn NAME DOCSTRING PARENT TYPE NAMED SLOTS CHILDREN-SYM TAG PRINT)
(defalias 'cl-struct-define #[2313 "\302	!\204\303\304\305\306E\"\210\204\307\310!\210\311=\203!\312\262\204-\203-\313\314!\210\315!\203;\316\"\210\202@CL\210\204P@@\317=\203PA\262\205Y\320!G\321\322\323\324$\325\312\"\326\n\203o\326\202p\310	\211\203\266\211@\211AA\327
\330\"\211\203\211\211A@\202\212\331\332@A@\333		\"$I\266\334
@\\#\210T\262
A\266\202\202r\210\266\203\f\f9?\205\306C\f\f


\311\335		\n
&\266\2129\204k
\336!>\204
\303\304\335D\"\210\337H
GY\204j
\331
G\326\211W\203Z
\211\336H!	>\204+
\303\304\340HD\"\210
H\310H\336H!	>\204E
\303\304\340\nHD\"\210H\310H=\204R
\312\262\210\211T\262
\202
\266\211\262
\204j
\341\342#\210\210\316\343\344B\"\210\345\"\210	\331=\204\222
=\204\222

L\210\346M\210
\347
\350#\262
\207" [cl-struct-cl-structure-class-tags cl-struct-cl-slot-descriptor-tags cl--struct-name-p signal wrong-type-argument cl--struct-name name cl-old-struct-compat-mode 1 record nil cl--assertion-failed (or type (not named)) boundp add-to-list cl-tag-slot cl--struct-get-class make-hash-table :test eq :size make-vector 0 plist-member :type t cl--make-slot-desc cl--plist-remove puthash cl-structure-class type-of 4 cl-slot-descriptor error "Included struct %S has changed since compilation of %S" current-load-list define-type cl--struct-register-child :quick-object-witness-check put cl--class] 35 (#$ . 3229)])
#@75 compiler-macro for inlining `cl--struct-class-p'.

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

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

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

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

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

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

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

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

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

(fn CL-X)
(defalias 'cl--struct-class-slots #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-cl-structure-class-tags type-of signal wrong-type-argument cl-structure-class 4] 5 (#$ . 8385)])
(byte-code "\300\301\302\303#\300\207" [function-put cl--struct-class-slots side-effect-free t] 4)
#@85 compiler-macro for inlining `cl--struct-class-index-table'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'cl--struct-class-index-table--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block cl--struct-class-index-table (progn (or (cl--struct-class-p cl-x) (signal 'wrong-type-argument (list 'cl-structure-class cl-x))) (aref cl-x 5))) nil] 9 (#$ . 8756)])
(put 'cl--struct-class-index-table 'compiler-macro 'cl--struct-class-index-table--cmacro)
#@75 Access slot "index-table" of `cl-structure-class' struct CL-X.

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

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

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

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

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

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

(fn CL-X)
(defalias 'cl--struct-class-named #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-cl-structure-class-tags type-of signal wrong-type-argument cl-structure-class 8] 5 (#$ . 11669)])
(byte-code "\300\301\302\303#\300\207" [function-put cl--struct-class-named side-effect-free t] 4)
#@79 compiler-macro for inlining `cl--struct-class-print'.

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

(fn CL-X)
(defalias 'cl--struct-class-print #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-cl-structure-class-tags type-of signal wrong-type-argument cl-structure-class 9] 5 (#$ . 12485)])
(byte-code "\300\301\302\303#\300\207" [function-put cl--struct-class-print side-effect-free t] 4)
#@86 compiler-macro for inlining `cl--struct-class-children-sym'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'cl--struct-class-children-sym--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block cl--struct-class-children-sym (progn (or (cl--struct-class-p cl-x) (signal 'wrong-type-argument (list 'cl-structure-class cl-x))) (aref cl-x 10))) nil] 9 (#$ . 12857)])
(put 'cl--struct-class-children-sym 'compiler-macro 'cl--struct-class-children-sym--cmacro)
#@76 Access slot "children-sym" of `cl-structure-class' struct CL-X.

(fn CL-X)
(defalias 'cl--struct-class-children-sym #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-cl-structure-class-tags type-of signal wrong-type-argument cl-structure-class 10] 5 (#$ . 13337)])
(byte-code "\300\301\302\303#\300\207" [function-put cl--struct-class-children-sym side-effect-free t] 4)
#@147 compiler-macro for inlining `cl--struct-new-class'.

(fn CL-WHOLE-ARG NAME DOCSTRING PARENTS TYPE NAMED SLOTS INDEX-TABLE CHILDREN-SYM TAG PRINT)
(defalias 'cl--struct-new-class--cmacro #[2827 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (name docstring parents type named slots index-table children-sym tag print) (cl-block cl--struct-new-class (record 'cl-structure-class name docstring parents slots index-table tag type named print children-sym)) nil] 27 (#$ . 13732)])
(put 'cl--struct-new-class 'compiler-macro 'cl--struct-new-class--cmacro)
#@136 Constructor for objects of type `cl-structure-class'.

(fn NAME DOCSTRING PARENTS TYPE NAMED SLOTS INDEX-TABLE CHILDREN-SYM TAG PRINT)
(defalias 'cl--struct-new-class #[2570 "\300\301		\n
&\207" [record cl-structure-class] 22 (#$ . 14316)])
(byte-code "\300\301\302\303#\304\305\306\307\310\311\312\313\305\303&	\207" [function-put cl--struct-new-class side-effect-free t cl-struct-define cl-structure-class "The type of CL structs descriptors." cl-structure-object record nil ((cl-tag-slot) (name nil :type symbol) (docstring nil :type string) (parents nil :type (list-of cl--class)) (slots nil :type (vector cl-slot-descriptor)) (index-table nil :type hash-table) (tag nil :type symbol) (type nil :type (memq (vector list))) (named nil :type bool) (print nil :type bool) (children-sym nil :type symbol)) cl-struct-cl-structure-class-tags] 11)
#@68 compiler-macro for inlining `cl-struct-p'.

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

(fn CL-X)
(defalias 'cl-struct-p #[257 "\301
!>\205	\302\207" [cl-struct-cl-structure-object-tags type-of t] 3 (#$ . 15523)])
(byte-code "\301\302\303\304#\305\306\307\302#\210\310\306\311\306\312\313\314\315\306\316&	\210\306\313\207" [cl--struct-default-parent function-put cl-struct-p side-effect-free error-free put cl-structure-object cl-deftype-satisfies cl-struct-define "The root parent of all \"normal\" CL structs" record nil ((cl-tag-slot)) cl-struct-cl-structure-object-tags t] 11)
#@77 compiler-macro for inlining `cl-slot-descriptor-p'.

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

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

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

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

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

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

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

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

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

(fn CL-X)
(defalias 'cl--slot-descriptor-props #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-cl-slot-descriptor-tags type-of signal wrong-type-argument cl-slot-descriptor 4] 5 (#$ . 19704)])
(byte-code "\300\301\302\303#\304\305\306\"\207" [function-put cl--slot-descriptor-props side-effect-free t defalias cl--copy-slot-descriptor-1 copy-sequence] 4)
#@111 compiler-macro for inlining `cl--make-slot-descriptor'.

(fn CL-WHOLE-ARG NAME &optional INITFORM TYPE PROPS)
(defalias 'cl--make-slot-descriptor--cmacro #[1282 "\300\301\302\303\211\211				&	\207" [cl--defsubst-expand (name initform type props) (cl-block cl--make-slot-descriptor (record 'cl-slot-descriptor name initform type props)) nil] 15 (#$ . 20143)])
(put 'cl--make-slot-descriptor 'compiler-macro 'cl--make-slot-descriptor--cmacro)
#@96 Constructor for objects of type `cl-slot-descriptor'.

(fn NAME &optional INITFORM TYPE PROPS)
(defalias 'cl--make-slot-descriptor #[1025 "\300\301%\207" [record cl-slot-descriptor] 10 (#$ . 20594)])
(byte-code "\300\301\302\303#\304\305\306\307\310\311\312\313\305\303&	\207" [function-put cl--make-slot-descriptor side-effect-free t cl-struct-define cl-slot-descriptor "Descriptor of structure slot." cl-structure-object record nil ((cl-tag-slot) (name) (initform) (type) (props nil :type alist)) cl-struct-cl-slot-descriptor-tags] 11)
#@13 

(fn SLOT)
(defalias 'cl--copy-slot-descriptor #[257 "\301
!\302
!>\204\303\304\305D\"\210\211\211\306\307\306H!I\266\211\207" [cl-struct-cl-slot-descriptor-tags cl--copy-slot-descriptor-1 type-of signal wrong-type-argument cl-slot-descriptor 4 copy-alist] 8 (#$ . 21142)])
#@68 compiler-macro for inlining `cl--class-p'.

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

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

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

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

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

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

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

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

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

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

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

(fn CL-X)
(defalias 'cl--class-index-table #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-cl--class-tags type-of signal wrong-type-argument cl--class 5] 5 (#$ . 25388)])
(byte-code "\304\305\306\307#\310\311\312\313\314\315\316\303\311\307&	\210\317\311N\320
!>\204$\321\322\317D\"\210\211\323H\262
\311\211N\320
!>\204;\321\322\317D\"\210\211\323H\262
\307
G\324\211W\203\205\211
HH\320!	>\204`\321\322\325D\"\210
\326H\320!	>\204r\321\322\325D\"\210
\326H=\204|\315\262\266\211T\262
\202D\266\266\202\204\220\327\330!\210\317\311N\320
!>\204\242\321\322\317D\"\210\211\211\331\311\211NCI\266\332\311\211N\317\311N\320
!>\204\302\321\322\317D\"\210\211\333H\262
\"\210\317\311N\204\323\327\334!\210\313\311N\204\335\327\335!\210\317\311N\320
!\n>\205\351\307\262
\204\362\327\336!\210\313\311N\320
!\n>\205\376\307\262
\204
\327\337!\210\317\311N\320
!>\205
\307\262
\204
\327\340!\210\313\311N\320
!>\205(
\307\262
\2041
\327\341!\210\342\343\344\"\210\345\346\347\331#\210\345\350\347\331#\210\345\351\347\331#\210\345\352\347\353#\210\354\355!\207" [cl-struct-cl-structure-class-tags cl-struct-cl-slot-descriptor-tags cl-struct-cl-structure-object-tags cl-struct-cl--class-tags function-put cl--class-index-table side-effect-free t cl-struct-define cl--class "Type of descriptors for any kind of structure-like data." cl-structure-object record nil ((cl-tag-slot) (name nil :type symbol) (docstring nil :type string) (parents nil :type (list-of cl--class)) (slots nil :type (vector cl-slot-descriptor)) (index-table nil :type hash-table)) cl-structure-class type-of signal wrong-type-argument 4 0 cl-slot-descriptor 1 cl--assertion-failed (let ((sc-slots (cl--struct-class-slots (cl--find-class 'cl-structure-class))) (c-slots (cl--struct-class-slots (cl--find-class 'cl--class))) (eq t)) (dotimes (i (length c-slots)) (let ((sc-slot (aref sc-slots i)) (c-slot (aref c-slots i))) (unless (eq (cl--slot-descriptor-name sc-slot) (cl--slot-descriptor-name c-slot)) (setq eq nil)))) eq) 3 cl--struct-register-child 6 (cl--find-class 'cl-structure-class) (cl--find-class 'cl-structure-object) (cl-struct-p (cl--find-class 'cl-structure-class)) (cl-struct-p (cl--find-class 'cl-structure-object)) (cl--class-p (cl--find-class 'cl-structure-class)) (cl--class-p (cl--find-class 'cl-structure-object)) autoload cl--defsubst-expand "cl-macs" put cl-defun doc-string-elt cl-defmacro cl-defsubst cl-defstruct 2 provide cl-preloaded] 14)