;;; compiled by rms@wookumz.gnu.ai.mit.edu on Mon May 31 20:12:17 1993
;;; from file /gd/gnu/emacs/19.0/lisp/cl.el
;;; emacs version 19.10.3.
;;; bytecomp version FSF 2.08
;;; optimization is on.

(byte-code "ÀÁ!„ ÂÀ‡" [boundp cl-version "3.0	07-February-1993"] 2)
(defalias 'psetq '(macro . #[(&rest args) "À	GÂ\"ÃU„ ÄÅ!ˆÆ	!Ç	B	@9„# ÄÈÉ	@!\"ˆ	AAƒ= Ê	Ë	A@Ç	AA‰BEC\"ˆ‚ ‡" [% args 2 0 error "Odd number of arguments to `psetq'" copy-sequence setq "`psetq' expected a symbol, found '%s'." prin1-to-string setcdr prog1] 8 "\
(psetq {VARIABLE VALUE}...): In parallel, set each VARIABLE to its VALUE.
All the VALUEs are evaluated, and then all the VARIABLEs are set.
Aside from order of evaluation, this is the same as `setq'."]))
(defalias 'pair-with-newsyms #[(oldforms) "Á‰‰‰<ƒ ?‚ ÆÇÈ!\")„4 É ‰\n@DB\n\nB)A‰‚ ËÌ!Ì\n!\"+‡" [oldforms nil newsyms bindings ptr x error "endp received a non-cons, non-null argument `%s'" prin1-to-string gentemp newsym values nreverse] 5 "\
PAIR-WITH-NEWSYMS OLDFORMS
The top-level components of the list oldforms are paired with fresh
symbols, the pairings list and the newsyms list are returned."])
(defalias 'zip-lists #[(evens odds) "\n	@@Æ	‰<ƒ ?‚\" ÉÊË!\")„V ‰<ƒ4 ?‚; ÉÊË!\")„V BB	AA	@@‚ Ì!-‡" [evens p0 odds p1 even odd nil result x error "endp received a non-cons, non-null argument `%s'" prin1-to-string nreverse] 5 "\
Merge two lists EVENS and ODDS, taking elts from each list alternatingly.
EVENS and ODDS are two lists.  ZIP-LISTS constructs a new list, whose
even numbered elements (0,2,...) come from EVENS and whose odd
numbered elements (1,3,...) come from ODDS. 
The construction stops when the shorter list is exhausted."])
(defalias 'unzip-list #[(list) "‰@	‰A@)ÅÅ	‰<ƒ  ?‚' ÉÊË!\")„K \nBB	‰AA)‰@	‰A@)‚ ÌÍ!Í!\"-‡" [list ptr this X next nil evens odds x error "endp received a non-cons, non-null argument `%s'" prin1-to-string values nreverse] 5 "\
Extract even and odd elements of LIST into two separate lists.
The argument LIST is separated in two strands, the even and the odd
numbered elements.  Numbering starts with 0, so the first element
belongs in EVENS. No check is made that there is an even number of
elements to start with."])
(defalias 'reassemble-argslists #[(argslists) "ÀÁÂÃ\"\"ÆÈ		T‰	Wƒ% ÂÊ\"B‚ Ë!+‡" [apply min mapcar length argslists minlen nil result -1 i #[(sublist) "À	\n\"‡" [elt sublist i] 3] nreverse] 5 "\
(reassemble-argslists ARGSLISTS) => a list of lists
ARGSLISTS is a list of sequences.  Return a list of lists, the first
sublist being all the entries coming from ELT 0 of the original
sublists, the next those coming from ELT 1 and so on, until the
shortest list is exhausted."])
(defalias 'duplicate-symbols-p #[(list) "ÀÁ <ƒ ÅÆ\"„ ÇÈ!ˆÀ	\n	ƒ4 	@\n	A	Ë\n\nÌ#ˆ‚ *À\nƒX @\nAË\n\n\n\nNT#ˆ‚; *À\nƒ @\nA\n\nNÏVƒ_ \nB‚_ *À\nƒž @\nAÑ\n\n\"ˆ‚† **‡" [nil gensym propname duplicates list every symbolp error "a list of symbols is needed" T$$_0 x put 0 T$$_1 T$$_2 1 T$$_3 remprop] 5 "\
Find all symbols appearing more than once in LIST.
Return a list of all such duplicates; `nil' if there are no duplicates."])
(defalias 'defkeyword '(macro . #[(x &optional docstring) "9ƒ ÁÂDF‡ÄÅÆ!\"‡" [x defconst quote docstring error "`%s' is not a symbol" prin1-to-string] 4 "\
Make symbol X a keyword (symbol whose value is itself).
Optional second argument is a documentation string for it."]))
(defalias 'keywordp #[(sym) "9… ÁÂ!ÃHÄ\"… ‰L‡" [sym char-equal symbol-name 0 58] 3 "\
t if SYM is a keyword."])
(defalias 'keyword-of #[(sym) "À	!ƒ 	‡	9ƒ ÂÃÄ	!P!‰‰L)‡ÆÇÈ	!\"‡" [keywordp sym intern ":" symbol-name newsym error "expected a symbol, not `%s'" prin1-to-string] 5 "\
Return a keyword that is naturally associated with symbol SYM.
If SYM is keyword, the value is SYM.
Otherwise it is a keyword whose name is `:' followed by SYM's name."])
(defvar *gentemp-index* 0 "\
Integer used by gentemp to produce new names.")
(defvar *gentemp-prefix* "T$$_" "\
Names generated by gentemp begin with this string by default.")
(defalias 'gentemp #[(&optional prefix oblist) "„ 	\n„ Ä‰„2 PÈ\\É\n\"„ Ê\n\"‰ƒ *‡" [prefix *gentemp-prefix* oblist obarray nil newname newsymbol *gentemp-index* 1 intern-soft intern] 4 "\
Generate a fresh interned symbol.
There are 2 optional arguments, PREFIX and OBLIST.  PREFIX is the
string that begins the new name, OBLIST is the obarray used to search for
old names.  The defaults are just right, YOU SHOULD NEVER NEED THESE
ARGUMENTS IN YOUR OWN CODE."])
(defvar *gensym-index* 0 "\
Integer used by gensym to produce new names.")
(defvar *gensym-prefix* "G$$_" "\
Names generated by gensym begin with this string by default.")
(defalias 'gensym #[(&optional prefix) "„ 	ÂÃ„' PÇ\\È!„\n É!‰ƒ *‡" [prefix *gensym-prefix* nil "" newname newsymbol *gensym-index* 1 intern-soft make-symbol] 3 "\
Generate a fresh uninterned symbol.
There is an  optional argument, PREFIX.  PREFIX is the
string that begins the new name. Most people take just the default,
except when debugging needs suggest otherwise."])
(byte-code "ÀÁÂÃ#ˆÀÄÂÃ#ˆÀÅÂÃ#ˆÀÆÂÃ#‡" [put case lisp-indent-hook 1 ecase when unless] 4)
(defalias 'when '(macro . #[(condition &rest body) "ÀÁÂDÄ$‡" [list* if not condition nil body] 5 "\
(when CONDITION . BODY) => evaluate BODY if CONDITION is true."]))
(defalias 'unless '(macro . #[(condition &rest body) "ÀÁ\nÃ$‡" [list* if condition nil body] 5 "\
(unless CONDITION . BODY) => evaluate BODY if CONDITION is false."]))
(defalias 'case '(macro . #[(expr &rest cases) "À Â	\"Å	DCÇÈÉ!\"E*‡" [gentemp newsym case-clausify cases clauses let expr list* cond nreverse] 6 "\
(case EXPR . CASES) => evals EXPR, chooses from CASES on that value.
EXPR   -> any form
CASES  -> list of clauses, non empty
CLAUSE -> HEAD . BODY
HEAD   -> t             = catch all, must be last clause
       -> otherwise     = same as t
       -> nil           = illegal
       -> atom          = activated if (eql  EXPR HEAD)
       -> list of atoms = activated if (memq EXPR HEAD)
BODY   -> list of forms, implicit PROGN is built around it.
EXPR is evaluated only once."]))
(defalias 'ecase '(macro . #[(expr &rest cases) "À Â	\"‰‰@@)Æ=ƒ ÇÈ!ˆÆÇÉÊDÌ	DFDBÍ	DCÎÏÐ!\"E*‡" [gentemp newsym case-clausify cases clauses X t error "no clause-head should be `t' or `otherwise' for `ecase'" "ecase on %s = %s failed to take any branch" quote expr prin1-to-string let list* cond nreverse] 7 "\
(ecase EXPR . CASES) => like `case', but error if no case fits.
`t'-clauses are not allowed."]))
(defalias 'case-clausify #[(cases newsym) "A@Ä	‰<ƒ ?‚ ÇÈÉ!\")„± @A\n‰„9 ÇÌÉ!\"ˆ‚¤ Í=„G Î=ƒn \n‰<ƒU ?‚\\ ÇÈÉ!\")„d ÇÏ!ˆÍ\nBB‚¤ :„… ÐÒDE\nBB‚¤ <ƒœ ÓÒDE\nBB‚¤ ÇÔÉ!\"ˆ*	A\nA	@‚\n ,‡" [cases currentpos nextpos curclause nil result x error "endp received a non-cons, non-null argument `%s'" prin1-to-string body head "case clauses cannot have null heads: `%s'" t otherwise "clause with `t' or `otherwise' head must be last" eql newsym quote memq "don't know how to parse case clause `%s'"] 5 "\
CASE-CLAUSIFY CASES NEWSYM => clauses for a 'cond'
Converts the CASES of a [e]case macro into cond clauses to be
evaluated inside a let that binds NEWSYM.  Returns the clauses in
reverse order."])
(byte-code "ÀÁÂÃ#ˆÀÄÂÃ#ˆÀÅÂÆ#ˆÀÇÂÆ#ˆÀÈÂÆ#ˆÀÉÂÆ#‡" [put do lisp-indent-hook 2 do* dolist 1 dotimes do-symbols do-all-symbols] 4)
(defalias 'do '(macro . #[(stepforms endforms &rest body) "À	!ƒ\n Â!ˆÄ	!Å	!@A	Ê	ËÌDÍ\"BBÍ!,BBB‡" [check-do-stepforms stepforms check-do-endforms endforms extract-do-inits extract-do-steps endbody endcond steplist initlist let while not append body] 7 "\
(do STEPFORMS ENDFORMS . BODY): Iterate BODY, stepping some local variables.
STEPFORMS must be a list of symbols or lists.  In the second case, the
lists must start with a symbol and contain up to two more forms. In
the STEPFORMS, a symbol is the same as a (symbol).  The other 2 forms
are the initial value (def. NIL) and the form to step (def. itself).
The values used by initialization and stepping are computed in parallel.
The ENDFORMS are a list (CONDITION . ENDBODY).  If the CONDITION
evaluates to true in any iteration, ENDBODY is evaluated and the last
form in it is returned.
The BODY (which may be empty) is evaluated at every iteration, with
the symbols of the STEPFORMS bound to the initial or stepped values."]))
(defalias 'do* '(macro . #[(stepforms endforms &rest body) "À	!ƒ\n Â!ˆÄ	!Å	!@A	Ê	ËÌDÍ\"BBÍ!,BBB‡" [check-do-stepforms stepforms check-do-endforms endforms extract-do-inits extract-do*-steps endbody endcond steplist initlist let* while not append body] 7 "\
`do*' is to `do' as `let*' is to `let'.
STEPFORMS must be a list of symbols or lists.  In the second case, the
lists must start with a symbol and contain up to two more forms. In
the STEPFORMS, a symbol is the same as a (symbol).  The other 2 forms
are the initial value (def. NIL) and the form to step (def. itself).
Initializations and steppings are done in the sequence they are written.
The ENDFORMS are a list (CONDITION . ENDBODY).  If the CONDITION
evaluates to true in any iteration, ENDBODY is evaluated and the last
form in it is returned.
The BODY (which may be empty) is evaluated at every iteration, with
the symbols of the STEPFORMS bound to the initial or stepped values."]))
(defalias 'check-do-stepforms #[(forms) "<„ ÁÂÃ!\"‡ÄÅ\"‡" [forms error "init/step form for do[*] should be a list, not `%s'" prin1-to-string mapcar #[(entry) "9† <… @9… GÁW?… ÂÃÄÅ!#‡" [entry 4 error "init/step must be %s, not `%s'" "symbol or (symbol [init [step]])" prin1-to-string] 5]] 4 "\
True if FORMS is a valid stepforms for the do[*] macro (q.v.)"])
(defalias 'check-do-endforms #[(forms) "<?… ÁÂÃ!\"‡" [forms error "termination form for do macro should be a list, not `%s'" prin1-to-string] 4 "\
True if FORMS is a valid endforms for the do[*] macro (q.v.)"])
(defalias 'extract-do-inits #[(forms) "ÀÁ\n\"‡" [mapcar #[(entry) "9ƒ	 ÁD‡<… @‰A@)D‡" [entry nil X] 3] forms] 3 "\
Returns a list of the initializations (for do) in FORMS
--a stepforms, see the do macro--. FORMS is assumed syntactically valid."])
(defalias 'extract-do-steps #[(forms) "ÀÁ\n!BC‡" [psetq select-stepping-forms forms] 3 "\
EXTRACT-DO-STEPS FORMS => an s-expr
FORMS is the stepforms part of a DO macro (q.v.).  This function
constructs an s-expression that does the stepping at the end of an
iteration."])
(defalias 'extract-do*-steps #[(forms) "ÀÁ\n!BC‡" [setq select-stepping-forms forms] 3 "\
EXTRACT-DO*-STEPS FORMS => an s-expr
FORMS is the stepforms part of a DO* macro (q.v.).  This function
constructs an s-expression that does the stepping at the end of an
iteration."])
(defalias 'select-stepping-forms #[(forms) "À	Àƒ/ @‰<ƒ( \nGÅUƒ( Æ\n‰AA@)\n@D\"A‰„\n È!+‡" [nil forms entry ptr result 3 append X nreverse] 4 "\
Separate only the forms that cause stepping."])
(defalias 'dolist '(macro . #[(stepform &rest body) "<„ ÁÂÃ!\"ˆ‚. @9„  ÁÄÃ@!\"ˆ‚. GÅVƒ. ÁÆÃ!\"ˆ@‰A@)	‰AA@)\nË ÍÎ	DDÍÏÐÑÒDÓD%E\"E\n…y ÑÕE\nCB\",‡" [stepform error "stepform for `dolist' should be (VAR LIST [RESULT]), not `%s'" prin1-to-string "first component of stepform should be a symbol, not `%s'" 3 "too many components in stepform `%s'" var X listform resultform gentemp listsym nconc let while list setq car cdr body nil] 14 "\
(dolist (VAR LIST [RESULTFORM]) . BODY): do BODY for each elt of LIST.
The RESULTFORM defaults to nil.  The VAR is bound to successive
elements of the value of LIST and remains bound (to the nil value) when the
RESULTFORM is evaluated."]))
(defalias 'dotimes '(macro . #[(stepform &rest body) "<„ ÁÂÃ!\"ˆ‚. @9„  ÁÄÃ@!\"ˆ‚. GÅVƒ. ÁÆÃ!\"ˆ@‰A@)	‰AA@)\n	:ƒP Ë ‚R 	ÍÎÏD	=?…i 	DCBÍÐÑÒÓDEED\"E\n…… \nC\",‡" [stepform error "stepform for `dotimes' should be (VAR COUNT [RESULT]), not `%s'" prin1-to-string "first component of stepform should be a symbol, not `%s'" 3 "too many components in stepform `%s'" var X countform resultform gentemp testsym nconc let -1 while < setq 1+ body] 11 "\
(dotimes (VAR COUNTFORM [RESULTFORM]) .  BODY): Repeat BODY, counting in VAR.
The COUNTFORM should return a positive integer.  The VAR is bound to
successive integers from 0 to COUNTFORM-1 and the BODY is repeated for
each of them.  At the end, the RESULTFORM is evaluated and its value
returned. During this last evaluation, the VAR is still bound, and its
value is the number of times the iteration occurred. An omitted RESULTFORM
defaults to nil."]))
(defalias 'do-symbols '(macro . #[(stepform &rest body) "<„ ÁÂÃ!\"ˆ‚. @9„  ÁÄÃ@!\"ˆ‚. GÅVƒ. ÁÆÃ!\"ˆ@‰A@)	‰AA@)\nËÌÍÎCBBD	EÐÑDC\nEE+‡" [stepform error "stepform for `do-symbols' should be (VAR OBARRAY [RESULT]), not `%s'" prin1-to-string "first component of stepform should be a symbol, not `%s'" 3 "too many components in stepform `%s'" var X oblist resultform progn mapatoms function lambda body let nil] 7 "\
(do_symbols (VAR [OBARRAY [RESULTFORM]]) . BODY)
The VAR is bound to each of the symbols in OBARRAY (def. obarray) and
the BODY is repeatedly performed for each of those bindings. At the
end, RESULTFORM (def. nil) is evaluated and its value returned.
During this last evaluation, the VAR is still bound and its value is nil.
See also the function `mapatoms'."]))
(defalias 'do-all-symbols '(macro . #[(stepform &rest body) "ÀÁ\n@Ã\n‰A@)E#‡" [list* do-symbols stepform obarray X body] 6 "\
(do-all-symbols (VAR [RESULTFORM]) . BODY)
Is the same as (do-symbols (VAR obarray RESULTFORM) . BODY)."]))
(defalias 'loop '(macro . #[(&rest body) "<„	 ÁÂ!‡ÃÄ\"ˆÅÆBB‡" [body error "body of `loop' should be a list of lists or nil" mapcar #[(component) "<?…	 ÁÂ!‡" [component error "components of `loop' should be lists"] 2] while t] 3 "\
(loop . BODY) repeats BODY indefinitely and does not return.
Normally BODY uses `throw' or `signal' to cause an exit.
The forms in BODY should be lists, as non-lists are reserved for new features."]))
(defalias 'first #[(x) "@‡" [x] 1 "\
Synonym for `car'"])
(put (quote first) (quote byte-optimizer) (quote byte-compile-inline-expand))
(defalias 'second #[(x) "A@‡" [x] 1 "\
Return the second element of the list LIST."])
(put (quote second) (quote byte-optimizer) (quote byte-compile-inline-expand))
(defalias 'third #[(x) "À	8‡" [2 x] 2 "\
Return the third element of the list LIST."])
(put (quote third) (quote byte-optimizer) (quote byte-compile-inline-expand))
(defalias 'fourth #[(x) "À	8‡" [3 x] 2 "\
Return the fourth element of the list LIST."])
(put (quote fourth) (quote byte-optimizer) (quote byte-compile-inline-expand))
(defalias 'fifth #[(x) "À	8‡" [4 x] 2 "\
Return the fifth element of the list LIST."])
(put (quote fifth) (quote byte-optimizer) (quote byte-compile-inline-expand))
(defalias 'sixth #[(x) "À	8‡" [5 x] 2 "\
Return the sixth element of the list LIST."])
(put (quote sixth) (quote byte-optimizer) (quote byte-compile-inline-expand))
(defalias 'seventh #[(x) "À	8‡" [6 x] 2 "\
Return the seventh element of the list LIST."])
(put (quote seventh) (quote byte-optimizer) (quote byte-compile-inline-expand))
(defalias 'eighth #[(x) "À	8‡" [7 x] 2 "\
Return the eighth element of the list LIST."])
(put (quote eighth) (quote byte-optimizer) (quote byte-compile-inline-expand))
(defalias 'ninth #[(x) "À	8‡" [8 x] 2 "\
Return the ninth element of the list LIST."])
(put (quote ninth) (quote byte-optimizer) (quote byte-compile-inline-expand))
(defalias 'tenth #[(x) "À	8‡" [9 x] 2 "\
Return the tenth element of the list LIST."])
(put (quote tenth) (quote byte-optimizer) (quote byte-compile-inline-expand))
(defalias 'rest #[(x) "A‡" [x] 1 "\
Synonym for `cdr'"])
(put (quote rest) (quote byte-optimizer) (quote byte-compile-inline-expand))
(defalias 'endp #[(x) "<ƒ ?‡ÁÂÃ!\"‡" [x error "endp received a non-cons, non-null argument `%s'" prin1-to-string] 4 "\
t if X is nil, nil if X is a cons; error otherwise."])
(put (quote endp) (quote byte-optimizer) (quote byte-compile-inline-expand))
(defalias 'last #[(x) "<„	 ÁÂ!ˆ‰A‰<ƒ ?‚  ÁÅÆ!\")„- AA‚ *‡" [x error "arg to `last' must be a list" next-cons current-cons "endp received a non-cons, non-null argument `%s'" prin1-to-string] 5 "\
Returns the last link in the list LIST."])
(defalias 'list-length #[(x) "À	‰Â„s ‰<ƒ 	?‚ ÇÈÉ	!\")ƒ( Ê‚e A‰<ƒ5 	?‚; ÇÈÉ	!\")ƒJ Ë\\Ê‚e =ƒ_ ÀVƒ_ ÂÊ‚e Ì\\‰AA)A‚	 ,‡" [0 x nil ready slow fast n error "endp received a non-cons, non-null argument `%s'" prin1-to-string t 1 2 X] 5 "\
Returns the length of a non-circular list, or `nil' for a circular one."])
(defalias 'butlast #[(list &optional n) "„ ÁÂÃÄ!\"!‡" [n 1 nreverse nthcdr reverse list] 5 "\
Return a new list like LIST but sans the last N elements.
N defaults to 1.  If the list doesn't have N elements, nil is returned."])
(defalias 'list* #[(arg &rest others) "„ 	‡	Â!B‰‰AAƒ A‰‚ Ä‰A@\"ˆ*‡" [others arg copy-sequence a setcdr] 4 "\
Return a new list containing the first arguments consed onto the last arg.
Thus, (list* 1 2 3 '(a b)) returns (1 2 3 a b)."])
(defalias 'adjoin #[(item list) "	>ƒ 	‡	B‡" [item list] 2 "\
Return a list which contains ITEM but is otherwise like LIST.
If ITEM occurs in LIST, the value is LIST.  Otherwise it is (cons ITEM LIST).
When comparing ITEM against elements, `eql' is used."])
(defalias 'ldiff #[(list sublist) "À	\n‰<ƒ ?‚ ÅÆÇ!\")„- \n=„- \n@B\nA‰‚ É!*‡" [nil list curcons result x error "endp received a non-cons, non-null argument `%s'" prin1-to-string sublist reverse] 5 "\
Return a new list like LIST but sans SUBLIST.
SUBLIST must be one of the links in LIST; otherwise the value is LIST itself."])
(defalias 'caar #[(X) "@@‡" [X] 1 "\
Return the car of the car of X."])
(put (quote caar) (quote byte-optimizer) (quote byte-compile-inline-expand))
(defalias 'cadr #[(X) "A@‡" [X] 1 "\
Return the car of the cdr of X."])
(put (quote cadr) (quote byte-optimizer) (quote byte-compile-inline-expand))
(defalias 'cdar #[(X) "@A‡" [X] 1 "\
Return the cdr of the car of X."])
(put (quote cdar) (quote byte-optimizer) (quote byte-compile-inline-expand))
(defalias 'cddr #[(X) "AA‡" [X] 1 "\
Return the cdr of the cdr of X."])
(put (quote cddr) (quote byte-optimizer) (quote byte-compile-inline-expand))
(defalias 'caaar #[(X) "@@@‡" [X] 1 "\
Return the car of the car of the car of X."])
(put (quote caaar) (quote byte-optimizer) (quote byte-compile-inline-expand))
(defalias 'caadr #[(X) "A@@‡" [X] 1 "\
Return the car of the car of the cdr of X."])
(put (quote caadr) (quote byte-optimizer) (quote byte-compile-inline-expand))
(defalias 'cadar #[(X) "@A@‡" [X] 1 "\
Return the car of the cdr of the car of X."])
(put (quote cadar) (quote byte-optimizer) (quote byte-compile-inline-expand))
(defalias 'cdaar #[(X) "@@A‡" [X] 1 "\
Return the cdr of the car of the car of X."])
(put (quote cdaar) (quote byte-optimizer) (quote byte-compile-inline-expand))
(defalias 'caddr #[(X) "AA@‡" [X] 1 "\
Return the car of the cdr of the cdr of X."])
(put (quote caddr) (quote byte-optimizer) (quote byte-compile-inline-expand))
(defalias 'cdadr #[(X) "A@A‡" [X] 1 "\
Return the cdr of the car of the cdr of X."])
(put (quote cdadr) (quote byte-optimizer) (quote byte-compile-inline-expand))
(defalias 'cddar #[(X) "@AA‡" [X] 1 "\
Return the cdr of the cdr of the car of X."])
(put (quote cddar) (quote byte-optimizer) (quote byte-compile-inline-expand))
(defalias 'cdddr #[(X) "AAA‡" [X] 1 "\
Return the cdr of the cdr of the cdr of X."])
(put (quote cdddr) (quote byte-optimizer) (quote byte-compile-inline-expand))
(defalias 'caaaar #[(X) "@@@@‡" [X] 1 "\
Return the car of the car of the car of the car of X."])
(put (quote caaaar) (quote byte-optimizer) (quote byte-compile-inline-expand))
(defalias 'caaadr #[(X) "A@@@‡" [X] 1 "\
Return the car of the car of the car of the cdr of X."])
(put (quote caaadr) (quote byte-optimizer) (quote byte-compile-inline-expand))
(defalias 'caadar #[(X) "@A@@‡" [X] 1 "\
Return the car of the car of the cdr of the car of X."])
(put (quote caadar) (quote byte-optimizer) (quote byte-compile-inline-expand))
(defalias 'cadaar #[(X) "@@A@‡" [X] 1 "\
Return the car of the cdr of the car of the car of X."])
(put (quote cadaar) (quote byte-optimizer) (quote byte-compile-inline-expand))
(defalias 'cdaaar #[(X) "@@@A‡" [X] 1 "\
Return the cdr of the car of the car of the car of X."])
(put (quote cdaaar) (quote byte-optimizer) (quote byte-compile-inline-expand))
(defalias 'caaddr #[(X) "AA@@‡" [X] 1 "\
Return the car of the car of the cdr of the cdr of X."])
(put (quote caaddr) (quote byte-optimizer) (quote byte-compile-inline-expand))
(defalias 'cadadr #[(X) "A@A@‡" [X] 1 "\
Return the car of the cdr of the car of the cdr of X."])
(put (quote cadadr) (quote byte-optimizer) (quote byte-compile-inline-expand))
(defalias 'cdaadr #[(X) "A@@A‡" [X] 1 "\
Return the cdr of the car of the car of the cdr of X."])
(put (quote cdaadr) (quote byte-optimizer) (quote byte-compile-inline-expand))
(defalias 'caddar #[(X) "@AA@‡" [X] 1 "\
Return the car of the cdr of the cdr of the car of X."])
(put (quote caddar) (quote byte-optimizer) (quote byte-compile-inline-expand))
(defalias 'cdadar #[(X) "@A@A‡" [X] 1 "\
Return the cdr of the car of the cdr of the car of X."])
(put (quote cdadar) (quote byte-optimizer) (quote byte-compile-inline-expand))
(defalias 'cddaar #[(X) "@@AA‡" [X] 1 "\
Return the cdr of the cdr of the car of the car of X."])
(put (quote cddaar) (quote byte-optimizer) (quote byte-compile-inline-expand))
(defalias 'cadddr #[(X) "AAA@‡" [X] 1 "\
Return the car of the cdr of the cdr of the cdr of X."])
(put (quote cadddr) (quote byte-optimizer) (quote byte-compile-inline-expand))
(defalias 'cddadr #[(X) "A@AA‡" [X] 1 "\
Return the cdr of the cdr of the car of the cdr of X."])
(put (quote cddadr) (quote byte-optimizer) (quote byte-compile-inline-expand))
(defalias 'cdaddr #[(X) "AA@A‡" [X] 1 "\
Return the cdr of the car of the cdr of the cdr of X."])
(put (quote cdaddr) (quote byte-optimizer) (quote byte-compile-inline-expand))
(defalias 'cdddar #[(X) "@AAA‡" [X] 1 "\
Return the cdr of the cdr of the cdr of the car of X."])
(put (quote cdddar) (quote byte-optimizer) (quote byte-compile-inline-expand))
(defalias 'cddddr #[(X) "AAAA‡" [X] 1 "\
Return the cdr of the cdr of the cdr of the cdr of X."])
(put (quote cddddr) (quote byte-optimizer) (quote byte-compile-inline-expand))
(defalias 'setnth #[(n list newval) "ÀÁ\n\"\"‡" [rplaca nthcdr n list newval] 4 "\
Set (nth N LIST) to NEWVAL.  Returns NEWVAL."])
(put (quote setnth) (quote byte-optimizer) (quote byte-compile-inline-expand))
(defalias 'setnthcdr #[(n list newval) "ÁWƒ ÂÃ\"ˆÁVƒ AÅZ‰‚ Æ@\"ˆÈA\"ˆ‡" [n 0 error "N must be 0 or greater, not %d" list 1 rplaca newval rplacd] 4 "\
(setnthcdr N LIST NEWVAL) => NEWVAL
As a side effect, sets the Nth cdr of LIST to NEWVAL."])
(defalias 'acons #[(key item alist) "	B\nB‡" [key item alist] 2 "\
Return a new alist with KEY paired with ITEM; otherwise like ALIST.
Does not copy ALIST."])
(put (quote acons) (quote byte-optimizer) (quote byte-compile-inline-expand))
(defalias 'pairlis #[(keys data &optional alist) "G	GU„ ÂÃ!ˆ	@@	‰\n<ƒ* \n?‚1 ÂËÌ\n!\")„\\ 	‰B+B	AA@@‚ 	-‡" [keys data error "keys and data should be the same length" kptr dptr key item alist result x "endp received a non-cons, non-null argument `%s'" prin1-to-string] 5 "\
Return a new alist with each elt of KEYS paired with an elt of DATA;
optional 3rd arg ALIST is nconc'd at the end.  KEYS and DATA must
have the same length."])
(defconst :test (quote :test) "\
Used to designate positive (selection) tests.")
(defconst :test-not (quote :test-not) "\
Used to designate negative (rejection) tests.")
(defconst :key (quote :key) "\
Used to designate component extractions.")
(defconst :predicate (quote :predicate) "\
Used to define matching of sequence components.")
(defconst :start (quote :start) "\
Inclusive low index in sequence")
(defconst :end (quote :end) "\
Exclusive high index in sequence")
(defconst :start1 (quote :start1) "\
Inclusive low index in first of two sequences.")
(defconst :start2 (quote :start2) "\
Inclusive low index in second of two sequences.")
(defconst :end1 (quote :end1) "\
Exclusive high index in first of two sequences.")
(defconst :end2 (quote :end2) "\
Exclusive high index in second of two sequences.")
(defconst :count (quote :count) "\
Number of elements to affect.")
(defconst :from-end (quote :from-end) "\
T when counting backwards.")
(defconst :initial-value (quote :initial-value) "\
For the syntax of #'reduce")
(defalias 'some #[(pred seq &rest moreseqs) "ÀÁ\n\"!ÅÅÅ‰	@\n„U 	‰<ƒ+ ?‚2 ÌÍÎ!\")„U Ï\n\"‰ƒI Ñ	A‰	@\n‚ .‡" [reassemble-argslists list* seq moreseqs args nil ready result applyval remaining current x error "endp received a non-cons, non-null argument `%s'" prin1-to-string apply pred t] 5 "\
Test PREDICATE on each element of SEQUENCE; is it ever non-nil?
Extra args are additional sequences; PREDICATE gets one arg from each
sequence and we advance down all the sequences together in lock-step.
A sequence means either a list or a vector."])
(defalias 'every #[(pred seq &rest moreseqs) "ÀÁ\n\"!ÅÇÅ	‰\n@„T \n‰<ƒ+ ?‚2 ÍÎÏ!\")„T Ð\"‰	„H ÇÅ\nA‰\n@‚ .‡" [reassemble-argslists list* seq moreseqs args nil ready t result applyval remaining current x error "endp received a non-cons, non-null argument `%s'" prin1-to-string apply pred] 5 "\
Test PREDICATE on each element of SEQUENCE; is it always non-nil?
Extra args are additional sequences; PREDICATE gets one arg from each
sequence and we advance down all the sequences together in lock-step.
A sequence means either a list or a vector."])
(defalias 'notany #[(pred seq &rest moreseqs) "ÀÁ\n\"!ÅÇÅ	‰\n@„T \n‰<ƒ+ ?‚2 ÍÎÏ!\")„T Ð\"‰	ƒH ÇÅ\nA‰\n@‚ .‡" [reassemble-argslists list* seq moreseqs args nil ready t result applyval remaining current x error "endp received a non-cons, non-null argument `%s'" prin1-to-string apply pred] 5 "\
Test PREDICATE on each element of SEQUENCE; is it always nil?
Extra args are additional sequences; PREDICATE gets one arg from each
sequence and we advance down all the sequences together in lock-step.
A sequence means either a list or a vector."])
(defalias 'notevery #[(pred seq &rest moreseqs) "ÀÁ\n\"!ÅÅÅ‰	@\n„T 	‰<ƒ+ ?‚2 ÌÍÎ!\")„T Ï\n\"‰„H ÑÑ	A‰	@\n‚ .‡" [reassemble-argslists list* seq moreseqs args nil ready result applyval remaining current x error "endp received a non-cons, non-null argument `%s'" prin1-to-string apply pred t] 5 "\
Test PREDICATE on each element of SEQUENCE; is it sometimes nil?
Extra args are additional sequences; PREDICATE gets one arg from each
sequence and we advance down all the sequences together in lock-step.
A sequence means either a list or a vector."])
(defalias 'concatenate #[(type &rest sequences) "À	Â\"‰Å=ƒ ÆÀ	\"‚7 Ç=ƒ! ÆÈ	\"‚7 É=ƒ1 ÆÉÆÀ	\"\"‚7 ÊËÌ!\"*‡" [append sequences (nil) type T$$_4 list apply string concat vector error "type for concatenate `%s' not 'list, 'string or 'vector" prin1-to-string] 6 "\
(concatenate TYPE &rest SEQUENCES) => a sequence
The sequence returned is of type TYPE (must be 'list, 'string, or 'vector) and
contains the concatenation of the elements of all the arguments, in the order
given."])
(defalias 'map #[(type function &rest sequences) "ÁÂÃÄF>„ ÅÆÇ!\"ˆÈ	!Ä\n„4 …d Ì@\"ˆA‰‚  ÎÏ\"\n‰Á=ƒI \n‚c Â=ƒW Ñ\n!‚c Ã=…c ÌÃ\n\")*‡" [type list string vector nil error "type for map `%s' not 'list, 'string, 'vector or nil" prin1-to-string reassemble-argslists sequences results argslists apply function mapcar #[(args) "À	\n\"‡" [apply function args] 3] T$$_5 concat] 6 "\
(map TYPE FUNCTION &rest SEQUENCES) => a sequence
The FUNCTION is called on each set of elements from the SEQUENCES (stopping
when the shortest sequence is terminated) and the results are possibly
returned in a sequence of type TYPE (one of 'list, 'vector, 'string, or nil)
giving NIL for TYPE gets rid of the values."])
(defalias 'setelt #[(seq n newval) "G\nÃW„ \n	Yƒ ÄÅ\n	#‚F <ƒ2 \nÈÉ\n\"\"+‚F Ê!ƒ@ \nI‚F ÄËÌ!\")‡" [seq l n 0 error "N(%d) should be between 0 and %d" newval list rplaca nthcdr arrayp "SEQ should be a sequence, not `%s'" prin1-to-string] 4 "\
In SEQUENCE, set the Nth element to NEWVAL.  Returns NEWVAL.
A sequence means either a list or a vector."])
(defalias 'build-klist #[(argslist acceptable &optional allow-other-keys) "<ƒ GÂ	Ã\"ÄU)„ ÅÆ!ˆ<ƒ$ ÈÉ\"„( ÅÊ!ˆËÍ ‰Ï!LˆƒA Ð!‚N ÒJCÐ!)‰A@@ÈÉ\"„k ÅÖ×!\"ˆ„‡ ÈÙ\"„‡ ÅÚ×ÛÜ\"!×!#ˆÝ\"‰@ Ë!Ë\"‰#<ƒ¬ #?‚³ Åä×#!\")„Ö å \"‰!ƒÊ !\"B\"A‰@ ‚ \".‡" [argslist number % 2 0 error "build-klist: odd number of keyword-args" acceptable every keywordp "build-klist: second arg should be a list of keywords" nil *mvalues-count* gensym it unzip-list copy-sequence *mvalues-values* 1 T$$_6 forms keywords "build-klist: expected keywords, found `%s'" prin1-to-string allow-other-keys #[(keyword) "	>‡" [keyword acceptable] 2] "bad keyword[s]: %s not in %s" mapcan #[(keyword) "	>?…	 C‡" [keyword acceptable] 2] pairlis auxlist ptr this auxval alist x "endp received a non-cons, non-null argument `%s'" assq] 7 "\
Decode a keyword argument list ARGSLIST for keywords in ACCEPTABLE.
ARGSLIST is a list, presumably the &rest argument of a call, whose
even numbered elements must be keywords.
ACCEPTABLE is a list of keywords, the only ones that are truly acceptable.
The result is an alist containing the arguments named by the keywords
in ACCEPTABLE, or an error is signalled, if something failed.
If the third argument (an optional) is non-nil, other keys are acceptable."])
(defalias 'extract-from-klist #[(klist key &optional default) "À	\n\"A‰† )‡" [assq key klist retrieved default] 4 "\
(extract-from-klist KLIST KEY [DEFAULT]) => value of KEY or DEFAULT
Extract value associated with KEY in KLIST (return DEFAULT if nil)."])
(defalias 'keyword-argument-supplied-p #[(klist key) "À	\n\"‡" [assq key klist] 3 "\
(keyword-argument-supplied-p KLIST KEY) => nil or something
NIL if KEY (a keyword) does not appear in the KLIST."])
(defalias 'add-to-klist #[(key item klist) "	\n‰	B+B‰‡" [key item klist alist] 4 "\
(ADD-TO-KLIST KEY ITEM KLIST) => new KLIST
Add association (KEY . ITEM) to KLIST."])
(defalias 'elt-satisfies-test-p #[(item elt klist) "À	\n\"À	\"À	Å#‰ƒ$ 	\n!\"‚= ƒ7 	\n!\"?‚= ËÌÍ	!\"+‡" [extract-from-klist klist :test :test-not :key identity keyfn test-not test item elt error "neither :test nor :test-not in `%s'" prin1-to-string] 7 "\
(elt-satisfies-test-p ITEM ELT KLIST) => t or nil
KLIST encodes a keyword-arguments test, as in CH. 14 of CLtL.
True if the given ITEM and ELT satisfy the test."])
(defalias 'elt-satisfies-if-p #[(item klist) "À	\n\"À	Ä#‰!!*‡" [extract-from-klist klist :predicate :key identity keyfn predicate item] 6 "\
(elt-satisfies-if-p ITEM KLIST) => t or nil
True if an -if style function was called and ITEM satisfies the
predicate under :predicate in KLIST."])
(defalias 'elt-satisfies-if-not-p #[(item klist) "À	\n\"À	Ä#‰!!*?‡" [extract-from-klist klist :predicate :key identity keyfn predicate item] 6 "\
(elt-satisfies-if-not-p ITEM KLIST) => t or nil
KLIST encodes a keyword-arguments test, as in CH. 14 of CLtL.
True if an -if-not style function was called and ITEM does not satisfy
the predicate under :predicate in KLIST."])
(defalias 'elts-match-under-klist-p #[(e1 e2 klist) "À	\n\"À	\"À	Å#‰ƒ# ƒ# ÉÊË	!\"ˆƒ8 !!\"‚T ƒN !!\"?‚T ÉÎË	!\"+‡" [extract-from-klist klist :test :test-not :key identity keyfn test-not test error "both :test and :test-not in `%s'" prin1-to-string e1 e2 "neither :test nor :test-not in `%s'"] 7 "\
(elts-match-under-klist-p E1 E2 KLIST) => t or nil
KLIST encodes a keyword-arguments test, as in CH. 14 of CLtL.
True if elements E1 and E2 match under the tests encoded in KLIST."])
(defalias 'with-keyword-args '(macro . #[(keyargslist vardefs &rest body) "À\n<ƒ5 \nGÃVƒ ÄÅÆ\n!\"ˆ‚C \n‰A@)\n@‰9ƒ. 	È>„C ÄÉ!ˆ‚C \n9ƒ? À‚C ÄÉ!ˆÀ‰‰‰ÊË!ÑÒ\"ˆÔÕÖ×\nØD	FDCÙ!\"D\".‡" [nil allow-other-keys keyargslist 2 error "`%s' should be SYMBOL, (SYMBOL), or (SYMBOL t-OR-nil)" prin1-to-string X (t nil) "first subform should be SYMBOL, (SYMBOL), or (SYMBOL t-OR-nil)" gensym "KLIST_" klistname forms keywords defaults vars mapcar #[(entry) "9ƒ ÁÂ!EG@‰A@)‰AA@)ÈW„/ ÉVƒ6 ÊËÌ!\"ˆƒ? 9„F ÊÍÌ!\"ˆBBÉWƒ^ Â!ÉUƒx ƒp Ð!„x ÊÑÌ!\"ˆBÓFDB‰,‡" [entry nil keyword-of l v X d k 1 3 error "`%s' must match (VAR [DEFAULT [KEYWORD]])" prin1-to-string "bad variable `%s': must be non-null symbol" vars defaults keywordp "bad keyword `%s'" keywords extract-from-klist klistname forms] 6] vardefs append let* nconc build-klist quote nreverse body] 9 "\
(WITH-KEYWORD-ARGS KEYARGSLIST VARDEFS . BODY)
KEYARGSLIST can be either a symbol or a list of one or two symbols.  
In the second case, the second symbol is either T or NIL, indicating whether
keywords other than the mentioned ones are tolerable.

VARDEFS is a list.  Each entry is either a VAR (symbol) or matches
(VAR [DEFAULT [KEYWORD]]).  Just giving VAR is the same as giving
(VAR nil :VAR).

The BODY is executed in an environment where each VAR (a symbol) is bound to
the value present in the KEYARGSLIST provided, or to the DEFAULT.  The value
is searched by using the keyword form of VAR (i.e., :VAR) or the optional
keyword if provided.

Notice that this macro doesn't distinguish between a default value given
explicitly by the user and one provided by default.  See also the more
primitive functions build-klist, add-to-klist, extract-from-klist,
keyword-argument-supplied-p, elt-satisfies-test-p, elt-satisfies-if-p,
elt-satisfies-if-not-p, elts-match-under-klist-p.  They provide more complete,
if clumsier, control over this feature."]))
(put (quote with-keyword-args) (quote lisp-indent-hook) 1)
(defalias 'reduce #[(function sequence &rest kargs) "À	Â\"GÆ\"É\n\"Æ	Í#Æ	#Ñ#ƒ7 Ò!ƒD Æ\n\"B„N  ‚{ @A‰ƒx ƒh @\"‚o @\"A‰„Y *.‡" [build-klist kargs (:from-end :start :end :initial-value) klist sequence length extract-from-klist :from-end from-end keyword-argument-supplied-p :initial-value initial-value-given :start 0 start :end end cl$subseq-as-list reverse function result] 5 "\
Apply FUNCTION (a function of two arguments) to succesive pairs of elements
from SEQUENCE.  Some keyword arguments are valid after FUNCTION and SEQUENCE:
:from-end       If non-nil, process the values backwards
:initial-value  If given, prefix it to the SEQUENCE.  Suffix, if :from-end
:start          Restrict reduction to the subsequence from this index
:end            Restrict reduction to the subsequence BEFORE this index.
If the sequence is empty and no :initial-value is given, the FUNCTION is
called on zero (not two) arguments.  Otherwise, if there is exactly one
element in the combination of SEQUENCE and the initial value, that element is
returned."])
(defalias 'cl$subseq-as-list #[(sequence start end) "À	Â\"	GÂÇWƒ ÈÉ\"ˆ\nVƒ% ÈË\n#ˆÇUƒ7 \nUƒ7 ‚_ ÌÍ\"‰\nU„[ Ï\"BÐ\\‰‚B Ñ!*+‡" [append sequence nil result length list start 0 error "start should be >= 0, not %d" end "end should be <= %d, not %d" apply vector i elt 1 nreverse] 5 "\
(cl$subseq-as-list SEQUENCE START END) => a list"])
(defalias 'cl-member #[(item list &rest kargs) "„ 	\n>‡ÃÄ\"Æ\"Æ	\"\nÆÌ#Î=„A Ï=„A ÎK=„A ÏK=ƒb \n„b Ì=„\\ Ì=„\\ ÌK=ƒb 	\n>‚-ƒp \nƒp ÐÑ!ˆ„} \n„} Ï\nƒ \n9ƒ› \nK\n‚› 9ƒ› K9ƒ¦ K\nÒ‰\nƒï „*‰<ƒÈ ?‚Ï Ð×Ø!\")„*\n	@!\"„ç ÙA‚´ „*‰<ƒ?‚\nÐ×Ø!\")„*	@!\"ƒ\"ÙA‚ï +,‡" [kargs item list build-klist (:test :test-not :key) klist extract-from-klist :test test :test-not testnot :key identity key eq eql error ":test and :test-not both specified for member" nil result done ptr x "endp received a non-cons, non-null argument `%s'" prin1-to-string t] 5 "\
Look for ITEM in LIST; return first tail of LIST the car of whose first
cons cell tests the same as ITEM.  Admits arguments :key, :test, and
:test-not."])
(byte-code "ÀÁÂÃ#ˆÀÄÂÃ#ˆÀÅÂÆ#ˆÀÇÂÈ#ˆÀÉÂÈ#‡" [put multiple-value-bind lisp-indent-hook 2 multiple-value-setq multiple-value-list nil multiple-value-call 1 multiple-value-prog1] 4)
(defvar *mvalues-values* nil "\
Most recently returned multiple-values")
(defvar *mvalues-count* nil "\
Count of multiple-values returned, or nil if the mechanism was not used")
(defalias 'values #[(&rest val-forms) "‰G	@‡" [val-forms *mvalues-values* *mvalues-count*] 2 "\
Produce multiple values (zero or more).  Each arg is one value.
See also `multiple-value-bind', which is one way to examine the
multiple values produced by a form.  If the containing form or caller
does not check specially to see multiple values, it will see only
the first value."])
(defalias 'values-list #[(&optional val-forms) "<„ ÁÂÃ!\"ˆ‰G@‡" [val-forms error "Argument to values-list must be a list, not `%s'" prin1-to-string *mvalues-values* *mvalues-count*] 5 "\
Produce multiple values (zero or more).  Each element of LIST is one value.
This is equivalent to (apply 'values LIST)."])
(defalias 'multiple-value-list '(macro . #[(form) "ÀÁÂÃEÄÅÆDCÇÅEÉÂÊËDÀÁÂÌEÁËÍÎÅDDEÊËDFFFE‡" [progn setq *mvalues-count* nil let it (gensym) set form if copy-sequence *mvalues-values* 1 list symbol-value] 15 "\
Execute FORM and return a list of all the (multiple) values FORM produces.
See `values' and `multiple-value-bind'."]))
(defalias 'multiple-value-call '(macro . #[(function &rest args) "À À ÃÄÅ!DÆ	ÇDCÈ\nÉ\nD	EË	Ì	ÍÅ\nDDEEEEE*‡" [gentemp result arg apply function eval let* nil dolist quote args setq append multiple-value-list] 13 "\
Call FUNCTION on all the values produced by the remaining arguments.
(multiple-value-call '+ (values 1 2) (values 3 4)) is 10."]))
(defalias 'multiple-value-bind '(macro . #[(vars form &rest body) "À Â	\"ÅÆ	ÇDDB	#*‡" [gentemp vals mv-bind-clausify vars clauses list* let* multiple-value-list form body] 5 "\
Bind VARS to the (multiple) values produced by FORM, then do BODY.
VARS is a list of variables; each is bound to one of FORM's values.
If FORM doesn't make enough values, the extra variables are bound to nil.
(Ordinary forms produce only one value; to produce more, use `values'.)
Extra values are ignored.
BODY (zero or more forms) is executed with the variables bound,
then the bindings are unwound."]))
(defalias 'multiple-value-setq '(macro . #[(vars form) "À Â	\"Å	ÆDDCÈÉÊ\"BE*‡" [gentemp vals mv-bind-clausify vars clauses let* multiple-value-list form setq apply append] 6 "\
Set VARS to the (multiple) values produced by FORM.
VARS is a list of variables; each is set to one of FORM's values.
If FORM doesn't make enough values, the extra variables are set to nil.
(Ordinary forms produce only one value; to produce more, use `values'.)
Extra values are ignored."]))
(defalias 'multiple-value-prog1 '(macro . #[(form &rest body) "À Â	ÃDDCÅÇ	DC\")BB‡" [gentemp heldvalues let* multiple-value-list form append body values-list] 6 "\
Evaluate FORM, then BODY, then produce the same values FORM produced.
Thus, (multiple-value-prog1 (values 1 2) (foobar)) produces values 1 and 2.
This is like `prog1' except that `prog1' would produce only one value,
which would be the first of FORM's values."]))
(defalias 'mv-bind-clausify #[(vars vals) "<ƒ ÁÂ\"ƒ ÃÄÅ!\"ˆGÇÉ\n\nT‰\nWƒ< \n8Ë\nEDB‚ +‡" [vars notevery symbolp error "expected a list of symbols, not `%s'" prin1-to-string nvars nil clauses -1 n nth vals] 4 "\
MV-BIND-CLAUSIFY VARS VALS => Auxiliary list
Forms a list of pairs `(,(nth i vars) (nth i vals)) for i from 0 to
the length of VARS (a list of symbols).  VALS is just a fresh symbol."])
(defalias 'plusp #[(number) "ÁV‡" [number 0] 2 "\
True if NUMBER is strictly greater than zero."])
(put (quote plusp) (quote byte-optimizer) (quote byte-compile-inline-expand))
(defalias 'minusp #[(number) "ÁW‡" [number 0] 2 "\
True if NUMBER is strictly less than zero."])
(put (quote minusp) (quote byte-optimizer) (quote byte-compile-inline-expand))
(defalias 'oddp #[(number) "À	Â\"ÃU?‡" [% number 2 0] 3 "\
True if INTEGER is not divisible by 2."])
(put (quote oddp) (quote byte-optimizer) (quote byte-compile-inline-expand))
(defalias 'evenp #[(number) "À	Â\"ÃU‡" [% number 2 0] 3 "\
True if INTEGER is divisible by 2."])
(put (quote evenp) (quote byte-optimizer) (quote byte-compile-inline-expand))
(defalias 'abs #[(number) "ÁWƒ	 [‡‡" [number 0] 2 "\
Return the absolute value of NUMBER."])
(put (quote abs) (quote byte-optimizer) (quote byte-compile-inline-expand))
(defalias 'signum #[(number) "ÁWƒ Â‡ÁVƒ Ã‡Á‡" [number 0 -1 1] 2 "\
Return -1, 0 or 1 according to the sign of NUMBER."])
(put (quote signum) (quote byte-optimizer) (quote byte-compile-inline-expand))
(defalias 'gcd #[(&rest integers) "G‰ÂUƒ Â‚À 	ÃUƒ& @‰ÂWƒ! [‚\" )‚À 	ÅVƒ= ÆÇ‰@A@\"AAB\"‚À È@A@\"ÂUƒM ÉÊ!ˆ@‰ÂWƒ[ [‚\\ )A@‰ÂWƒn [‚o )]^ÂÂÑÂ„¼ Ô\"Õ\"‰ÂUƒ± Ö‚Œ ‚Œ .)‡" [integers howmany 0 1 number 2 apply gcd * error "a zero argument is invalid for `gcd'" absa absb dd ds q r nil done result / % t] 6 "\
Return the greatest common divisor of all the arguments.
The arguments must be integers.  With no arguments, value is zero."])
(defalias 'lcm #[(integer &rest more) "G	@ÂA‰ÈUƒ+ ‰	ÈWƒ% 	[‚' 	)‚h ÊVƒ? ËÌ‰\"B\"‚h Í\"‰ÈUƒO È‚h Î‰	ÈWƒ_ 	[‚a 	)Ï\"\"-‡" [more integer nil yetmore prod b a howmany 0 number 1 apply lcm * / gcd] 6 "\
Return the least common multiple of all the arguments.
The arguments must be integers and there must be at least one of them."])
(defalias 'isqrt #[(number) "‰ÁW)ƒ ÂÃ\"‡ÁUƒ Á‡ÄÁÇ„B ÉÉ\"\\Ê\"‰U†: Ä\\U‚ Ë‰\"VƒQ ÄZ‚R +‡" [number 0 error "argument to `isqrt' (%d) must not be negative" 1 approx new nil done / 2 *] 6 "\
Return the integer square root of NUMBER.
NUMBER must not be negative.  Result is largest integer less than or
equal to the real square root of the argument."])
(defalias 'cl-floor #[(number &optional divisor) "„ Á\n!ƒ Ã\nÄ\"‡ÅÇ ‰É\n\"Lˆƒ) Ê!‚6 ÌJCÊ!)Î8A@@ÄUƒX ÃÄ‰\"‚Ž ‰ÄV)ƒk Ã\"‚Ž ÄUƒ{ Ã[Ä\"‚Ž Ì\\[Ã\nÒ\"Z\"),‡" [divisor numberp number values 0 nil *mvalues-count* gensym it safe-idiv copy-sequence *mvalues-values* 1 T$$_7 2 s r q *] 7 "\
Divide DIVIDEND by DIVISOR, rounding toward minus infinity.
DIVISOR defaults to 1.  The remainder is produced as a second value."])
(defalias 'cl-ceiling #[(number &optional divisor) "„ Á\n!ƒ Ã\nÄ\"‡ÅÇ ‰É\n\"Lˆƒ) Ê!‚6 ÌJCÊ!)Î8A@@ÄUƒX ÃÄ‰\"‚{ ‰ÄV)ƒo ÃÌ\\Z\"‚{ Ã[\nÒ\"\\\",‡" [divisor numberp number values 0 nil *mvalues-count* gensym it safe-idiv copy-sequence *mvalues-values* 1 T$$_8 2 s r q *] 7 "\
Divide DIVIDEND by DIVISOR, rounding toward plus infinity.
DIVISOR defaults to 1.  The remainder is produced as a second value."])
(defalias 'cl-truncate #[(number &optional divisor) "„ Á\n!ƒ Ã\nÄ\"‡ÅÇ ‰É\n\"Lˆƒ) Ê!‚6 ÌJCÊ!)Î8A@@ÄUƒX ÃÄ‰\"‚w ‰ÄV)ƒk Ã\"‚w Ã[\nÒ\"\\\",‡" [divisor numberp number values 0 nil *mvalues-count* gensym it safe-idiv copy-sequence *mvalues-values* 1 T$$_9 2 s r q *] 7 "\
Divide DIVIDEND by DIVISOR, rounding toward zero.
DIVISOR defaults to 1.  The remainder is produced as a second value."])
(defalias 'cl-round #[(number &optional divisor) "„ Á\n!ƒ Ã\nÄ\"‡ÅÇ ‰É\n\"Lˆƒ) Ê!‚6 ÌJCÊ!)Î8A@@‰ÄWƒX \n[‚Y \n)‰ÄWƒi \n[‚j \n)ZVƒ Ì\\‚œ Uƒœ Ó\nÎ\"ÄU)„œ Ì\\Ô\"\nÔ\"ZÃ\"-‡" [divisor numberp number values 0 nil *mvalues-count* gensym it safe-idiv copy-sequence *mvalues-values* 1 T$$_10 2 s r q other-r % *] 5 "\
Divide DIVIDEND by DIVISOR, rounding to nearest integer.
DIVISOR defaults to 1.  The remainder is produced as a second value."])
(defalias 'mod #[(number divisor) "À	\n\"ˆ‰A@)‡" [cl-floor number divisor *mvalues-values* X] 4 "\
Return remainder of X by Y (rounding quotient toward minus infinity).
That is, the remainder goes with the quotient produced by `cl-floor'.
Emacs Lisp hint:
If you know that both arguments are positive, use `%' instead for speed."])
(defalias 'rem #[(number divisor) "À	\n\"ˆ‰A@)‡" [cl-truncate number divisor *mvalues-values* X] 4 "\
Return remainder of X by Y (rounding quotient toward zero).
That is, the remainder goes with the quotient produced by `cl-truncate'.
Emacs Lisp hint:
If you know that both arguments are positive, use `%' instead for speed."])
(defalias 'safe-idiv #[(a b) "À	‰ÃWƒ \n[‚ \n)‰ÃWƒ \n[‚ \n)\"Æ	‰ÃWƒ. Ç‚9 \nÃVƒ8 È‚9 Ã)‰ÃWƒF Ç‚Q \nÃVƒP È‚Q Ã)\"		Æ	#Z\nË\n	#+‡" [/ a number 0 b q * -1 1 s r values] 6 "\
SAFE-IDIV A B => Q R S
Q=|A|/|B|, S is the sign of A/B, R is the rest A - S*Q*B."])
(defconst :setf-update-fn (quote :setf-update-fn) "\
Property, its value is the function setf must invoke to update a
generalized variable whose access form is a function call of the
symbol that has this property.")
(defconst :setf-update-doc (quote :setf-update-doc) "\
Property of symbols that have a `defsetf' update function on them,
installed by the `defsetf' from its optional third argument.")
(defalias 'setf '(macro . #[(&rest pairs) "GÂ	Ã\"ÄU„ ÅÆ!‚o	ÄUƒ Ç‚o	ÃVƒ€ È‰	@\n	‰A@)Ç	‰<ƒF ?‚M ÅÏÐ!\")„w Ñ\nEB	‰AA)‰	@\n	‰A@)‚7 Ò!,B‚o@\n‰A@)ÇÇ\n9ƒ¢ Õ\nE‚n\n<ƒg\n@‰ƒg9ƒgN‰ƒg:ƒâ @×=ƒâ ØÙDÚ\nAC\"BB‚n9ƒ Û!ƒ KÝ!†:…@×=†@Þ=)ƒ Ú\nAC\"B‚nÇà ‰!âÚ\nAC\"!Lˆƒ@ã$!‚Må!JC$ã$!)‰&A@'&@(é('BE+‚nÅêÐ\n!\",)‡" [pairs nforms % 2 0 error "odd number of arguments to `setf'" nil progn args place X value result x "endp received a non-cons, non-null argument `%s'" prin1-to-string setf nreverse head updatefn setq :setf-update-fn lambda funcall function append fboundp defn subrp macro *mvalues-count* gensym it pair-with-newsyms copy-sequence *mvalues-values* 1 T$$_11 newsyms bindings let "no `setf' update-function for `%s'"] 6 "\
Generalized `setq' that can set things other than variable values.
A use of `setf' looks like (setf {PLACE VALUE}...).
The behavior of (setf PLACE VALUE) is to access the generalized variable
at PLACE and store VALUE there.  It returns VALUE.  If there is more
than one PLACE and VALUE, each PLACE is set from its VALUE before
the next PLACE is evaluated."]))
(defalias 'defsetf '(macro . #[(accessfn updatefn &optional docstring) "9„ ÁÂÃ!\"ˆÄÅÆÇDÉ\nDFDÆÇDFÇDF‡" [accessfn error "first argument of `defsetf' must be a symbol, not `%s'" prin1-to-string progn eval-and-compile put quote :setf-update-fn function updatefn :setf-update-doc docstring] 7 "\
Define how `setf' works on a certain kind of generalized variable.
A use of `defsetf' looks like (defsetf ACCESSFN UPDATEFN [DOCSTRING]).
ACCESSFN is a symbol.  UPDATEFN is a function or macro which takes
one more argument than ACCESSFN does.  DEFSETF defines the translation
of (SETF (ACCESFN . ARGS) NEWVAL) to be a form like (UPDATEFN ARGS... NEWVAL).
The function UPDATEFN must return its last arg, after performing the
updating called for."]))
(byte-code "ÀÁ\nÃ#ˆÀÁÅ#ˆÀÆ\nÇ#ˆÀÆÈ#ˆÀÉ\nÊ#ˆÀÉË#ˆÀÌ\nÍ#ˆÀÌÎ#ˆÀÏ\nÐ#ˆÀÏÑ#ˆÀÒ\nÓ#ˆÀÒÔ#ˆÀÕ\nÖ#ˆÀÕ×#ˆÀØ\nÙ#ˆÀØÚ#ˆÀÛ\nÜ#ˆÀÛÝ#ˆÀÞ\nß#ˆÀÞà#ˆÀá\nâ#ˆÀáã#ˆÀä\nå#ˆÀäæ#ˆÀç\nè#ˆÀçé#ˆÀê\në#ˆÀêì#ˆÀí\nî#ˆÀíï#ˆÀð\nñ#ˆÀðò#ˆÀó\nô#ˆÀóõ#ˆÀö\n÷#ˆÀöø#ˆÀù\nú#ˆÀùû#ˆÀü\ný#ˆÀüþ#ˆÀÿ\n@ #ˆÀÿA #ˆÀB \nC #ˆÀB D #ˆÀE \nF #ˆÀE G #ˆÀH \nI #ˆÀH J #ˆÀK \nL #ˆÀK M #ˆÀN \nO #ˆÀN P #ˆÀQ \nR #ˆÀQ S #ˆÀT \nU #ˆÀT V #ˆÀW \nX #ˆÀW Y #ˆÀZ \n[ #ˆÀZ \\ #ˆÀ] \n^ #ˆÀ] _ #ˆÀ` \na #ˆÀ` b #ˆÀc \nd #ˆÀc e #ˆÀf \ng #ˆÀf h #ˆÀi \nj #ˆÀi k #ˆÀl \nm #ˆÀl n #ˆÀo \np #ˆÀo q #ˆÀr \ns #ˆÀr t #ˆÀu \nv #ˆÀu w #ˆÀx \ny #ˆÀx z #ˆÀ{ \n| #ˆÀ{ } #ˆÀ~ \n #ˆÀ~ € #ˆÀ \n‚ #ˆÀ ƒ #ˆÀ„ \n… #ˆÀ„ † #ˆÀ‡ \nˆ #ˆÀ‡ ‰ #ˆÀŠ \n‹ #ˆÀŠ Œ #ˆÀ \nÀ#ˆÀ Ž #ˆÀ \n #ˆÀ ‘ #ˆÀ’ \n“ #ˆÀ’ ” #ˆÀ• \n– #ˆÀ• — #ˆÀ˜ \n™ #ˆÀ˜ š #‡" [put apply :setf-update-fn #[(&rest args) "@ÂÃÄÅA!\"Æ!\"È		9ƒ, 	\nN‰	ƒ, Ã	\"‚2 ËÌÍ	!\"+‡" [args fnform append apply list* butlast last applyargs nil newupdater :setf-update-fn error "can't `setf' to `%s'" prin1-to-string] 5] :setf-update-doc "`apply' is a special case for `setf'" aref aset "`setf' inversion for `aref'" nth setnth "`setf' inversion for `nth'" nthcdr setnthcdr "`setf' inversion for `nthcdr'" elt setelt "`setf' inversion for `elt'" first #[(list val) "À	\nÅÆ	\"\"+‡" [0 list val newval n rplaca nthcdr] 4] "`setf' inversion for `first'" second #[(list val) "À	\nÅÆ	\"\"+‡" [1 list val newval n rplaca nthcdr] 4] "`setf' inversion for `second'" third #[(list val) "À	\nÅÆ	\"\"+‡" [2 list val newval n rplaca nthcdr] 4] "`setf' inversion for `third'" fourth #[(list val) "À	\nÅÆ	\"\"+‡" [3 list val newval n rplaca nthcdr] 4] "`setf' inversion for `fourth'" fifth #[(list val) "À	\nÅÆ	\"\"+‡" [4 list val newval n rplaca nthcdr] 4] "`setf' inversion for `fifth'" sixth #[(list val) "À	\nÅÆ	\"\"+‡" [5 list val newval n rplaca nthcdr] 4] "`setf' inversion for `sixth'" seventh #[(list val) "À	\nÅÆ	\"\"+‡" [6 list val newval n rplaca nthcdr] 4] "`setf' inversion for `seventh'" eighth #[(list val) "À	\nÅÆ	\"\"+‡" [7 list val newval n rplaca nthcdr] 4] "`setf' inversion for `eighth'" ninth #[(list val) "À	\nÅÆ	\"\"+‡" [8 list val newval n rplaca nthcdr] 4] "`setf' inversion for `ninth'" tenth #[(list val) "À	\nÅÆ	\"\"+‡" [9 list val newval n rplaca nthcdr] 4] "`setf' inversion for `tenth'" rest #[(list val) "À	\n\"‡" [setcdr list val] 3] "`setf' inversion for `rest'" car setcar "Replace the car of a cons" cdr setcdr "Replace the cdr of a cons" caar #[(list val) "À	@\n\"‡" [setcar list val] 3] "`setf' inversion for `caar'" cadr #[(list val) "À	A\n\"‡" [setcar list val] 3] "`setf' inversion for `cadr'" cdar #[(list val) "À	@\n\"‡" [setcdr list val] 3] "`setf' inversion for `cdar'" cddr #[(list val) "À	A\n\"‡" [setcdr list val] 3] "`setf' inversion for `cddr'" caaar #[(list val) "À	‰@@)\"‡" [setcar list X val] 4] "`setf' inversion for `caaar'" caadr #[(list val) "À	‰A@)\"‡" [setcar list X val] 4] "`setf' inversion for `caadr'" cadar #[(list val) "À	‰@A)\"‡" [setcar list X val] 4] "`setf' inversion for `cadar'" cdaar #[(list val) "À	‰@@)\"‡" [setcdr list X val] 4] "`setf' inversion for `cdaar'" caddr #[(list val) "À	‰AA)\"‡" [setcar list X val] 4] "`setf' inversion for `caddr'" cdadr #[(list val) "À	‰A@)\"‡" [setcdr list X val] 4] "`setf' inversion for `cdadr'" cddar #[(list val) "À	‰@A)\"‡" [setcdr list X val] 4] "`setf' inversion for `cddar'" cdddr #[(list val) "À	‰AA)\"‡" [setcdr list X val] 4] "`setf' inversion for `cdddr'" caaaar #[(list val) "À	‰@@@)\"‡" [setcar list X val] 4] "`setf' inversion for `caaaar'" caaadr #[(list val) "À	‰A@@)\"‡" [setcar list X val] 4] "`setf' inversion for `caaadr'" caadar #[(list val) "À	‰@A@)\"‡" [setcar list X val] 4] "`setf' inversion for `caadar'" cadaar #[(list val) "À	‰@@A)\"‡" [setcar list X val] 4] "`setf' inversion for `cadaar'" cdaaar #[(list val) "À	‰@@)\"‡" [setcdr list X val] 4] "`setf' inversion for `cdaaar'" caaddr #[(list val) "À	‰AA@)\"‡" [setcar list X val] 4] "`setf' inversion for `caaddr'" cadadr #[(list val) "À	‰A@A)\"‡" [setcar list X val] 4] "`setf' inversion for `cadadr'" cdaadr #[(list val) "À	‰A@@)\"‡" [setcdr list X val] 4] "`setf' inversion for `cdaadr'" caddar #[(list val) "À	‰@AA)\"‡" [setcar list X val] 4] "`setf' inversion for `caddar'" cdadar #[(list val) "À	‰@A@)\"‡" [setcdr list X val] 4] "`setf' inversion for `cdadar'" cddaar #[(list val) "À	‰@@A)\"‡" [setcdr list X val] 4] "`setf' inversion for `cddaar'" cadddr #[(list val) "À	‰AAA)\"‡" [setcar list X val] 4] "`setf' inversion for `cadddr'" cddadr #[(list val) "À	‰A@A)\"‡" [setcdr list X val] 4] "`setf' inversion for `cddadr'" cdaddr #[(list val) "À	‰AA@)\"‡" [setcdr list X val] 4] "`setf' inversion for `cdaddr'" cdddar #[(list val) "À	‰@AA)\"‡" [setcdr list X val] 4] "`setf' inversion for `cdddar'" cddddr #[(list val) "À	‰AA)\"‡" [setcdr list X val] 4] "`setf' inversion for `cddddr'" get "`setf' inversion for `get' is `put'" symbol-function fset "`setf' inversion for `symbol-function' is `fset'" symbol-plist setplist "`setf' inversion for `symbol-plist' is `setplist'" symbol-value set "`setf' inversion for `symbol-value' is `set'" point goto-char "To set (point) to N, use (goto-char N)"] 4)
(defalias 'incf '(macro . #[(ref &optional delta) "„ ÁÂÄEE‡" [delta 1 setf ref +] 5 "\
(incf REF [DELTA]) -> increment the g.v. REF by DELTA (default 1)"]))
(defalias 'decf '(macro . #[(ref &optional delta) "„ ÁÂÄEE‡" [delta 1 setf ref -] 5 "\
(decf REF [DELTA]) -> decrement the g.v. REF by DELTA (default 1)"]))
(defalias 'push '(macro . #[(item ref) "À	Â	EE‡" [setf ref cons item] 5 "\
(push ITEM REF) -> cons ITEM at the head of the g.v. REF (a list)"]))
(defalias 'pushnew '(macro . #[(item ref) "À	Â	EE‡" [setf ref adjoin item] 5 "\
(pushnew ITEM REF): adjoin ITEM at the head of the g.v. REF (a list)"]))
(defalias 'pop '(macro . #[(ref) "À Â	DCÄÅ	DÆÇ	DEEE)‡" [gensym listname let ref prog1 car setf cdr] 8 "\
(pop REF) -> (prog1 (car REF) (setf REF (cdr REF)))"]))
(defalias 'psetf '(macro . #[(&rest body) "GÂ	Ã\"ÄU„ ÅÆ	\"‚g „ Ç‚g ÈÇ‰É!\n\nƒc \n@\n‰A@)\n‰AA)\n„S ÏE‚_ ÏÈEE*‚% *E)‡" [body length % 2 0 error "psetf needs an even number of arguments, %d given" nil prog1 reverse bodyforms setfs value X place setf] 8 "\
(psetf {var value }...) => nil
Like setf, but all the values are computed before any assignment is made."]))
(defalias 'shiftf '(macro . #[(&rest forms) "GÁV„ ÂÃ!ˆÄ!Å!@È	Ê ‰Ì!Lˆ	ƒ0 Í!‚= Á	JCÍ!)‰A@@ÒÓÔÕAC\"\"B@F-‡" [forms 1 error "`shiftf' needs more than one argument" butlast last newvalue places nil *mvalues-count* gensym it pair-with-newsyms copy-sequence *mvalues-values* T$$_12 newsyms bindings let setf zip-lists append] 9 "\
(shiftf PLACE1 PLACE2... NEWVALUE)
Set PLACE1 to PLACE2, PLACE2 to PLACE3...
Each PLACE is set to the old value of the following PLACE,
and the last PLACE is set to the value NEWVALUE.  
Returns the old value of PLACE1."]))
(defalias 'rotatef '(macro . #[(&rest places) "??…H ÁÃ ‰Å!Lˆ\nƒ Æ!‚' ÈJCÆ!)‰	A@\n	@ÌÍÎÏ\nA\n@C\"\"BÁF+‡" [places nil *mvalues-count* gensym it pair-with-newsyms copy-sequence *mvalues-values* 1 T$$_13 newsyms bindings let setf zip-lists append] 9 "\
(rotatef PLACE...) sets each PLACE to the old value of the following PLACE.
The last PLACE is set to the old value of the first PLACE.
Thus, the values rotate through the PLACEs.  Returns nil."]))
(defalias 'getf #[(place indicator &optional default) "ƒ @	=„ AA‰„ ƒ A@‡\n‡" [place indicator default] 3 "\
Return PLACE's PROPNAME property, or DEFAULT if not present."])
(defalias 'getf$setf$method '(macro . #[(place indicator default &rest newval) "G‰Â=ƒ Ä‚  	Å=ƒ @‚  ÆÇ!ˆ)È È È 	\nÌÍD\nD	DEÐÑÒÓÔD\nEDEÕÖ‰DDEE×ØÖD	EÙÚÌ\nEEEF	%+‡" [newval T$$_14 0 default nil 1 error "Wrong number of arguments to (setf (getf ...)) form" gentemp vsym isym psym list let place indicator while and not eq car setq cdr if setcar setf nconc] 15 "\
SETF method for GETF.  Not for public use."]))
(byte-code "ÀÁ\nÃ#ˆÀÁÅ#‡" [put getf :setf-update-fn getf$setf$method :setf-update-doc nil] 4)
(defalias 'remf '(macro . #[(place indicator) "À À Ã\nD	DDÆÇ	È\nDEÉÊ‰\nDDEËEËÌ\nÊ\nDEÍÎÊ\nDÏÇÈÊ\nDD	EDEÌ\nÊ‰\nDDEEÆÊ\nDÐ\nÊ‰‰\nDDDEËEDFEE*‡" [gentemp isym psym let place indicator cond eq car setf cdr t setq while and not setcdr] 15 "\
Remove from the property list at PLACE its PROPNAME property.
Returns non-nil if and only if the property existed."]))
(defalias 'remprop #[(symbol indicator) "À	!\n@=ƒ Å	AA\"ˆÆ‚> A‰Aƒ0 A@=„0 AA‰‚ A…> Ç‰AAA\"ˆÆ*‡" [symbol-plist symbol indicator T$$_16 T$$_15 setplist t setcdr] 4 "\
Remove SYMBOL's PROPNAME property, returning non-nil if it was present."])
(defconst :include (quote :include) "\
Syntax of `defstruct'")
(defconst :named (quote :named) "\
Syntax of `defstruct'")
(defconst :conc-name (quote :conc-name) "\
Syntax of `defstruct'")
(defconst :copier (quote :copier) "\
Syntax of `defstruct'")
(defconst :predicate (quote :predicate) "\
Syntax of `defstruct'")
(defconst :print-function (quote :print-function) "\
Syntax of `defstruct'")
(defconst :type (quote :type) "\
Syntax of `defstruct'")
(defconst :initial-offset (quote :initial-offset) "\
Syntax of `defstruct'")
(defconst :structure-doc (quote :structure-doc) "\
Documentation string for a structure.")
(defconst :structure-slotsn (quote :structure-slotsn) "\
Number of slots in structure")
(defconst :structure-slots (quote :structure-slots) "\
List of the slot's names")
(defconst :structure-indices (quote :structure-indices) "\
List of (KEYWORD-NAME . INDEX)")
(defconst :structure-initforms (quote :structure-initforms) "\
List of (KEYWORD-NAME . INITFORM)")
(defconst :structure-includes (quote :structure-includes) "\
() or list of a symbol, that this struct includes")
(defconst :structure-included-in (quote :structure-included-in) "\
List of the structs that include this")
(defalias 'defstruct '(macro . #[(&rest args) "ÀÂ ‰Ä!Lˆ	ƒ Æ!‚! ÈJCÆ!)	Ê	8Ì	8Î	8Ð	8	A@	@ÀÂ ‰Ô#Lˆ	ƒb Æ!‚m ÈJCÆ!)Ö8Ø8Ê8Ì8Î8Ð8A@@à!ƒÄ áVƒÄ \\â\"â\"áV„Ó ãäå!\"ˆæ!‰'ƒå ãèå'!\"ˆ)é\"À‰‰‰‰‰*+,-./âðñòD3FñòD4FñòD5òDFñòD6òDFñòD7òø!DF%ƒañòD9òDFúòDûò@D<EED‚Â =þ=ÿûòD9EDDC@ =ñ=<A òDâû=<EÀEEFEE)ñòD9ÀFDÂ =þ=ûòD<EDC@ =B C òDå=DFEE)C#/D òDE F G ÅDH òDÅEEDED òDE ÆDEÂ ID òDE F J CK L J DþIM J áEDCN K O IòDEP Q J DTEER IûòD<EEEEEEDE)E.ÀÂ ‰S %Lˆ	ƒxÆ!‚ƒÈJCÆ!)TÐT8-TA@+T@,)U V W B\"BC*X Y /.-,+*&.B‡" [nil *mvalues-count* gensym it parse$defstruct$args args copy-sequence *mvalues-values* 1 T$$_17 5 initlist 4 slots 3 slotsn 2 docstring options name parse$defstruct$options T$$_18 7 included 6 moreinits moreslots moreslotsn predicate copier constructor conc-name numberp 0 append error "%s needs at least one slot" prin1-to-string duplicate-symbols-p dups "`%s' are duplicates" simplify$inits returned alterators accessors keywords functions properties list put quote :structure-doc :structure-slotsn :structure-slots :structure-initforms :structure-indices extract$indices :structure-includes pushnew get :structure-included-in old let car when delq message "`%s' redefined.  Should redefine `%s'?" fset function lambda &rest make$structure$instance typetag thing and vectorp elt or eq = length memq build$accessors$for T$$_19 vector mapcar #[(x) "À	D‡" [quote x] 2] progn nconc] 19 "\
(defstruct NAME [DOC-STRING] . SLOTS)  define NAME as structure type.
NAME must be a symbol, the name of the new structure.  It could also
be a list (NAME . OPTIONS).  

Each option is either a symbol, or a list of a keyword symbol taken from the
list {:conc-name, :copier, :constructor, :predicate, :include,
:print-function, :type, :initial-offset}.  The meanings of these are as in
CLtL, except that no BOA-constructors are provided, and the options
{:print-fuction, :type, :initial-offset} are ignored quietly.  All these
structs are named, in the sense that their names can be used for type
discrimination.

The DOC-STRING is established as the `structure-doc' property of NAME.

The SLOTS are one or more of the following:
SYMBOL -- meaning the SYMBOL is the name of a SLOT of NAME
list of SYMBOL and VALUE -- meaning that VALUE is the initial value of
the slot.
`defstruct' defines functions `make-NAME', `NAME-p', `copy-NAME' for the
structure, and functions with the same name as the slots to access
them.  `setf' of the accessors sets their values."]))
(defalias 'parse$defstruct$args #[(args) "À‰ÁÀÂÀ‰	\n@9ƒ$ \n@	À‚R \n@<ƒN \n‰@@)9ƒN \n‰@@)	\n‰@A)‚R ÌÍ!ˆ\nA‰@;ƒg @AÀÏ ‰Ñ!Lˆƒ Ò!‚Ž ÔJCÒ!)Ö8A@@×	&.‡" [nil "" 0 initlist slots slotsn slotargs docstring options name args X error "first arg to `defstruct' must be symbol or (symbol ...)" *mvalues-count* gensym it process$slots copy-sequence *mvalues-values* 1 T$$_20 2 values] 8 "\
(parse$defstruct$args ARGS) => NAME OPTIONS DOCSTRING SLOTSN SLOTS INITLIST
NAME=symbol, OPTIONS=list of, DOCSTRING=string, SLOTSN=count of slots,
SLOTS=list of their names, INITLIST=alist (keyword . initform)."])
(defalias 'process$slots #[(slots) "GÁ‰‰@‰<ƒ ?‚\" ÈÉÊ!\")„• 9ƒI BË!Á\n‰B+B‚‹ <ƒƒ @9ƒƒ @‰A@)‰BË!\n‰B+B*‚‹ ÈÒÊ!\"ˆA‰@‚ *ÓÔ!Ô\n!#+‡" [slots nil initlist slotslist slotsn ptr this x error "endp received a non-cons, non-null argument `%s'" prin1-to-string keyword-of alist item key X form name "slot should be symbol or (symbol ...), not `%s'" values nreverse] 6 "\
(process$slots SLOTS) => SLOTSN SLOTSLIST INITLIST
Converts a list of symbols or lists of symbol and form into the last 3
values returned by PARSE$DEFSTRUCT$ARGS."])
(defalias 'parse$defstruct$options #[(name options slots) "À	!‰ÃPÅÆ\nP!ÅÈ\nP!	Å\nÊP!ÌÎÎÎÎÎÎÎÎÎÎƒ2@AÛ!ƒn ‰Ý=„j Þßà!\"ˆ)‚B <ƒ'Û@‰!ƒ'‰!A@)AA‰\"ã=ƒ¸ ;ƒ¤ ‚´ „­ ä‚´ Þåà!\"‚#\"æ=ƒÛ 9ƒÏ „Ï ‚Ö Þßà!\"	‚#\"ç=ƒþ 9ƒò „ò ‚ù Þßà!\"‚#\"è=ƒ!9ƒ„‚Þßà!\"‚#\"é=ƒ9„6Þêà!\"ˆ+N,N-Nî!ƒYÌV„aÞïà!\"ˆƒsÞð	@$ˆ‚zBÎ1ò ‰3ô!Lˆ1ƒ”õ6!‚¡÷13JC6õ6!)8ù88:8A@;8@‰<ÌVƒóÎ;=>=ƒè=@>=A=>>„ÂÞÿà>!à!#ˆ‚Â*@ :\"\\@ \"@ \",‚#\"A >„#Þßà!\"ˆ)‚B Þßà!\"ˆ‚B *B 	&.‡" [symbol-name name namestring "-" conc-name intern "make-" const "copy-" copier "-p" pred 0 moreslotsn nil moreslots moreinits option-head option-second option-rest these-slotsn these-slots these-inits included options T$$_21 option keywordp T$$_22 :named error "can't recognize option `%s'" prin1-to-string x T$$_23 :conc-name "" "`%s' is invalid as `conc-name'" :copier :constructor :predicate :include "arg to `:include' should be a symbol, not `%s'" :structure-slotsn :structure-slots :structure-initforms numberp "`%s' is not a valid structure" "`%s' already includes `%s', can't include `%s' too" *mvalues-count* gensym it process$slots copy-sequence *mvalues-values* 1 T$$_24 2 xtra-inits xtra-slots xtra-slotsn T$$_25 xslot "`%s' is not a slot of `%s'" append (:print-function :type :initial-offset) values] 10 "\
(parse$defstruct$options name OPTIONS SLOTS) => many values
A defstruct named NAME, with options list OPTIONS, has already slots SLOTS.
Parse the OPTIONS and return the updated form of the struct's slots and other
information.  The values returned are:

   CONC-NAME is the string to use as prefix/suffix in the methods,
   CONST is the name of the official constructor,
   COPIER is the name of the structure copier,
   PRED is the name of the type predicate,
   MORESLOTSN is the number of slots added by :include,
   MORESLOTS is the list of slots added by :include,
   MOREINITS is the list of initialization forms added by :include,
   INCLUDED is nil, or the list of the symbol added by :include"])
(defalias 'simplify$inits #[(slots initlist) "À‰Àƒ/ @AÆ!‰Ç	\"A\n	\n‰\nB	+B‚ *Ë\n!*‡" [nil key result slots T$$_26 slot keyword-of assoc initlist alist item nreverse] 5 "\
(simplify$inits SLOTS INITLIST) => new INITLIST
Removes from INITLIST - an ALIST - any shadowed bindings."])
(defalias 'extract$indices #[(initlist) "ÀÁÀƒ/ @A@\n‰	B+B\nÊ\\‚	 ÀË!,‡" [nil 0 index result initlist T$$_27 entry alist item key 1 nreverse] 4 "\
(extract$indices INITLIST) => indices list
Kludge.  From a list of pairs (keyword . form) build a list of pairs
of the form (keyword . position in list from 0).  Useful to precompute
some of the work of MAKE$STRUCTURE$INSTANCE."])
(defalias 'build$accessors$for #[(name conc-name predicate slots slotsn) "ÀÁ‰‰Â‰Y„‡ É\nË8!P!ÍÎDÏÐÑCÒÑDÔÑTEDÕÖ×ØÑDØÎDDFDEEDEBÚÐÑÛDÒÑDÜÑTÛFDÕÖÝØÑDØÎDDFDEEEBÞß8!DBT‰‚ àá!á!á!#-‡" [0 nil "" canonic keywords alterators accessors i slotsn intern conc-name symbol-name slots fset quote function lambda object cond predicate aref t error "`%s' is not a struct %s" prin1-to-string name defsetf newval aset "`%s' not a `%s'" defkeyword keyword-of values nreverse] 15 "\
(build$accessors$for NAME PREDICATE SLOTS SLOTSN) => FSETS DEFSETFS KWDS
Generate the code for accesors and defsetfs of a structure called
NAME, whose slots are SLOTS.  Also, establishes the keywords for the
slots names."])
(defalias 'make$structure$instance #[(name args) "9„ ÁÂÃ!\"ˆNNNÇ‰	\nÍ!ƒ0 ÎV„7 ÁÏÃ!\"ˆGÒÓ\"ÎU)„O ÁÔÃ!\"ˆÇÖ ‰Ø!Lˆƒi Ù!‚v ÛJCÙ!)‰A@@ßà\"„“ ÁáÃ!\"ˆÇ\"#\"ƒÃ \"@#\"A\"Íä#\n\"A!„š ÁåÃ#!Ã!#ˆ‚š *æ‰'@(Ç)'‰*<ƒá *?‚è ÁëÃ*!\")„ì(D)B)'A‰'@(‚Ò í)!+Ù!#	\n‰'‰.@@)/Ç)'‰*<ƒ,*?‚3ÁëÃ*!\")„Vðä/	\"A!)B)'A‰'‰.@@)/‚í)!+ñòB\".‡" [name error "`%s' is not a possible name for a structure" prin1-to-string :structure-initforms :structure-slotsn :structure-indices nil initializers initalist indices slotsn initforms numberp 0 "`%s' is not a defined structure" args number % 2 "slot initializers `%s' not of even length" *mvalues-count* gensym it unzip-list copy-sequence *mvalues-values* 1 T$$_28 specvals speckwds every keywordp "all of the names in `%s' should be keywords" T$$_29 kwd assoc "`%s' is not a valid slot name for %s" pairlis ptr val result x "endp received a non-cons, non-null argument `%s'" quote nreverse X key eval apply vector] 7 "\
(make$structure$instance NAME ARGS) => new struct NAME
A struct of type NAME is created, some slots might be initialized
according to ARGS (the &rest argument of MAKE-name)."])
(defvar - nil "\
form currently under evaluation")
(defvar + nil "\
previous -")
(defvar ++ nil "\
previous +")
(defvar +++ nil "\
previous ++")
(defvar / nil "\
list of values returned by +")
(defvar // nil "\
list of values returned by ++")
(defvar /// nil "\
list of values returned by +++")
(defvar * nil "\
(first) value of +")
(defvar ** nil "\
(first) value of ++")
(defvar *** nil "\
(first) value of +++")
(defalias 'cl-eval-print-last-sexp #[nil "ÀÀÃÄÅ ÇŽŠÈ	!ˆÊË!ˆ`+`\"!@Ð!\n	ƒO \n@=„X ×p\"ˆ‚n „d Øp!ˆ‚n Øp!ˆÙÚ\"ˆÀÀ‰‡" [nil *mvalues-count* *mvalues-values* read-from-string buffer-substring syntax-table stab ((set-syntax-table stab)) set-syntax-table emacs-lisp-mode-syntax-table forward-sexp -1 - ** *** * eval // /// / ++ +++ + print terpri mapcar #[(value) "À	p\"ˆÂp!‡" [prin1 value terpri] 3]] 4 "\
Evaluate sexp before point; print value(s) into current buffer.
If the evaled form returns multiple values, they are shown one to a line.
The variables -, +, ++, +++, *, **, ***, /, //, /// have their usual meaning.

It clears the multiple-value passing mechanism, and does not pass back
multiple values.  Use this only if you are debugging cl.el and understand well
how the multiple-value stuff works, because it can be fooled into believing
that multiple values have been returned when they actually haven't, for
instance 
    (identity (values nil 1))
However, even when this fails, you can trust the first printed value to be
(one of) the returned value(s)." nil])
(defalias 'mapc #[(function list) "‰ƒ \n	@!ˆ	A‰„ )‡" [list args function] 3 "\
(MAPC FUNCTION LIST) => LIST
Apply FUNCTION to each element of LIST, return LIST.
Like mapcar, but called only for effect."])
(defalias 'maplist #[(function list) "Á‰‰ƒ !BA‰„\n Æ!+‡" [list nil quote results args function nreverse] 4 "\
(MAPLIST FUNCTION LIST) => list'ed results of FUNCTION on cdrs of LIST
Apply FUNCTION to successive sublists of LIST, return the list of the results"])
(defalias 'mapl #[(function list) "‰ƒ \n	!ˆ	A‰„ )‡" [list args function] 3 "\
(MAPL FUNCTION LIST) => LIST
Apply FUNCTION to successive cdrs of LIST, return LIST.
Like maplist, but called only for effect."])
(defalias 'mapcan #[(function list) "Á‰ƒ Ä@!\n\"A‰„ Æ\n!*‡" [list nil results args nconc function nreverse] 4 "\
(MAPCAN FUNCTION LIST) => nconc'd results of FUNCTION on LIST
Apply FUNCTION to each element of LIST, nconc the results.
Beware: nconc destroys its first argument!  See copy-list."])
(defalias 'mapcon #[(function list) "Á‰ƒ Ä!\n\"A‰„ Æ\n!*‡" [list nil results args nconc function nreverse] 4 "\
(MAPCON FUNCTION LIST) => nconc'd results of FUNCTION on cdrs of LIST
Apply FUNCTION to successive sublists of LIST, nconc the results.
Beware: nconc destroys its first argument!  See copy-list."])
(defalias 'copy-list #[(list) "À	Â\"‡" [append list nil] 3 "\
Build a copy of LIST"])
(put (quote copy-list) (quote byte-optimizer) (quote byte-compile-inline-expand))
(defalias 'copy-tree #[(tree) ":ƒ Á@!ÁA!B‡‡" [tree copy-tree] 3 "\
Build a copy of the tree of conses TREE
The argument is a tree of conses, it is recursively copied down to
non conses.  Circularity and sharing of substructure are not
necessarily preserved."])
(defalias 'revappend #[(x y) "‰<ƒ ?‚ ÁÂÃ!\")ƒ ‡ÅA@B\"‡" [x error "endp received a non-cons, non-null argument `%s'" prin1-to-string y revappend] 5 "\
does what (append (reverse X) Y) would, only faster"])
(defalias 'nreconc #[(x y) "‰<ƒ ?‚ ÁÂÃ!\")ƒ ‡ÅAÆ\"ˆ\"‡" [x error "endp received a non-cons, non-null argument `%s'" prin1-to-string y nreconc rplacd] 7 "\
does (nconc (nreverse X) Y) would, only faster
Destructive on X, be careful."])
(defalias 'nbutlast #[(list &optional n) "„ ÁÂ!‰„ ‚% Wƒ Å‚% ÆZÅ#ˆ)‡" [n 1 list-length list length nil setnthcdr] 5 "\
Side-effected LIST truncated N+1 conses from the end.
This is the destructive version of BUTLAST.  Returns () and does not
modify the LIST argument if the length of the list is not at least N."])
(defalias 'subst #[(new old tree) "À	Â#‡" [subst-if new #[(x) "	=‡" [x old] 2] tree] 4 "\
NEW replaces OLD in a copy of TREE
Uses eql for the test."])
(defalias 'subst-if-not #[(new test tree) "	!„ \n‡	:„ 	‡Ã\n	@#Ã\n	A#‰	@=ƒ/ 	A=ƒ/ 	‚2 B*‡" [test tree new subst-if-not tail head] 6 "\
NEW replaces any subtree or leaf that fails TEST in a copy of TREE"])
(defalias 'subst-if #[(new test tree) "	!ƒ \n‡	:„ 	‡Ã\n	@#Ã\n	A#‰	@=ƒ/ 	A=ƒ/ 	‚2 B*‡" [test tree new subst-if tail head] 6 "\
NEW replaces any subtree or leaf that satisfies TEST in a copy of TREE"])
(defalias 'sublis #[(alist tree) "À	\n\"‰ƒ A‚; 	:„ 	‚; Ä\n	@\"Ä\n	A\"‰	@=ƒ6 	A=ƒ6 	‚: B*)‡" [assoc tree alist toplevel sublis tail head] 5 "\
Use association list ALIST to modify a copy of TREE
If a subtree or leaf of TREE is a key in ALIST, it is replaced by the
associated value.  Not exactly Common Lisp, but close in spirit and
compatible with the native Emacs Lisp ASSOC, which uses EQUAL."])
(defalias 'member-if #[(predicate list) "ÀÁ‡" [found-member-if (byte-code "‰<ƒ 	?‚ ÂÃÄ	!\")„, @!ƒ% ÆÇ\"ˆ‚  A‰‚ È‡" [list x error "endp received a non-cons, non-null argument `%s'" prin1-to-string predicate throw found-member-if nil] 5)] 2 "\
PREDICATE is applied to the members of LIST.  As soon as one of them
returns true, that tail of the list if returned.  Else NIL."])
(defalias 'member-if-not #[(predicate list) "ÀÁ‡" [found-member-if-not (byte-code "‰<ƒ 	?‚ ÂÃÄ	!\")„, @!ƒ$ A‰‚ ÆÇ\"ˆ‚  È‡" [list x error "endp received a non-cons, non-null argument `%s'" prin1-to-string predicate throw found-member-if-not nil] 5)] 2 "\
PREDICATE is applied to the members of LIST.  As soon as one of them
returns false, that tail of the list if returned.  Else NIL."])
(defalias 'tailp #[(sublist list) "ÀÁ‡" [tailp-found (byte-code "‰<ƒ 	?‚ ÂÃÄ	!\")„+ =ƒ$ ÆÇÈ\"ˆ‚  A‰‚ É‡" [list x error "endp received a non-cons, non-null argument `%s'" prin1-to-string sublist throw tailp-found t nil] 5)] 2 "\
(tailp SUBLIST LIST) => True if SUBLIST is a sublist of LIST."])
(defmacro declare (&rest decls) "\
Ignore a Common-Lisp declaration." "declarations are ignored in this implementation")
(defun proclaim (&rest decls) "\
Ignore a Common-Lisp proclamation." "declarations are ignored in this implementation")
(defmacro the (type form) "\
(the TYPE FORM) macroexpands to FORM
No checking is even attempted.  This is just for compatibility with
Common-Lisp codes." form)
(put (quote progv) (quote common-lisp-indent-hook) (quote (4 4 &body)))
(defalias 'progv '(macro . #[(vars vals &rest body) "À	\nÃÄÅ\"DF‡" [progv$runtime vars vals function append (lambda nil) body] 7 "\
progv vars vals &body forms
bind vars to vals then execute forms.
If there are more vars than vals, the extra vars are unbound, if
there are more vals than vars, the extra vals are just ignored."]))
(byte-code "ÀÁMˆÂÃ!‡" [progv$runtime #[(vars vals body) "ÀÁ‰‰‰<ƒ ?‚  ÉÊË!\")„M @Ì@DDB„? ÍÌ@DD\nBAA‰‚ *ÎÏC\nÐÌDDC$*!‡" [eval nil unbind-forms vars-n-vals vars vals l r x error "endp received a non-cons, non-null argument `%s'" prin1-to-string quote makunbound append (let) funcall body] 9] provide cl] 2)