;ELC
;;; Compiled by mockbuild@buildfarm06-new.corp.cloudlinux.com on Fri Oct 11 10:09:02 2024
;;; from file /builddir/build/BUILD/emacs-24.3/lisp/emacs-lisp/eieio.el
;;; in Emacs version 24.3.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.

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


#@27 Current version of EIEIO.
(defvar eieio-version "1.4" (#$ . 559))
#@39 Display the current version of EIEIO.
(defalias 'eieio-version #[nil "\301!\207" [eieio-version message] 2 (#$ . 631) nil])
(byte-code "\300\301!\203\302\303\301\"\210\202\302\303\304\"\210\300\207" [fboundp compiled-function-arglist defalias eieio-compiled-function-arglist #[(func) "\301H\207" [func 0] 2 "Return the argument list for the compiled function FUNC."]] 3)
#@69 This hook is executed, then cleared each time `defclass' is called.
(defvar eieio-hook nil (#$ . 1014))
#@184 Non-nil to throw an error if an encountered tag is unsupported.
This may prevent classes from CLOS applications from being used with EIEIO
since EIEIO does not support all CLOS tags.
(defvar eieio-error-unsupported-class-tags nil (#$ . 1125))
#@223 If non-nil, skip all slot typechecking.
Set this to t permanently if a program is functioning well to get a
small speed increase.  This variable is also used internally to handle
default setting for optimization purposes.
(defvar eieio-skip-typecheck nil (#$ . 1375))
#@67 Non-nil means to optimize the method dispatch on primary methods.
(defvar eieio-optimize-primary-methods-flag t (#$ . 1649))
#@46 Set to non-nil while initializing an object.
(defvar eieio-initializing-object nil (#$ . 1780))
#@62 Uninterned symbol representing an unbound slot in an object.
(defconst eieio-unbound (byte-code "\301\300!\203
9\203
\207\302\303!\207" [eieio-unbound boundp make-symbol "unbound"] 2) (#$ . 1882))
(defvar eieio-default-superclass nil)
#@37 Class's symbol (self-referencing.).
(defconst class-symbol 1 (#$ . 2127))
#@20 Class parent slot.
(defconst class-parent 2 (#$ . 2207))
#@28 Class children class slot.
(defconst class-children 3 (#$ . 2270))
#@62 Obarray permitting fast access to variable position indexes.
(defconst class-symbol-obarray 4 (#$ . 2343))
#@24 Class attribute index.
(defconst class-public-a 5 (#$ . 2456))
#@33 Class attribute defaults index.
(defconst class-public-d 6 (#$ . 2525))
#@45 Class documentation strings for attributes.
(defconst class-public-doc 7 (#$ . 2603))
#@24 Class type for a slot.
(defconst class-public-type 8 (#$ . 2695))
#@31 Class custom type for a slot.
(defconst class-public-custom 9 (#$ . 2767))
#@32 Class custom group for a slot.
(defconst class-public-custom-label 10 (#$ . 2848))
#@32 Class custom group for a slot.
(defconst class-public-custom-group 11 (#$ . 2937))
#@21 Printer for a slot.
(defconst class-public-printer 12 (#$ . 3026))
#@30 Class protection for a slot.
(defconst class-protection 13 (#$ . 3099))
#@28 Class initarg tuples list.
(defconst class-initarg-tuples 14 (#$ . 3177))
#@29 Class allocated attributes.
(defconst class-class-allocation-a 15 (#$ . 3257))
#@32 Class allocated documentation.
(defconst class-class-allocation-doc 16 (#$ . 3342))
#@29 Class allocated value type.
(defconst class-class-allocation-type 17 (#$ . 3432))
#@36 Class allocated custom descriptor.
(defconst class-class-allocation-custom 18 (#$ . 3520))
#@36 Class allocated custom descriptor.
(defconst class-class-allocation-custom-label 19 (#$ . 3617))
#@31 Class allocated custom group.
(defconst class-class-allocation-custom-group 20 (#$ . 3720))
#@37 Class allocated printer for a slot.
(defconst class-class-allocation-printer 21 (#$ . 3818))
#@34 Class allocated protection list.
(defconst class-class-allocation-protection 22 (#$ . 3917))
#@31 Class allocated value vector.
(defconst class-class-allocation-values 23 (#$ . 4016))
#@215 Cache index of what a newly created object would look like.
This will speed up instantiation time as only a `copy-sequence' will
be needed, instead of looping over all the values and setting them
from the default.
(defconst class-default-object-cache 24 (#$ . 4109))
#@95 Storage location of tagged class options.
Stored outright without modifications or stripping.
(defconst class-options 25 (#$ . 4382))
#@49 Number of slots in the class definition object.
(defconst class-num-slots 26 (#$ . 4522))
#@54 Index in an object vector where the class is stored.
(defconst object-class 1 (#$ . 4618))
#@46 Index in an object where the name is stored.
(defconst object-name 2 (#$ . 4715))
#@37 Index into :static tag on a method.
(defconst method-static 0 (#$ . 4803))
#@37 Index into :before tag on a method.
(defconst method-before 1 (#$ . 4884))
#@38 Index into :primary tag on a method.
(defconst method-primary 2 (#$ . 4965))
#@36 Index into :after tag on a method.
(defconst method-after 3 (#$ . 5048))
#@78 Number of indexes into methods vector in which groups of functions are kept.
(defconst method-num-lists 4 (#$ . 5127))
#@45 Index into generic :before tag on a method.
(defconst method-generic-before 4 (#$ . 5252))
#@46 Index into generic :primary tag on a method.
(defconst method-generic-primary 5 (#$ . 5349))
#@44 Index into generic :after tag on a method.
(defconst method-generic-after 6 (#$ . 5448))
#@43 Number of indexes into a method's vector.
(defconst method-num-slots 7 (#$ . 5543))
#@54 Convert a specialized KEY into a generic method key.
(defalias 'eieio-specialized-key-to-generic-key #[(key) "	=\203\303\207\nW\203\304\\\207\207" [key method-static method-num-lists 0 3] 2 (#$ . 5633)])
(put 'eieio-specialized-key-to-generic-key 'byte-optimizer 'byte-compile-inline-expand)
#@58 Internal: Return the class vector from the CLASS symbol.
(defalias 'class-v '(macro . #[(class) "\301\302BB\207" [class get ('eieio-class-definition)] 3 (#$ . 5939)]))
#@63 Return t if CLASS is a valid class vector.
CLASS is a symbol.
(defalias 'class-p '(macro . #[(class) "\301\302\303\304\305D\306BB\307BB\310BBB\207" [class condition-case nil eq aref class-v (0) ('defclass) ((error nil))] 6 (#$ . 6114)]))
#@43 Return non-nil if OBJ is an EIEIO object.
(defalias 'eieio-object-p '(macro . #[(obj) "\301\302\303\304DC\305BB\306BBB\207" [obj condition-case nil let tobj ((and (eq (aref tobj 0) 'object) (class-p (aref tobj object-class)))) ((error nil))] 5 (#$ . 6359)]))
(defalias 'object-p 'eieio-object-p)
#@58 Return the symbol representing the constructor of CLASS.
(defalias 'class-constructor '(macro . #[(class) "\301\302D\303BB\207" [class aref class-v (class-symbol)] 3 (#$ . 6662)]))
#@177 Return t if symbol METHOD is a generic function.
Only methods have the symbol `eieio-method-obarray' as a property
(which contains a list of all bindings to that method type.)
(defalias 'generic-p '(macro . #[(method) "\301\302D\303\304BBE\207" [method and fboundp get ('eieio-method-obarray)] 5 (#$ . 6851)]))
#@279 Return t if symbol METHOD is a generic function with only primary methods.
Only methods have the symbol `eieio-method-obarray' as a property (which
contains a list of all bindings to that method type.)
Methods with only primary implementations are executed in an optimized way.
(defalias 'generic-primary-only-p #[(method) "\306!\205D\307N\205D\310N\311	\nHGW\205C	H?\205C	\fH?\205C	
H?\205C	\nH?\205C	H?\205C	\fH?)\207" [method M method-primary method-static method-before method-after fboundp eieio-method-obarray eieio-method-tree 0 method-generic-before method-generic-primary method-generic-after] 3 (#$ . 7171)])
#@279 Return t if symbol METHOD is a generic function with only primary methods.
Only methods have the symbol `eieio-method-obarray' as a property (which
contains a list of all bindings to that method type.)
Methods with only primary implementations are executed in an optimized way.
(defalias 'generic-primary-only-one-p #[(method) "\306!\205D\307N\205D\310N\211\nHG\311U\205C	H?\205C	\fH?\205C	
H?\205C	\nH?\205C	H?\205C	\fH?)\207" [method M method-primary method-static method-before method-after fboundp eieio-method-obarray eieio-method-tree 1 method-generic-before method-generic-primary method-generic-after] 3 (#$ . 7814)])
#@64 Return from LIST the found OPTION, or nil if it doesn't exist.
(defalias 'class-option-assoc '(macro . #[(list option) "\302\303\304	EDD\207" [option list car-safe cdr memq] 5 (#$ . 8463)]))
#@85 Return the value stored for CLASS' OPTION.
Return nil if that option doesn't exist.
(defalias 'class-option '(macro . #[(class option) "\302\303\304D\305BB\306	DE\207" [class option class-option-assoc aref class-v (class-options) quote] 4 (#$ . 8661)]))
#@79 Return non-nil if CLASS is abstract.
Abstract classes cannot be instantiated.
(defalias 'class-abstract-p '(macro . #[(class) "\301\302BB\207" [class class-option (:abstract)] 3 (#$ . 8922)]))
#@80 Return the invocation order of CLASS.
Abstract classes cannot be instantiated.
(defalias 'class-method-invocation-order '(macro . #[(class) "\301\302\303BB\304BB\207" [class or class-option (:method-invocation-order) (:breadth-first)] 4 (#$ . 9122)]))
#@2685 Define NAME as a new class derived from SUPERCLASS with SLOTS.
OPTIONS-AND-DOC is used as the class' options and base documentation.
SUPERCLASS is a list of superclasses to inherit from, with SLOTS
being the slots residing in that class definition.  NOTE: Currently
only one slot may exist in SUPERCLASS as multiple inheritance is not
yet supported.  Supported tags are:

  :initform   - Initializing form.
  :initarg    - Tag used during initialization.
  :accessor   - Tag used to create a function to access this slot.
  :allocation - Specify where the value is stored.
                Defaults to `:instance', but could also be `:class'.
  :writer     - A function symbol which will `write' an object's slot.
  :reader     - A function symbol which will `read' an object.
  :type       - The type of data allowed in this slot (see `typep').
  :documentation
              - A string documenting use of this slot.

The following are extensions on CLOS:
  :protection - Specify protection for this slot.
                Defaults to `:public'.  Also use `:protected', or `:private'.
  :custom     - When customizing an object, the custom :type.  Public only.
  :label      - A text string label used for a slot when customizing.
  :group      - Name of a customization group this slot belongs in.
  :printer    - A function to call to print the value of a slot.
                See `eieio-override-prin1' as an example.

A class can also have optional options.  These options happen in place
of documentation (including a :documentation tag), in addition to
documentation, or not at all.  Supported options are:

  :documentation - The doc-string used for this class.

Options added to EIEIO:

  :allow-nil-initform - Non-nil to skip typechecking of null initforms.
  :custom-groups      - List of custom group names.  Organizes slots into
                        reasonable groups for customizations.
  :abstract           - Non-nil to prevent instances of this class.
                        If a string, use as an error string if someone does
                        try to make an instance.
  :method-invocation-order
                      - Control the method invocation order if there is
                        multiple inheritance.  Valid values are:
                         :breadth-first - The default.
                         :depth-first

Options in CLOS not supported in EIEIO:

  :metaclass - Class to use in place of `standard-class'
  :default-initargs - Initargs to use when initializing new objects of
                      this class.

Due to the way class options are set up, you can add any tags you wish,
and reference them using the function `class-option'.
(defalias 'defclass '(macro . #[(name superclass slots &rest options-and-doc) "\304\305\306D\306	D\306\nD\306D\257D\207" [name superclass slots options-and-doc eval-and-compile eieio-defclass quote] 7 (#$ . 9383)]))
#@50 Symbol map of superclasses we find in autoloads.
(defvar eieio-defclass-autoload-map (make-vector 7 nil) (#$ . 12292))
#@289 Create autoload symbols for the EIEIO class CNAME.
SUPERCLASSES are the superclasses that CNAME inherits from.
DOC is the docstring for CNAME.
This function creates a mock-class for CNAME and adds it into
SUPERCLASSES as children.
It creates an autoload function for CNAME's constructor.
(defalias 'eieio-defclass-autoload #[(cname superclasses filename doc) "\306\307\310\217\205\n\311N\312\n\306\"	?\205\344\313\314I\210\fI\210\306\204+\315\316\306\211\203\230@\306\317\320\217\204f\321\322!\"\323!\204\\CL\210\202b\324\"\210)\202\203\311N H\235\204\203\311N \311N HBI\210!!HBI\210A\211\2046*\211L\210\325\311#\210
\203\255!\306I\210\326\"#\306\211%\210\326\321\322!\327P!\"\330\306\211%\210\326\321\322!\331P!\"\330\306\211%\210\326\321\322!\332P!\"\330\306\211%)*\207" [cname oldc class-num-slots newc class-symbol clear-parent nil (byte-code "\301N\302H\303=\207" [cname eieio-class-definition 0 defclass] 2) ((error)) eieio-class-definition make-vector 0 defclass (eieio-default-superclass) t (byte-code "\301N\302H\303=\207" [SC eieio-class-definition 0 defclass] 2) ((error)) intern symbol-name boundp add-to-list put autoload "-p" "" "-child-p" "-list-p" superclasses SC --dolist-tail-- eieio-defclass-autoload-map sym class-children class-parent filename doc] 7 (#$ . 12418)])
#@56 If class CNAME is in an autoload state, load its file.
(defalias 'eieio-class-un-autoload #[(cname) "K\242\301=\205\302KA@!\207" [cname autoload load-library] 2 (#$ . 13795)])
(put 'eieio-class-un-autoload 'byte-optimizer 'byte-compile-inline-expand)
#@232 Define CNAME as a new subclass of SUPERCLASSES.
SLOTS are the slots residing in that class definition, and options or
documentation OPTIONS-AND-DOC is the toplevel documentation for this class.
See `defclass' for more information.
(defalias 'eieio-defclass #[(cname superclasses slots options-and-doc) "\306\300!\210\307	<\204\310\311\312\"\210	\313\307\"\307\314\315\217\205!
\316N@\307\211AB\307C\f\317\320I\210\fD
I\210@\203I\fE@EHI\210\202d\321\322
!F\"\211G\203c\307\323\324\217\210\325\322
!F\"\210)H@;\203|HG\326\246\327U\204|\330\331!\210\202\221H@9\203\221HG\326\246\317U\204\221\330\331!\210H@;\203\237\332HB\202\241HB\n\203
\n\203

\n@\203

\n@9\203

\307\333\334\217\204\306\330\335\n@\"\210\202

\n@\316NEH\235\204\343\n@\316NE
\n@\316NEHBI\210\336\337\340\n@\316NIH>A\242\"\210\fJ\n@\fJHBI\210\202
\330\341\n\"\210\nA\211\204\253\fJ\fJH\237I\210\202E

\342=\204E
\343C
\342\316NEH\235\204=
\342\316NE
\342\316NEHBI\210\fJ\"CI\210
\211L\210\344\322
!\345P!\211K\346\347C\350\351
\"\352\353\354\347
EEFM\210)\355B>A\242\211L\203~
L\356\235\204~
\330\357L\"\210)\344\322
!\360P!\211K\346\361\350\362
\"\352\363\364\347
EEFM\210\344\322
!\365P!\211K\346\366\350\367
\"\370\371\372\373\374\375\376\377\352\201\203\364\201\204
EEE\201\205BBB\201\206BBBEFM\210)\201\207
\201\210\346\307\201\211\201\212\201\213KDEE#\210)\201\214\f	\"\210\201\207
\316\f#\210M\203M@\211N@ONAP\201\215P\201\216\"Q\201\215P\201\217\"\206-\201\217P\235?\205-RS\201\215P\201\220\"T\201\215P\332\"U\201\215P\201\221\"V\201\215P\201\222\"W\201\215P\201\223\"X\201\215P\201\224\"Y\201\215P\201\225\"Z\201\215P\201\226\"[\201\215P\201\227\"\\\201\215P\201\230\"]\201\215P\201\231\"^\201\232B>A\242_`\203\334P\211a\203\333a@\201\233\235\204\321\310\201\234a@C\"\210aAA\211a\204\275)V\201\235=\204\356V\201\236=\203\364\307V\202;V\201\237=\204V\201\240=\203\201\237V\202;V\201\241=\204 V\201\242=\203(\201\241V\202;V\307=\204;\310\201\234\201\221VD\"\210Y\203^Y\201\243=\204^Y\201\244=\204^\310\201\234\201\224YD\"\210Z\204f\343Z\\\203}\\;\204}\310\201\234\201\227\\D\"\210T\203\223Y\201\243=\203\223\201\245\201\246!\210T\203\235T\211L\210]\204\252\201\247]\202\265]<\204\265]C]\336\201\250]\"\210\201\251\fOSUZ[\\]^VTY\201\252_&\210\336\201\253]\"\210Q\203\253\201\254QY\201\243=\203\201\255\202\201\256
\346\201\257\350\201\260O
#\201\261\201\262\201\263\201\213ODE\201\264\201\263\201\213ODE\201\265BBBF$\210\201\266\201\267!\203i\201\270\201\267Q\201\271\201\211\201\272\201\273\201\213\211ODD\201\274BBBBF!\210\202\253\201\207Q\201\275\346\201\276\201\277\201\300\201\211\201\301\201\302\201\303\201\211\201\304\201\305\201\213\211ODD\201\306BBBB\201\307BBBBBEE#\210X\203\333\201\254X\307
\346\201\310\350\201\311O
#\201\312\201\313\201\263\201\213ODE\201\314BBF$\210W\203\201\254W\307
\346\201\315\350\201\316O
#\201\313\201\263\201\213ODEF$\210.MA\211M\204\374
\fb\fbH\237I\210\fc\fcH\237I\210\fd\fdH\237I\210\fe\201\317\201\320\feH\237\"I\210\ff\ffH\237I\210\fg\fgH\237I\210\fh\fhH\237I\210\fi\fiH\237I\210\fj\fjH\237I\210\fk\fkH\237I\210\fl\201\317\201\320\flH\"I\210\fm\201\317\201\320\fmH\"I\210\317n\fbHo\fjHpoGq\201\321rr@qW\203\304rA\211r\204\262r@)s\313s\317\"t\307uo\203\344\322o@!t\"\211unL\210nTnp@\203
\201\207u\201\322p@#\210oAopAp\202\324\fvtI\210.\201\323B>A\242\203O\201\323B>A\242\211w;\2049\350\201\324
\"w
\346\201\325\350\201\326
\"\330wDFM\210)\202j
\346\201\327\350\201\330
\"\201\317\201\331
\201\332BBBFM\210\201\207
\201\333\332B>A\242#\210x\203\203y\202\205z\307{\211|\203\257\201\334\201\335|\"\203\244|\317|GSO|\201\207
\201\336|#\210*\340B>A\242}\336\201\337A\"\210\340B>\203\323\340B>A}\240\210\202\334\340}BBBB)\fIBI\210C\203\357\fJ\307I\210\313\fbHG\201\340\\\307\"\211~\317\201\341I\210~
I\210~\200\201\342I\210\343\201\201\343~\343\"\210)\f\202~I\210)
.\207" [eieio-hook superclasses pname class-num-slots newc cname run-hooks nil signal wrong-type-argument (listp superclasses) make-vector (byte-code "\301N\302H\303=\207" [cname eieio-class-definition 0 defclass] 2) ((error)) eieio-class-definition 0 defclass intern-soft symbol-name (byte-code "	\nJI\207" [newc class-children sym] 3) ((error)) unintern 2 1 error "Too many arguments to `defclass'" :documentation (byte-code "@\301N\302H\303=\207" [pname eieio-class-definition 0 defclass] 2) ((error)) "Given parent class %s is not a class" mapc #[(g) "\301\302\"\207" [g add-to-list groups] 3] :custom-groups "Invalid parent class %s" eieio-default-superclass t intern "-p" lambda obj format "Test OBJ to see if it an object of type %s" and (eieio-object-p obj) same-class-p :method-invocation-order (:depth-first :breadth-first :c3) "Method invocation order %s is not allowed" "-child-p" (obj) "Test OBJ to see if it an object is a child of type %s" (eieio-object-p obj) object-of-class-p "-list-p" (obj) "Test OBJ to see if it a list of objects which are a child of type %s" when (listp obj) let ((ans t)) while (and obj ans) setq ans oldc groups options clearparent class-symbol class-children eieio-defclass-autoload-map sym options-and-doc class-options class-parent csym io slots slot1 name slot acces eieio-unbound init initarg docstr prot reader writer alloc type custom label customg printer skip-nil eieio-error-unsupported-class-tags tmp class-public-a class-public-d class-public-doc class-public-type class-public-custom class-public-custom-label class-public-custom-group class-public-printer class-protection class-initarg-tuples class-class-allocation-type class-class-allocation-values cnt pubsyms prots l primes vl oa newsym class-symbol-obarray abs load-in-progress load-file-name buffer-file-name loc fname g cache object-class object-name eieio-skip-typecheck class-default-object-cache (eieio-object-p (car obj)) (car obj) ((setq obj (cdr obj))) (ans) put cl-deftype-handler list 'satisfies quote eieio-copy-parents-into-subclass plist-get :accessor :initform :initarg :protection :reader :writer :allocation :type :custom :label :group :printer :allow-nil-initform (:accessor :initform :initarg :documentation :protection :reader :writer :allocation :type :custom :label :group :printer :allow-nil-initform :custom-groups) invalid-slot-type public :public protected :protected private :private :class :instance message "Class allocated slots do not need :initarg" (default) #[(cg) "9?\205\f\301\302\303D\"\207" [cg signal invalid-slot-type :group] 4] eieio-add-new-slot defaultoverride #[(cg) "\301\302\"\207" [cg add-to-list groups] 3] eieio--defmethod :static :primary (this) "Retrieves the slot `%s' from an object of class `%s'" if slot-boundp this eieio-oref (nil) fboundp gv-define-setter eval (eieio--store eieio--object) 'eieio-oset eieio--object (eieio--store) setf-method (widget) let* ((--widget-sym-- (make-symbol "--widget--")) (--store-sym-- (make-symbol "--store--"))) (list --widget-sym--) (list widget) (list --store-sym--) 'eieio-oset --widget-sym-- (--store-sym--) ((list 'getfoo --widget-sym--)) (this value) "Set the slot `%s' of an object of class `%s'" setf slot-value (value) (this) "Access the slot `%s' from object of class `%s'" apply vector (3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97 101) protection :abstract "Class %s is abstract" (&rest stuff) "You cannot create a new object of type %s" (newname &rest slots) "Create a new object with name NAME of class type %s" 'constructor (newname slots) variable-documentation string-match "\\.elc$" class-location #[(cg) "\301\302\"\207" [cg add-to-list g] 3] 3 object default-cache-object eieio-set-defaults] 18 (#$ . 14057)])
#@110 For SLOT, signal if SPEC does not match VALUE.
If SKIPNIL is non-nil, then if VALUE is nil return t instead.
(defalias 'eieio-perform-slot-validation-for-default #[(slot spec value skipnil) "\211:\205	@9\205\306	@!)?\2054\n?\2054\205!??\2054\307\f\"?\2054\310\311
\fE\"\207" [value val eieio-skip-typecheck skipnil spec slot fboundp eieio-perform-slot-validation signal invalid-slot-type] 6 (#$ . 22077)])
#@466 Add into NEWC attribute A.
If A already exists in NEWC, then do nothing.  If it doesn't exist,
then also add in D (default), DOC, TYPE, CUST, LABEL, CUSTG, PRINT, PROT, and INIT arg.
Argument ALLOC specifies if the slot is allocated per instance, or per class.
If optional DEFAULTOVERRIDE is non-nil, then if A exists in NEWC,
we must override its value for a default.
Optional argument SKIPNIL indicates if type checking should be skipped
if default value is nil.
(defalias 'eieio-add-new-slot #[(newc a d doc type cust label custg print prot init alloc &optional defaultoverride skipnil) "\306\307\310\217\210\311!\203\312!\311	!\203\312	!\311\n!\203#\312\n!\f
H\235\203.\313\203@9\203\314=\203\fH\235\204\310\315$\210\f\fHBI\210\f\fHBI\210\f\fHBI\210\f\fHBI\210\f	\fHBI\210\f\fHBI\210\f \n\f HBI\210\f!\"\f!HBI\210\f#$\f#HBI\210\f%&B\f%HBI\207'\205\fH((\235)(G)GZ*)\205\356*\fH\233+)\205\374*\fH8,)\204\n
\316\317\"\202\320=\204
,\232\204
\316\321,$\210-=\2047
\315,$\210+\240\210&\203O
\f%H.\322.\"\211/&\240\210**\f#H80$0=\204i
\316\323$0$\210)\n\203\311
*\f H\233\2111@2\n<\203\204
\n\202\206
\nC32G3GW\203\232
32323\3064\2115\203\301
5@\21142>\204\270
42B25A\2115\204\245
*12\240\210+	\203\327
*\fH\233	\240\210\203\347
*\fH\233\240\210\203\367
*\fH\233\240\210\"\205*\f!H\233\"\240-\207\324!6\f
H\235\204{\3156$\210\f
\f
HBI\210\f7\f7HBI\210\f8\f8HBI\210\f9	\f9HBI\210\f:\f:HBI\210\f;\n\f;HBI\210\f<$\f<HBI\210\f=6\f=HBI\202}'\205}\f
H((\235)(G)GZ*)\205\240*\f=H\233+)\205\256*\f8H8,)\204\275\316\317\"\210\202\342\320=\204\322,\232\204\322\316\321,$\210\315,6$\210+6\240\210*\f<H\233@0$0=\204\375\316\323$0$\210)\n\203]*\f;H\233\2111@2\n<\203\n\202\nC32G3GW\203.32323\3064\2115\203U5@\21142>\204L42B25A\2115\2049*12\240\210+\203m*\f7H\233\240\210\"\205|*\f>H\233\"\240-)\207" [type cust custg a newc class-class-allocation-a nil (byte-code "\301!\203\n\302!\301\207" [d sequencep copy-sequence] 2) ((error)) sequencep copy-sequence :class :instance eieio-perform-slot-validation-for-default error "EIEIO internal error overriding default value for %s" t "Child slot type `%s' does not match inherited type `%s' for `%s'" rassq "Child slot protection `%s' does not match inherited protection `%s' for `%s'" eieio-default-eval-maybe alloc class-public-a d skipnil class-public-d class-public-doc doc class-public-type class-public-custom class-public-custom-label label class-public-custom-group class-public-printer print class-protection prot class-initarg-tuples init defaultoverride ca np num dp tp eieio-unbound inits inita super-prot groups list1 list2 elt --dolist-tail-- value class-class-allocation-doc class-class-allocation-type class-class-allocation-custom class-class-allocation-custom-label class-class-allocation-custom-group class-class-allocation-protection class-class-allocation-values class-class-allocation-printer] 6 (#$ . 22505)])
#@126 Copy into NEWC the slots of PARENTS.
Follow the rules of not overwriting early parents when applying to
the new child class.
(defalias 'eieio-copy-parents-into-subclass #[(newc parents) "	H\306\nH>A\242\211\205S
\f@\307N\211\fH

H
H
H
H
H
H
H
H
H\310  \203\267\311 @@@H@@@@@@\242\312\211&\210 A AATAAAAAA\202T.
!H
\"H
#H
$H
%H
&H
'H
(H
)H\310*  \203I
\311 @*H@H@@@@@\312\313&
\210 A AAAAAAT\202\362.\fA\211\204\312*\207" [newc class-parent class-options sn ps pcv :allow-nil-initform eieio-class-definition 0 eieio-add-new-slot nil :class class-public-a class-public-d class-public-doc class-public-type class-public-custom class-public-custom-label class-public-custom-group class-public-printer class-protection class-initarg-tuples i pinit pprot printer pcustg plabel pcust ptype pdoc pd pa class-class-allocation-a class-class-allocation-doc class-class-allocation-type class-class-allocation-custom class-class-allocation-custom-label class-class-allocation-custom-group class-class-allocation-printer class-class-allocation-protection class-class-allocation-values pval] 16 (#$ . 25692)])
#@589 Make a new instance of CLASS based on INITARGS.
CLASS is a class symbol.  For example:

  (make-instance 'foo)

  INITARGS is a property list with keywords based on the :initarg
for each slot.  For example:

  (make-instance 'foo :slot1 value1 :slotN valueN)

Compatibility note:

If the first element of INITARGS is a string, it is used as the
name of the class.

In EIEIO, the class' constructor requires a name for use when printing.
`make-instance' in CLOS doesn't use names the way Emacs does, so the
class is used as the name slot instead when INITARGS doesn't start with
a string.
(defalias 'make-instance #[(class &rest initargs) "@\203@;\203\303	\304N\nH\"\207\303	\304N\nH	9\203%\305	!\202)\306\307	\"#\207" [initargs class class-symbol apply eieio-class-definition symbol-name format "%S"] 5 (#$ . 26989)])
(put 'eieio--defalias 'byte-hunk-handler 'byte-compile-file-form-defalias)
#@163 Like `defalias', but with less side-effects.
More specifically, it has no side-effects at all when the new function
definition is the same (`eq') as the old one.
(defalias 'eieio--defalias #[(name body) "\302!\205\nK	=?\205\303	\"\207" [name body fboundp defalias] 3 (#$ . 27899)])
#@401 Create a generic function METHOD.
DOC-STRING is the base documentation for this class.  A generic
function has no body, as its purpose is to decide which method body
is appropriate to use.  Uses `defmethod' to create methods, and calls
`defgeneric' for you.  With this implementation the ARGS are
currently ignored.  You can use `defgeneric' to apply specialized
top level documentation to a method.
(defalias 'defgeneric '(macro . #[(method args &optional doc-string) "\302\303D\304\303D	EE\207" [method doc-string eieio--defalias quote eieio--defgeneric-init-form] 5 (#$ . 28194)]))
#@54 Form to use for the initial definition of a generic.
(defalias 'eieio--defgeneric-init-form #[(method doc-string) "\302!\203K\242\303=\203\304!\210\305	\"\207\302!\203&\306N\203&K\207\307\310\"\207" [method doc-string fboundp autoload eieiomt-install eieio-defgeneric-form eieio-method-obarray error "You cannot create a generic/method over an existing symbol: %s"] 3 (#$ . 28787)])
#@185 The lambda form that would be used as the function defined on METHOD.
All methods should call the same EIEIO function for dispatch.
DOC-STRING is the documentation attached to METHOD.
(defalias 'eieio-defgeneric-form #[(method doc-string) "\302\303\304\305	D\306BBF\207" [doc-string method lambda (&rest local-args) eieio-generic-call quote (local-args)] 6 (#$ . 29191)])
#@40 Setup METHOD to call the generic form.
(defalias 'eieio-defgeneric-reset-generic-form #[(method) "\302!\303	\"M)\207" [method doc-string documentation eieio-defgeneric-form] 4 (#$ . 29570)])
(put 'eieio-defgeneric-reset-generic-form 'byte-optimizer 'byte-compile-inline-expand)
#@185 The lambda form that would be used as the function defined on METHOD.
All methods should call the same EIEIO function for dispatch.
DOC-STRING is the documentation attached to METHOD.
(defalias 'eieio-defgeneric-form-primary-only #[(method doc-string) "\302\303\304\305	D\306BBF\207" [doc-string method lambda (&rest local-args) eieio-generic-call-primary-only quote (local-args)] 6 (#$ . 29859)])
#@40 Setup METHOD to call the generic form.
(defalias 'eieio-defgeneric-reset-generic-form-primary-only #[(method) "\302!\303	\"M)\207" [method doc-string documentation eieio-defgeneric-form-primary-only] 4 (#$ . 30264)])
(put 'eieio-defgeneric-reset-generic-form-primary-only 'byte-optimizer 'byte-compile-inline-expand)
#@299 The lambda form that would be used as the function defined on METHOD.
All methods should call the same EIEIO function for dispatch.
DOC-STRING is the documentation attached to METHOD.
CLASS is the class symbol needed for private method access.
IMPL is the symbol holding the method implementation.
(defalias 'eieio-defgeneric-form-primary-only-one #[(method doc-string class impl) "\306\307!\210\310\311\312\313	\314\315\316\317\320\321\nD\322BBE\314\f=?\205&\323\324\325\321DED\326\327\330\321\nD\331BBBB\332\333\321DD\334\335\336\321\nDD\337BBBB
\340W\203T\326\321$D\341BB\202\\\326\342$D\343BBEFFF!)\207" [byte-compile-warnings doc-string method class eieio-default-superclass emacs-major-version require bytecomp nil byte-compile lambda (&rest local-args) if (not (eieio-object-p (car local-args))) signal 'no-method-definition list quote (local-args) not child-of-class-p (aref (car local-args) object-class) apply 'no-applicable-method (car local-args) (local-args) let scoped-class (eieio-generic-call-next-method-list nil) (eieio-generic-call-key method-primary) eieio-generic-call-methodname ((eieio-generic-call-arglst local-args)) 24 (local-args) function (local-args) impl] 17 (#$ . 30592)])
#@40 Setup METHOD to call the generic form.
(defalias 'eieio-defgeneric-reset-generic-form-primary-only-one #[(method) "\305!\306N\211H@\307	\f@\fA$M+\207" [method doc-string M method-primary entry documentation eieio-method-tree eieio-defgeneric-form-primary-only-one] 7 (#$ . 31811)])
(put 'eieio-defgeneric-reset-generic-form-primary-only-one 'byte-optimizer 'byte-compile-inline-expand)
#@166 Make the generic method METHOD have no implementations.
It will leave the original generic function in place,
but remove reference to all implementations of METHOD.
(defalias 'eieio-unbind-method-implementations #[(method) "\301\302\303#\210\301\304\303#\207" [method put eieio-method-tree nil eieio-method-obarray] 4 (#$ . 32212)])
#@1030 Create a new METHOD through `defgeneric' with ARGS.

The optional second argument KEY is a specifier that
modifies how the method is called, including:
   :before  - Method will be called before the :primary
   :primary - The default if not specified
   :after   - Method will be called after the :primary
   :static  - First arg could be an object or class
The next argument is the ARGLIST.  The ARGLIST specifies the arguments
to the method as with `defun'.  The first argument can have a type
specifier, such as:
  ((VARNAME CLASS) ARG2 ...)
where VARNAME is the name of the local variable for the method being
created.  The CLASS is a class symbol for a class made with `defclass'.
A DOCSTRING comes after the ARGLIST, and is optional.
All the rest of the args are the BODY of the method.  A method will
return the value of the last form in the BODY.

Summary:

 (defmethod mymethod [:before | :primary | :after | :static]
                     ((typearg class-name) arg2 &optional opt &rest rest)
    "doc-string"
     body)
(defalias 'defmethod '(macro . #[(method &rest args) "\306@!\205\f\211A@@\211@\211:\203 @\nAB\202!\n:\205*A@\307\fABB\310\311\312!\206D\313\314\"F\315\316D\316	D\316
D\317D\257E.\207" [args key params arg1 fargs class keywordp lambda progn defgeneric documentation format "Generically created method `%s'." eieio--defmethod quote function code method] 9 (#$ . 32555)]))
#@63 Work part of the `defmethod' macro defining METHOD with ARGS.
(defalias 'eieio--defmethod #[(method kind argclass code) "\306=\204\f\307=\203	\202A\310=\204\311=\203 \n\202A\312=\204,\313=\2030\202A\314=\204<\315=\203@\f\202A\316%\317%\320&!\206T\321\322%\"\"\"\210'\203l\323\324\325\217\204\225\326\327'\"\210\202\225
\330U\203y\331\332\315\333D\"\210
\211\f=\203\205\334\202\223
(W\203\222
\335\\\202\223
)\336%&
'$\210))\203\n
\337%!\203\365\340%!\203\335%%\320%!*%\341N\211+H@,%\342%*,@,A$M,\210\202\n
%%\320%!*%\343%*\"M*\210\202\n
%%\320%!*%\344%*\"M*\210%\207" [kind method-before method-after method-primary method-static key :BEFORE :before :AFTER :after :PRIMARY :primary :STATIC :static eieio--defalias eieio--defgeneric-init-form documentation format "Generically created method `%s'." nil (byte-code "\301N\302H\303=\207" [argclass eieio-class-definition 0 defclass] 2) ((error)) error "Unknown class type %s in method parameters" -1 signal wrong-type-argument non-class-arg 0 3 eieiomt-add generic-primary-only-p generic-primary-only-one-p eieio-method-tree eieio-defgeneric-form-primary-only-one eieio-defgeneric-form-primary-only eieio-defgeneric-form method code argclass method-num-lists eieio-optimize-primary-methods-flag doc-string M entry] 8 (#$ . 33993)])
(defalias 'eieio--typep #[(val type) "9\203\200\305N\203\306	\305N \"\207\307=\203\307\207\310=\203$	?\207\311=\203.	:?\207\312=\203=	\247\205	\250?\207\313=\203F	\247\207\314=\203O	\250\207\315>\203Y\316	!\207\317!\320\n\321P!\322!\203s\323\324\325BE \202~\323\324\320\n\326P!\327BE *\207@\305N\203\223\306	\330@\305NA\"\"\207@\331>\203\372\306	@\"\2051
\211A@)\332>\204\316\211A@):\203\303	\211A@)@V\202\313	\211A@)Y\2051
AA@\333>\2061
\211AA)@:\203\360	\211AA)\211@@)W\207	\211AA)@X\207@\334>\203\f
\335@\336\337A\"B!\207@\340>\203
\341	A\"\207@\342=\203-
\323\324\211A@)\343BE \207\344\345\"\207" [type val name namep x cl-deftype-handler eieio--typep t null atom float real fixnum (character string-char) characterp symbol-name intern "p" fboundp lambda nil (val) "-p" (val) apply (integer float real number) (* nil) (* nil) (and or not) eval mapcar #[(x) "\302\303D\303	DE\207" [val x eieio--typep quote] 4] (member member*) memql satisfies (val) error "Bad type spec: %s"] 6])
#@46 Return non-nil if SPEC does not match VALUE.
(defalias 'eieio-perform-slot-validation #[(spec value) "\303=\206	\n=\206\304	\"\207" [spec value eieio-unbound t eieio--typep] 3 (#$ . 36410)])
#@173 Make sure that for CLASS referencing SLOT-IDX, VALUE is valid.
Checks the :type specifier.
SLOT is the slot that is being checked, and is only used when throwing
an error.
(defalias 'eieio-validate-slot-value #[(class slot-idx value slot) "?\205#	\306Z\n\307NH	H\310\f
\"?\205\"\311\312\n\f
F\")\207" [eieio-skip-typecheck slot-idx class class-public-type st value 3 eieio-class-definition eieio-perform-slot-validation signal invalid-slot-type slot] 6 (#$ . 36614)])
#@173 Make sure that for CLASS referencing SLOT-IDX, VALUE is valid.
Checks the :type specifier.
SLOT is the slot that is being checked, and is only used when throwing
an error.
(defalias 'eieio-validate-class-slot-value #[(class slot-idx value slot) "?\205	\306N\nHH\307\f
\"?\205\310\311	\n\f
F\")\207" [eieio-skip-typecheck class class-class-allocation-type slot-idx st value eieio-class-definition eieio-perform-slot-validation signal invalid-slot-type slot] 6 (#$ . 37097)])
#@224 Throw a signal if VALUE is a representation of an UNBOUND slot.
INSTANCE is the object being referenced.  SLOTNAME is the offending
slot.  If the slot is ok, return VALUE.
Argument FN is the function calling this verifier.
(defalias 'eieio-barf-if-slot-unbound #[(value instance slotname fn) "	=\203\n\204\306\307!\f
$\207\207" [value eieio-unbound eieio-skip-typecheck instance slotname fn slot-unbound object-class] 5 (#$ . 37586)])
#@159 Retrieve the value stored in OBJ in the slot named by SLOT.
Slot is the name of the slot when created by `defclass' or the label
created by the :initarg tag.
(defalias 'oref '(macro . #[(obj slot) "\302\303	DE\207" [obj slot eieio-oref quote] 4 (#$ . 38036)]))
#@55 Return the value in OBJ at SLOT in the object vector.
(defalias 'eieio-oref #[(obj slot) "\306\307\310\217\204\306\311\312\217\204\313\314\315D\"\210	9\204!\313\314\316	D\"\210\306\317\320\217\203:\211K\242\321=\2058\322\nKA@!)\210\306\323\324\217\203E\202HH\325\f	#\211\204o\326\f	\"\211\203g\f\327NH
H\202\205\330	\331#\202\205\306\332\333\217\204}\313\314\334D\"\210\335
H	\331$*\207" [obj slot cname object-class class c nil (byte-code "\211\302H\303=\205\304\305\306\217)\207" [obj tobj 0 object nil (byte-code "	H\302N\303H\304=\207" [tobj object-class eieio-class-definition 0 defclass] 2) ((error))] 4) ((error)) (byte-code "\301N\302H\303=\207" [obj eieio-class-definition 0 defclass] 2) ((error)) signal wrong-type-argument (or eieio-object-p class-p) symbolp (byte-code "\301N\302H\303=\207" [obj eieio-class-definition 0 defclass] 2) ((error)) autoload load-library (byte-code "\301N\302H\303=\207" [obj eieio-class-definition 0 defclass] 2) ((error)) eieio-slot-name-index eieio-class-slot-name-index eieio-class-definition slot-missing oref (byte-code "\211\302H\303=\205\304\305\306\217)\207" [obj tobj 0 object nil (byte-code "	H\302N\303H\304=\207" [tobj object-class eieio-class-definition 0 defclass] 2) ((error))] 4) ((error)) eieio-object-p eieio-barf-if-slot-unbound class-class-allocation-values] 6 (#$ . 38304)])
(byte-code "\300\301\302\"\210\300\303\304\"\207" [defalias slot-value eieio-oref set-slot-value eieio-oset] 3)
#@225 Get the default value of OBJ (maybe a class) for SLOT.
The default value is the value installed in a class with the :initform
tag.  SLOT can be the slot name, or the tag specified by the :initarg
tag in the `defclass' call.
(defalias 'oref-default '(macro . #[(obj slot) "\302\303	DE\207" [obj slot eieio-oref-default quote] 4 (#$ . 39803)]))
#@111 Do the work for the macro `oref-default' with similar parameters.
Fills in OBJ's SLOT with its default value.
(defalias 'eieio-oref-default #[(obj slot) "\306\307\310\217\204\306\311\312\217\204\313\314\315D\"\210	9\204!\313\314\316	D\"\210\306\317\320\217\203.\nH\202/\321	#\211\204U\322	\"\211\203M\323N
H\fH\202k\324	\325#\202k\326\f\327Z\323NH8\330!)\325$*\207" [obj slot object-class cl c class-class-allocation-values nil (byte-code "\211\302H\303=\205\304\305\306\217)\207" [obj tobj 0 object nil (byte-code "	H\302N\303H\304=\207" [tobj object-class eieio-class-definition 0 defclass] 2) ((error))] 4) ((error)) (byte-code "\301N\302H\303=\207" [obj eieio-class-definition 0 defclass] 2) ((error)) signal wrong-type-argument eieio-object-p symbolp (byte-code "\211\302H\303=\205\304\305\306\217)\207" [obj tobj 0 object nil (byte-code "	H\302N\303H\304=\207" [tobj object-class eieio-class-definition 0 defclass] 2) ((error))] 4) ((error)) eieio-slot-name-index eieio-class-slot-name-index eieio-class-definition slot-missing oref-default eieio-barf-if-slot-unbound 3 eieio-default-eval-maybe class-public-d val] 6 (#$ . 40154)])
#@60 Whether the default value VAL should be evaluated for use.
(defalias 'eieio-eval-default-p #[(val) ":\205@9\205\301@!\207" [val fboundp] 2 (#$ . 41340)])
(put 'eieio-eval-default-p 'byte-optimizer 'byte-compile-inline-expand)
#@58 Check VAL, and return what `oref-default' would provide.
(defalias 'eieio-default-eval-maybe #[(val) "\211:\205@9\205\301@!)\203\302!\207\207" [val fboundp eval] 3 (#$ . 41579)])
#@682 Bind SPEC-LIST lexically to slot values in OBJECT, and execute BODY.
This establishes a lexical environment for referring to the slots in
the instance named by the given slot-names as though they were
variables.  Within such a context the value of the slot can be
specified by using its slot name, as if it were a lexically bound
variable.  Both setf and setq can be used to set the value of the
slot.

SPEC-LIST is of a form similar to `let'.  For example:

  ((VAR1 SLOT1)
    SLOT2
    SLOTN
   (VARN+1 SLOTN+1))

Where each VAR is the local variable given to the associated
SLOT.  A slot specified without a variable name is given a
variable name of the same name as the slot.
(defalias 'with-slots '(macro . #[(spec-list object &rest body) "\303\304\"\305\306	D\n\")\207" [spec-list mappings body mapcar #[(entry) "<\203\n@\202<\203\211A@)\202\211\305\f\306\nDE*D\207" [entry x slot var object slot-value quote] 6] append symbol-macrolet] 3 (#$ . 41777)]))
(put 'with-slots 'lisp-indent-function 2)
#@53 Return the class struct defining OBJ with no check.
(defalias 'object-class-fast '(macro . #[(obj) "\301\302BB\207" [obj aref (object-class)] 3 (#$ . 42805)]))
#@43 Return a Lisp like symbol name for CLASS.
(defalias 'class-name #[(class) "\301\302\303\217\204\304\305\306D\"\210\307\310\311!\"\207" [class nil (byte-code "\301N\302H\303=\207" [class eieio-class-definition 0 defclass] 2) ((error)) signal wrong-type-argument class-p format "#<class %s>" symbol-name] 4 (#$ . 42972)])
#@121 Return a Lisp like symbol string for object OBJ.
If EXTRA, include that in the string returned to represent the symbol.
(defalias 'object-name #[(obj &optional extra) "\304\305\306\217\204\307\310\311D\"\210\312\313\314	H!\nH\206\315$\207" [obj object-class object-name extra nil (byte-code "\211\302H\303=\205\304\305\306\217)\207" [obj tobj 0 object nil (byte-code "	H\302N\303H\304=\207" [tobj object-class eieio-class-definition 0 defclass] 2) ((error))] 4) ((error)) signal wrong-type-argument eieio-object-p format "#<%s %s%s>" symbol-name ""] 5 (#$ . 43304)])
#@38 Return a string which is OBJ's name.
(defalias 'object-name-string #[(obj) "\302\303\304\217\204\305\306\307D\"\210	H\207" [obj object-name nil (byte-code "\211\302H\303=\205\304\305\306\217)\207" [obj tobj 0 object nil (byte-code "	H\302N\303H\304=\207" [tobj object-class eieio-class-definition 0 defclass] 2) ((error))] 4) ((error)) signal wrong-type-argument eieio-object-p] 4 (#$ . 43890)])
#@37 Set the string which is OBJ's NAME.
(defalias 'object-set-name-string #[(obj name) "\303\304\305\217\204\306\307\310D\"\210	;\204\306\307\311	D\"\210\n	I\207" [obj name object-name nil (byte-code "\211\302H\303=\205\304\305\306\217)\207" [obj tobj 0 object nil (byte-code "	H\302N\303H\304=\207" [tobj object-class eieio-class-definition 0 defclass] 2) ((error))] 4) ((error)) signal wrong-type-argument eieio-object-p stringp] 4 (#$ . 44301)])
#@39 Return the class struct defining OBJ.
(defalias 'object-class #[(obj) "\302\303\304\217\204\305\306\307D\"\210	H\207" [obj object-class nil (byte-code "\211\302H\303=\205\304\305\306\217)\207" [obj tobj 0 object nil (byte-code "	H\302N\303H\304=\207" [tobj object-class eieio-class-definition 0 defclass] 2) ((error))] 4) ((error)) signal wrong-type-argument eieio-object-p] 4 (#$ . 44763)])
(defalias 'class-of 'object-class)
#@49 Return a Lisp like symbol name for OBJ's class.
(defalias 'object-class-name #[(obj) "\302\303\304\217\204\305\306\307D\"\210\310	H!\207" [obj object-class nil (byte-code "\211\302H\303=\205\304\305\306\217)\207" [obj tobj 0 object nil (byte-code "	H\302N\303H\304=\207" [tobj object-class eieio-class-definition 0 defclass] 2) ((error))] 4) ((error)) signal wrong-type-argument eieio-object-p class-name] 4 (#$ . 45205)])
#@47 Return parent classes to CLASS with no check.
(defalias 'class-parents-fast '(macro . #[(class) "\301\302D\303BB\207" [class aref class-v (class-parent)] 3 (#$ . 45643)]))
#@134 Return parent classes to CLASS.  (overload of variable).

The CLOS function `class-direct-superclasses' is aliased to this function.
(defalias 'class-parents #[(class) "\302\303\304\217\204\305\306\307D\"\210\310N	H\207" [class class-parent nil (byte-code "\301N\302H\303=\207" [class eieio-class-definition 0 defclass] 2) ((error)) signal wrong-type-argument class-p eieio-class-definition] 4 (#$ . 45823)])
#@46 Return child classes to CLASS with no check.
(defalias 'class-children-fast '(macro . #[(class) "\301\302D\303BB\207" [class aref class-v (class-children)] 3 (#$ . 46243)]))
#@106 Return child classes to CLASS.

The CLOS function `class-direct-subclasses' is aliased to this function.
(defalias 'class-children #[(class) "\302\303\304\217\204\305\306\307D\"\210\310N	H\207" [class class-children nil (byte-code "\301N\302H\303=\207" [class eieio-class-definition 0 defclass] 2) ((error)) signal wrong-type-argument class-p eieio-class-definition] 4 (#$ . 46425)])
#@61 Returns CLASS if it can go in the result now, otherwise nil
(defalias 'eieio-c3-candidate #[(class remaining-inputs) "\303	\203\204\n	@A\235	A\211\204)?\205\n\207" [found remaining-inputs class nil] 3 (#$ . 46820)])
#@139 Merge REVERSED-PARTIAL-RESULT REMAINING-INPUTS in a consistent order, if possible.
If a consistent order does not exist, signal an error.
(defalias 'eieio-c3-merge-lists #[(reversed-partial-result remaining-inputs) "\306\211\203	\204\n@\nA\211\204	*\204\237\207\306\211\203@	\204@\n@\2058\307\n\211@@)\"\nA\211\204&	\211\203R\310
B\311\312\"\"\202W\313\314C\"+\207" [remaining-inputs found tail reversed-partial-result x next nil eieio-c3-candidate eieio-c3-merge-lists mapcar #[(l) "@	=\203\nA\207\207" [l next] 2] signal inconsistent-class-hierarchy] 6 (#$ . 47056)])
#@51 Return all parents of CLASS in depth-first order.
(defalias 'eieio-class-precedence-dfs #[(class) "\305N	H\306\307\310C\311\312\n\"\206\313#!\211\211\203,\f\314\f@\fA\"\241\210\fA\211\204+\207" [class class-parent parents classes tail eieio-class-definition copy-sequence apply append mapcar #[(parent) "\301!B\207" [parent eieio-class-precedence-dfs] 3] ((eieio-default-superclass)) delq] 8 (#$ . 47667)])
#@53 Return all parents of CLASS in breadth-first order.
(defalias 'eieio-class-precedence-bfs #[(class) "\305\306N	H\206\n\307\n\2037\n\211A@\211\235\2043\fB\f\310=\2043\311\n\f\306N	H\2061\312\")\202\f\237*B\207" [class class-parent queue result head nil eieio-class-definition (eieio-default-superclass) eieio-default-superclass append (eieio-default-superclass)] 5 (#$ . 48094)])
#@42 Return all parents of CLASS in c3 order.
(defalias 'eieio-class-precedence-c3 #[(class) "\303N	H\304C\305\306\307\n\"\206\310\nC\"\")\207" [class class-parent parents eieio-class-definition eieio-c3-merge-lists append mapcar #[(x) "\301!\207" [x eieio-class-precedence-c3] 2] ((eieio-default-superclass))] 6 (#$ . 48496)])
#@166 Return (transitively closed) list of parents of CLASS.
The order, in which the parents are returned depends on the
method invocation orders of the involved classes.
(defalias 'class-precedence-list #[(class) "?\206\303=?\205?\304\305N	H>A\242\206\306\307\n\310\"\203'\311!\202>\307\n\306\"\2034\312!\202>\307\n\313\"\205>\314!)\207" [class class-options #1=#:--cl-var-- eieio-default-superclass :method-invocation-order eieio-class-definition :breadth-first eql :depth-first eieio-class-precedence-dfs eieio-class-precedence-bfs :c3 eieio-class-precedence-c3] 3 (#$ . 48832)])
(byte-code "\300\301\302\"\210\300\303\304\"\207" [defalias class-direct-superclasses class-parents class-direct-subclasses class-children] 3)
#@51 Return first parent class to CLASS with no check.
(defalias 'class-parent-fast '(macro . #[(class) "\301\302DD\207" [class car class-parents-fast] 3 (#$ . 49575)]))
#@62 Return first parent class to CLASS.  (overload of variable).
(defalias 'class-parent '(macro . #[(class) "\301\302DD\207" [class car class-parents] 3 (#$ . 49747)]))
#@64 Return t if OBJ is of class-type CLASS with no error checking.
(defalias 'same-class-fast-p '(macro . #[(obj class) "\302\303\304BB	E\207" [obj class eq aref (object-class)] 4 (#$ . 49920)]))
#@41 Return t if OBJ is of class-type CLASS.
(defalias 'same-class-p #[(obj class) "\303\304\305\217\204\306\307\310D\"\210\303\311\312\217\204\306\307\313	D\"\210	\nH=\207" [class obj object-class nil (byte-code "\301N\302H\303=\207" [class eieio-class-definition 0 defclass] 2) ((error)) signal wrong-type-argument class-p (byte-code "\211\302H\303=\205\304\305\306\217)\207" [obj tobj 0 object nil (byte-code "	H\302N\303H\304=\207" [tobj object-class eieio-class-definition 0 defclass] 2) ((error))] 4) ((error)) eieio-object-p] 4 (#$ . 50119)])
#@69 Return non-nil if OBJ is an instance of CLASS or CLASS' subclasses.
(defalias 'object-of-class-p #[(obj class) "\303\304\305\217\204\306\307\310D\"\210\311	H\n\"\207" [obj object-class class nil (byte-code "\211\302H\303=\205\304\305\306\217)\207" [obj tobj 0 object nil (byte-code "	H\302N\303H\304=\207" [tobj object-class eieio-class-definition 0 defclass] 2) ((error))] 4) ((error)) signal wrong-type-argument eieio-object-p child-of-class-p] 4 (#$ . 50682)])
(defalias 'obj-of-class-p 'object-of-class-p)
#@55 Return non-nil if CHILD class is a subclass of CLASS.
(defalias 'child-of-class-p #[(child class) "\304\305\306\217\204\307\310\311D\"\210\304\312\313\217\204\307\310\311	D\"\210\304	\203:	=\204:\314\n	\315NH\"\211@\nA\202	\205?\316)\207" [class child p class-parent nil (byte-code "\301N\302H\303=\207" [class eieio-class-definition 0 defclass] 2) ((error)) signal wrong-type-argument class-p (byte-code "\301N\302H\303=\207" [child eieio-class-definition 0 defclass] 2) ((error)) append eieio-class-definition t] 5 (#$ . 51207)])
#@40 Return list of slots available in OBJ.
(defalias 'object-slots #[(obj) "\303\304\305\217\204\306\307\310D\"\210	H\311N\nH\207" [obj object-class class-public-a nil (byte-code "\211\302H\303=\205\304\305\306\217)\207" [obj tobj 0 object nil (byte-code "	H\302N\303H\304=\207" [tobj object-class eieio-class-definition 0 defclass] 2) ((error))] 4) ((error)) signal wrong-type-argument eieio-object-p eieio-class-definition] 4 (#$ . 51763)])
#@36 Fetch from CLASS, SLOT's :initarg.
(defalias 'class-slot-initarg #[(class slot) "\305\306\307\217\204\310\311\312D\"\210\313N	H\305\211\2031\n\2041@A\f=\203*@@A\211\204\n*\207" [class class-initarg-tuples f ia slot nil (byte-code "\301N\302H\303=\207" [class eieio-class-definition 0 defclass] 2) ((error)) signal wrong-type-argument class-p eieio-class-definition] 5 (#$ . 52217)])
#@172 Set the value in OBJ for slot SLOT to VALUE.
SLOT is the slot name as specified in `defclass' or the tag created
with in the :initarg slot.  VALUE can be any Lisp object.
(defalias 'oset '(macro . #[(obj slot value) "\303\304	D\nF\207" [obj slot value eieio-oset quote] 4 (#$ . 52624)]))
#@67 Do the work for the macro `oset'.
Fills in OBJ's SLOT with VALUE.
(defalias 'eieio-oset #[(obj slot value) "\306\307\310\217\204\311\312\313D\"\210	9\204\311\312\314	D\"\210\315\nH	#\211\204P\316\nH	\"\211\203G\317\nH\f	$\210\nH\320N
H\fI\202]\321	\322\f$\202]\323\nH\f	$\210\fI)\207" [obj slot object-class c value class-class-allocation-values nil (byte-code "\211\302H\303=\205\304\305\306\217)\207" [obj tobj 0 object nil (byte-code "	H\302N\303H\304=\207" [tobj object-class eieio-class-definition 0 defclass] 2) ((error))] 4) ((error)) signal wrong-type-argument eieio-object-p symbolp eieio-slot-name-index eieio-class-slot-name-index eieio-validate-class-slot-value eieio-class-definition slot-missing oset eieio-validate-slot-value] 6 (#$ . 52919)])
#@214 Set the default slot in CLASS for SLOT to VALUE.
The default value is usually set with the :initform tag during class
creation.  This allows users to change the default behavior of classes
after they are created.
(defalias 'oset-default '(macro . #[(class slot value) "\303\304	D\nF\207" [class slot value eieio-oset-default quote] 4 (#$ . 53713)]))
#@100 Do the work for the macro `oset-default'.
Fills in the default value in CLASS' in SLOT with VALUE.
(defalias 'eieio-oset-default #[(class slot value) "\306\307\310\217\204\311\312\313D\"\210	9\204\311\312\314	D\"\210\315\306	#\211\204L\316	\"\211\203A\317\f	$\210\320N
H\fI\202j\311\321\322!	D\"\202j\323\f	$\210\324Z\320NH\233\f\240\210\325\320NH	\f#*\207" [class slot scoped-class c value class-class-allocation-values nil (byte-code "\301N\302H\303=\207" [class eieio-class-definition 0 defclass] 2) ((error)) signal wrong-type-argument class-p symbolp eieio-slot-name-index eieio-class-slot-name-index eieio-validate-class-slot-value eieio-class-definition invalid-slot-name class-name eieio-validate-slot-value 3 eieio-oset class-public-d class-default-object-cache] 6 (#$ . 54071)])
#@174 Return non-nil if OBJECT's SLOT is bound.
Setting a slot's value makes it bound.  Calling `slot-makeunbound' will
make a slot unbound.
OBJECT can be an instance or a class.
(defalias 'slot-boundp #[(object slot) "\304\305\306\307\217\203\310	\n\"\202$\305\311\312\217\203\313	\n\"\202$\314\315\316	D\")=?\207" [eieio-skip-typecheck object slot eieio-unbound t nil (byte-code "\211\302H\300=\205\303\304\305\217)\207" [object tobj 0 nil (byte-code "	H\302N\303H\304=\207" [tobj object-class eieio-class-definition 0 defclass] 2) ((error))] 4) ((error)) eieio-oref (byte-code "\301N\302H\303=\207" [object eieio-class-definition 0 defclass] 2) ((error)) eieio-oref-default signal wrong-type-argument eieio-object-p] 4 (#$ . 54897)])
#@31 In OBJECT, make SLOT unbound.
(defalias 'slot-makeunbound #[(object slot) "\303	\n#\207" [object slot eieio-unbound eieio-oset] 4 (#$ . 55648)])
#@45 Return non-nil if OBJECT-OR-CLASS has SLOT.
(defalias 'slot-exists-p #[(object-or-class slot) "\305\306\307\217\203
\310!\202\305\311\312\217\205\313N\n	H>\206%\n	\fH>)\207" [object-or-class cv slot class-public-a class-class-allocation-a nil (byte-code "\211\302H\303=\205\304\305\306\217)\207" [object-or-class tobj 0 object nil (byte-code "	H\302N\303H\304=\207" [tobj object-class eieio-class-definition 0 defclass] 2) ((error))] 4) ((error)) object-class (byte-code "\301N\302H\303=\207" [object-or-class eieio-class-definition 0 defclass] 2) ((error)) eieio-class-definition] 3 (#$ . 55800)])
#@155 Return the class that SYMBOL represents.
If there is no class, nil is returned if ERRORP is nil.
If ERRORP is non-nil, `wrong-argument-type' is signaled.
(defalias 'find-class #[(symbol &optional errorp) "\302\303\304\217\204\205\305\306\307	D\"\207	\310N\207" [errorp symbol nil (byte-code "\301N\302H\303=\207" [symbol eieio-class-definition 0 defclass] 2) ((error)) signal wrong-type-argument class-p eieio-class-definition] 4 (#$ . 56422)])
#@268 Return an object if KEY is `equal' to SLOT's value of an object in LIST.
LIST is a list of objects whose slots are searched.
Objects in LIST do not need to have a slot named SLOT, nor does
SLOT need to be bound.  If these errors occur, those objects will
be ignored.
(defalias 'object-assoc #[(key slot list) "<\204\f\301\302\303D\"\210\203\304\305\306\217\204A\211\204@\207" [list signal wrong-type-argument listp nil (byte-code "\303	@\n\"\232\207" [key list slot eieio-oref] 4) ((error))] 5 (#$ . 56880)])
#@193 Return an association list with the contents of SLOT as the key element.
LIST must be a list of objects with SLOT in it.
This is useful when you need to do completing read on an object group.
(defalias 'object-assoc-list #[(slot list) "<\204\f\303\304\305D\"\210\306\203$\307@\n\"@B	BA\211\204	\237)\207" [list assoclist slot signal wrong-type-argument listp nil eieio-oref] 5 (#$ . 57410)])
#@228 Return an association list with the contents of SLOT as the key element.
LIST must be a list of objects, but those objects do not need to have
SLOT in it.  If it does not, then that element is left out of the association
list.
(defalias 'object-assoc-list-safe #[(slot list) "<\204\f\303\304\305D\"\210\306\203,\307@\n\"\203%\310@\n\"@B	BA\211\204	\237)\207" [list assoclist slot signal wrong-type-argument listp nil slot-exists-p eieio-oref] 5 (#$ . 57822)])
#@310 In OBJECT's SLOT, add ITEM to the list of elements.
Optional argument APPEND indicates we need to append to the list.
If ITEM already exists in the list in SLOT, then it is not added.
Comparison is done with `equal' through the `member' function call.
If SLOT is unbound, bind it to the list containing ITEM.
(defalias 'object-add-to-list #[(object slot item &optional append) "\305\306	\n\"\204C\2022\307	\n\"\211<\204C\235\2042\f\203.\304C\"\2021B\310	\n#)\207" [ov object slot item append nil slot-boundp eieio-oref eieio-oset] 5 (#$ . 58304)])
#@180 In OBJECT's SLOT, remove occurrences of ITEM.
Deletion is done with `delete', which deletes by side effect,
and comparisons are done with `equal'.
If SLOT is unbound, do nothing.
(defalias 'object-remove-from-list #[(object slot item) "\303	\"\205\304	\305\n\306	\"\"#\207" [object slot item slot-boundp eieio-oset delete eieio-oref] 8 (#$ . 58881)])
#@173 Return non-nil if START-CLASS is the first class to define SLOT.
This is for testing if `scoped-class' is the class that defines SLOT
so that we can protect private slots.
(defalias 'eieio-slot-originating-class-p #[(start-class slot) "\305!\306\211\204\306\202.\n\203-	\203-\307\310!\n@\311N\fH\"\203&\312\nA\211\204	*\207" [start-class ret par slot class-symbol-obarray class-parents t intern-soft symbol-name eieio-class-definition nil] 5 (#$ . 59244)])
#@401 In CLASS for OBJ find the index of the named SLOT.
The slot is a symbol which is installed in CLASS by the `defclass'
call.  OBJ can be nil, but if it is an object, and the slot in question
is protected, access will be allowed if OBJ is a child of the currently
`scoped-class'.
If SLOT is the value created with :initarg instead,
reverse-lookup that name, and recurse with the associated slot value.
(defalias 'eieio-slot-name-index #[(class obj slot) "\306\307!	\310N\nH\"\2119\205J\211\250\203|\311N\204$\312\f\\\202\216\311N\313=\203T\314\305!\203T
\203T\315	
\"\204N\316\317\320\217\203T\315	\321!\"\203T\312\f\\\202\216\311N\322=\203x\314\305!\203m
\203m\323
\"\204r\203x\312\f\\\202\216\316\202\216\324	\"\211\205\215\325	#)*\207" [slot class class-symbol-obarray fsym fsi scoped-class intern-soft symbol-name eieio-class-definition protection 3 protected boundp child-of-class-p nil (byte-code "\211\302H\303=\205\304\305\306\217)\207" [obj tobj 0 object nil (byte-code "	H\302N\303H\304=\207" [tobj object-class eieio-class-definition 0 defclass] 2) ((error))] 4) ((error)) object-class private eieio-slot-originating-class-p eieio-initarg-to-attribute eieio-slot-name-index obj eieio-initializing-object fn] 5 (#$ . 59722)])
#@240 In CLASS find the index of the named SLOT.
The slot is a symbol which is installed in CLASS by the `defclass'
call.  If SLOT is the value created with :initarg instead,
reverse-lookup that name, and recurse with the associated slot value.
(defalias 'eieio-class-slot-name-index #[(class slot) "\306N	H\211G\f\n>\211G
\205Z,\207" [class class-class-allocation-a a l1 slot af eieio-class-definition l2] 3 (#$ . 61007)])
#@68 When using `call-next-method', provides a context on how to do it.
(defvar eieio-generic-call-methodname nil (#$ . 61442))
#@67 When using `call-next-method', provides a context for parameters.
(defvar eieio-generic-call-arglst nil (#$ . 61571))
#@142 When using `call-next-method', provides a context for the current key.
Keys are a number representing :before, :primary, and :after methods.
(defvar eieio-generic-call-key nil (#$ . 61696))
#@194 When executing a PRIMARY or STATIC method, track the 'next-method'.
During executions, the list is first generated, then as each next method
is called, the next method is popped off the stack.
(defvar eieio-generic-call-next-method-list nil (#$ . 61893))
(byte-code "\302\303\304\305#\210\306\305\211\203,	@\303N\203%\304N\204%\307\304\303N#\210	A\211\204*\310\303\304\311#\207" [prop --dolist-tail-- defvaralias eieio-pre-method-execution-hooks eieio-pre-method-execution-functions nil (saved-value saved-variable-comment) put make-obsolete-variable "24.3"] 6)
#@144 Abnormal hook run just before an EIEIO method is executed.
The hook function must accept one argument, the list of forms
about to be executed.
(defvar eieio-pre-method-execution-functions nil (#$ . 62475))
#@134 Call METHOD with ARGS.
ARGS provides the context on which implementation to use.
This should only be called from a generic function.
(defalias 'eieio-generic-call #[(method args) "\306\211\211\211\211	\306\211!\"#$%	\211%@\2119\203=\307!\203=K<\203=K@\310=\203=\311KA@!\210\306\312\313\217\203M&H$\202W\306\314\315\217\203W$$\203j\306\316\317\217\204j\320\321$#\210\306\322\323\217\203\374$\203\200\324'$#\202\207\325'\306#C\"\326\"#\"#\326\327\"G'\"!\"!$\203\255\325($#\206\263\325(\306#\211\"\203\317\"#B#(!B!\324($#$\203\336\324)$#\202\345\325)\306#C\"\326\"#\"#\326\327\"G)\"!\"!$\203'
#\204H
\325*$#\211\"#B#*!B!\324*$#\202H
\325(\306#\211\"\203H
\"#B#(!B!\324(\306#\330\331\n\"\210\306\211\211\211+,-.#\203\254
#@\203\237
#@A/!@\2110(U\206{
0*U\2111\205\203
\nA2\332+\333#@@%\"-1\203\236
-.\332,,#A#!A!\202Y
+\204\316
\306\334\335\217\203\307
\333\336	@	$.\332,\202\316
\337\340	D\"\210..
\207" [method args primarymethodlist firstarg eieio-generic-call-arglst eieio-generic-call-methodname nil fboundp autoload load (byte-code "\211\302H\303=\205\304\305\306\217)\207" [firstarg tobj 0 object nil (byte-code "	H\302N\303H\304=\207" [tobj object-class eieio-class-definition 0 defclass] 2) ((error))] 4) ((error)) (byte-code "\301N\302H\303=\207" [firstarg eieio-class-definition 0 defclass] 2) ((error)) (byte-code "\301N\302H\303=\207" [mclass eieio-class-definition 0 defclass] 2) ((error)) error "Cannot dispatch method %S on class %S" (byte-code "\211\302H\303=\205\304\305\306\217)\207" [firstarg tobj 0 object nil (byte-code "	H\302N\303H\304=\207" [tobj object-class eieio-class-definition 0 defclass] 2) ((error))] 4) ((error)) eieiomt-method-list eieio-generic-form append make-list run-hook-with-args eieio-pre-method-execution-functions t apply (byte-code "@\211\302H\303=\205\304\305\306\217)\207" [args tobj 0 object nil (byte-code "	H\302N\303H\304=\207" [tobj object-class eieio-class-definition 0 defclass] 2) ((error))] 4) ((error)) no-applicable-method signal no-method-definition keys tlambdas lambdas mclass newargs object-class method-after method-primary method-before method-static found rvalever lastval rval scoped-class eieio-generic-call-key has-return-val eieio-generic-call-next-method-list] 10 (#$ . 62688)])
#@460 Call METHOD with ARGS for methods with only :PRIMARY implementations.
ARGS provides the context on which implementation to use.
This should only be called from a generic function.

This method is like `eieio-generic-call', but only
implementations in the :PRIMARY slot are queried.  After many
years of use, it appears that over 90% of methods in use
have :PRIMARY implementations only.  We can therefore optimize
for this common case to improve performance.
(defalias 'eieio-generic-call-primary-only #[(method args) "\306\211\211	\306\211	\211@\306\307\310\217\203'H\202G\2043\311\312\"\210\202G\306\313\314\217\204B\311\315\"\210\202G\311\316\"\210\204S\311\317#\210\320#\321#\306\211 !\306\"A#$\nA%\203\205@\204\245\306\322\323\217\203\233\324\325	@	$ \326\"\202\272\327\330	D\"\210\202\272\331\332\"\210\324@\"\211! \326\" .
\207" [method args primarymethodlist firstarg eieio-generic-call-arglst eieio-generic-call-methodname nil (byte-code "\211\302H\303=\205\304\305\306\217)\207" [firstarg tobj 0 object nil (byte-code "	H\302N\303H\304=\207" [tobj object-class eieio-class-definition 0 defclass] 2) ((error))] 4) ((error)) error "Method %s called on nil" (byte-code "\211\302H\303=\205\304\305\306\217)\207" [firstarg tobj 0 object nil (byte-code "	H\302N\303H\304=\207" [tobj object-class eieio-class-definition 0 defclass] 2) ((error))] 4) ((error)) "Primary-only method %s called on something not an object" "EIEIO Error: Improperly classified method %s as primary only" "Cannot dispatch method %S on class %S" eieio-generic-form eieiomt-method-list (byte-code "@\211\302H\303=\205\304\305\306\217)\207" [args tobj 0 object nil (byte-code "	H\302N\303H\304=\207" [tobj object-class eieio-class-definition 0 defclass] 2) ((error))] 4) ((error)) apply no-applicable-method t signal no-method-definition run-hook-with-args eieio-pre-method-execution-functions lambdas mclass newargs object-class method-primary rval lastval rvalever scoped-class eieio-generic-call-key eieio-generic-call-next-method-list] 8 (#$ . 65104)])
#@249 Return an alist list of methods lambdas.
METHOD is the method name.
KEY represents either :before, or :after methods.
CLASS is the starting class to search from in the method tree.
If CLASS is nil, then an empty list of methods should be returned.
(defalias 'eieiomt-method-list #[(method key class) "\306\307	!\306\211\2032@\310\f
\n#\211	\203*\203%	\235\204*	B)A\211\204\f*
\n=\203>\202@\237)\207" [lambdas class ancestor --dolist-tail-- method key nil class-precedence-list eieio-generic-form tmpl method-after] 5 (#$ . 67240)])
#@114 Return non-nil if there is a next method.
Returns a list of lambda expressions which is the `next-method'
order.
(defalias 'next-method-p #[nil "\207" [eieio-generic-call-next-method-list] 1 (#$ . 67803)])
#@369 Call the superclass method from a subclass method.
The superclass method is specified in the current method list,
and is called the next method.

If REPLACEMENT-ARGS is non-nil, then use them instead of
`eieio-generic-call-arglst'.  The generic arg list are the
arguments passed in at the top level.

Use `next-method-p' to find out if there is a next method to call.
(defalias 'call-next-method #[(&rest replacement-args) "\306\300!\203\n\204\307\310!\210	\nU\204	U\204\307\311!\210\f\206#
\f@

\2035
@\204A\312\313@A#\202Y\fA\f
A
@\312\",*\207" [scoped-class eieio-generic-call-key method-primary method-static replacement-args eieio-generic-call-arglst boundp error "`call-next-method' not called within a class specific method" "Cannot `call-next-method' except in :primary or :static methods" apply no-next-method eieio-generic-call-next-method-list next newargs fcn] 4 (#$ . 68017)])
#@64 While mapping atoms, this contain the obarray being optimized.
(defvar eieiomt-optimizing-obarray nil (#$ . 68950))
#@98 Install the method tree, and obarray onto METHOD-NAME.
Do not do the work if they already exist.
(defalias 'eieiomt-install #[(method-name) "\304N\305N\211\203	?\205B\306\304\307\310\"#\306\305\307\310\"#\211\311\307\312\311\"I\210	\313\307\312\311\"I\210	\314\307\315\311\"I\210	\316\307\312\311\"I*\207" [method-name emto emtv method-num-slots eieio-method-tree eieio-method-obarray put make-vector nil 0 11 1 2 41 3] 7 (#$ . 69072)])
#@410 Add to METHOD-NAME the forms METHOD in a call position KEY for CLASS.
METHOD-NAME is the name created by a call to `defgeneric'.
METHOD are the forms for a given implementation.
KEY is an integer (see comment in eieio.el near this function) which
is associated with the :static :before :primary and :after tags.
It also indicates if CLASS is defined or not.
CLASS is the class this method is associated with.
(defalias 'eieiomt-add #[(method-name method key class) "	V\204\f\306W\203\307\310!\210\n\311N\n\312N\211\203 \204$\307\313!\210
\fH\236\2038
\fH\236\241\210\202D\f
B\fHBI\210W\203[\314\315
!H\"\211M\210)\203e\202g\316\211\203\226\317\320\"\203\202\306GSO\n\321N\322\323
D\"\210\324\n\321#\210*W\205\251H\325\326\")*\207" [key method-num-slots method-name emto emtv class 0 error "eieiomt-add: method key error!" eieio-method-tree eieio-method-obarray "Programmer error: eieiomt-add" intern symbol-name nil string-match "\\.elc$" method-locations add-to-list loc put mapatoms eieiomt-sym-optimize method method-num-lists nsym load-in-progress load-file-name buffer-file-name fname eieiomt-optimizing-obarray] 6 (#$ . 69529)])
#@311 Return the next parent class for CLASS.
If CLASS is a superclass, return variable `eieio-default-superclass'.
If CLASS is variable `eieio-default-superclass' then return nil.
This is different from function `class-parent' as class parent returns
nil for superclasses.  This function performs no type checking!
(defalias 'eieiomt-next #[(class) "\302N	H\206\303=?\205\304\207" [class class-parent eieio-class-definition eieio-default-superclass (eieio-default-superclass)] 2 (#$ . 70739)])
#@74 Find the next class above S which has a function body for the optimizer.
(defalias 'eieiomt-sym-optimize #[(s) "\302L\210\303\304!!\305\306\215)\207" [s external-symbol nil intern-soft symbol-name done (byte-code "\306!A\307\211\205-\n@\310\311	!\"\312\f!\203$
\fL\210\313\314	\"\210)\nA\211\204\307*\207" [external-symbol ancestor --dolist-tail-- eieiomt-optimizing-obarray ov s class-precedence-list nil intern-soft symbol-name fboundp throw done] 4)] 3 (#$ . 71240)])
#@308 Return the lambda form belonging to METHOD using KEY based upon CLASS.
If CLASS is not a class then use `generic' instead.  If class has
no form, but has a parent class, then trace to that parent class.
The first time a form is requested from a symbol, an optimized path
is memorized for faster future use.
(defalias 'eieio-generic-form #[(method key class) "\306N	\203\n\202%\n\211=\203\307\202$\n\fW\203#\n\310\\\202$\n)H\311\312\313\217\203\200\314\315	!
\"\211\204K\316\315	!
\"
\317!\210)\320!\203^	\321NHB\202|J\205|J\314\315	!
\"\211\316\315	!!\321NHB)\202\263\322N	\203\213\n\202\245\n\211=\203\227\307\202\244\n\fW\203\243\n\310\\\202\244\n)H\211\205\262@A\311B))\207" [method class key method-static method-num-lists emto eieio-method-obarray 0 3 nil (byte-code "\301N\302H\303=\207" [class eieio-class-definition 0 defclass] 2) ((error)) intern-soft symbol-name intern eieiomt-sym-optimize fboundp eieio-class-definition eieio-method-tree cs eieiomt-optimizing-obarray class-symbol emtl] 5 (#$ . 71732)])
#@201 Take object OBJ, and reset all slots to their defaults.
If SET-ALL is non-nil, then when a default is nil, that value is
reset.  If SET-ALL is nil, the slots are only reset if the default is
not nil.
(defalias 'eieio-set-defaults #[(obj &optional set-all) "	H\306	H\307N\nH\2053\310@\"\211\204\"\f\203*\311@#\210)A\211\204\312+\207" [obj object-class class-public-a pub eieio-initializing-object scoped-class t eieio-class-definition eieio-oref-default eieio-oset nil df set-all] 5 (#$ . 72811)])
#@163 For CLASS, convert INITARG to the actual attribute name.
If there is no translation, pass it in directly (so we can cheat if
need be... May remove that later...)
(defalias 'eieio-initarg-to-attribute #[(class initarg) "\304	\305N\nH\"\211\205A)\207" [initarg class class-initarg-tuples tuple assoc eieio-class-definition] 5 (#$ . 73337)])
#@122 In CLASS, convert the ATTRIBUTE into the corresponding init argument tag.
This is usually a symbol that starts with `:'.
(defalias 'eieio-attribute-to-initarg #[(class attribute) "\304	\305N\nH\"\211\205@)\207" [attribute class class-initarg-tuples tuple rassoc eieio-class-definition] 5 (#$ . 73688)])
(byte-code "\300\301!\210\302\303\304\305#\210\302\303\306\307#\210\300\310!\210\302\311\304\312#\210\302\311\306\313#\210\300\314!\210\302\315\304\316#\210\302\315\306\317#\210\300\320!\210\302\321\304\322#\210\302\321\306\323#\210\300\324!\210\302\325\304\326#\210\302\325\306\327#\210\300\330!\210\302\331\304\332#\210\302\331\306\333#\210\302\334\335\336#\210\337\340\341\211\342$\210\343\344\340\"\210\345\346\347\346\350\"\"\210\345\346\347\346\351\"\"\210\352\346\353\340\354$\210\345\355\347\355\356\"\"\210\345\355\347\355\356\"\"\210\352\355\341\340\357$\210\345\360\347\360\361\"\"\210\345\360\347\360\362\"\"\210\352\360\341\340\363$\210\345\364\347\364\365\"\"\210\345\364\347\364\366\"\"\210\352\364\341\340\367$\210\345\370\347\370\371\"\"\210\345\370\347\370\372\"\"\210\352\370\341\340\373$\210\345\374\347\374\375\"\"\210\345\374\347\374\376\"\"\210\352\374\341\340\377$\210\345\311\347\311\201@\"\"\210\345\311\347\311\201A\"\"\210\352\311\341\340\201B$\210\345\201C\347\201C\201D\"\"\210\345\201C\347\201C\201E\"\"\210\352\201C\341\340\201F$\210\345\201G\347\201G\201H\"\"\210\345\201G\347\201G\201I\"\"\210\352\201G\341\340\201J$\210\345\201K\347\201K\201L\"\"\210\345\201K\347\201K\201M\"\"\210\352\201K\341\340\201N$\207" [intern "no-method-definition" put no-method-definition error-conditions (no-method-definition error) error-message "No method definition" "no-next-method" no-next-method (no-next-method error) "No next method" "invalid-slot-name" invalid-slot-name (invalid-slot-name error) "Invalid slot name" "invalid-slot-type" invalid-slot-type (invalid-slot-type error nil) "Invalid slot type" "unbound-slot" unbound-slot (unbound-slot error nil) "Unbound slot" "inconsistent-class-hierarchy" inconsistent-class-hierarchy (inconsistent-class-hierarchy error nil) "Inconsistent class hierarchy" eieio-oref gv-expander #[(do &rest args) "\302\303\304	$\207" [do args gv--defsetter eieio-oref #[(val &rest args) "\302\303	C\"B\207" [args val eieio-oset append] 4]] 5] eieio-defclass eieio-default-superclass nil ("Default parent class for classes with no specified parent class.\nIts slots are automatically adopted by classes with no specified parents.\nThis class is not stored in the `parent' slot of a class vector." :abstract t) defalias standard-class eieio--defalias constructor eieio--defgeneric-init-form "Default constructor for CLASS `eieio-default-superclass'." #1="Default constructor for CLASS `eieio-default-superclass'.\nNEWNAME is the name to be given to the constructed object.\nSLOTS are the initialization slots used by `shared-initialize'.\nThis static method is called when an object is constructed.\nIt allocates the vector used to represent an EIEIO object, and then\ncalls `shared-initialize' on that object." eieio--defmethod :static #[(class newname &rest slots) "\306\307N	H!\211\fI\210\310\n
\"\210\n)\207" [class class-default-object-cache new-object object-name newname slots copy-sequence eieio-class-definition initialize-instance] 4 #1#] shared-initialize "Set slots of OBJ with SLOTS which is a list of name/value pairs.\nCalled from the constructor routine." #[(obj slots) "	H\2053\305	H@\"\211\204!\306@\307A@$\210\202)\310\fA@#\210)AA\211\204\311)\207" [obj object-class scoped-class slots rn eieio-initarg-to-attribute slot-missing oset eieio-oset nil] 6 "Set slots of OBJ with SLOTS which is a list of name/value pairs.\nCalled from the constructor routine."] initialize-instance "Construct the new object THIS based on SLOTS." #2="Construct the new object THIS based on SLOTS.\nSLOTS is a tagged list where odd numbered elements are tags, and\neven numbered elements are the values to store in the tagged slot.\nIf you overload the `initialize-instance', there you will need to\ncall `shared-initialize' yourself, or you can call `call-next-method'\nto have this constructor called automatically.  If these steps are\nnot taken, then new objects of your class will not have their values\ndynamically set from SLOTS." #[(this &optional slots) "	H\306N\211H\n
H\n\f\2036\307\n@!\211\n@=\204*\310\f@#\210)\fA\nA\n\202+\311\f\"\207" [this object-class scoped-class class-public-a slot class-public-d eieio-class-definition eieio-default-eval-maybe eieio-oset shared-initialize defaults dflt slots] 5 #2#] slot-missing "Method invoked when an attempt to access a slot in OBJECT fails." #3="Method invoked when an attempt to access a slot in OBJECT fails.\nSLOT-NAME is the name of the failed slot, OPERATION is the type of access\nthat was requested, and optional NEW-VALUE is the value that was desired\nto be set.\n\nThis method is called from `oref', `oset', and other functions which\ndirectly reference slots in EIEIO objects." #[(object slot-name operation &optional new-value) "\302\303\304!	D\"\207" [object slot-name signal invalid-slot-name object-name] 4 #3#] slot-unbound "Slot unbound is invoked during an attempt to reference an unbound slot." #4="Slot unbound is invoked during an attempt to reference an unbound slot.\nOBJECT is the instance of the object being reference.  CLASS is the\nclass of OBJECT, and SLOT-NAME is the offending slot.  This function\nthrows the signal `unbound-slot'.  You can overload this function and\nreturn the value to use in place of the unbound value.\nArgument FN is the function signaling this error.\nUse `slot-boundp' to determine if a slot is bound or not.\n\nIn CLOS, the argument list is (CLASS OBJECT SLOT-NAME), but\nEIEIO can only dispatch on the first argument, so the first two are swapped." #[(object class slot-name fn) "\304\305\306!\307	!\nF\"\207" [class object slot-name fn signal unbound-slot class-name object-name] 6 #4#] no-applicable-method "Called if there are no implementations for OBJECT in METHOD." #5="Called if there are no implementations for OBJECT in METHOD.\nOBJECT is the object which has no method implementation.\nARGS are the arguments that were passed to METHOD.\n\nImplement this for a class to block this signal.  The return\nvalue becomes the return value of the original method call." #[(object method &rest args) "\302\303\304	!D\"\207" [method object signal no-method-definition object-name] 5 #5#] "Called from `call-next-method' when no additional methods are available." #6="Called from `call-next-method' when no additional methods are available.\nOBJECT is othe object being called on `call-next-method'.\nARGS are the arguments it is called by.\nThis method signals `no-next-method' by default.  Override this\nmethod to not throw an error, and its return value becomes the\nreturn value of `call-next-method'." #[(object &rest args) "\302\303\304!	D\"\207" [object args signal no-next-method object-name] 4 #6#] clone "Make a copy of OBJ, and then supply PARAMS.\nPARAMS is a parameter list of the same form used by `initialize-instance'.\n\nWhen overloading `clone', be sure to call `call-next-method'\nfirst and modify the returned object." #7="Make a copy of OBJ, and then apply PARAMS." #[(obj &rest params) "\306!	H\n\205
\n@;\307\n\203&\310\f\203#\nA\202$\n\"\210\f\204T\311 \312\216\313\314
\"\203E\315\316\307
\"!T
\317\211\224O	
\320\321!QI\210*\202[	\n@I\210,\207" [obj object-name params num passname nm copy-sequence 1 shared-initialize match-data ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) string-match "-\\([0-9]+\\)" string-to-number match-string 0 "-" int-to-string nobj save-match-data-internal] 6 #7#] destructor "Destructor for cleaning up any dynamic links to our object." #8="Destructor for cleaning up any dynamic links to our object.\nArgument THIS is the object being destroyed.  PARAMS are additional\nignored parameters." #[(this &rest params) "\300\207" [#8#] 1 #8#] object-print "Pretty printer for object THIS.  Call function `object-name' with STRINGS.\n\nIt is sometimes useful to put a summary of the object into the\ndefault #<notation> string when using EIEIO browsing tools.\nImplement this method to customize the summary." #9="Pretty printer for object THIS.  Call function `object-name' with STRINGS.\nThe default method for printing object THIS is to use the\nfunction `object-name'.\n\nIt is sometimes useful to put a summary of the object into the\ndefault #<notation> string when using EIEIO browsing tools.\n\nImplement this function and specify STRINGS in a call to\n`call-next-method' to provide additional summary information.\nWhen passing in extra strings from child classes, always remember\nto prepend a space." #[(this &rest strings) "\302\303\304	\"\"\207" [this strings object-name apply concat] 5 #9#]] 5)
#@61 When printing, keep track of the current indentation depth.
(defvar eieio-print-depth 0 (#$ . 82676))
(byte-code "\300\301\302\301\303\"\"\210\300\301\302\301\304\"\"\210\305\301\306\307\310$\207" [eieio--defalias object-write eieio--defgeneric-init-form "Write out object THIS to the current stream.\nOptional COMMENT will add comments to the beginning of the output." #1="Write object THIS out to the current stream.\nThis writes out the vector version of this object.  Complex and recursive\nobject are discouraged from being written.\n  If optional COMMENT is non-nil, include comments when outputting\nthis object." eieio--defmethod nil eieio-default-superclass #[(this &optional comment) "\203\306\307!\210\306\310	!!\210\306\311!\210\306!\210\306\311!\210\312	!\211\313N\306\314\f\315_\316\"!\210\306\317!\210\306\320\312	!\313N
H!!\210\306\321!\210\322\310	!!\210\306\311!\210HHH\fT\203\311\323	@\"\203\267\324\n@\"\325	@\"\211\203\266@\232\204\266\306\314\f\315_\316\"!\210\306\320!!\210\306\321!\210@\203\255@!\210\202\262\326!\210\306\311!\210*AAA\202^\306\314\f\315_\316\"!\210,\306\327!*\207" [comment this cl cv eieio-print-depth class-symbol princ ";; Object " object-name-string "\n" object-class eieio-class-definition make-string 2 32 "(" symbol-name " " prin1 slot-boundp class-slot-initarg eieio-oref eieio-override-prin1 ")\n" class-public-a class-public-d class-public-printer publp publd publa v i] 5 #1#]] 5)
#@66 Perform a `prin1' on THING taking advantage of object knowledge.
(defalias 'eieio-override-prin1 #[(thing) "\301\302\303\217\203\304!\207<\203\305!\207\301\306\307\217\203!\310\311!!\2079\203.\310\312\313!P!\207\314!\207" [thing nil (byte-code "\211\302H\303=\205\304\305\306\217)\207" [thing tobj 0 object nil (byte-code "	H\302N\303H\304=\207" [tobj object-class eieio-class-definition 0 defclass] 2) ((error))] 4) ((error)) object-write eieio-list-prin1 (byte-code "\301N\302H\303=\207" [thing eieio-class-definition 0 defclass] 2) ((error)) princ class-name "'" symbol-name prin1] 4 (#$ . 84182)])
#@46 Display LIST where list may contain objects.
(defalias 'eieio-list-prin1 #[(list) "\302\303\304\217\204\305\306!\210\307!\207\305\310!\210\302\311\312\217\203\305\313!\210\203E\302\314\315\217\2031\316@!\210\202:\305\306!\210\307@!\210\305\317!\210A\211\204\"\305\320	\321_\322\"!\210\305\323!\207" [list eieio-print-depth nil (byte-code "@\211\302H\303=\205\304\305\306\217)\207" [list tobj 0 object nil (byte-code "	H\302N\303H\304=\207" [tobj object-class eieio-class-definition 0 defclass] 2) ((error))] 4) ((error)) princ "'" prin1 "(list " (byte-code "@\211\302H\303=\205\304\305\306\217)\207" [list tobj 0 object nil (byte-code "	H\302N\303H\304=\207" [tobj object-class eieio-class-definition 0 defclass] 2) ((error))] 4) ((error)) "\n " (byte-code "@\211\302H\303=\205\304\305\306\217)\207" [list tobj 0 object nil (byte-code "	H\302N\303H\304=\207" [tobj object-class eieio-class-definition 0 defclass] 2) ((error))] 4) ((error)) object-write " " make-string 2 32 ")"] 5 (#$ . 84809)])
#@119 Change the class of OBJ to type CLASS.
This may create or delete slots, but does not affect the return value
of `eq'.
(defalias 'change-class #[(obj class) "\300\301!\207" [error "EIEIO: `change-class' is unimplemented"] 2 (#$ . 85841)])
#@64 Obsolete work part of an old version of the `defmethod' macro.
(defalias 'eieio-defmethod #[(method args) "\306\211\211\211\211\211(@\307=\204(@\310=\203&(A()\202v(@\311=\2046(@\312=\203@(A(*\202v(@\313=\204P(@\314=\203Z(A(+\202v(@\315=\204j(@\316=\203t(A(,\202v+(A(@\211(\211\203\236@<\203\222@@\202\224@\nBA\211\204\206\317-\f@;\203\254\f@\202\261\320\321-\"\"\210(@\211<\203\321A@\306\322\323\217\204\373\324\325A@\"\210\202\373
\326U\203\336\327\330\316\331D\"\210
\211,=\203\353\332\202\371
.W\203\370
\333\\\202\371
)\334\f\242!\203
\335-\f\242
	$\210\202
\335-\336\337\340\n!D\f\"
	$\210./\203\212
\341-!\203u
\342-!\203]
--\343-!0-\344N\2111+H@2-\345-02@2A$M,\210\202\212
--\343-!0-\346-0\"M*\210\202\212
--\343-!0-\347-0\"M*\210-\207" [loopa argclass argfix firstarg body key nil :BEFORE :before :AFTER :after :PRIMARY :primary :STATIC :static eieio-defgeneric format "Generically created method `%s'." (byte-code "\301N\302H\303=\207" [argclass eieio-class-definition 0 defclass] 2) ((error)) error "Unknown class type %s in method parameters" -1 signal wrong-type-argument non-class-arg 0 3 byte-code-function-p eieiomt-add append lambda reverse generic-primary-only-p generic-primary-only-one-p documentation eieio-method-tree eieio-defgeneric-form-primary-only-one eieio-defgeneric-form-primary-only eieio-defgeneric-form args method-before method-after method-primary method-static method method-num-lists eieio-optimize-primary-methods-flag doc-string M entry] 7 (#$ . 86085)])
(make-obsolete 'eieio-defmethod 'eieio--defmethod "24.1")
#@65 Obsolete work part of an old version of the `defgeneric' macro.
(defalias 'eieio-defgeneric #[(method doc-string) "\302!\203&\302!\203\303N\204&\304K!\204!K@\305=\204&\306\307\"\210\302\300!?\205;\210\310!\210\311	\"M\210\300\207" [method doc-string fboundp eieio-method-obarray byte-code-function-p autoload error "You cannot create a generic/method over an existing symbol: %s" eieiomt-install eieio-defgeneric-form] 4 (#$ . 87756)])
(make-obsolete 'eieio-defgeneric nil "24.1")
#@145 Display EIEIO OBJECT in fancy format.
Overrides the edebug default.
Optional argument NOESCAPE is passed to `prin1-to-string' when appropriate.
(defalias 'eieio-edebug-prin1-to-string #[(object &optional noescape) "\302\303\304\217\203\305!\207\302\306\307\217\203\310!\207<\2032\302\311\312\217\204)\302\313\314\217\2032\315\316\317\320#\321Q\207\322	\"\207" [object noescape nil (byte-code "\301N\302H\303=\207" [object eieio-class-definition 0 defclass] 2) ((error)) class-name (byte-code "\211\302H\300=\205\303\304\305\217)\207" [object tobj 0 nil (byte-code "	H\302N\303H\304=\207" [tobj object-class eieio-class-definition 0 defclass] 2) ((error))] 4) ((error)) object-print (byte-code "@\301N\302H\303=\207" [object eieio-class-definition 0 defclass] 2) ((error)) (byte-code "@\211\302H\300=\205\303\304\305\217)\207" [object tobj 0 nil (byte-code "	H\302N\303H\304=\207" [tobj object-class eieio-class-definition 0 defclass] 2) ((error))] 4) ((error)) "(" mapconcat eieio-edebug-prin1-to-string " " ")" prin1-to-string] 5 (#$ . 88261)])
(add-hook 'edebug-setup-hook #[nil "\300\301\302\303#\210\300\304\302\305#\210\300\306\302\307#\210\300\310\302\311#\210\300\312\302\313#\210\300\314\302\315#\210\300\316\302\315#\210\300\317\302\315#\210\300\320\302\315#\210\300\321\302\315#\210\300\322\302\323#\207" [put defmethod edebug-form-spec (&define [&or name ("setf" :name setf name)] [&optional symbolp] list [&optional stringp] def-body) oref (form quote) oref-default (form quote) oset (form quote form) oset-default (form quote form) class-v form class-p eieio-object-p class-constructor generic-p with-slots (list list def-body)] 4])
#@123 Customize OBJ in a custom buffer.
Optional argument GROUP is the sub-group of slots to display.

(fn OBJ &optional GROUP)
(autoload 'customize-object "eieio-custom" '(#$ . 89938) nil nil)
#@185 Create an object browser window to show all objects.
If optional ROOT-CLASS, then start with that, otherwise start with
variable `eieio-default-superclass'.

(fn &optional ROOT-CLASS)
(autoload 'eieio-browse "eieio-opt" '(#$ . 90133) t nil)
(defalias 'describe-class 'eieio-describe-class)
#@234 Describe a CLASS defined by a string or symbol.
If CLASS is actually an object, then also display current values of that object.
Optional HEADERFCN should be called to insert a few bits of info first.

(fn CLASS &optional HEADERFCN)
(autoload 'eieio-describe-class "eieio-opt" '(#$ . 90430) t nil)
#@119 Describe the constructor function FCN.
Uses `eieio-describe-class' to describe the class being constructed.

(fn FCN)
(autoload 'eieio-describe-constructor "eieio-opt" '(#$ . 90735) t nil)
(defalias 'describe-generic 'eieio-describe-generic)
#@124 Describe the generic function GENERIC.
Also extracts information about all methods specific to this generic.

(fn GENERIC)
(autoload 'eieio-describe-generic "eieio-opt" '(#$ . 90984) t nil)
#@105 For buffers thrown into help mode, augment for EIEIO.
Arguments UNUSED are not used.

(fn &rest UNUSED)
(autoload 'eieio-help-mode-augmentation-maybee "eieio-opt" '(#$ . 91181) nil nil)
(provide 'eieio)