HOME

;ELC
;;; Compiled
;;; in Emacs version 26.1
;;; 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)])
(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 (#$ . 1045)])
#@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 (#$ . 1528)])
#@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 (#$ . 1698)])
#@70 

(fn NAME DOCSTRING PARENT TYPE NAMED SLOTS CHILDREN-SYM TAG PRINT)
(defalias 'cl-struct-define #[2313 "\204\302\303!\210\304=\203\305\262\204\203\306\307!\210\310!\203+\311\"\210\2020CL\210\204@@@\312=\203@A\262\205I\313!G\314\315\316\317$\320\305\"\321\n\203_\321\202`\303	\211\203\246\211@\211AA\322
\323\"\211\203y\211A@\202z\324\325@A@\326		\"$I\266\327
@\\#\210T\262
A\266\202\202b\210\266\203\f\f9?\205\266C\f\f


\304\330		\n
&\266\2129\204[
\331!>\204\362\332\333\330D\"\210\334H
GY\204Z
\324
G\321\211W\203J
\211\331H!	>\204
\332\333\335HD\"\210
H\303H\331H!	>\2045
\332\333\335\nHD\"\210H\303H=\204B
\305\262\210\211T\262
\202
\266\211\262
\204Z
\336\337#\210\210\311\340\341B\"\210\342\"\210	\324=\204\202
=\204\202

L\210\343M\210
\344
\345#\262
\207" [cl-struct-cl-structure-class-tags cl-struct-cl-slot-descriptor-tags 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 signal wrong-type-argument 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 (#$ . 2018)])
#@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 (#$ . 3495)])
(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 (#$ . 3867)])
(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 (or (cl--struct-class-p cl-x) (signal 'wrong-type-argument (list 'cl-structure-class cl-x))) (aref cl-x 1)) nil] 9 (#$ . 4169)])
(put 'cl--struct-class-name 'compiler-macro 'cl--struct-class-name--cmacro)
#@279 Access slot "name" of `(cl-structure-class (:conc-name cl--struct-class-) (:predicate cl--struct-class-p) (:constructor nil) (:constructor cl--struct-new-class (name docstring parents type named slots index-table children-sym tag print)) (:copier nil))' 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 (#$ . 4600)])
(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 (or (cl--struct-class-p cl-x) (signal 'wrong-type-argument (list 'cl-structure-class cl-x))) (aref cl-x 2)) nil] 9 (#$ . 5179)])
(put 'cl--struct-class-docstring 'compiler-macro 'cl--struct-class-docstring--cmacro)
#@284 Access slot "docstring" of `(cl-structure-class (:conc-name cl--struct-class-) (:predicate cl--struct-class-p) (:constructor nil) (:constructor cl--struct-new-class (name docstring parents type named slots index-table children-sym tag print)) (:copier nil))' 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 (#$ . 5635)])
(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 (or (cl--struct-class-p cl-x) (signal 'wrong-type-argument (list 'cl-structure-class cl-x))) (aref cl-x 3)) nil] 9 (#$ . 6229)])
(put 'cl--struct-class-parents 'compiler-macro 'cl--struct-class-parents--cmacro)
#@282 Access slot "parents" of `(cl-structure-class (:conc-name cl--struct-class-) (:predicate cl--struct-class-p) (:constructor nil) (:constructor cl--struct-new-class (name docstring parents type named slots index-table children-sym tag print)) (:copier nil))' 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 (#$ . 6675)])
(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 (or (cl--struct-class-p cl-x) (signal 'wrong-type-argument (list 'cl-structure-class cl-x))) (aref cl-x 4)) nil] 9 (#$ . 7263)])
(put 'cl--struct-class-slots 'compiler-macro 'cl--struct-class-slots--cmacro)
#@280 Access slot "slots" of `(cl-structure-class (:conc-name cl--struct-class-) (:predicate cl--struct-class-p) (:constructor nil) (:constructor cl--struct-new-class (name docstring parents type named slots index-table children-sym tag print)) (:copier nil))' 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 (#$ . 7699)])
(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 (or (cl--struct-class-p cl-x) (signal 'wrong-type-argument (list 'cl-structure-class cl-x))) (aref cl-x 5)) nil] 9 (#$ . 8281)])
(put 'cl--struct-class-index-table 'compiler-macro 'cl--struct-class-index-table--cmacro)
#@286 Access slot "index-table" of `(cl-structure-class (:conc-name cl--struct-class-) (:predicate cl--struct-class-p) (:constructor nil) (:constructor cl--struct-new-class (name docstring parents type named slots index-table children-sym tag print)) (:copier nil))' 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 (#$ . 8747)])
(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 (or (cl--struct-class-p cl-x) (signal 'wrong-type-argument (list 'cl-structure-class cl-x))) (aref cl-x 6)) nil] 9 (#$ . 9347)])
(put 'cl--struct-class-tag 'compiler-macro 'cl--struct-class-tag--cmacro)
#@278 Access slot "tag" of `(cl-structure-class (:conc-name cl--struct-class-) (:predicate cl--struct-class-p) (:constructor nil) (:constructor cl--struct-new-class (name docstring parents type named slots index-table children-sym tag print)) (:copier nil))' 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 (#$ . 9773)])
(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 (or (cl--struct-class-p cl-x) (signal 'wrong-type-argument (list 'cl-structure-class cl-x))) (aref cl-x 7)) nil] 9 (#$ . 10349)])
(put 'cl--struct-class-type 'compiler-macro 'cl--struct-class-type--cmacro)
#@279 Access slot "type" of `(cl-structure-class (:conc-name cl--struct-class-) (:predicate cl--struct-class-p) (:constructor nil) (:constructor cl--struct-new-class (name docstring parents type named slots index-table children-sym tag print)) (:copier nil))' 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 (#$ . 10781)])
(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 (or (cl--struct-class-p cl-x) (signal 'wrong-type-argument (list 'cl-structure-class cl-x))) (aref cl-x 8)) nil] 9 (#$ . 11361)])
(put 'cl--struct-class-named 'compiler-macro 'cl--struct-class-named--cmacro)
#@280 Access slot "named" of `(cl-structure-class (:conc-name cl--struct-class-) (:predicate cl--struct-class-p) (:constructor nil) (:constructor cl--struct-new-class (name docstring parents type named slots index-table children-sym tag print)) (:copier nil))' 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 (#$ . 11798)])
(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 (or (cl--struct-class-p cl-x) (signal 'wrong-type-argument (list 'cl-structure-class cl-x))) (aref cl-x 9)) nil] 9 (#$ . 12381)])
(put 'cl--struct-class-print 'compiler-macro 'cl--struct-class-print--cmacro)
#@280 Access slot "print" of `(cl-structure-class (:conc-name cl--struct-class-) (:predicate cl--struct-class-p) (:constructor nil) (:constructor cl--struct-new-class (name docstring parents type named slots index-table children-sym tag print)) (:copier nil))' 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 (#$ . 12818)])
(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 (or (cl--struct-class-p cl-x) (signal 'wrong-type-argument (list 'cl-structure-class cl-x))) (aref cl-x 10)) nil] 9 (#$ . 13401)])
(put 'cl--struct-class-children-sym 'compiler-macro 'cl--struct-class-children-sym--cmacro)
#@287 Access slot "children-sym" of `(cl-structure-class (:conc-name cl--struct-class-) (:predicate cl--struct-class-p) (:constructor nil) (:constructor cl--struct-new-class (name docstring parents type named slots index-table children-sym tag print)) (:copier nil))' 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 (#$ . 13874)])
(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 (#$ . 14480)])
(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 (#$ . 15064)])
(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 (#$ . 15933)])
(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 (#$ . 16272)])
(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 (#$ . 16777)])
(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 (#$ . 17160)])
(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 (or (cl-slot-descriptor-p cl-x) (signal 'wrong-type-argument (list 'cl-slot-descriptor cl-x))) (aref cl-x 1)) nil] 9 (#$ . 17467)])
(put 'cl--slot-descriptor-name 'compiler-macro 'cl--slot-descriptor-name--cmacro)
#@237 Access slot "name" of `(cl-slot-descriptor (:conc-name cl--slot-descriptor-) (:constructor nil) (:constructor cl--make-slot-descriptor (name &optional initform type props)) (:copier cl--copy-slot-descriptor-1))' 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 (#$ . 17916)])
(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 (or (cl-slot-descriptor-p cl-x) (signal 'wrong-type-argument (list 'cl-slot-descriptor cl-x))) (aref cl-x 2)) nil] 9 (#$ . 18460)])
(put 'cl--slot-descriptor-initform 'compiler-macro 'cl--slot-descriptor-initform--cmacro)
#@241 Access slot "initform" of `(cl-slot-descriptor (:conc-name cl--slot-descriptor-) (:constructor nil) (:constructor cl--make-slot-descriptor (name &optional initform type props)) (:copier cl--copy-slot-descriptor-1))' 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 (#$ . 18929)])
(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 (or (cl-slot-descriptor-p cl-x) (signal 'wrong-type-argument (list 'cl-slot-descriptor cl-x))) (aref cl-x 3)) nil] 9 (#$ . 19485)])
(put 'cl--slot-descriptor-type 'compiler-macro 'cl--slot-descriptor-type--cmacro)
#@237 Access slot "type" of `(cl-slot-descriptor (:conc-name cl--slot-descriptor-) (:constructor nil) (:constructor cl--make-slot-descriptor (name &optional initform type props)) (:copier cl--copy-slot-descriptor-1))' 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 (#$ . 19934)])
(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 (or (cl-slot-descriptor-p cl-x) (signal 'wrong-type-argument (list 'cl-slot-descriptor cl-x))) (aref cl-x 4)) nil] 9 (#$ . 20478)])
(put 'cl--slot-descriptor-props 'compiler-macro 'cl--slot-descriptor-props--cmacro)
#@238 Access slot "props" of `(cl-slot-descriptor (:conc-name cl--slot-descriptor-) (:constructor nil) (:constructor cl--make-slot-descriptor (name &optional initform type props)) (:copier cl--copy-slot-descriptor-1))' 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 (#$ . 20932)])
(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 (#$ . 21540)])
(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 (#$ . 21991)])
(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 (#$ . 22539)])
#@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 (#$ . 22826)])
(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 (#$ . 23155)])
(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 (or (cl--class-p cl-x) (signal 'wrong-type-argument (list 'cl--class cl-x))) (aref cl-x 1)) nil] 9 (#$ . 23426)])
(put 'cl--class-name 'compiler-macro 'cl--class-name--cmacro)
#@94 Access slot "name" of `(cl--class (:constructor nil) (:copier nil))' 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 (#$ . 23806)])
(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 (or (cl--class-p cl-x) (signal 'wrong-type-argument (list 'cl--class cl-x))) (aref cl-x 2)) nil] 9 (#$ . 24169)])
(put 'cl--class-docstring 'compiler-macro 'cl--class-docstring--cmacro)
#@99 Access slot "docstring" of `(cl--class (:constructor nil) (:copier nil))' 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 (#$ . 24574)])
(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 (or (cl--class-p cl-x) (signal 'wrong-type-argument (list 'cl--class cl-x))) (aref cl-x 3)) nil] 9 (#$ . 24952)])
(put 'cl--class-parents 'compiler-macro 'cl--class-parents--cmacro)
#@97 Access slot "parents" of `(cl--class (:constructor nil) (:copier nil))' 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 (#$ . 25347)])
(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 (or (cl--class-p cl-x) (signal 'wrong-type-argument (list 'cl--class cl-x))) (aref cl-x 4)) nil] 9 (#$ . 25719)])
(put 'cl--class-slots 'compiler-macro 'cl--class-slots--cmacro)
#@95 Access slot "slots" of `(cl--class (:constructor nil) (:copier nil))' 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 (#$ . 26104)])
(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 (or (cl--class-p cl-x) (signal 'wrong-type-argument (list 'cl--class cl-x))) (aref cl-x 5)) nil] 9 (#$ . 26470)])
(put 'cl--class-index-table 'compiler-macro 'cl--class-index-table--cmacro)
#@101 Access slot "index-table" of `(cl--class (:constructor nil) (:copier nil))' 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 (#$ . 26886)])
(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)