HOME

;ELC
;;; Compiled
;;; in Emacs version 26.1
;;; with all optimizations.

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

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

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


#@1333 Tell the byte-compiler that function FN is defined, in FILE.
The FILE argument is not used by the byte-compiler, but by the
`check-declare' package, which checks that FILE contains a
definition for FN.

FILE can be either a Lisp file (in which case the ".el"
extension is optional), or a C file.  C files are expanded
relative to the Emacs "src/" directory.  Lisp files are
searched for using `locate-library', and if that fails they are
expanded relative to the location of the file containing the
declaration.  A FILE with an "ext:" prefix is an external file.
`check-declare' will check such files if they are found, and skip
them without error if they are not.

Optional ARGLIST specifies FN's arguments, or is t to not specify
FN's arguments.  An omitted ARGLIST defaults to t, not nil: a nil
ARGLIST specifies an empty argument list, and an explicit t
ARGLIST is a placeholder that allows supplying a later arg.

Optional FILEONLY non-nil means that `check-declare' will check
only that FILE exists, not that it defines FN.  This is intended
for function definitions that `check-declare' does not recognize,
e.g., `defstruct'.

Note that for the purposes of `check-declare', this statement
must be the first non-whitespace on a line.

For more information, see Info node `(elisp)Declaring Functions'.

(fn FN FILE &rest ARGS)
(defalias 'declare-function '(macro . #[642 "\300\207" [nil] 4 (#$ . 410)]))
(byte-code "\300\301\302\303#\210\304\305\306\"\210\304\307\310\"\207" [set-advertised-calling-convention declare-function (fn file &optional arglist fileonly) nil defalias not null sxhash sxhash-equal] 4)
#@93 Evaluate FORM, expecting it not to return.
If FORM does return, signal an error.

(fn FORM)
(defalias 'noreturn '(macro . #[257 "\300
\301BB\207" [prog1 ((error "Form marked with `noreturn' did return"))] 4 (#$ . 2031)]))
(put 'noreturn 'edebug-form-spec t)
#@193 Evaluate FORM, expecting a constant return value.
This is the global do-nothing version.  There is also `testcover-1value'
that complains if FORM ever does return differing values.

(fn FORM)
(defalias '1value '(macro . #[257 "\207" [] 2 (#$ . 2296)]))
(put '1value 'edebug-form-spec t)
#@378 Set the `edebug-form-spec' property of SYMBOL according to SPEC.
Both SYMBOL and SPEC are unevaluated.  The SPEC can be:
0 (instrument no arguments); t (instrument all arguments);
a symbol (naming a function with an Edebug specification); or a list.
The elements of the list describe the argument types; see
Info node `(elisp)Specification List' for details.

(fn SYMBOL SPEC)
(defalias 'def-edebug-spec '(macro . #[514 "\300\301D\302\301DF\207" [put quote 'edebug-form-spec] 7 (#$ . 2590)]))
#@748 Return a lambda expression.
A call of the form (lambda ARGS DOCSTRING INTERACTIVE BODY) is
self-quoting; the result of evaluating the lambda expression is the
expression itself.  The lambda expression may then be treated as a
function, i.e., stored as the function value of a symbol, passed to
`funcall' or `mapcar', etc.

ARGS should take the same form as an argument list for a `defun'.
DOCSTRING is an optional documentation string.
 If present, it should describe how to call the function.
 But documentation strings are usually not useful in nameless functions.
INTERACTIVE should be a call to the function `interactive', which see.
It may also be omitted.
BODY should be a list of Lisp expressions.

(fn ARGS [DOCSTRING] [INTERACTIVE] BODY)
(defalias 'lambda '(macro . #[128 "\300\301BD\207" [function lambda] 4 (#$ . 3092)]))
(byte-code "\300\301\302\303#\300\301\304\305#\306\301\307\310#\207" [function-put lambda doc-string-elt 2 lisp-indent-function defun put edebug-form-spec (&define lambda-list lambda-doc [&optional ("interactive" interactive)] def-body)] 6)
#@64 Set variable VAR to value VAL in current buffer.

(fn VAR VAL)
(defalias 'setq-local '(macro . #[514 "\300\301\302DDE\207" [set make-local-variable quote] 6 (#$ . 4173)]))
(put 'setq-local 'edebug-form-spec '(symbolp form))
#@203 Define VAR as a buffer-local variable with default value VAL.
Like `defvar' but additionally marks the variable as being automatically
buffer-local wherever it is set.

(fn VAR VAL &optional DOCSTRING)
(defalias 'defvar-local '(macro . #[770 "\300\301F\302\303DDE\207" [progn defvar make-variable-buffer-local quote] 8 (#$ . 4406)]))
(byte-code "\300\301\302\303#\210\304\301\305\306#\300\207" [put defvar-local edebug-form-spec defvar function-put doc-string-elt 3] 4)
#@206 Add NEWELT to the list stored in the generalized variable PLACE.
This is morally equivalent to (setf PLACE (cons NEWELT PLACE)),
except that PLACE is only evaluated once (after NEWELT).

(fn NEWELT PLACE)
(defalias 'push '(macro . #[514 "\2119\203
\300
\301EE\207\302\303!\210
\304
!\203\211\202\305\306!\307\310\311\312\313\314!\315\"\316\317%\"
=\2039\211\202@\320DC\"\207" [setq cons require macroexp macroexp-copyable-p make-symbol "v" gv-get make-byte-code 514 "\211\301\300E!\207" vconcat vector [cons] 6 "\n\n(fn GETTER SETTER)" macroexp-let*] 12 (#$ . 4888)]))
(put 'push 'edebug-form-spec '(form gv-place))
#@223 Return the first element of PLACE's value, and remove it from the list.
PLACE must be a generalized variable whose value is a list.
If the value is nil, `pop' returns nil but does not actually
change the list.

(fn PLACE)
(defalias 'pop '(macro . #[257 "\300
9\203\301\302\303DEE\202\304\305\"D\207" [car-safe prog1 setq cdr gv-get #[514 "
\300
!\203\211\202\301\302!\303
\304D!E
=\203 \211\202'\305DC\"\207" [macroexp-copyable-p make-symbol "x" prog1 cdr macroexp-let*] 9 "\n\n(fn GETTER SETTER)"]] 8 (#$ . 5528)]))
(put 'pop 'edebug-form-spec '(gv-place))
#@181 If COND yields non-nil, do BODY, else return nil.
When COND yields non-nil, eval BODY forms sequentially and return
value of last one, or nil if there are none.

(fn COND BODY...)
(defalias 'when '(macro . #[385 "\300\301BE\207" [if progn] 6 (#$ . 6114)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put when lisp-indent-function 1 put edebug-form-spec t] 5)
#@173 If COND yields nil, do BODY, else return nil.
When COND yields nil, eval BODY forms sequentially and return
value of last one, or nil if there are none.

(fn COND BODY...)
(defalias 'unless '(macro . #[385 "\300\301BBB\207" [if nil] 6 (#$ . 6501)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put unless lisp-indent-function 1 put edebug-form-spec t] 5)
#@169 Loop over a list.
Evaluate BODY with VAR bound to each car from LIST, in turn.
Then evaluate RESULT to get return value, default nil.

(fn (VAR LIST [RESULT]) BODY...)
(defalias 'dolist '(macro . #[385 "
:\204\f\301\302\303D\"\210\304\305G\306#\204\301\307\310GD\"\210\311\203N\312
A@DC\313\312@\314DDC\315\316	\317DEC\"BBEAABBB\202\207\312
A@D@D\313\316@\314DE\315\316\317\nDEC\"BBBAA\205\204\316@\320BBAABBBB\207" [lexical-binding signal wrong-type-argument consp <= 2 3 wrong-number-of-arguments (2 . 3) --dolist-tail-- let while car append setq cdr (nil)] 15 (#$ . 6883)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put dolist lisp-indent-function 1 put edebug-form-spec ((symbolp form &optional form) body)] 5)
#@242 Loop a certain number of times.
Evaluate BODY with VAR bound to successive integers running from 0,
inclusive, to COUNT, exclusive.  Then evaluate RESULT to get
the return value (nil if RESULT is omitted).

(fn (VAR COUNT [RESULT]) BODY...)
(defalias 'dotimes '(macro . #[385 "\301\302A@\203J\303\304DDD\305\306E\304\n@DC\nBB\307\310DEFAA\205B\304	@DC\nAABBCBBB\262
\202t\304D@DD\305\306@E\311\307@\310
@DEC\"BBAABBB\207" [lexical-binding --dotimes-limit-- 0 --dotimes-counter-- let while < setq 1+ append] 15 (#$ . 7665)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put dotimes lisp-indent-function 1 put edebug-form-spec dolist] 5)
#@477 Do not evaluate any arguments, and return nil.
If a `declare' form appears as the first form in the body of a
`defun' or `defmacro' form, SPECS specifies various additional
information about the function or macro; these go into effect
during the evaluation of the `defun' or `defmacro' form.

The possible values of SPECS are specified by
`defun-declarations-alist' and `macro-declarations-alist'.

For more information, see info node `(elisp)Declare Form'.

(fn &rest SPECS)
(defalias 'declare '(macro . #[128 "\300\207" [nil] 2 (#$ . 8367)]))
#@200 Execute BODY; if an error occurs, return nil.
Otherwise, return result of last form in BODY.
See also `with-demoted-errors' that does something similar
without silencing all errors.

(fn &rest BODY)
(defalias 'ignore-errors '(macro . #[128 "\300\301\302B\303BBB\207" [condition-case nil progn ((error nil))] 5 (#$ . 8919)]))
(byte-code "\300\301\302\303#\210\304\301\305\306#\300\207" [put ignore-errors edebug-form-spec t function-put lisp-indent-function 0] 4)
#@75 Number used to construct the name of the next symbol created by `gensym'.
(defvar gensym-counter 0 (#$ . 9389))
#@155 Return a new uninterned symbol.
The name is made by appending `gensym-counter' to PREFIX.
PREFIX is a string, and defaults to "g".

(fn &optional PREFIX)
(defalias 'gensym #[256 "\211T\301\302\303\206\f\304#!\207" [gensym-counter make-symbol format "%s%d" "g"] 7 (#$ . 9508)])
#@112 Do nothing and return nil.
This function accepts any number of arguments, but ignores them.

(fn &rest IGNORE)
(defalias 'ignore #[128 "\300\207" [nil] 2 (#$ . 9797) nil])
#@374 Signal an error, making a message by passing args to `format-message'.
In Emacs, the convention is that error messages start with a capital
letter but *do not* end with a period.  Please follow this convention
for the sake of consistency.

Note: (error "%s" VALUE) makes the message VALUE without
interpreting format characters like `%', `\=`', and `\=''.

(fn &rest ARGS)
(defalias 'error #[128 "\300\301\302\303\"C\"\207" [signal error apply format-message] 6 (#$ . 9976)])
(set-advertised-calling-convention 'error '(string &rest args) "23.1")
#@572 Signal a pilot error, making a message by passing args to `format-message'.
In Emacs, the convention is that error messages start with a capital
letter but *do not* end with a period.  Please follow this convention
for the sake of consistency.
This is just like `error' except that `user-error's are expected to be the
result of an incorrect manipulation on the part of the user, rather than the
result of an actual problem.

Note: (user-error "%s" VALUE) makes the message VALUE without
interpreting format characters like `%', `\=`', and `\=''.

(fn FORMAT &rest ARGS)
(defalias 'user-error #[385 "\300\301\302\303#C\"\207" [signal user-error apply format-message] 8 (#$ . 10531)])
#@294 Define NAME as a new error signal.
MESSAGE is a string that will be output to the echo area if such an error
is signaled without being caught by a `condition-case'.
PARENT is either a signal or a list of signals from which it inherits.
Defaults to `error'.

(fn NAME MESSAGE &optional PARENT)
(defalias 'define-error #[770 "\211\204\300\262
\211:\203\301\302\303\304\"\"\202\211
\305NB\306\305\307\310B!!#\210\2052\306\311#\207" [error apply append mapcar #[257 "\211
\300N\206\301\302\"B\207" [error-conditions error "Unknown signal `%s'"] 5 "\n\n(fn PARENT)"] error-conditions put delete-dups copy-sequence error-message] 11 (#$ . 11224)])
#@158 Return non-nil if OBJECT seems to be a frame configuration.
Any list whose car is `frame-configuration' is assumed to be a frame
configuration.

(fn OBJECT)
(defalias 'frame-configuration-p #[257 "\211:\205	\211@\300=\207" [frame-configuration] 3 (#$ . 11892)])
#@294 Return a function that is a partial application of FUN to ARGS.
ARGS is a list of the first N arguments to pass to FUN.
The result is a new function which does the same as FUN, except that
the first N arguments are fixed at the values with which this function
was called.

(fn FUN &rest ARGS)
(defalias 'apply-partially #[385 "\300\301\302\303\304\"\305\"\306\307%\207" [make-byte-code 128 "\302\300\303\301\"\"\207" vconcat vector [apply append] 6 "\n\n(fn &rest ARGS2)"] 9 (#$ . 12162)])
#@15 

(fn FORM X)
(defalias 'internal--compiler-macro-cXXr #[514 "
@\300@!\211G\301Z\302\303\"\204/\304!\203)K9\203)\305KAB\"\202O\306\307!\202O\211\310\224V\203N

H\311=\203B\312\202C\313D\262\211S\262
\202/\207" [symbol-name 2 string-match "c[ad]+r\\'" fboundp internal--compiler-macro-cXXr error "Compiler macro for cXXr applied to non-cXXr form" 0 97 car cdr] 8 (#$ . 12663)])
#@41 Return the car of the car of X.

(fn X)
(defalias 'caar #[257 "\211@@\207" [] 2 (#$ . 13066)])
(byte-code "\300\301\302\303#\300\207" [function-put caar compiler-macro internal--compiler-macro-cXXr] 4)
#@41 Return the car of the cdr of X.

(fn X)
(defalias 'cadr #[257 "\211A@\207" [] 2 (#$ . 13274)])
(byte-code "\300\301\302\303#\300\207" [function-put cadr compiler-macro internal--compiler-macro-cXXr] 4)
#@41 Return the cdr of the car of X.

(fn X)
(defalias 'cdar #[257 "\211@A\207" [] 2 (#$ . 13482)])
(byte-code "\300\301\302\303#\300\207" [function-put cdar compiler-macro internal--compiler-macro-cXXr] 4)
#@41 Return the cdr of the cdr of X.

(fn X)
(defalias 'cddr #[257 "\211AA\207" [] 2 (#$ . 13690)])
(byte-code "\300\301\302\303#\300\207" [function-put cddr compiler-macro internal--compiler-macro-cXXr] 4)
#@58 Return the `car' of the `car' of the `car' of X.

(fn X)
(defalias 'caaar #[257 "\211@@@\207" [] 2 (#$ . 13898)])
(byte-code "\300\301\302\303#\300\207" [function-put caaar compiler-macro internal--compiler-macro-cXXr] 4)
#@58 Return the `car' of the `car' of the `cdr' of X.

(fn X)
(defalias 'caadr #[257 "\211A@@\207" [] 2 (#$ . 14126)])
(byte-code "\300\301\302\303#\300\207" [function-put caadr compiler-macro internal--compiler-macro-cXXr] 4)
#@58 Return the `car' of the `cdr' of the `car' of X.

(fn X)
(defalias 'cadar #[257 "\211@A@\207" [] 2 (#$ . 14354)])
(byte-code "\300\301\302\303#\300\207" [function-put cadar compiler-macro internal--compiler-macro-cXXr] 4)
#@58 Return the `car' of the `cdr' of the `cdr' of X.

(fn X)
(defalias 'caddr #[257 "\211AA@\207" [] 2 (#$ . 14582)])
(byte-code "\300\301\302\303#\300\207" [function-put caddr compiler-macro internal--compiler-macro-cXXr] 4)
#@58 Return the `cdr' of the `car' of the `car' of X.

(fn X)
(defalias 'cdaar #[257 "\211@@A\207" [] 2 (#$ . 14810)])
(byte-code "\300\301\302\303#\300\207" [function-put cdaar compiler-macro internal--compiler-macro-cXXr] 4)
#@58 Return the `cdr' of the `car' of the `cdr' of X.

(fn X)
(defalias 'cdadr #[257 "\211A@A\207" [] 2 (#$ . 15038)])
(byte-code "\300\301\302\303#\300\207" [function-put cdadr compiler-macro internal--compiler-macro-cXXr] 4)
#@58 Return the `cdr' of the `cdr' of the `car' of X.

(fn X)
(defalias 'cddar #[257 "\211@AA\207" [] 2 (#$ . 15266)])
(byte-code "\300\301\302\303#\300\207" [function-put cddar compiler-macro internal--compiler-macro-cXXr] 4)
#@58 Return the `cdr' of the `cdr' of the `cdr' of X.

(fn X)
(defalias 'cdddr #[257 "\211AAA\207" [] 2 (#$ . 15494)])
(byte-code "\300\301\302\303#\300\207" [function-put cdddr compiler-macro internal--compiler-macro-cXXr] 4)
#@71 Return the `car' of the `car' of the `car' of the `car' of X.

(fn X)
(defalias 'caaaar #[257 "\211@@@@\207" [] 2 (#$ . 15722)])
(byte-code "\300\301\302\303#\300\207" [function-put caaaar compiler-macro internal--compiler-macro-cXXr] 4)
#@71 Return the `car' of the `car' of the `car' of the `cdr' of X.

(fn X)
(defalias 'caaadr #[257 "\211A@@@\207" [] 2 (#$ . 15966)])
(byte-code "\300\301\302\303#\300\207" [function-put caaadr compiler-macro internal--compiler-macro-cXXr] 4)
#@71 Return the `car' of the `car' of the `cdr' of the `car' of X.

(fn X)
(defalias 'caadar #[257 "\211@A@@\207" [] 2 (#$ . 16210)])
(byte-code "\300\301\302\303#\300\207" [function-put caadar compiler-macro internal--compiler-macro-cXXr] 4)
#@71 Return the `car' of the `car' of the `cdr' of the `cdr' of X.

(fn X)
(defalias 'caaddr #[257 "\211AA@@\207" [] 2 (#$ . 16454)])
(byte-code "\300\301\302\303#\300\207" [function-put caaddr compiler-macro internal--compiler-macro-cXXr] 4)
#@71 Return the `car' of the `cdr' of the `car' of the `car' of X.

(fn X)
(defalias 'cadaar #[257 "\211@@A@\207" [] 2 (#$ . 16698)])
(byte-code "\300\301\302\303#\300\207" [function-put cadaar compiler-macro internal--compiler-macro-cXXr] 4)
#@71 Return the `car' of the `cdr' of the `car' of the `cdr' of X.

(fn X)
(defalias 'cadadr #[257 "\211A@A@\207" [] 2 (#$ . 16942)])
(byte-code "\300\301\302\303#\300\207" [function-put cadadr compiler-macro internal--compiler-macro-cXXr] 4)
#@71 Return the `car' of the `cdr' of the `cdr' of the `car' of X.

(fn X)
(defalias 'caddar #[257 "\211@AA@\207" [] 2 (#$ . 17186)])
(byte-code "\300\301\302\303#\300\207" [function-put caddar compiler-macro internal--compiler-macro-cXXr] 4)
#@71 Return the `car' of the `cdr' of the `cdr' of the `cdr' of X.

(fn X)
(defalias 'cadddr #[257 "\211AAA@\207" [] 2 (#$ . 17430)])
(byte-code "\300\301\302\303#\300\207" [function-put cadddr compiler-macro internal--compiler-macro-cXXr] 4)
#@71 Return the `cdr' of the `car' of the `car' of the `car' of X.

(fn X)
(defalias 'cdaaar #[257 "\211@@@A\207" [] 2 (#$ . 17674)])
(byte-code "\300\301\302\303#\300\207" [function-put cdaaar compiler-macro internal--compiler-macro-cXXr] 4)
#@71 Return the `cdr' of the `car' of the `car' of the `cdr' of X.

(fn X)
(defalias 'cdaadr #[257 "\211A@@A\207" [] 2 (#$ . 17918)])
(byte-code "\300\301\302\303#\300\207" [function-put cdaadr compiler-macro internal--compiler-macro-cXXr] 4)
#@71 Return the `cdr' of the `car' of the `cdr' of the `car' of X.

(fn X)
(defalias 'cdadar #[257 "\211@A@A\207" [] 2 (#$ . 18162)])
(byte-code "\300\301\302\303#\300\207" [function-put cdadar compiler-macro internal--compiler-macro-cXXr] 4)
#@71 Return the `cdr' of the `car' of the `cdr' of the `cdr' of X.

(fn X)
(defalias 'cdaddr #[257 "\211AA@A\207" [] 2 (#$ . 18406)])
(byte-code "\300\301\302\303#\300\207" [function-put cdaddr compiler-macro internal--compiler-macro-cXXr] 4)
#@71 Return the `cdr' of the `cdr' of the `car' of the `car' of X.

(fn X)
(defalias 'cddaar #[257 "\211@@AA\207" [] 2 (#$ . 18650)])
(byte-code "\300\301\302\303#\300\207" [function-put cddaar compiler-macro internal--compiler-macro-cXXr] 4)
#@71 Return the `cdr' of the `cdr' of the `car' of the `cdr' of X.

(fn X)
(defalias 'cddadr #[257 "\211A@AA\207" [] 2 (#$ . 18894)])
(byte-code "\300\301\302\303#\300\207" [function-put cddadr compiler-macro internal--compiler-macro-cXXr] 4)
#@71 Return the `cdr' of the `cdr' of the `cdr' of the `car' of X.

(fn X)
(defalias 'cdddar #[257 "\211@AAA\207" [] 2 (#$ . 19138)])
(byte-code "\300\301\302\303#\300\207" [function-put cdddar compiler-macro internal--compiler-macro-cXXr] 4)
#@71 Return the `cdr' of the `cdr' of the `cdr' of the `cdr' of X.

(fn X)
(defalias 'cddddr #[257 "\211AAAA\207" [] 2 (#$ . 19382)])
(byte-code "\300\301\302\303#\300\207" [function-put cddddr compiler-macro internal--compiler-macro-cXXr] 4)
#@219 Return the last link of LIST.  Its car is the last element.
If LIST is nil, return nil.
If N is non-nil, return the Nth-to-last link of LIST.
If N is bigger than the length of LIST, return LIST.

(fn LIST &optional N)
(defalias 'last #[513 "\211\203\211\300Y\205'\301!

W\203\211Z\233\202\207
\205'\301!S\233\207" [0 safe-length] 5 (#$ . 19627)])
#@147 Return a copy of LIST with the last N elements removed.
If N is omitted or nil, the last element is removed from the
copy.

(fn LIST &optional N)
(defalias 'butlast #[513 "\211\203\f\211\300X\203\f
\207\301\302!\"\207" [0 nbutlast copy-sequence] 5 (#$ . 19995)])
#@118 Modifies LIST to remove the last N elements.
If N is omitted or nil, remove the last element.

(fn LIST &optional N)
(defalias 'nbutlast #[513 "
G
\204	\300\262

W\205
\301V\203\211SZ\233\302\241\210\207" [1 0 nil] 5 (#$ . 20269)])
#@42 Return t if NUMBER is zero.

(fn NUMBER)
(defalias 'zerop #[257 "\211\300U\207" [0] 3 (#$ . 20516)])
(byte-code "\300\301\302\303#\300\207" [function-put zerop compiler-macro zerop--anon-cmacro] 4)
#@17 

(fn _ NUMBER)
(defalias 'zerop--anon-cmacro #[514 "\300\301E\207" [= 0] 5 (#$ . 20720)])
#@209 Destructively remove `equal' duplicates from LIST.
Store the result in LIST and return it.  LIST must be a proper list.
Of several `equal' occurrences of an element in LIST, the first
one is kept.

(fn LIST)
(defalias 'delete-dups #[257 "\211G\211\300V\203C\301\302\303\304$\305\306@\307#\210
A\211\262\203>\211@\310
\"\2030A\241\210\202:\306
\307#\210
\262\210\202\266\202Y
\211\203X\211\311@A\"\241\210\211A\262
\202D\210\210\207" [100 make-hash-table :test equal :size nil puthash t gethash delete] 10 (#$ . 20819)])
#@169 Destructively remove `equal' consecutive duplicates from LIST.
First and last elements are considered consecutive if CIRCULAR is
non-nil.

(fn LIST &optional CIRCULAR)
(defalias 'delete-consecutive-dups #[513 "
\300
A\203#
@A@\232\203
\211AA\241\210\202
\262

A\262\202\2037\211\2037
@@\232\2037\211\300\241\210\266
\207" [nil] 6 (#$ . 21369)])
#@1307 Return a sequence of numbers from FROM to TO (both inclusive) as a list.
INC is the increment used between numbers in the sequence and defaults to 1.
So, the Nth element of the list is (+ FROM (* N INC)) where N counts from
zero.  TO is only included if there is an N for which TO = FROM + N * INC.
If TO is nil or numerically equal to FROM, return (FROM).
If INC is positive and TO is less than FROM, or INC is negative
and TO is larger than FROM, return nil.
If INC is zero and TO is neither nil nor numerically equal to
FROM, signal an error.

This function is primarily designed for integer arguments.
Nevertheless, FROM, TO and INC can be integer or float.  However,
floating point arithmetic is inexact.  For instance, depending on
the machine, it may quite well happen that
(number-sequence 0.4 0.6 0.2) returns the one element list (0.4),
whereas (number-sequence 0.4 0.8 0.2) returns a list with three
elements.  Thus, if some of the arguments are floats and one wants
to make sure that TO is included, one may have to explicitly write
TO as (+ FROM (* N INC)) or use a variable whose value was
computed with this exact expression.  Alternatively, you can,
of course, also replace TO with a slightly larger value
(or a slightly more negative value if INC is negative).

(fn FROM &optional TO INC)
(defalias 'number-sequence #[769 "
\203\nU\203
C\207\211\204\300\262
\211\301U\203\302\303!\210\304\301\211\301V\203M

Y\203o
X\203o
B\262T\262
\262
_\\\262\202(

X\203o
Y\203o
B\262T\262_\\\262\202M\237\207" [1 0 error "The increment can not be zero" nil] 10 (#$ . 21737)])
#@252 Make a copy of TREE.
If TREE is a cons cell, this recursively copies both its car and its cdr.
Contrast to `copy-sequence', which copies only along the cdrs.  With second
argument VECP, this copies vectors as well as conses.

(fn TREE &optional VECP)
(defalias 'copy-tree #[513 "
:\203G\300:\2031@@:\204\203%\301@!\203%\302@\"\262
\211B\266\202A\262\202\211\237\203D\301!\203D\302\"\202E\244\207\211\203q\301!\203q\303!\211\262G\211S\211\262\304Y\203o
\302H\"I\210\202X\207
\207" [nil vectorp copy-tree copy-sequence 0] 8 (#$ . 23368)])
#@511 Find object KEY in a pseudo-alist ALIST.
ALIST is a list of conses or objects.  Each element
 (or the element's car, if it is a cons) is compared with KEY by
 calling TEST, with two arguments: (i) the element or its car,
 and (ii) KEY.
If that is non-nil, the element matches; then `assoc-default'
 returns the element's cdr, if it is a cons, or DEFAULT if the
 element is not a cons.

If no element matches, the value is nil.
If TEST is omitted or nil, `equal' is used.

(fn KEY ALIST &optional TEST DEFAULT)
(defalias 'assoc-default #[1026 "\300\300
\203;\204;
@\206\301
:\203
@\202
	\"\2033\302\262\211:\2030\211A\2021\262\210
A\262\202\207" [nil equal t] 11 (#$ . 23951)])
#@226 Like `assoc', but ignores differences in case and text representation.
KEY must be a string.  Upper-case and lower-case letters are treated as equal.
Unibyte strings are converted to multibyte for comparison.

(fn KEY ALIST)
(defalias 'assoc-ignore-case #[514 "\300\301#\207" [assoc-string t] 6 (#$ . 24656)])
(make-obsolete 'assoc-ignore-case 'assoc-string "22.1")
#@160 Like `assoc', but ignores differences in text representation.
KEY must be a string.
Unibyte strings are converted to multibyte for comparison.

(fn KEY ALIST)
(defalias 'assoc-ignore-representation #[514 "\300\301#\207" [assoc-string nil] 6 (#$ . 25031)])
(make-obsolete 'assoc-ignore-representation 'assoc-string "22.1")
#@258 Like `member', but ignore differences in case and text representation.
ELT must be a string.  Upper-case and lower-case letters are treated as equal.
Unibyte strings are converted to multibyte for comparison.
Non-strings in LIST are ignored.

(fn ELT LIST)
(defalias 'member-ignore-case #[514 "\211\203!\211@;\203\300\301\302@\301\302\303&\303=\204!\211A\262
\202\207" [compare-strings 0 nil t] 10 (#$ . 25362)])
#@152 Delete from ALIST all elements whose car is `eq' to KEY.
Return the modified alist.
Elements of ALIST that are not conses are ignored.

(fn KEY ALIST)
(defalias 'assq-delete-all #[514 "\211@:\203\211@@=\203\211A\262
\202\211\300
A\211\262\203;\211@:\2035\211@@=\2035

A\241\210\202\211\262\202\266\207" [nil] 6 (#$ . 25791)])
#@156 Delete from ALIST all elements whose cdr is `eq' to VALUE.
Return the modified alist.
Elements of ALIST that are not conses are ignored.

(fn VALUE ALIST)
(defalias 'rassq-delete-all #[514 "\211@:\203\211@A=\203\211A\262
\202\211\300
A\211\262\203;\211@:\2035\211@A=\2035

A\241\210\202\211\262\202\266\207" [nil] 6 (#$ . 26142)])
#@406 Return the value associated with KEY in ALIST.
If KEY is not found in ALIST, return DEFAULT.
Use TESTFN to lookup in the alist if non-nil.  Otherwise, use `assq'.

This is a generalized variable suitable for use with `setf'.
When using it to set a value, optional argument REMOVE non-nil
means to remove KEY from ALIST if the new value is `eql' to DEFAULT.

(fn KEY ALIST &optional DEFAULT REMOVE TESTFN)
(defalias 'alist-get #[1282 "\211\204\n\236\202\300#\211\203\211A\202\207" [assoc] 9 (#$ . 26498)])
#@150 Return a copy of SEQ with all occurrences of ELT removed.
SEQ must be a list, vector, or string.  The comparison is done with `equal'.

(fn ELT SEQ)
(defalias 'remove #[514 "\211<\204\n\300\"\207\300\301!\"\207" [delete copy-sequence] 6 (#$ . 27023)])
#@191 Return LIST with all occurrences of ELT removed.
The comparison is done with `eq'.  Contrary to `delq', this does not use
side-effects, and the argument LIST is not modified.

(fn ELT LIST)
(defalias 'remq #[514 "

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

>\203\300\301!\"\207\207" [delq copy-sequence] 6 (#$ . 27287)])
#@298 Convert KEYS to the internal Emacs key representation.
KEYS should be a string in the format returned by commands such
as `C-h k' (`describe-key').
This is the same format used for saving keyboard macros (see
`edmacro-mode').

For an approximate inverse of this, see `key-description'.

(fn KEYS)
(defalias 'kbd #[257 "\300
!\207" [read-kbd-macro] 3 (#$ . 27607)])
(put 'kbd 'pure t)
#@50 Beep to tell the user this binding is undefined.
(defalias 'undefined #[0 "\304 \210\203\305\306\307\310 !\"\210\202\311\306\307\310 !\"\210\312 \210\313\314	!>\205&\n\211\207" [defining-kbd-macro last-command-event current-prefix-arg prefix-arg ding error "%s is undefined" key-description this-single-command-keys message force-mode-line-update down event-modifiers] 4 (#$ . 27997) nil])
(put 'undefined 'suppress-keymap t)
#@247 Make MAP override all normally self-inserting keys to be undefined.
Normally, as an exception, digits and minus-sign are set to make prefix args,
but optional second arg NODIGITS non-nil treats them like other chars.

(fn MAP &optional NODIGITS)
(defalias 'suppress-keymap #[513 "\300\301\302#\210\211\206+\303\300\304\305#\210\306\262
\211\307X\205)\300\310!\311#\210\211T\262
\202\262
\207" [define-key [remap self-insert-command] undefined nil "-" negative-argument 48 57 char-to-string digit-argument] 7 (#$ . 28437)])
#@557 Construct a new keymap composed of MAPS and inheriting from PARENT.
When looking up a key in the returned map, the key is looked in each
keymap of MAPS in turn until a binding is found.
If no binding is found in MAPS, the lookup continues in PARENT, if non-nil.
As always with keymap inheritance, a nil binding in MAPS overrides
any corresponding binding in PARENT, but it does not override corresponding
bindings in other keymaps of MAPS.
MAPS can be a list of keymaps or a single keymap.
PARENT if non-nil should be a keymap.

(fn MAPS &optional PARENT)
(defalias 'make-composed-keymap #[513 "\300\301\302!\203
C\202\"B\207" [keymap append keymapp] 6 (#$ . 28975)])
#@688 Add binding in KEYMAP for KEY => DEFINITION, right after AFTER's binding.
This is like `define-key' except that the binding for KEY is placed
just after the binding for the event AFTER, instead of at the beginning
of the map.  Note that AFTER must be an event type (like KEY), NOT a command
(like DEFINITION).

If AFTER is t or omitted, the new binding goes at the end of the keymap.
AFTER should be a single event type--a symbol or a character, not a sequence.

Bindings are always added before any inherited map.

The order of bindings in a keymap only matters when it is used as
a menu, so this function is not useful for non-menu keymaps.

(fn KEYMAP KEY DEFINITION &optional AFTER)
(defalias 'define-key-after #[1027 "\211\204\300\262
\301!\204\302\303\301D\"\210G\304X\203\"\305H\2026\306\307\310\311\312\313	\"!\"\"\262\211GSH\262\314\211
?\205\236\205\236A@\242=\203T\211AA\241\210\301@!\203_@\262@\242=\203m\300=\203zA@\315=\204zA\204\227A@\315=\203\205\300\262\211\204\224BAB\241\210\300\262
A\262\202;\207" [t keymapp signal wrong-type-argument 1 0 lookup-key apply vector butlast mapcar identity nil keymap] 12 (#$ . 29657)])
#@115 Implement `map-keymap' with sorting.
Don't call this function; it is for internal use only.

(fn FUNCTION KEYMAP)
(defalias 'map-keymap-sorted #[514 "\300C\301\302\303\304\305\306!\307\"\310\311%\"\210\211\312\242\313\"\240\210\211\242\211\2051\211@
@A\"\210
A\266\202\202\262
\207" [nil map-keymap make-byte-code 514 "\300B\300\242B\240\207" vconcat vector [] 5 "\n\n(fn A B)" sort #[514 "
@\262\211@\262

\250\203\211\250\203

W\207\300\207\211\250\203\300\207

\231\207" [t] 4 "\n\n(fn A B)"]] 10 (#$ . 30853)])
#@51 Return the binding part of a menu-item.

(fn VAL)
(defalias 'keymap--menu-item-binding #[257 "\211:\204\207\211@\300=\203#\301
8\302\233\303
\304\"\211\203!\211!\202\"\207\211A:\2034\211A@;\2034\211AA\207\211@;\203=\211A\207\207" [menu-item 2 3 plist-get :filter] 6 (#$ . 31392)])
#@89 Build a menu-item like ITEM but with its binding changed to BINDING.

(fn ITEM BINDING)
(defalias 'keymap--menu-item-with-binding #[514 "
:\204\207
@\300=\203-\301!\262
AA\211\240\210\302
A\303\"\203*\211\304A\303\305#\241\210\210
\207
A:\203C
A@;\203C
@A@BB\207
@
B\207" [menu-item copy-sequence plist-get :filter plist-put nil] 8 (#$ . 31690)])
#@47 Merge bindings VAL1 and VAL2.

(fn VAL1 VAL2)
(defalias 'keymap--merge-bindings #[514 "\300!\300!\301!\203\301
!\204\2022\302E\301!\203+\301!?\205,\202,\303
\"\266\202\207" [keymap--menu-item-binding keymapp keymap keymap--menu-item-with-binding] 9 (#$ . 32055)])
#@269 Return a simpler equivalent keymap.
This resolves inheritance and redefinitions.  The returned keymap
should behave identically to a copy of KEYMAP w.r.t `lookup-key'
and use in active keymaps and menus.
Subkeymaps may be modified but are not canonicalized.

(fn MAP)
(defalias 'keymap-canonicalize #[257 "\300C\300C\301!\302!\203$\303\304\305\306\307\310\"\311\"\312\313%\"\262\202
\242\203-\314\202.\315
!\262
\242\211\203L\211@\316\310@!A#\210
A\266\202\2024\210\242\300\240\210\211\203\212\211@\211@\211\242\236
\204j\202|\317\n\242\"\240\210\320AA\"B\242B\240\266
A\266\202\202S\210\242\244\207" [nil keymap-prompt keymapp map-keymap make-byte-code 514 "
:\203\301B\301\242B\240\207\300B\300\242B\240\207" vconcat vector [] 5 "\n\n(fn KEY ITEM)" make-keymap make-sparse-keymap define-key delq keymap--merge-bindings] 13 (#$ . 32345)])
(put 'keyboard-translate-table 'char-table-extra-slots 0)
#@170 Translate character FROM to TO on the current terminal.
This function creates a `keyboard-translate-table' if necessary
and then modifies one entry in it.

(fn FROM TO)
(defalias 'keyboard-translate #[514 "\301!\204\302\300\303\"I\207" [keyboard-translate-table char-table-p make-char-table nil] 5 (#$ . 33299)])
#@523 Give KEY a global binding as COMMAND.
COMMAND is the command definition to use; usually it is
a symbol naming an interactively-callable function.
KEY is a key sequence; noninteractively, it is a string or vector
of characters or event types, and non-ASCII characters with codes
above 127 (such as ISO Latin-1) can be included if you use a vector.

Note that if KEY has a local binding in the current buffer,
that local binding will continue to shadow any global binding
that you make with this function.

(fn KEY COMMAND)
(defalias 'global-set-key #[514 "\300!\204
;\204\301\302\303D\"\210\304\305 #\207" [vectorp signal wrong-type-argument arrayp define-key current-global-map] 6 (#$ . 33626) (byte-code "\301\302\303!\211\304\305\306\307!\"!)D\207" [menu-prompting nil read-key-sequence "Set key globally: " read-command format "Set key %s to command: " key-description] 7)])
#@495 Give KEY a local binding as COMMAND.
COMMAND is the command definition to use; usually it is
a symbol naming an interactively-callable function.
KEY is a key sequence; noninteractively, it is a string or vector
of characters or event types, and non-ASCII characters with codes
above 127 (such as ISO Latin-1) can be included if you use a vector.

The binding goes in the current buffer's local map, which in most
cases is shared with all other buffers in the same major mode.

(fn KEY COMMAND)
(defalias 'local-set-key #[514 "\300 \211\204\301\302 \211\262!\210\303!\204 ;\204 \304\305\306D\"\210\307
#\207" [current-local-map use-local-map make-sparse-keymap vectorp signal wrong-type-argument arrayp define-key] 7 (#$ . 34521) "KSet key locally: \nCSet key %s locally to command: "])
#@106 Remove global binding of KEY.
KEY is a string or vector representing a sequence of keystrokes.

(fn KEY)
(defalias 'global-unset-key #[257 "\300
\301\"\207" [global-set-key nil] 4 (#$ . 35324) "kUnset key globally: "])
#@105 Remove local binding of KEY.
KEY is a string or vector representing a sequence of keystrokes.

(fn KEY)
(defalias 'local-unset-key #[257 "\300 \203\n\301
\302\"\210\302\207" [current-local-map local-set-key nil] 4 (#$ . 35550) "kUnset key locally: "])
#@49 Used internally by `substitute-key-definition'.
(defvar key-substitution-in-progress nil (#$ . 35809))
#@495 Replace OLDDEF with NEWDEF for any keys in KEYMAP now defined as OLDDEF.
In other words, OLDDEF is replaced with NEWDEF wherever it appears.
Alternatively, if optional fourth argument OLDMAP is specified, we redefine
in KEYMAP as NEWDEF those keys which are defined as OLDDEF in OLDMAP.

If you don't specify OLDMAP, you can usually get the same results
in a cleaner way with command remapping, like this:
  (define-key KEYMAP [remap OLDDEF] NEWDEF)

(fn OLDDEF NEWDEF KEYMAP &optional OLDMAP)
(defalias 'substitute-key-definition #[1283 "\211C\211\242\204\211\301\240\210\206\302\242\303\"
B\304\305\306\307\302\310


\n%\311\"\312\313%\")\266\202\207" [key-substitution-in-progress "" vconcat [nil] map-keymap make-byte-code 514 "\304\303\242GI\210\305
\300\301\304\302%\207" vector [substitute-key-definition-key] 8 "\n\n(fn CHAR DEFN)"] 19 (#$ . 35919)])
#@41 

(fn DEFN OLDDEF NEWDEF PREFIX KEYMAP)
(defalias 'substitute-key-definition-key #[1285 "\301\211\211\242\302=\203\262
\3038\262\2029\242;\203-\211A\262	\242B\262\202\242:\2039A\262=\204V;\204N\304!\203w\232\203w\305\203n\306!\211AA\n\240\210\211\262
\202s\237	\244#\202\263\307!\206\200\262\310!\205\263\311\"\211?\206\233\312
!\206\233\310
!\262
\205\263>?\205\263\313	%\207" [key-substitution-in-progress nil menu-item 2 vectorp define-key copy-sequence indirect-function keymapp lookup-key natnump substitute-key-definition] 14 (#$ . 36801)])
#@148 Default global keymap mapping Emacs keyboard input into commands.
The value is a keymap which is usually (but not necessarily) Emacs's
global map.
(defvar global-map nil (#$ . 37433))
#@117 Default keymap for ESC (meta) commands.
The normal global definition of the character ESC indirects to this keymap.
(defvar esc-map nil (#$ . 37624))
#@110 Default keymap for C-x commands.
The normal global definition of the character C-x indirects to this keymap.
(defvar ctl-x-map nil (#$ . 37781))
#@34 Keymap for subcommands of C-x 4.
(defvar ctl-x-4-map (make-sparse-keymap) (#$ . 37932))
(byte-code "\302\303\"\210\304	\305\303#\207" [ctl-x-4-map ctl-x-map defalias ctl-x-4-prefix define-key "4"] 4)
#@28 Keymap for frame commands.
(defvar ctl-x-5-map (make-sparse-keymap) (#$ . 38139))
(byte-code "\302\303\"\210\304	\305\303#\207" [ctl-x-5-map ctl-x-map defalias ctl-x-5-prefix define-key "5"] 4)
(defconst listify-key-sequence-1 134217856)
#@55 Convert a key sequence to a list of events.

(fn KEY)
(defalias 'listify-key-sequence #[257 "\300
!\203\301
\302\"\207\303\304\"\207" [vectorp append nil mapcar #[257 "\211\301V\203\302
\"\207\207" [listify-key-sequence-1 127 logxor] 4 "\n\n(fn C)"]] 4 (#$ . 38384)])
#@52 True if the argument is an event object.

(fn OBJ)
(defalias 'eventp #[257 "\211\205!\211\250\206!\2119\203\211\203\300
!?\206!\211:\205!\211@9\207" [keywordp] 3 (#$ . 38664)])
#@442 Return a list of symbols representing the modifier keys in event EVENT.
The elements of the list may include `meta', `control',
`shift', `hyper', `super', `alt', `click', `double', `triple', `drag',
and `down'.
EVENT may be an event or an event type.  If EVENT is a symbol
that has never been used in an event that has been read as input
in the current Emacs session, then this function may fail to include
the `click' modifier.

(fn EVENT)
(defalias 'event-modifiers #[257 "\211\211<\203\n\211@\262
\2119\203\300
!A\202\301\302\303\"\302\304\"\305U\204)\306B\262\302\307\"\305U\2038\211\310W\203=\311B\262\302\312\"\305U\203M\211
\227U\204R\313B\262\302\314\"\305U\204`\315B\262\302\316\"\305U\204n\317B\262\302\320\"\305U\204|\321B\262
\266\202\207" [internal-event-symbol-parse-modifiers nil logand -264241153 134217728 0 meta 67108864 32 control 33554432 shift 16777216 hyper 8388608 super 4194304 alt] 7 (#$ . 38856)])
#@335 Return the basic type of the given event (all modifiers removed).
The value is a printing character (not upper case) or a symbol.
EVENT may be an event or an event type.  If EVENT is a symbol
that has never been used in an event that has been read as input
in the current Emacs session, then this function may return nil.

(fn EVENT)
(defalias 'event-basic-type #[257 "\211:\203	\211@\262
\2119\203\211\300N@\207\301
\302\"\211\303W\203$\304
\305\"\202%\211\3061/\211\2270\2021\210\211\207" [event-symbol-elements logand 4194303 32 logior 64 (error)] 5 (#$ . 39819)])
#@66 Return non-nil if OBJECT is a mouse movement event.

(fn OBJECT)
(defalias 'mouse-movement-p #[257 "\211\242\300=\207" [mouse-movement] 3 (#$ . 40400)])
(put 'mouse-movement-p 'byte-optimizer 'byte-compile-inline-expand)
#@63 Return non-nil if OBJECT is a mouse click event.

(fn OBJECT)
(defalias 'mouse-event-p #[257 "\300
!\301>\207" [event-basic-type (mouse-1 mouse-2 mouse-3 mouse-movement)] 3 (#$ . 40627)])
#@1030 Return the starting position of EVENT.
EVENT should be a mouse click, drag, or key press event.  If
EVENT is nil, the value of `posn-at-point' is used instead.

The following accessor functions are used to access the elements
of the position:

`posn-window': The window the event is in.
`posn-area': A symbol identifying the area the event occurred in,
or nil if the event occurred in the text area.
`posn-point': The buffer position of the event.
`posn-x-y': The pixel-based coordinates of the event.
`posn-col-row': The estimated column and row corresponding to the
position of the event.
`posn-actual-col-row': The actual column and row corresponding to the
position of the event.
`posn-string': The string object of the event, which is either
nil or (STRING . POSITION)'.
`posn-image': The image object of the event, if any.
`posn-object': The image or string object of the event, if any.
`posn-timestamp': The time the event occurred, in milliseconds.

For more information, see Info node `(elisp)Click Events'.

(fn EVENT)
(defalias 'event-start #[257 "\211:\203	\211A@\207\300 \206\301 `\302\303F\207" [posn-at-point selected-window (0 . 0) 0] 5 (#$ . 40823)])
#@161 Return the ending position of EVENT.
EVENT should be a click, drag, or key press event.

See `event-start' for a description of the value returned.

(fn EVENT)
(defalias 'event-end #[257 "\211:\203\300
8:\203\300\202\301
8\207\302 \206\303 `\304\305F\207" [2 1 posn-at-point selected-window (0 . 0) 0] 5 (#$ . 42001)])
#@115 Return the multi-click count of EVENT, a click or drag event.
The return value is a positive integer.

(fn EVENT)
(defalias 'event-click-count #[257 "\211:\203\300
8\250\203\300
8\207\301\207" [2 1] 3 (#$ . 42335)])
(put 'event-click-count 'byte-optimizer 'byte-compile-inline-expand)
#@105 Return the line count of EVENT, a mousewheel event.
The return value is a positive integer.

(fn EVENT)
(defalias 'event-line-count #[257 "\211:\203\300
8\250\203\300
8\207\301\207" [3 1] 3 (#$ . 42631)])
(put 'event-line-count 'byte-optimizer 'byte-compile-inline-expand)
#@245 Return non-nil if OBJ appears to be a valid `posn' object specifying a window.
A `posn' object is returned from functions such as `event-start'.
If OBJ is a valid `posn' object, but specifies a frame rather
than a window, return nil.

(fn OBJ)
(defalias 'posnp #[257 "\300
\242!\205!\211A\211\262\242:?\205!\211A\211\262\242\242\250\205!\211A\242\250\207" [windowp] 3 (#$ . 42915)])
#@142 Return the window in POSITION.
POSITION should be a list of the form returned by the `event-start'
and `event-end' functions.

(fn POSITION)
(defalias 'posn-window #[257 "\211@\207" [] 2 (#$ . 43310)])
(put 'posn-window 'byte-optimizer 'byte-compile-inline-expand)
#@182 Return the window area recorded in POSITION, or nil for the text area.
POSITION should be a list of the form returned by the `event-start'
and `event-end' functions.

(fn POSITION)
(defalias 'posn-area #[257 "\211A@:\203\211A@@\202\211A@\2119\205\211\207" [] 3 (#$ . 43582)])
(put 'posn-area 'byte-optimizer 'byte-compile-inline-expand)
#@250 Return the buffer location in POSITION.
POSITION should be a list of the form returned by the `event-start'
and `event-end' functions.
Returns nil if POSITION does not correspond to any buffer location (e.g.
a click on a scroll bar).

(fn POSITION)
(defalias 'posn-point #[257 "\300
8\206\211A@\211\242\206\211\250\205\211\262
\207" [5] 3 (#$ . 43932)])
#@81 Move point to POSITION.
Select the corresponding window as well.

(fn POSITION)
(defalias 'posn-set-point #[257 "\300
\211@\262
!\204\301\302!\210\303
\211@\262
!\210\304
!\247\205!\304
!b\207" [windowp error "Position not in text area of window" select-window posn-point] 4 (#$ . 44298)])
#@216 Return the x and y coordinates in POSITION.
The return value has the form (X . Y), where X and Y are given in
pixels.  POSITION should be a list of the form returned by
`event-start' and `event-end'.

(fn POSITION)
(defalias 'posn-x-y #[257 "\300
8\207" [2] 3 (#$ . 44598)])
(put 'posn-x-y 'byte-optimizer 'byte-compile-inline-expand)
#@492 Return the nominal column and row in POSITION, measured in characters.
The column and row values are approximations calculated from the x
and y coordinates in POSITION and the frame's default character width
and default line height, including spacing.
For a scroll-bar event, the result column is 0, and the row
corresponds to the vertical position of the click in the scroll bar.
POSITION should be a list of the form returned by the `event-start'
and `event-end' functions.

(fn POSITION)
(defalias 'posn-col-row #[257 "\211\301
8\262

\211@\262
\302
!\203\211\202\303
!\304!\205
\211A@:\203.\211A@@\2021\211A@\2119\2057\211\266\202\204A\305\202\251\211\306=\203T\307\310\311!S\"B\202\251\211\312=\203e\310\313!\"\307B\202\251\314!\205|r\315\316!!q\210)\206|\317\300\"\320
!\203\217\321
\322!_!\262
\202\226\211\204\226\307\262
@\323!\245A\322!\\\245B\262
\207" [line-spacing 2 framep window-frame windowp (0 . 0) vertical-scroll-bar 0 scroll-bar-scale window-height horizontal-scroll-bar window-width display-graphic-p window-buffer frame-selected-window frame-parameter floatp truncate frame-char-height frame-char-width] 11 (#$ . 44940)])
#@543 Return the window row number in POSITION and character number in that row.

Return nil if POSITION does not contain the actual position; in that case
`posn-col-row' can be used to get approximate values.
POSITION should be a list of the form returned by the `event-start'
and `event-end' functions.

This function does not account for the width on display, like the
number of visual columns taken by a TAB or image.  If you need
the coordinates of POSITION in character units, you should use
`posn-col-row', not this function.

(fn POSITION)
(defalias 'posn-actual-col-row #[257 "\300
8\207" [6] 3 (#$ . 46132)])
#@145 Return the timestamp of POSITION.
POSITION should be a list of the form returned by the `event-start'
and `event-end' functions.

(fn POSITION)
(defalias 'posn-timestamp #[257 "\300
8\207" [3] 3 (#$ . 46752)])
(put 'posn-timestamp 'byte-optimizer 'byte-compile-inline-expand)
#@212 Return the string object of POSITION.
Value is a cons (STRING . STRING-POS), or nil if not a string.
POSITION should be a list of the form returned by the `event-start'
and `event-end' functions.

(fn POSITION)
(defalias 'posn-string #[257 "\300
8\211:\205	\211\207" [4] 3 (#$ . 47035)])
#@201 Return the image object of POSITION.
Value is a list (image ...), or nil if not an image.
POSITION should be a list of the form returned by the `event-start'
and `event-end' functions.

(fn POSITION)
(defalias 'posn-image #[257 "\300
8\207" [7] 3 (#$ . 47331)])
(put 'posn-image 'byte-optimizer 'byte-compile-inline-expand)
#@295 Return the object (image or string) of POSITION.
Value is a list (image ...) for an image object, a cons cell
(STRING . STRING-POS) for a string object, and nil for a buffer position.
POSITION should be a list of the form returned by the `event-start'
and `event-end' functions.

(fn POSITION)
(defalias 'posn-object #[257 "\211\300
8\262
\206\f\301
!\207" [7 posn-string] 4 (#$ . 47662)])
(put 'posn-object 'byte-optimizer 'byte-compile-inline-expand)
#@243 Return the x and y coordinates relative to the object of POSITION.
The return value has the form (DX . DY), where DX and DY are
given in pixels.  POSITION should be a list of the form returned
by `event-start' and `event-end'.

(fn POSITION)
(defalias 'posn-object-x-y #[257 "\300
8\207" [8] 3 (#$ . 48123)])
(put 'posn-object-x-y 'byte-optimizer 'byte-compile-inline-expand)
#@207 Return the pixel width and height of the object of POSITION.
The return value has the form (WIDTH . HEIGHT).  POSITION should
be a list of the form returned by `event-start' and `event-end'.

(fn POSITION)
(defalias 'posn-object-width-height #[257 "\300
8\207" [9] 3 (#$ . 48506)])
(byte-code "\300\301\302\303#\210\304\305\306\307#\210\304\310\311\312#\210\304\313\314\315#\210\304\316\314\315#\210\304\317\314\315#\210\304\320\321\315#\210\304\322\321\315#\210\304\323\321\315#\207" [put posn-object-width-height byte-optimizer byte-compile-inline-expand make-obsolete forward-point "use (+ (point) N) instead." "23.1" buffer-has-markers-at nil "24.3" string-to-unibyte "use `encode-coding-string'." "26.1" string-as-unibyte string-make-unibyte string-to-multibyte "use `decode-coding-string'." string-as-multibyte string-make-multibyte] 4)
#@50 Return (log X 10), the log base 10 of X.

(fn X)
(defalias 'log10 #[257 "\300
\301\"\207" [log 10] 4 (#$ . 49355)])
(byte-code "\300\301\302\303#\210\304\305\306\307#\210\300\305\310\311#\210\304\312\306\307#\210\300\312\310\311#\210\313\314\315\316#\210\313\317\320\321#\210\313\322\323\324#\210\313\325\326\327#\210\330\331\332\333#\210\330\334\335\316#\210\330\336\337\340#\210\330\341\337\340#\210\330\342\332\343#\210\300\344\332\316#\210\300\345\332\316#\210\300\346\332\316#\210\300\347\332\316#\210\330\350\351\352#\210\353\354\355\332#\210\356\211\203\232\211@\354
N\203\223\355
N\204\223\357\355\354N#\210
A\266\202\202y\210\330\354\355\360#\210\353\361\362\332#\210\363\211\203\311\211@\361
N\203\302\362
N\204\302\357\362\361N#\210
A\266\202\202\250\210\330\361\362\311#\210\353\364\365\332#\210\366\211\203\370\211@\364
N\203\361\365
N\204\361\357\365\364N#\210
A\266\202\202\327\210\330\364\365\311#\210\330\367\332\316#\210\330\370\332\371#\210\353\372\373\"\210\304\374\375\"\210\304\376\377\"\210\304\201@\201A\"\210\304\201B\201C\"\210\304\201D\201E\"\210\304\201F\201G\"\210\304\201H\201I\"\210\304\201J\201K\"\210\304\201L\201M\"\210\304\201N\201O\"\210\304\201P\201Q\"\210\304\201R\201SK\"\210\304\201T\201UK\"\210\304\201V\201W\"\210\304\201X\201Y\"\210\304\201Z\201[\"\210\304\201\\\201]\"\210\304\201^\201_\"\210\304\201`\201a\"\210\304\201b\201c\"\207" [make-obsolete log10 log "24.4" defalias focus-frame ignore "" "it does nothing." "22.1" unfocus-frame set-advertised-calling-convention all-completions (string collection &optional predicate) "23.1" unintern (name obarray) "23.3" indirect-function (object) "25.1" redirect-frame-focus (frame focus-frame) "24.3" make-obsolete-variable define-key-rebound-commands nil "23.2" redisplay-end-trigger-functions jit-lock-register deferred-action-list post-command-hook "24.1" deferred-action-function redisplay-dont-pause "24.5" window-redisplay-end-trigger set-window-redisplay-end-trigger process-filter-multibyte-p set-process-filter-multibyte command-debug-status "expect it to be removed in a future version." "25.2" defvaralias executing-macro executing-kbd-macro (saved-value saved-variable-comment) put "before 19.34" x-lost-selection-hooks x-lost-selection-functions (saved-value saved-variable-comment) x-sent-selection-hooks x-sent-selection-functions (saved-value saved-variable-comment) translation-table-for-input x-gtk-use-window-move "26.1" messages-buffer-max-lines message-log-max send-string process-send-string send-region process-send-region string= string-equal string< string-lessp string> string-greaterp move-marker set-marker rplaca setcar rplacd setcdr beep ding indent-to-column indent-to backward-delete-char delete-backward-char search-forward-regexp re-search-forward search-backward-regexp re-search-backward int-to-string number-to-string store-match-data set-match-data chmod set-file-modes mkdir make-directory point-at-eol line-end-position point-at-bol line-beginning-position user-original-login-name user-login-name] 7)
#@786 Add to the value of HOOK the function FUNCTION.
FUNCTION is not added if already present.
FUNCTION is added (if necessary) at the beginning of the hook list
unless the optional argument APPEND is non-nil, in which case
FUNCTION is added at the end.

The optional fourth argument, LOCAL, if non-nil, says to modify
the hook's buffer-local value rather than its global value.
This makes the hook buffer-local, and it makes t a member of the
buffer-local value.  That acts as a flag to run the hook
functions of the global value as well as in the local value.

HOOK should be a symbol, and FUNCTION may be any valid function.  If
HOOK is void, it is first set to nil.  If HOOK's value is a single
function, it is changed to a list of functions.

(fn HOOK FUNCTION &optional APPEND LOCAL)
(defalias 'add-hook #[1026 "\300!\204\n\301L\210\302!\204\303\301\"\210\211\203)\304!\2049\305!\306CL\210\2029J:\2036\306J>\2049\306\262
\211\203BJ\202E\307!\211<\203P\310
!\203T\211C\262

\235\204u;\203d\311!\262\203p\312
C\"\202s
B\262

\203\2269\203\220\313N\203\220\314N\204\220\315\314\313#\210
L\202\232\303\"\207" [boundp nil default-boundp set-default local-variable-if-set-p make-local-variable t default-value functionp purecopy append permanent-local-hook permanent-local put] 9 (#$ . 52448)])
#@425 Remove from the value of HOOK the function FUNCTION.
HOOK should be a symbol, and FUNCTION may be any valid function.  If
FUNCTION isn't the value of HOOK, or, if FUNCTION doesn't appear in the
list of hooks to run in HOOK, then nothing is done.  See `add-hook'.

The optional third argument, LOCAL, if non-nil, says to modify
the hook's buffer-local value rather than its default value.

(fn HOOK FUNCTION &optional LOCAL)
(defalias 'remove-hook #[770 "\300!\204\n\301L\210\302!\204\303\301\"\210\211\205\304!??\205\304!\2037J:\2034\305J>\2047\305\262
\211\203@J\202C\306!\211<\203O\211@\307=\203[\211\232\203c\301\262
\202c\310\311!\"\262

\204n\303\"\202}\211\312\232\203z\313!\202}
L\262
\207" [boundp nil default-boundp set-default local-variable-p t default-value lambda delete copy-sequence (t) kill-local-variable] 8 (#$ . 53790)])
#@282 Bind variables according to BINDERS then eval BODY.
The value of the last form in BODY is returned.
Each element of BINDERS is a list (SYMBOL VALUEFORM) which binds
SYMBOL to the value of VALUEFORM.
All symbols are bound before the VALUEFORMs are evalled.

(fn BINDERS &rest BODY)
(defalias 'letrec '(macro . #[385 "\300\301\302\"\303\301\304\"\"BB\207" [let mapcar car append #[257 "\300
B\207" [setq] 3 "\n\n(fn BINDER)"]] 8 (#$ . 54674)]))
(byte-code "\300\301\302\303#\210\304\301\305\306#\300\207" [put letrec edebug-form-spec let function-put lisp-indent-function 1] 4)
#@1161 Run BODY, using wrapper functions from HOOK with additional ARGS.
HOOK is an abnormal hook.  Each hook function in HOOK "wraps"
around the preceding ones, like a set of nested `around' advices.

Each hook function should accept an argument list consisting of a
function FUN, followed by the additional arguments in ARGS.

The first hook function in HOOK is passed a FUN that, if it is called
with arguments ARGS, performs BODY (i.e., the default operation).
The FUN passed to each successive hook function is defined based
on the preceding hook functions; if called with arguments ARGS,
it does what the `with-wrapper-hook' call would do if the
preceding hook functions were the only ones present in HOOK.

Each hook function may call its FUN argument as many times as it wishes,
including never.  In that case, such a hook function acts to replace
the default definition altogether, and any preceding hook functions.
Of course, a subsequent hook function may do the same thing.

Each hook function definition is used to construct the FUN passed
to the next hook function, if any.  The last (or "outermost")
FUN is then called once.

(fn HOOK ARGS &rest BODY)
(defalias 'with-wrapper-hook '(macro . #[642 "\300BBB\207" [subr--with-wrapper-hook-no-warnings] 7 (#$ . 55262)]))
(byte-code "\300\301\302\303#\304\301\305\306#\210\307\301\310\311#\207" [function-put with-wrapper-hook lisp-indent-function 2 put edebug-form-spec (form sexp body) make-obsolete "use a <foo>-function variable modified by `add-function'." "24.4"] 5)
#@91 Like (with-wrapper-hook HOOK ARGS BODY), but without warnings.

(fn HOOK ARGS &rest BODY)
(defalias 'subr--with-wrapper-hook-no-warnings '(macro . #[642 "\300\301!\300\302!\300\303!\300\304!\305
\306E\307\310	D\307\311\312\313
DE\314	\315
\316DE\317
\257\320\313D\321\306\322F\314\257E\316DF
FF\320\306BB\nEFEDC\314\n\2119\205\307\323\324DD\325\324DDE\326\fB\257E\207" [make-symbol "funs" "global" "args" "runrestofhook" letrec lambda if consp eq t car funcall append cdr nil apply apply-partially &rest local-variable-p quote default-value list] 26 (#$ . 56797)]))
#@908 Add ELEMENT to the value of LIST-VAR if it isn't there yet.
The test for presence of ELEMENT is done with `equal', or with
COMPARE-FN if that's non-nil.
If ELEMENT is added, it is added at the beginning of the list,
unless the optional argument APPEND is non-nil, in which case
ELEMENT is added at the end.

The return value is the new value of LIST-VAR.

This is handy to add some elements to configuration variables,
but please do not abuse it in Elisp code, where you are usually
better off using `push' or `cl-pushnew'.

If you want to use `add-to-list' on a variable that is not
defined until a certain package is loaded, you should put the
call to `add-to-list' into a hook function that will be run only
after loading the package.  `eval-after-load' provides one way to
do this.  In some cases other hooks, such as major mode hooks,
can do the job.

(fn LIST-VAR ELEMENT &optional APPEND COMPARE-FN)
(defalias 'add-to-list #[1026 "\211\204J\235\202>\211\300=\203J>\202>\211\301=\203&\302J\"\202>J\211\203;
@\"\204;\211A\262
\202(\211\262
\203DJ\207\203R\303JC\"\202VJBL\207" [eq eql memql append] 8 (#$ . 57421)])
(byte-code "\300\301\302\303#\300\207" [function-put add-to-list compiler-macro add-to-list--anon-cmacro] 4)
#@57 

(fn EXP LIST-VAR ELEMENT &optional APPEND COMPARE-FN)
(defalias 'add-to-list--anon-cmacro #[1283 "\242\300=\203\301A@!\204\302!\204\207A@\303!\304\305\"\306\307\310\311\312\"\313\"\314$\315
!\203;\211\202>\316\317!\320\203T\321\322!\210\323\324\257\202Y\325E\203o\326	\327\330DEE\202t\331\nEF
=\203\211\202\206\332DC\"\266\203\333 \204\221\211\202\231\334\335\300DDE\207" [quote special-variable-p macroexp-const-p eval format-message "`add-to-list' can't use lexical var `%s'; use `push' or `cl-pushnew'" make-byte-code 0 "\300\n\236\205\n\303\301\304\"\207" vconcat vector [byte-compile--lexical-environment byte-compile-report-error :fill] 3 macroexp-copyable-p make-symbol "x" if require cl-lib cl-member :test member setq append list push macroexp-let* macroexp--compiling-p progn macroexp--funcall-if-compiled] 20 (#$ . 58687)])
#@743 Add ELEMENT to the value of LIST-VAR if it isn't there yet.
The test for presence of ELEMENT is done with `eq'.

The resulting list is reordered so that the elements are in the
order given by each element's numeric list order.  Elements
without a numeric list order are placed at the end of the list.

If the third optional argument ORDER is a number (integer or
float), set the element's list order to the given value.  If
ORDER is nil or omitted, do not change the numeric order of
ELEMENT.  If ORDER has any other value, remove the numeric order
of ELEMENT if it has one.

The list order for each element is stored in LIST-VAR's
`list-order' property.

The return value is the new value of LIST-VAR.

(fn LIST-VAR ELEMENT &optional ORDER)
(defalias 'add-to-ordered-list #[770 "\300NC\211\242\204\301\300\302\303\304\305\306$\240#\210
\203&\307\247\205\"\242#\210J>\2044JBL\210\310J\311\312\313\314\315!\316\"\317\320%\"L\207" [list-order put make-hash-table :weakness key :test eq puthash sort make-byte-code 514 "\301\300\242\"\301\300\242\"
\203\211\203

W\202
\207" vconcat vector [gethash] 6 "\n\n(fn A B)"] 13 (#$ . 59590)])
#@649 Add NEWELT to the history list stored in the variable HISTORY-VAR.
Return the new history list.
If MAXELT is non-nil, it specifies the maximum length of the history.
Otherwise, the maximum history length is the value of the `history-length'
property on symbol HISTORY-VAR, if set, or the value of the `history-length'
variable.  The possible values of maximum length have the same meaning as
the values of `history-length'.
Remove duplicates of NEWELT if `history-delete-duplicates' is non-nil.
If optional fourth arg KEEP-ALL is non-nil, add NEWELT to history even
if it is empty or a duplicate.

(fn HISTORY-VAR NEWELT &optional MAXELT KEEP-ALL)
(defalias 'add-to-history #[1026 "
\204
\300N\206\262J\302
<\203_\204%;\203%G\303V\203_\2040
@\232\204_	\203:\304\"\262B\262\250\203_\303U\203P\302\262\202_S\233\262
\211:\203_\211\302\241\210L\207" [history-length history-delete-duplicates nil 0 delete] 9 (#$ . 60759)])
#@62 If non-nil, `run-mode-hooks' should delay running the hooks.
(defvar delay-mode-hooks nil (#$ . 61721))
#@47 List of delayed mode hooks waiting to be run.
(defvar delayed-mode-hooks nil (#$ . 61831))
(byte-code "\300\301!\210\302\303\304\305#\207" [make-variable-buffer-local delayed-mode-hooks put delay-mode-hooks permanent-local t] 4)
#@99 List of delayed :after-hook forms waiting to be run.
These forms come from `define-derived-mode'.
(defvar delayed-after-hook-functions nil (#$ . 62066))
(make-variable-buffer-local 'delayed-after-hook-functions)
#@65 Normal hook run in major mode functions, before the mode hooks.
(defvar change-major-mode-after-body-hook nil (#$ . 62284))
#@58 Normal hook run at the very end of major mode functions.
(defvar after-change-major-mode-hook nil (#$ . 62414))
#@684 Run mode hooks `delayed-mode-hooks' and HOOKS, or delay HOOKS.
Call `hack-local-variables' to set up file local and directory local
variables.

If the variable `delay-mode-hooks' is non-nil, does not do anything,
just adds the HOOKS to the list `delayed-mode-hooks'.
Otherwise, runs hooks in the sequence: `change-major-mode-after-body-hook',
`delayed-mode-hooks' (in reverse order), HOOKS, then runs
`hack-local-variables', runs the hook `after-change-major-mode-hook', and
finally evaluates the functions in `delayed-after-hook-functions' (see
`define-derived-mode').

Major mode functions should use this instead of `run-hooks' when
running their FOO-mode-hook.

(fn &rest HOOKS)
(defalias 'run-mode-hooks #[128 "\203\211\211\205\211@\211	B
A\266\202\202\207	\237
\244\262
\303\304\305\306B\"\210\307 \203=\31016\311\312!0\202<\313\314\"\262
\210\305\315!\210\n\237\211\203S\211@\211 \210
A\266\202\202C\210\303\211\207" [delay-mode-hooks delayed-mode-hooks delayed-after-hook-functions nil apply run-hooks change-major-mode-after-body-hook buffer-file-name (debug error) hack-local-variables no-mode message "File local-variables error: %s" after-change-major-mode-hook] 5 (#$ . 62533)])
#@236 Execute BODY, but delay any `run-mode-hooks'.
These hooks will be executed by the first following call to
`run-mode-hooks' that occurs outside any `delay-mode-hooks' form.
Only affects hooks run in the current buffer.

(fn &rest BODY)
(defalias 'delay-mode-hooks '(macro . #[128 "\300\301\302\303BBE\207" [progn (make-local-variable 'delay-mode-hooks) let ((delay-mode-hooks t))] 6 (#$ . 63749)]))
(byte-code "\300\301\302\303#\210\304\301\305\306#\300\207" [put delay-mode-hooks edebug-form-spec t function-put lisp-indent-function 0] 4)
#@206 Non-nil if MODE is derived from one of MODES.
Uses the `derived-mode-parent' property of the symbol to trace backwards.
If you just want to check `major-mode', use `derived-mode-p'.

(fn MODE &rest MODES)
(defalias 'provided-mode-derived-p #[385 "

>\204
\300N\211\262\204
\207" [derived-mode-parent] 4 (#$ . 64296)])
#@157 Non-nil if the current major mode is derived from one of MODES.
Uses the `derived-mode-parent' property of the symbol to trace backwards.

(fn &rest MODES)
(defalias 'derived-mode-p #[128 "\301\302#\207" [major-mode apply provided-mode-derived-p] 5 (#$ . 64626)])
#@35 List of all minor mode functions.
(defvar minor-mode-list '(auto-save-mode auto-fill-mode abbrev-mode overwrite-mode view-mode hs-minor-mode) (#$ . 64898))
#@964 Register a new minor mode.

This is an XEmacs-compatibility function.  Use `define-minor-mode' instead.

TOGGLE is a symbol which is the name of a buffer-local variable that
is toggled on or off to say whether the minor mode is active or not.

NAME specifies what will appear in the mode line when the minor mode
is active.  NAME should be either a string starting with a space, or a
symbol whose value is such a string.

Optional KEYMAP is the keymap for the minor mode that will be added
to `minor-mode-map-alist'.

Optional AFTER specifies that TOGGLE should be added after AFTER
in `minor-mode-alist'.

Optional TOGGLE-FUN is an interactive function to toggle the mode.
It defaults to (and should by convention be) TOGGLE.

If TOGGLE has a non-nil `:included' property, an entry for the mode is
included in the mode-line minor mode menu.
If TOGGLE has a `:menu-tag', that is used for the menu item's label.

(fn TOGGLE NAME &optional KEYMAP AFTER TOGGLE-FUN)
(defalias 'add-minor-mode #[1282 ">\204\nB\211\204\262
\211=\204\305\306#\210\203s	\236\211\2030\211C\241\210\202r	\307
\203O\211\204O@@=\203H
\262
\2022
A\262\2022\211\203h\211A
\307\241\210
		DC\244
\244\266\202pD	B\266\210\310N\203\277\311\n\312!\313\314N\206\226;\203\222\202\226\315	!9\205\237J\211;\205\263\316\317\"\205\263\320\321\322\"\323Q)P\324\325\fB\257#\210\205
\f\236\211\203\320\211\241\202
\f\307
\203\357\211\204\357@@=\203\350
\262
\202\322
A\262\202\322\211\203
\211A
\307\241\210
	BC\244
\244\262
\202
B\fB\211\266\202\262
\207" [minor-mode-list minor-mode-alist mode-line-mode-menu mode-name minor-mode-map-alist put :minor-mode-function nil :included define-key vector menu-item :menu-tag symbol-name string-match "[^ ]+" " (" match-string 0 ")" :button :toggle] 15 (#$ . 65061)])
#@48 Non-nil if OBJECT is an autoload.

(fn OBJECT)
(defalias 'autoloadp #[257 "\211\242\300=\207" [autoload] 3 (#$ . 66924)])
(put 'autoloadp 'byte-optimizer 'byte-compile-inline-expand)
#@116 Define the property PROP of SYMBOL to be VAL.
This is to `put' what `defalias' is to `fset'.

(fn SYMBOL PROP VAL)
(defalias 'define-symbol-prop #[771 "\301\236\211\204\301C\262
\211B
\236\211\204!C\262


AB\241\210
A\235\204/\211AB\241\210\266\302#\207" [current-load-list define-symbol-props put] 8 (#$ . 67114)])
#@535 Return the name of the file that defined SYMBOL.
The value is normally an absolute file name.  It can also be nil,
if the definition is not associated with any file.  If SYMBOL
specifies an autoloaded function, the value can be a relative
file name without extension.

If TYPE is nil, then any kind of definition is acceptable.  If
TYPE is `defun', `defvar', or `defface', that specifies function
definition, variable definition, or face definition only.
Otherwise TYPE is assumed to be a symbol property.

(fn SYMBOL &optional TYPE)
(defalias 'symbol-file #[513 "\211\203\n\211\301=\203
9\203
K\211\242\302=\262
\203
KA@\207\3032\207\211\205\204\211@\211@
A\211\203\\\304=\203C\235\202sB\235\204v\305\305\306\"\">\202s\235\204v\307\"\211\205q\211@\310=?\262
\203{\311\303\"\210\266
A\266\202\202$\262
0\207" [load-history defun autoload found defvar alist-get define-symbol-props rassq require throw] 14 (#$ . 67454)])
#@823 Show the precise file name of Emacs library LIBRARY.
LIBRARY should be a relative file name of the library, a string.
It can omit the suffix (a.k.a. file-name extension) if NOSUFFIX is
nil (which is the default, see below).
This command searches the directories in `load-path' like `\[load-library]'
to find the file that `\[load-library] RET LIBRARY RET' would load.
Optional second arg NOSUFFIX non-nil means don't add suffixes `load-suffixes'
to the specified name LIBRARY.

If the optional third arg PATH is specified, that list of directories
is used instead of `load-path'.

When called from a program, the file name is normally returned as a
string.  When run interactively, the argument INTERACTIVE-CALL is t,
and the file name is displayed in the echo area.

(fn LIBRARY &optional NOSUFFIX PATH INTERACTIVE-CALL)
(defalias 'locate-library #[1025 "\302\206\303?\205\304 	\"#
\203+\211\203%\305\306\307!\"\210\202+\305\310\"\210\211\207" [load-path load-file-rep-suffixes locate-file append get-load-suffixes message "Library is file %s" abbreviate-file-name "No library %s in search path"] 10 (#$ . 68427) (byte-code "\301\302\303\304\305 #\"\306\211\307F\207" [load-path completing-read "Locate library: " apply-partially locate-file-completion-table get-load-suffixes nil t] 6)])
#@1071 Start a program in a subprocess.  Return the process object for it.
NAME is name for process.  It is modified if necessary to make it unique.
BUFFER is the buffer (or buffer name) to associate with the process.

Process output (both standard output and standard error streams)
goes at end of BUFFER, unless you specify a filter function to
handle the output.  BUFFER may also be nil, meaning that this
process is not associated with any buffer.

PROGRAM is the program file name.  It is searched for in `exec-path'
(which see).  If nil, just associate a pty with the buffer.  Remaining
arguments PROGRAM-ARGS are strings to give program as arguments.

If you want to separate standard output from standard error, use
`make-process' or invoke the command through a shell and redirect
one of them using the shell syntax.

The process runs in `default-directory' if that is local (as
determined by `unhandled-file-name-directory'), or "~"
otherwise.  If you want to run a process in a remote directory
use `start-file-process'.

(fn NAME BUFFER PROGRAM &rest PROGRAM-ARGS)
(defalias 'start-process #[899 "\300\301!\204\n\302\303!\210\304\301\305\306\307F\205\310BD\"\"\207" [fboundp make-process error "Emacs was compiled without subprocess support" apply append :name :buffer :command] 11 (#$ . 69741)])
#@162 Execute PROGRAM with ARGS, returning its output as a list of lines.
Signal an error if the program returns with a non-zero exit status.

(fn PROGRAM &rest ARGS)
(defalias 'process-lines #[385 "\300\301!r\211q\210\302\303\304\305\306!\307\"\310$\216\311\312\313p\313&\211\303=\204)\314\315#\210eb\210\313m\204A\316\317 \320 \"
B\262
\321y\210\202-\211\237\262
\262
*\207" [generate-new-buffer " *temp*" make-byte-code 0 "\301\300!\205	\302\300!\207" vconcat vector [buffer-name kill-buffer] 2 apply call-process nil error "%s exited with status %s" buffer-substring-no-properties line-beginning-position line-end-position 1] 10 (#$ . 71062)])
#@188 Returns non-nil if PROCESS is alive.
A process is considered alive if its status is `run', `open',
`listen', `connect' or `stop'.  Value is nil if PROCESS is not a
process.

(fn PROCESS)
(defalias 'process-live-p #[257 "\300
!\205\301
!\302>\207" [processp process-status (run open listen connect stop)] 3 (#$ . 71722)])
#@200 Say no query needed if PROCESS is running when Emacs is exited.
Optional second argument if non-nil says to require a query.
Value is t if a query was formerly required.

(fn PROCESS &optional FLAG)
(defalias 'process-kill-without-query #[513 "\300!\301\302\"\210\211\207" [process-query-on-exit-flag set-process-query-on-exit-flag nil] 6 (#$ . 72052)])
(make-obsolete 'process-kill-without-query "use `process-query-on-exit-flag' or `set-process-query-on-exit-flag'." "22.1")
#@57 Ask before killing a buffer that has a running process.
(defalias 'process-kill-buffer-query-function #[0 "\300p!\211?\206 \301
!\302>?\206 \303
!?\206 \304\305\306\307p!\"!\207" [get-buffer-process process-status (run stop open listen) process-query-on-exit-flag yes-or-no-p format "Buffer %S has a running process; kill it? " buffer-name] 6 (#$ . 72537)])
(add-hook 'kill-buffer-query-functions 'process-kill-buffer-query-function)
#@147 Return the value of PROCESS' PROPNAME property.
This is the last value stored with `(process-put PROCESS PROPNAME VALUE)'.

(fn PROCESS PROPNAME)
(defalias 'process-get #[514 "\300\301!\"\207" [plist-get process-plist] 5 (#$ . 72981)])
#@133 Change PROCESS' PROPNAME property to VALUE.
It can be retrieved with `(process-get PROCESS PROPNAME)'.

(fn PROCESS PROPNAME VALUE)
(defalias 'process-put #[771 "\300\301\302!#\"\207" [set-process-plist plist-put process-plist] 9 (#$ . 73226)])
(defconst read-key-empty-map (make-sparse-keymap))
(defvar read-key-delay 0.01)
#@418 Read a key from the keyboard.
Contrary to `read-event' this will not return a raw event but instead will
obey the input decoding and translations usually done by `read-key-sequence'.
So escape sequences and keyboard encoding are taken into account.
When there's an ambiguity because the key looks like the prefix of
some sort of escape sequence, the ambiguity is resolved via `read-key-delay'.

(fn &optional PROMPT)
(defalias 'read-key #[256 "\306\307\310 \311	\312\313#\314\307\315\316\317\"\320\"\321$\216\322\323 \324
\325\326
\327\"#\210\324
\330\331
\236A\2069\326
\332\"#\210\211\262
!\210\3332K\334\306\312#0\211\307H
G\335V\203a\211\336>\203a
\335H\202b\211\266\202,\207" [read-key-empty-map read-key-delay echo-keystrokes overriding-local-map overriding-terminal-local-map global-map nil 0 current-global-map run-with-idle-timer t #[0 "\300 \211G\301U?\205\302\303\"\207" [this-command-keys-vector 0 throw read-key] 4] make-byte-code "\302\301!\210\303\304!\210\305\300!\207" vconcat vector [cancel-timer message nil use-global-map] 2 use-global-map make-sparse-keymap define-key [menu-bar] lookup-key [menu-bar] [tool-bar] tool-bar [tool-bar] read-key read-key-sequence-vector 1 (mode-line header-line left-fringe right-fringe)] 14 (#$ . 73563)])
#@38 Keymap used while reading passwords.
(defvar read-passwd-map (byte-code "\301 \302
\"\210\303
\304\305#\210\211\207" [minibuffer-local-map make-sparse-keymap set-keymap-parent define-key "" delete-minibuffer-contents] 5) (#$ . 74848))
#@468 Read a password, prompting with PROMPT, and return it.
If optional CONFIRM is non-nil, read the password twice to make sure.
Optional DEFAULT is a default password to use instead of empty input.

This function echoes `.' for each character that the user types.
You could let-bind `read-hide-char' to another hiding character, though.

Once the caller uses the password, it can erase the password
by doing (clear-string STRING).

(fn PROMPT &optional CONFIRM DEFAULT)
(defalias 'read-passwd #[769 "
\203R\302\211\204P\303\302#\303\304\302#

\232\203/\305
!\203)

=\204)\306
!\210
\262\202K\305!\2039\306!\210\305
!\203C\306
!\210\307\310!\210\311\312!\210\266\202\211\207\313\302C\314\315\316\317\320\"\321\"\322$\302C\211\314\315\323\317\320\"\324\"\325$\240\210\314\315\326\317\320!\327\"\325$\216\330\331\242\"\210\314\315\332\317\320\"\333\"\334$\216\335\206\235\336\337\302\335$,\266\202\207" [read-hide-char enable-recursive-minibuffers nil read-passwd "Confirm password: " arrayp clear-string message "Password not repeated accurately; please start over" sit-for 1 #[771 "\301 \210
\302 ]^\262
Z\303\211W\2053\211\304
\\\305\306\n#\307\310\206(\311!$\266\211T\262
\202\207" [read-hide-char clear-this-command-keys minibuffer-prompt-end 0 put-text-property + 1 display string 46] 12 "\n\n(fn BEG END LEN)"] make-byte-code 0 "\301p\240\210\306\302!\210\307\306\303!\210\310\306\304!\210\307\311
!\210\306\312!\210\307\n\306\313!\210\307\314\315\300\307\316$\207" vconcat vector [post-self-insert-hook buffer-undo-list select-active-regions read-passwd-map make-local-variable nil t use-local-map inhibit-modification-hooks show-paren-mode add-hook after-change-functions local] 5 "\302\303\301\242\"\210\300 \207" [remove-hook minibuffer-setup-hook] 3 "\301\302\300\242\"\207" [remove-hook minibuffer-setup-hook] add-hook minibuffer-setup-hook "\302\301\242!\205r\301\242q\210\303\304\300\305#\210\306\307!\210\310 )\207" [buffer-live-p remove-hook after-change-functions local kill-local-variable post-self-insert-hook erase-buffer] 4 t 46 read-string] 15 (#$ . 75092)])
#@273 Read a numeric value in the minibuffer, prompting with PROMPT.
DEFAULT specifies a default value to return if the user just types RET.
The value of DEFAULT is inserted into PROMPT.
This function is used by the `interactive' code letter `n'.

(fn PROMPT &optional DEFAULT)
(defalias 'read-number #[513 "\300
:\203
@\202\f
\211\2032\301\302\"\203%\303\304\305\"\306\211\307%\2020\310\311\304\312\"\306\211%\262\313\300\211\211\211\205R:\203N\314\315\316\300\f\"\"\202R\315	!&\3171r\211G\320U\203c
\202k\211;\205k\321
!\211\2620\202v\210\202w\210\210
\247\204\210\322\323!\210\324\307!\210\2022
\207" [nil string-match "\\(\\):[ 	]*\\'" replace-match format " (default %s)" t 1 replace-regexp-in-string "[ 	]*\\'" " (default %s) " read-from-minibuffer mapcar number-to-string delq (error) 0 read message "Please enter a number." sit-for] 15 (#$ . 77236)])
#@268 Read and return one of CHARS, prompting for PROMPT.
Any input that is not one of CHARS is ignored.

If optional argument INHIBIT-KEYBOARD-QUIT is non-nil, ignore
keyboard-quit events while waiting for a valid input.

(fn PROMPT CHARS &optional INHIBIT-KEYBOARD-QUIT)
(defalias 'read-char-choice #[770 "
:\204	\305\306!\210\307\211\211\310\311\307
\312 \313\314\315\316\317!\320\"\321$\216\204\261\322\314\323
#\2048\324\323\325#\262\326!)\262\203S\327\330!!\203S\331!\210\247\203\"\203p\f=\203p\311\211\262\203p\332 \204\"\n>\203~\311\262\202\"\203\216\333U\203\216\307\202\"\204\"
\204\244\334=\203\244\311\262\202\"\335>\203\"\336 \210\202\")\210*\266\337\340\341!#\210\207" [executing-kbd-macro cursor-in-echo-area inhibit-quit help-form help-char error "Called `read-char-choice' without valid char choices" nil " *Char Help*" t current-window-configuration make-byte-code 0 "\301\300!\207" vconcat vector [set-window-configuration] 2 get-text-property face propertize minibuffer-prompt read-key buffer-live-p get-buffer kill-buffer help-form-show -1 27 (7 27) keyboard-quit message "%s%s" char-to-string] 17 (#$ . 78130)])
#@756 Redisplay, then wait for SECONDS seconds.  Stop when input is available.
SECONDS may be a floating-point value.
(On operating systems that do not support waiting for fractions of a
second, floating-point values are rounded down to the nearest integer.)

If optional arg NODISP is t, don't redisplay, just wait for input.
Redisplay does not happen if input is available before it starts.

Value is t if waited the full time with no input arriving, and nil otherwise.

An obsolete, but still supported form is
(sit-for SECONDS &optional MILLISECONDS NODISP)
where the optional arg MILLISECONDS specifies an additional wait period,
in milliseconds; this was useful when Emacs was built without
floating point support.

(fn SECONDS &optional NODISP OBSOLETE)
(defalias 'sit-for #[769 "
\247\203\304_\\\262\211\262\202\211\203\211\262\203#\305!\210\306\207\307\306!\203+\310\207\311X\2045	\203<
\206Y\312 \207
\204C\312 \210\310\313\310\306#)\211?\206W\306
BB\310\262
\207" [noninteractive defining-kbd-macro input-method-function unread-command-events 0.001 sleep-for t input-pending-p nil 0 redisplay read-event] 7 (#$ . 79334)])
(set-advertised-calling-convention 'sit-for '(seconds &optional nodisp) "22.1")
#@975 Ask user a "y or n" question.
Return t if answer is "y" and nil if it is "n".
PROMPT is the string to display to ask the question.  It should
end in a space; `y-or-n-p' adds "(y or n) " to it.

No confirmation of the answer is requested; a single character is
enough.  SPC also means yes, and DEL means no.

To be precise, this function translates user input into responses
by consulting the bindings in `query-replace-map'; see the
documentation of that variable for more information.  In this
case, the useful bindings are `act', `skip', `recenter',
`scroll-up', `scroll-down', and `quit'.
An `act' response means yes, and a `skip' response means no.
A `quit' response means to invoke `keyboard-quit'.
If the user enters `recenter', `scroll-up', or `scroll-down'
responses, perform the requested window recentering or scrolling
and ask again.

Under a windowing system a dialog box will be used if `last-nonmenu-event'
is nil and `use-dialog-box' is non-nil.

(fn PROMPT)
(defalias 'y-or-n-p #[257 "\306\307\203:\211!\262\310>\2046\311
!\211\312\235\203!\313\262\2022\211\314\235\203-\315\262\2022\316P\262\210\202\f\210\202.
\317 \203]	\203]\n<\203]\203]\211\320\"\262\321\320\322B\"\262\202.
\211!\262\323\320
\203p\324\325\326 !!\210\327\330>\203|\202\200\316P\331\332#!)\3333\334!\320#\262\335>\203\231\336\202 
\306=\203\246\306 \210\320\202 
\337=\203\277\3401\266\341 0\202\272\210\202\273\210\320\202 
\342=\203\330\3431\317\344 0\202\323\210\202\324\210\320\202 
\345=\203\361\3461\350\345 0\202\354\210\202\355\210\320\202 
\347=\203\n
\3501

\347 0\202
\210\202
\210\320\202 
\351>\204
\211\352=\203
\353\354\336\"\210\320\202 
\320\266\202\203.
\355 \210\356 \210\202b
\313=\204C
\357\360\203@
\361\202A
\362#\210\211\262
\207" [noninteractive last-input-event last-nonmenu-event use-dialog-box cursor-in-echo-area minibuffer-auto-raise recenter #[513 "
G
\300U\204SH\301=\203\302\202\303\203\302\202 \304Q\207" [0 32 "" " " "(y or n) "] 6 "\n\n(fn PROMPT &optional DIALOG)"] (act skip) read-string ("y" "Y") act ("n" "N") skip "Please answer y or n.  " display-popup-menus-p t x-popup-dialog (("Yes" . act) ("No" . skip)) (recenter scroll-up scroll-down scroll-other-window scroll-other-window-down) raise-frame window-frame minibuffer-window read-key propertize face minibuffer-prompt lookup-key vector (skip act) nil scroll-up (error) scroll-up-command scroll-down (error) scroll-down-command scroll-other-window (error) scroll-other-window-down (error) (exit-prefix quit) 27 signal quit ding discard-input message "%s%c" 121 110 query-replace-map] 9 (#$ . 80573)])
#@364 Perform BODY as an atomic change group.
This means that if BODY exits abnormally,
all of its changes to the current buffer are undone.
This works regardless of whether undo is enabled in the buffer.

This mechanism is transparent to ordinary use of undo;
if undo is enabled in the buffer and BODY succeeds, the
user can undo the change normally.

(fn &rest BODY)
(defalias 'atomic-change-group '(macro . #[128 "\300\301!\300\302!\303\304B\305\306\307\310B\257\311\312\313D\314\315\316BBC\"BB\317\320D\321	DFEE\207" [make-symbol "--change-group-handle--" "--change-group-success--" let ((prepare-change-group)) (undo-outer-limit nil) (undo-limit most-positive-fixnum) (undo-strong-limit most-positive-fixnum) (nil) unwind-protect progn activate-change-group append setq (t) if accept-change-group cancel-change-group] 13 (#$ . 83244)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put atomic-change-group lisp-indent-function 0 put edebug-form-spec t] 5)
#@1309 Return a handle for the current buffer's state, for a change group.
If you specify BUFFER, make a handle for BUFFER's state instead.

Pass the handle to `activate-change-group' afterward to initiate
the actual changes of the change group.

To finish the change group, call either `accept-change-group' or
`cancel-change-group' passing the same handle as argument.  Call
`accept-change-group' to accept the changes in the group as final;
call `cancel-change-group' to undo them all.  You should use
`unwind-protect' to make sure the group is always finished.  The call
to `activate-change-group' should be inside the `unwind-protect'.
Once you finish the group, don't use the handle again--don't try to
finish the same group twice.  For a simple example of correct use, see
the source code of `atomic-change-group'.

The handle records only the specified buffer.  To make a multibuffer
change group, call this function once for each buffer you want to
cover, then use `nconc' to combine the returned values, like this:

  (nconc (prepare-change-group buffer-1)
         (prepare-change-group buffer-2))

You can then activate that multibuffer change group with a single
call to `activate-change-group' and finish it with a single call
to `accept-change-group' or `cancel-change-group'.

(fn &optional BUFFER)
(defalias 'prepare-change-group #[256 "\211\203\211r
q\210)BC\207pBC\207" [buffer-undo-list] 3 (#$ . 84237)])
#@84 Activate a change group made with `prepare-change-group' (which see).

(fn HANDLE)
(defalias 'activate-change-group #[257 "\211\211\205\211@r\211@q\210\301=\203\302)
A\266\202\202
\207" [buffer-undo-list t nil] 5 (#$ . 85665)])
#@148 Finish a change group made with `prepare-change-group' (which see).
This finishes the change group by accepting its changes as final.

(fn HANDLE)
(defalias 'accept-change-group #[257 "\211\211\205\211@r\211@q\210\211A\301=\203\301)
A\266\202\202
\207" [buffer-undo-list t] 5 (#$ . 85907)])
#@146 Finish a change group made with `prepare-change-group' (which see).
This finishes the change group by reverting all of its changes.

(fn HANDLE)
(defalias 'cancel-change-group #[257 "\211\211\205v\211@Cr\211\242@q\210\211
\242A\240\210\214~\210\211\242\242
\242\243\303\304\305\306\307#\310\"\311$\216\242:\203>\242\312\240\210\242\312\241\210\313=\204G\314 \210\242:\203Z\242\315	!=\204Z\316\317!\210\212	<\203g\320\321!\210\202[)\242)\266*
A\266\202\202
\207" [last-command pending-undo-list buffer-undo-list make-byte-code 0 "\300\242:\205\300\242\301\240\210\300\242\302\241\207" vconcat vector [] 2 nil undo undo-start last error "Undoing to some unrelated state" undo-more 1] 13 (#$ . 86211)])
(byte-code "\300\301\302\303#\210\304\301\302\305#\207" [defalias redraw-modeline force-mode-line-update nil make-obsolete "24.3"] 4)
#@561 Momentarily display STRING in the buffer at POS.
Display remains until next event is input.
If POS is a marker, only its position is used; its buffer is ignored.
Optional third arg EXIT-CHAR can be a character, event or event
description list.  EXIT-CHAR defaults to SPC.  If the input is
EXIT-CHAR it is swallowed; otherwise it is then available as
input (as a command if nothing else).
Display MESSAGE (optional fourth arg) in the echo area.
If MESSAGE is nil, instructions to type EXIT-CHAR are displayed there.

(fn STRING POS &optional EXIT-CHAR MESSAGE)
(defalias 'momentary-string-display #[1026 "
\204\301\262\302\211\"\303!\304\305\306\307\310!\311\"\312$\216\212\313\314#\210b\210`\262\315\316\317\"X\2038\320\321 \312\245!\210)\322\206?\323\324!\"\210\325 \211=\206]\211\326!=\206]\327\330 \"\211\262
)\207" [unread-command-events 32 make-overlay copy-sequence make-byte-code 0 "\301\300!\207" vconcat vector [delete-overlay] 2 overlay-put after-string window-end nil t recenter window-height message "Type %s to continue editing." single-key-description read-key event-convert-list append this-single-command-raw-keys] 12 (#$ . 87077)])
#@37 Return a copy of overlay O.

(fn O)
(defalias 'copy-overlay #[257 "\300
!\203\301\302!\303!\300!#\202\301ee\"\304
!\210\211\262
\305!\211\2039\306\211A\262\242\211A\262\242#\210\202\"
\207" [overlay-buffer make-overlay overlay-start overlay-end delete-overlay overlay-properties overlay-put] 8 (#$ . 88256)])
#@206 Clear BEG and END of overlays whose property NAME has value VAL.
Overlays might be moved and/or split.
BEG and END default respectively to the beginning and end of buffer.

(fn &optional BEG END NAME VAL)
(defalias 'remove-overlays #[1024 "\204e\262\204d\262\300!\210W\203\262\262\212\301\"\211\205\205\211@\302
\"=\203~\303
!W\203f\304
!V\203Z\305\306!\303!#\210\305
\304!#\210\202~\305
\303!#\210\202~\304
!V\203z\305
\304!#\210\202~\307
!\210
A\266\202\202#\262
)\207" [overlay-recenter overlays-in overlay-get overlay-start overlay-end move-overlay copy-overlay delete-overlay] 11 (#$ . 88587)])
#@56 Normal hook run by `suspend-emacs', before suspending.
(defvar suspend-hook nil (#$ . 89240))
#@63 Normal hook run by `suspend-emacs', after Emacs is continued.
(defvar suspend-resume-hook nil (#$ . 89340))
#@179 Normal hook run by `with-output-to-temp-buffer' after displaying the buffer.
When the hook runs, the temporary buffer is current, and the window it
was displayed in is selected.
(defvar temp-buffer-show-hook nil (#$ . 89455))
#@193 Normal hook run by `with-output-to-temp-buffer' at the start.
When the hook runs, the temporary buffer is current.
This hook is normally set up with a function to put the buffer in Help
mode.
(defvar temp-buffer-setup-hook nil (#$ . 89688))
#@230 Directory beneath which additional per-user Emacs-specific files are placed.
Various programs in Emacs store information in this directory.
Note that this should end with a directory separator.
See also `locate-user-emacs-file'.
(defconst user-emacs-directory (byte-code "\301=\203\302\207\303\207" [system-type ms-dos "~/_emacs.d/" "~/.emacs.d/"] 2) (#$ . 89936))
#@51 Return non-nil if the current buffer is narrowed.
(defalias 'buffer-narrowed-p #[0 "deZ\300 U?\207" [buffer-size] 2 (#$ . 90310)])
(put 'buffer-narrowed-p 'byte-optimizer 'byte-compile-inline-expand)
#@180 Determine the boundaries of the default tag, based on text at point.
Return a cons cell with the beginning and end of the found tag.
If there is no plausible default, return nil.
(defalias 'find-tag-default-bounds #[0 "\300\301!\207" [bounds-of-thing-at-point symbol] 2 (#$ . 90517)])
#@108 Determine default tag to search for, based on text at point.
If there is no plausible default, return nil.
(defalias 'find-tag-default #[0 "\300 \211\205\f\301
@A\"\207" [find-tag-default-bounds buffer-substring-no-properties] 4 (#$ . 90809)])
#@234 Return regexp that matches the default tag at point.
If there is no tag at point, return nil.

When in a major mode that does not provide its own
`find-tag-default-function', return a regexp that matches the
symbol at point exactly.
(defalias 'find-tag-default-as-regexp #[0 "\206	\300N\206\302 \211\205\303
!\207" [find-tag-default-function major-mode find-tag-default regexp-quote] 3 (#$ . 91062)])
#@244 Return regexp that matches the default tag at point as symbol.
If there is no tag at point, return nil.

When in a major mode that does not provide its own
`find-tag-default-function', return a regexp that matches the
symbol at point exactly.
(defalias 'find-tag-default-as-symbol-regexp #[0 "\302 \211\203\206	\300N\206\303\303=\203\304\305\"\202\211\207" [find-tag-default-function major-mode find-tag-default-as-regexp find-tag-default format "\\_<%s\\_>"] 4 (#$ . 91477)])
#@678 SOUND is a list of the form `(sound KEYWORD VALUE...)'.
The following keywords are recognized:

  :file FILE - read sound data from FILE.  If FILE isn't an
absolute file name, it is searched in `data-directory'.

  :data DATA - read sound data from string DATA.

Exactly one of :file or :data must be present.

  :volume VOL - set volume to VOL.  VOL must an integer in the
range 0..100 or a float in the range 0..1.0.  If not specified,
don't change the volume setting of the sound device.

  :device DEVICE - play sound on DEVICE.  If not specified,
a system-dependent default device name is used.

Note: :data and :device are currently not supported on Windows.

(fn SOUND)
(defalias 'play-sound #[257 "\300\301!\203\n\301
!\207\302\303!\207" [fboundp play-sound-internal error "This Emacs binary lacks sound support"] 3 (#$ . 91973)])
#@266 Quote ARGUMENT for passing as argument to an inferior shell.

This function is designed to work with the syntax of your system's
standard shell, and might produce incorrect results with unusual shells.
See Info node `(elisp)Security Considerations'.

(fn ARGUMENT)
(defalias 'shell-quote-argument #[257 "\301=\203C\302\303\304\305\306\"\203\303\225GW\203:\305\307#\203:\303\224\262
O\310\211TOR\262\211T\262\202\311\304O\311R\207\312=\203o\313 \203o\314\315\316\314\317\320##\262
\305\321\"\203j\322\314\323\324#\322Q\207\311
\311Q\207\211\302\232\203w\325\207\314\326\327\314\330\331##\207" [system-type ms-dos "" 0 nil string-match "[^\"]" "[\"]" "\\" "\"" windows-nt w32-shell-dos-semantics replace-regexp-in-string "\\(\\\\*\\)$" "\\1\\1" "\\(\\\\*\\)\"" "\\1\\1\\\\\"" "[%!\"]" "^\"" "\\([%!()\"<>&|^]\\)" "^\\1" "''" "\n" "'\n'" "[^-0-9a-zA-Z_./\n]" "\\\\\\&"] 10 (#$ . 92820)])
#@53 Return a list of characters in STRING.

(fn STRING)
(defalias 'string-to-list #[257 "\300
\301\"\207" [append nil] 4 (#$ . 93746)])
(put 'string-to-list 'byte-optimizer 'byte-compile-inline-expand)
#@55 Return a vector of characters in STRING.

(fn STRING)
(defalias 'string-to-vector #[257 "\300
!\207" [vconcat] 3 (#$ . 93950)])
(put 'string-to-vector 'byte-optimizer 'byte-compile-inline-expand)
#@76 Return t if OBJECT is a string or nil.
Otherwise, return nil.

(fn OBJECT)
(defalias 'string-or-null-p #[257 "\211;\206\211?\207" [] 2 (#$ . 94152)])
#@110 Return t if OBJECT is one of the two canonical boolean values: t or nil.
Otherwise, return nil.

(fn OBJECT)
(defalias 'booleanp #[257 "\211\300>\205\301\207" [(nil t) t] 3 (#$ . 94311)])
#@63 Non-nil if and only if OBJECT is a special form.

(fn OBJECT)
(defalias 'special-form-p #[257 "\2119\203\300
!\203\301
!\262
\302
!\205\303
!A\304=\207" [fboundp indirect-function subrp subr-arity unevalled] 3 (#$ . 94507)])
#@56 Non-nil if and only if OBJECT is a macro.

(fn OBJECT)
(defalias 'macrop #[257 "\300
!\211:\205\211@\301=\206\211\211\242\302=\262
\205\303
8\304>\207" [indirect-function macro autoload 4 (macro t)] 5 (#$ . 94744)])
#@81 Return the field at position POS, taking stickiness etc into account.

(fn POS)
(defalias 'field-at-pos #[257 "\300\301!\302\"\211\303=\203\300\304!S\302\"\202\211\207" [get-char-property field-beginning field boundary field-end] 5 (#$ . 94972)])
#@306 Return the SHA1 (Secure Hash Algorithm) of an OBJECT.
OBJECT is either a string or a buffer.  Optional arguments START and
END are character positions specifying which portion of OBJECT for
computing the hash.  If BINARY is non-nil, return a string in binary
form.

(fn OBJECT &optional START END BINARY)
(defalias 'sha1 #[1025 "\300\301%\207" [secure-hash sha1] 10 (#$ . 95232)])
#@245 Return the value of property PROP of function F.
If AUTOLOAD is non-nil and F is autoloaded, try to autoload it
in the hope that it will set PROP.  If AUTOLOAD is `macro', only do it
if it's an autoloaded macro.

(fn F PROP &optional AUTOLOAD)
(defalias 'function-get #[770 "\3009\203>N\211\262\204>\301!\203>K\2037\211\211\242\302=\262
\2037\211\303\304=\2052\304#\232\203:\211\262\210\202
\211\207" [nil fboundp autoload autoload-do-load macro] 11 (#$ . 95624)])
#@212 Process text properties between START and END, inserted for a `yank'.
Perform the handling specified by `yank-handled-properties', then
remove properties specified by `yank-excluded-properties'.

(fn START END)
(defalias 'remove-yank-excluded-properties #[514 "\303	\211\2034\211@\211@
A\211W\203+\304
\"\305\306\n$#\210\266\202\202\266
A\266\202\202\210\n\303=\203C\307\306#\202H\310\n#)\207" [inhibit-read-only yank-handled-properties yank-excluded-properties t get-text-property next-single-property-change nil set-text-properties remove-list-of-text-properties] 13 (#$ . 96117)])
#@250 Insert STRING at point for the `yank' command.

This function is like `insert', except it honors the variables
`yank-handled-properties' and `yank-excluded-properties', and the
`yank-handler' text property, in the way that `yank' does.

(fn STRING)
(defalias 'insert-for-yank #[257 "\300\301\302\303#\211\262\203\304\302O!\210

\300O\262\202
\210\304
!\207" [nil next-single-property-change 0 yank-handler insert-for-yank-1] 6 (#$ . 96733)])
#@55 Helper for `insert-for-yank', which see.

(fn STRING)
(defalias 'insert-for-yank-1 #[257 "\211;\205\n\303\304\305#\211A@\206
`\306\307@\203$@!\210\202'c\210`\262
\307\3108\2047\311\"\210\211V\203L\312
S!\203L\313
S\314\307$\210	\307=\203V\3158\3168\205a\3168\211)\207" [inhibit-read-only yank-undo-function this-command get-text-property 0 yank-handler nil t 2 remove-yank-excluded-properties text-properties-at put-text-property rear-nonsticky 3 4] 10 (#$ . 97189)])
#@286 Insert before point a substring of BUFFER, without text properties.
BUFFER may be a buffer or a buffer name.
Arguments START and END are character positions specifying the substring.
They default to the values of (point-min) and (point-max) in BUFFER.

(fn BUFFER &optional START END)
(defalias 'insert-buffer-substring-no-properties #[769 "`\301#\210\302\303
`\304#)\207" [inhibit-read-only insert-buffer-substring t set-text-properties nil] 8 (#$ . 97693)])
#@401 Insert before point a part of BUFFER, stripping some text properties.
BUFFER may be a buffer or a buffer name.
Arguments START and END are character positions specifying the substring.
They default to the values of (point-min) and (point-max) in BUFFER.
Before insertion, process text properties according to
`yank-handled-properties' and `yank-excluded-properties'.

(fn BUFFER &optional START END)
(defalias 'insert-buffer-substring-as-yank #[769 "`\300#\210\301
`\"\207" [insert-buffer-substring remove-yank-excluded-properties] 8 (#$ . 98164)])
#@176 If `font-lock-defaults' is nil, apply FACE as a `face' property.
START and END denote the start and end of the text to act on.
Do nothing if FACE is nil.

(fn FACE START END)
(defalias 'yank-handle-font-lock-face-property #[771 "\205?\205\301\302$\207" [font-lock-defaults put-text-property face] 8 (#$ . 98723)])
#@95 Apply property category CATEGORY's properties between START and END.

(fn CATEGORY START END)
(defalias 'yank-handle-category-property #[771 "\205*
\211W\205(\300
\301#\302!\303\304	!#\210\305#\210
\266\203\202\262
\207" [next-property-change nil text-properties-at set-text-properties symbol-plist add-text-properties] 11 (#$ . 99053)])
#@653 Start a program in a subprocess.  Return the process object for it.
NAME is name for process.  It is modified if necessary to make it unique.
BUFFER is the buffer (or buffer name) to associate with the process.
 Process output goes at end of that buffer, unless you specify
 an output stream or filter function to handle the output.
 BUFFER may be also nil, meaning that this process is not associated
 with any buffer
COMMAND is the shell command to run.

An old calling convention accepted any number of arguments after COMMAND,
which were just concatenated to COMMAND.  This is still supported but strongly
discouraged.

(fn NAME BUFFER &rest ARGS)
(defalias 'start-process-shell-command #[642 "\302	\303\304\305#%\207" [shell-file-name shell-command-switch start-process mapconcat identity " "] 12 (#$ . 99412)])
(set-advertised-calling-convention 'start-process-shell-command '(name buffer command) "23.1")
#@172 Start a program in a subprocess.  Return the process object for it.
Similar to `start-process-shell-command', but calls `start-file-process'.

(fn NAME BUFFER &rest ARGS)
(defalias 'start-file-process-shell-command #[642 "\303\304!\203
\305\202	\304!\203\306\202\n\307\310\311#%\207" [default-directory shell-file-name shell-command-switch start-file-process file-remote-p "/bin/sh" "-c" mapconcat identity " "] 12 (#$ . 100336)])
(set-advertised-calling-convention 'start-file-process-shell-command '(name buffer command) "23.1")
#@1244 Execute the shell command COMMAND synchronously in separate process.
The remaining arguments are optional.
The program's input comes from file INFILE (nil means `/dev/null').
Insert output in BUFFER before point; t means current buffer;
 nil for BUFFER means discard it; 0 means discard and don't wait.
BUFFER can also have the form (REAL-BUFFER STDERR-FILE); in that case,
REAL-BUFFER says what to do with standard output, as above,
while STDERR-FILE says what to do with standard error in the child.
STDERR-FILE may be nil (discard standard error output),
t (mix it with ordinary output), or a file name string.

Fourth arg DISPLAY non-nil means redisplay buffer as output is inserted.
Wildcards and redirection are handled as usual in the shell.

If BUFFER is 0, `call-process-shell-command' returns immediately with value nil.
Otherwise it waits for COMMAND to terminate and returns a numeric exit
status or a signal description string.
If you quit, the process is killed with SIGINT, or SIGKILL if you quit again.

An old calling convention accepted any number of arguments after DISPLAY,
which were just concatenated to COMMAND.  This is still supported but strongly
discouraged.

(fn COMMAND &optional INFILE BUFFER DISPLAY &rest ARGS)
(defalias 'call-process-shell-command #[1153 "\302	\303\304\f	B\305#&\207" [shell-file-name shell-command-switch call-process mapconcat identity " "] 15 (#$ . 100888)])
(set-advertised-calling-convention 'call-process-shell-command '(command &optional infile buffer display) "24.5")
#@176 Process files synchronously in a separate process.
Similar to `call-process-shell-command', but calls `process-file'.

(fn COMMAND &optional INFILE BUFFER DISPLAY &rest ARGS)
(defalias 'process-file-shell-command #[1153 "\303\304!\203\305\202\f	\304!\203\306\202\n\307\310\f	B\311#&\207" [default-directory shell-file-name shell-command-switch process-file file-remote-p "/bin/sh" "-c" mapconcat identity " "] 15 (#$ . 102428)])
(set-advertised-calling-convention 'process-file-shell-command '(command &optional infile buffer display) "24.5")
#@1023 Send text from START to END as input to an inferior shell running COMMAND.
Delete the text if fourth arg DELETE is non-nil.

Insert output in BUFFER before point; t means current buffer; nil for
 BUFFER means discard it; 0 means discard and don't wait; and `(:file
 FILE)', where FILE is a file name string, means that it should be
 written to that file (if the file already exists it is overwritten).
BUFFER can also have the form (REAL-BUFFER STDERR-FILE); in that case,
REAL-BUFFER says what to do with standard output, as above,
while STDERR-FILE says what to do with standard error in the child.
STDERR-FILE may be nil (discard standard error output),
t (mix it with ordinary output), or a file name string.

If BUFFER is 0, `call-shell-region' returns immediately with value nil.
Otherwise it waits for COMMAND to terminate
and returns a numeric exit status or a signal description string.
If you quit, the process is killed with SIGINT, or SIGKILL if you quit again.

(fn START END COMMAND &optional DELETE BUFFER)
(defalias 'call-shell-region #[1283 "\302\303	\n&\207" [shell-file-name shell-command-switch call-process-region nil] 14 (#$ . 102994)])
#@206 Evaluate BODY with mouse movement events enabled.
Within a `track-mouse' form, mouse motion generates input events that
 you can read with `read-event'.
Normally, mouse motion is ignored.

(fn &rest BODY)
(defalias 'track-mouse '(macro . #[128 "\300\301\302BBD\207" [internal--track-mouse lambda nil] 5 (#$ . 104167)]))
(byte-code "\300\301\302\303#\210\304\301\305\306#\300\207" [put track-mouse edebug-form-spec t function-put lisp-indent-function 0] 4)
#@255 Execute the forms in BODY with BUFFER-OR-NAME temporarily current.
BUFFER-OR-NAME must be a buffer or the name of an existing buffer.
The value returned is the value of the last form in BODY.  See
also `with-temp-buffer'.

(fn BUFFER-OR-NAME &rest BODY)
(defalias 'with-current-buffer '(macro . #[385 "\300\301DBB\207" [save-current-buffer set-buffer] 5 (#$ . 104631)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put with-current-buffer lisp-indent-function 1 put edebug-form-spec t] 5)
#@15 

(fn WINDOW)
(defalias 'internal--before-with-selected-window #[257 "\300
!
\301 \302 =?\205\303!\302 =?\205\304!F\207" [window-frame selected-window selected-frame frame-selected-window tty-top-frame] 7 (#$ . 105146)])
#@14 

(fn STATE)
(defalias 'internal--after-with-selected-window #[257 "\300\3018!\203'\302\3018\303\"\210\304\3058!\203'\306 \3058=\204'\307\3058\303\"\210\300
A@!\2055\302
A@\303\"\207" [window-live-p 2 select-window norecord frame-live-p 3 tty-top-frame select-frame] 4 (#$ . 105381)])
#@759 Execute the forms in BODY with WINDOW as the selected window.
The value returned is the value of the last form in BODY.

This macro saves and restores the selected window, as well as the
selected window of each frame.  It does not change the order of
recently selected windows.  If the previously selected window of
some frame is no longer live at the end of BODY, that frame's
selected window is left alone.  If the selected window is no
longer live, then whatever window is selected at the end of BODY
remains selected.

This macro uses `save-current-buffer' to save and restore the
current buffer, since otherwise its normal operation could
potentially make a different buffer current.  It does not alter
the buffer list ordering.

(fn WINDOW &rest BODY)
(defalias 'with-selected-window '(macro . #[385 "\300\301\302DDC\303\304\305\306BB\307BBDE\207" [let save-selected-window--state internal--before-with-selected-window save-current-buffer unwind-protect progn (select-window (car save-selected-window--state) 'norecord) ((internal--after-with-selected-window save-selected-window--state))] 9 (#$ . 105682)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put with-selected-window lisp-indent-function 1 put edebug-form-spec t] 5)
#@292 Execute the forms in BODY with FRAME as the selected frame.
The value returned is the value of the last form in BODY.

This macro saves and restores the selected frame, and changes the
order of neither the recently selected windows nor the buffers in
the buffer list.

(fn FRAME &rest BODY)
(defalias 'with-selected-frame '(macro . #[385 "\300\301!\300\302!\303\304B\305BD\306\307\310\311BBBB\312\313D\310\314BBE\312\315D\316DEFE\207" [make-symbol "old-frame" "old-buffer" let ((selected-frame)) ((current-buffer)) unwind-protect progn select-frame ('norecord) when frame-live-p ('norecord) buffer-live-p set-buffer] 13 (#$ . 106944)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put with-selected-frame lisp-indent-function 1 put edebug-form-spec t] 5)
#@590 Execute BODY, then restore previous window configuration.
This macro saves the window configuration on the selected frame,
executes BODY, then calls `set-window-configuration' to restore
the saved window configuration.  The return value is the last
form in BODY.  The window configuration is also restored if BODY
exits nonlocally.

BEWARE: Most uses of this macro introduce bugs.
E.g. it should not be used to try and prevent some code from opening
a new window, since that window may sometimes appear in another frame,
in which case `save-window-excursion' cannot help.

(fn &rest BODY)
(defalias 'save-window-excursion '(macro . #[128 "\300\301!\302
\303BC\304\305B\306DEE\207" [make-symbol "wconfig" let ((current-window-configuration)) unwind-protect progn set-window-configuration] 8 (#$ . 107738)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put save-window-excursion lisp-indent-function 0 put edebug-form-spec t] 5)
#@66 Internal function for `with-output-to-temp-buffer'.

(fn BUFFER)
(defalias 'internal-temp-output-buffer-show #[257 "r\211q\210\304\305!\210eb\210)\203
!\210\202|r\211q\210	\306=\204+	\307=\203/\n\203/\310\2020	\311
!)\211\205<\312
!
\203y\211\313 =\204K\314
!\210
\315\316\"\210\317e\310#\210\320e\"\210\321!r\322\316\323\324\325!\326\"\327$\216\330
@\331\"\210\332\333!\210*\210\266)\305\207" [temp-buffer-show-function window-combination-limit temp-buffer-resize-mode minibuffer-scroll-window set-buffer-modified-p nil temp-buffer temp-buffer-resize t display-buffer window-frame selected-frame make-frame-visible set-window-hscroll 0 set-window-start set-window-point internal--before-with-selected-window make-byte-code "\301\300!\207" vconcat vector [internal--after-with-selected-window] 2 select-window norecord run-hooks temp-buffer-show-hook] 10 (#$ . 108691)])
#@1572 Bind `standard-output' to buffer BUFNAME, eval BODY, then show that buffer.

This construct makes buffer BUFNAME empty before running BODY.
It does not make the buffer current for BODY.
Instead it binds `standard-output' to that buffer, so that output
generated with `prin1' and similar functions in BODY goes into
the buffer.

At the end of BODY, this marks buffer BUFNAME unmodified and displays
it in a window, but does not select it.  The normal way to do this is
by calling `display-buffer', then running `temp-buffer-show-hook'.
However, if `temp-buffer-show-function' is non-nil, it calls that
function instead (and does not run `temp-buffer-show-hook').  The
function gets one argument, the buffer to display.

The return value of `with-output-to-temp-buffer' is the value of the
last form in BODY.  If BODY does not finish normally, the buffer
BUFNAME is not displayed.

This runs the hook `temp-buffer-setup-hook' before BODY,
with the buffer BUFNAME temporarily current.  It runs the hook
`temp-buffer-show-hook' after displaying buffer BUFNAME, with that
buffer temporarily current, and the window that was used to display it
temporarily selected.  But it doesn't run `temp-buffer-show-hook'
if it uses `temp-buffer-show-function'.

By default, the setup hook puts the buffer into Help mode before running BODY.
If BODY does not change the major mode, the show hook makes the buffer
read-only, and scans it for function and variable names to make them into
clickable cross-references.

See the related form `with-temp-buffer-window'.

(fn BUFNAME &rest BODY)
(defalias 'with-output-to-temp-buffer '(macro . #[385 "\300\301!\300\302!\303\304B\305\306D\307\310\311\312\313E\314BBBBED\315DE\307\316B\317DEE\207" [make-symbol "old-dir" "buf" let* (default-directory) with-current-buffer get-buffer-create prog1 (current-buffer) (kill-all-local-variables) setq default-directory ((setq buffer-read-only nil) (setq buffer-file-name nil) (setq buffer-undo-list t) (let ((inhibit-read-only t) (inhibit-modification-hooks t)) (erase-buffer) (run-hooks 'temp-buffer-setup-hook))) standard-output progn internal-temp-output-buffer-show] 15 (#$ . 109590)]))
(put 'with-output-to-temp-buffer 'edebug-form-spec t)
#@182 Create a new buffer, evaluate BODY there, and write the buffer to FILE.
The value returned is the value of the last form in BODY.
See also `with-temp-buffer'.

(fn FILE &rest BODY)
(defalias 'with-temp-file '(macro . #[385 "\300\301!\300\302!\303D\304BD\305\306\307BB\307\310\311\211\312BBBBEE\313\314D\315DEEE\207" [make-symbol "temp-file" "temp-buffer" let ((get-buffer-create (generate-new-buffer-name " *temp file*"))) unwind-protect prog1 with-current-buffer write-region nil (nil 0) and buffer-name kill-buffer] 16 (#$ . 111819)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put with-temp-file lisp-indent-function 1 put edebug-form-spec t] 5)
#@428 Display MESSAGE temporarily if non-nil while BODY is evaluated.
The original message is restored to the echo area after BODY has finished.
The value returned is the value of the last form in BODY.
MESSAGE is written to the message log buffer if `message-log-max' is non-nil.
If MESSAGE is nil, the echo area and message log buffer are unchanged.
Use a MESSAGE of "" to temporarily clear the echo area.

(fn MESSAGE &rest BODY)
(defalias 'with-temp-message '(macro . #[385 "\300\301!\300\302!\303
DCD\304\305\306\307\310BB\311\312	EFBB\313\314\311\312E\315BBBEEE\207" [make-symbol "current-message" "with-temp-message" let unwind-protect progn when setq ((current-message)) message "%s" and if ((message nil))] 15 (#$ . 112509)]))
(byte-code "\300\301\302\303#\210\304\301\305\306#\300\207" [put with-temp-message edebug-form-spec t function-put lisp-indent-function 1] 4)
#@138 Create a temporary buffer, and evaluate BODY there like `progn'.
See also `with-temp-file' and `with-output-to-string'.

(fn &rest BODY)
(defalias 'with-temp-buffer '(macro . #[128 "\300\301!\302
\303BC\304\305\306B\307\310D\311	DEEEE\207" [make-symbol "temp-buffer" let ((generate-new-buffer " *temp*")) with-current-buffer unwind-protect progn and buffer-name kill-buffer] 12 (#$ . 113401)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put with-temp-buffer lisp-indent-function 0 put edebug-form-spec t] 5)
#@586 Execute BODY, pretending it does not modify the buffer.
This macro is typically used around modifications of
text properties which do not really affect the buffer's content.
If BODY performs real modifications to the buffer's text, other
than cosmetic ones, undo data may become corrupted.

This macro will run BODY normally, but doesn't count its buffer
modifications as being buffer modifications.  This affects things
like `buffer-modified-p', checking whether the file is locked by
someone else, running buffer modification hooks, and other things
of that nature.

(fn &rest BODY)
(defalias 'with-silent-modifications '(macro . #[128 "\300\301!\302
\303B\304B\305\306B\307\310BBEE\207" [make-symbol "modified" let* ((buffer-modified-p)) ((buffer-undo-list t) (inhibit-read-only t) (inhibit-modification-hooks t)) unwind-protect progn unless ((restore-buffer-modified-p nil))] 9 (#$ . 113942)]))
(byte-code "\300\301\302\303#\210\304\301\305\306#\300\207" [put with-silent-modifications edebug-form-spec t function-put lisp-indent-function 0] 4)
#@91 Execute BODY, return the text it sent to `standard-output', as a string.

(fn &rest BODY)
(defalias 'with-output-to-string '(macro . #[128 "\300\301\302\303\300\304BB\305BB\306BBE\207" [let ((standard-output (get-buffer-create (generate-new-buffer-name " *string-output*")))) unwind-protect progn ((standard-output standard-output)) ((with-current-buffer standard-output (buffer-string))) ((kill-buffer standard-output))] 8 (#$ . 114999)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put with-output-to-string lisp-indent-function 0 put edebug-form-spec t] 5)
#@289 Execute BODY, allowing quits to terminate BODY but not escape further.
When a quit terminates BODY, `with-local-quit' returns nil but
requests another quit.  That quit will be processed as soon as quitting
is allowed once again.  (Immediately, if `inhibit-quit' is nil.)

(fn &rest BODY)
(defalias 'with-local-quit '(macro . #[128 "\300\301\302\303BB\304BBB\207" [condition-case nil let ((inhibit-quit nil)) ((quit (setq quit-flag t) (eval '(ignore nil))))] 6 (#$ . 115587)]))
(byte-code "\301\302\303\304#\210\305\302\306\307#\310\301\207" [while-no-input-ignore-events put with-local-quit edebug-form-spec t function-put lisp-indent-function 0 (focus-in focus-out help-echo iconify-frame make-frame-visible selection-request)] 4)
#@260 Execute BODY only as long as there's no pending input.
If input arrives, that ends the execution of BODY,
and `while-no-input' returns t.  Quitting makes it return nil.
If BODY finishes, `while-no-input' returns whatever value BODY produced.

(fn &rest BODY)
(defalias 'while-no-input '(macro . #[128 "\300\301!\302\303\304D\305\306\304DDC\307\310\311	BEEED\207" [make-symbol "input" with-local-quit catch quote let throw-on-input or (input-pending-p) progn] 11 (#$ . 116328)]))
(byte-code "\300\301\302\303#\210\304\301\305\306#\300\207" [put while-no-input edebug-form-spec t function-put lisp-indent-function 0] 4)
#@212 Like `condition-case' except that it does not prevent debugging.
More specifically if `debug-on-error' is set then the debugger will be invoked
even if this catches the signal.

(fn VAR BODYFORM &rest HANDLERS)
(defalias 'condition-case-unless-debug '(macro . #[642 "\300\301\302\"BBB\207" [condition-case mapcar #[257 "\300
@<\203\f
@\202
@CB
AB\207" [debug] 3 "\n\n(fn HANDLER)"]] 9 (#$ . 116957)]))
(byte-code "\300\301\302\303#\210\304\301\305\306#\307\310\301\311#\210\312\310\301\313#\207" [put condition-case-unless-debug edebug-form-spec condition-case function-put lisp-indent-function 2 defalias condition-case-no-debug nil make-obsolete "24.1"] 5)
#@575 Run BODY and demote any errors to simple messages.
FORMAT is a string passed to `message' to format any error message.
It should contain a single %-sequence; e.g., "Error: %S".

If `debug-on-error' is non-nil, run BODY without catching its errors.
This is to be used around code which is not expected to signal an error
but which should be robust in the unexpected case that an error is signaled.

For backward compatibility, if FORMAT is not a constant string, it
is assumed to be part of BODY, in which case the message format
used is "Error: %S".

(fn FORMAT &rest BODY)
(defalias 'with-demoted-errors '(macro . #[385 "\300\301!;\203
\203\202\302\203B\262\303\304!\305\306E\307BBF\207" [make-symbol "err" "Error: %S" condition-case-unless-debug macroexp-progn error message (nil)] 11 (#$ . 117629)]))
(byte-code "\300\301\302\303#\210\304\301\305\306#\300\207" [put with-demoted-errors edebug-form-spec t function-put lisp-indent-function 1] 4)
#@514 Execute BODY, but don't call the after-change functions till the end.
If BODY makes changes in the buffer, they are recorded
and the functions on `after-change-functions' are called several times
when BODY is finished.
The return value is the value of the last form in BODY.

If `before-change-functions' is non-nil, then calls to the after-change
functions can't be deferred, so in that case this macro has no effect.

Do not alter `after-change-functions' or `before-change-functions'
in BODY.

(fn &rest BODY)
(defalias 'combine-after-change-calls '(macro . #[128 "\300\301\302BB\303BB\207" [unwind-protect let ((combine-after-change-calls t)) ((combine-after-change-execute))] 5 (#$ . 118603)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put combine-after-change-calls lisp-indent-function 0 put edebug-form-spec t] 5)
#@146 Execute the forms in BODY with TABLE as the current case table.
The value returned is the value of the last form in BODY.

(fn TABLE &rest BODY)
(defalias 'with-case-table '(macro . #[385 "\300\301!\300\302!\303\304B\305BD\306\307\310DBB\311\310DEEE\207" [make-symbol "table" "buffer" let ((current-case-table)) ((current-buffer)) unwind-protect progn set-case-table with-current-buffer] 12 (#$ . 119454)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put with-case-table lisp-indent-function 1 put edebug-form-spec t] 5)
#@135 Execute BODY with default file permissions temporarily set to MODES.
MODES is as for `set-default-file-modes'.

(fn MODES &rest BODY)
(defalias 'with-file-modes '(macro . #[385 "\300\301!\302
\303BC\304\305\306DBB\306DEE\207" [make-symbol "umask" let ((default-file-modes)) unwind-protect progn set-default-file-modes] 9 (#$ . 120010)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put with-file-modes lisp-indent-function 1 put edebug-form-spec t] 5)
#@146 Execute the BODY forms, restoring the global value of the match data.
The value returned is the value of the last form in BODY.

(fn &rest BODY)
(defalias 'save-match-data '(macro . #[128 "\300\301\302\303B\304EE\207" [let ((save-match-data-internal (match-data))) unwind-protect progn (set-match-data save-match-data-internal 'evaporate)] 6 (#$ . 120492)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put save-match-data lisp-indent-function 0 put edebug-form-spec t] 5)
#@461 Return string of text matched by last search.
NUM specifies which parenthesized expression in the last regexp.
 Value is nil if NUMth pair didn't match, or there were less than NUM pairs.
Zero means the entire text matched by the whole regexp or whole string.
STRING should be given if the last search was by `string-match' on STRING.
If STRING is nil, the current buffer should be the same buffer
the search/match was performed in.

(fn NUM &optional STRING)
(defalias 'match-string #[513 "
\224\205\211\203\211\224\225O\207
\224\225{\207" [] 5 (#$ . 120991)])
#@486 Return string of text matched by last search, without text properties.
NUM specifies which parenthesized expression in the last regexp.
 Value is nil if NUMth pair didn't match, or there were less than NUM pairs.
Zero means the entire text matched by the whole regexp or whole string.
STRING should be given if the last search was by `string-match' on STRING.
If STRING is nil, the current buffer should be the same buffer
the search/match was performed in.

(fn NUM &optional STRING)
(defalias 'match-string-no-properties #[513 "
\224\205\211\203\300
\224\225#\207\301\224\225\"\207" [substring-no-properties buffer-substring-no-properties] 6 (#$ . 121567)])
#@342 Return REPLACEMENT as it will be inserted by `replace-match'.
In other words, all back-references in the form `\&' and `\N'
are substituted with actual strings matched by the last search.
Optional FIXEDCASE, LITERAL, STRING and SUBEXP have the same
meaning as for `replace-match'.

(fn REPLACEMENT &optional FIXEDCASE LITERAL STRING SUBEXP)
(defalias 'match-substitute-replacement #[1281 "\301\302\"\303 \304\216\305\306\307\303\310!\"!\210\311%*\207" [save-match-data-internal match-string 0 match-data #[0 "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3] set-match-data mapcar #[257 "\211\247\203\n\211\300\224Z\207\207" [0] 3 "\n\n(fn X)"] t replace-match] 12 (#$ . 122242)])
#@655 Return non-nil if text before point matches regular expression REGEXP.
Like `looking-at' except matches before point, and is slower.
LIMIT if non-nil speeds up the search by specifying a minimum
starting position, to avoid checking matches that would start
before LIMIT.

If GREEDY is non-nil, extend the match backwards as far as
possible, stopping when a single additional previous character
cannot be part of a match for REGEXP.  When the match is
extended, its starting position is allowed to occur before
LIMIT.

As a general recommendation, try to avoid using `looking-back'
wherever possible, since it is slow.

(fn REGEXP &optional LIMIT GREEDY)
(defalias 'looking-back #[769 "`\212\300\301\302Q\303#\205`)\203H\211\203H\214e}\210\211eV\203;\212\211b\210\304u\210\305\301\306Q!)\203;\211S\262
\202\212\211b\210\305\301\306Q!\210*\211??\207" [re-search-backward "\\(?:" "\\)\\=" t -1 looking-at "\\)\\'"] 9 (#$ . 122964)])
(set-advertised-calling-convention 'looking-back '(regexp limit &optional greedy) "25.1")
#@88 Same as `looking-at' except this function does not change the match data.

(fn REGEXP)
(defalias 'looking-at-p #[257 "\301\302
!)\207" [inhibit-changing-match-data t looking-at] 3 (#$ . 124006)])
(put 'looking-at-p 'byte-optimizer 'byte-compile-inline-expand)
#@113 Same as `string-match' except this function does not change the match data.

(fn REGEXP STRING &optional START)
(defalias 'string-match-p #[770 "\301\302#)\207" [inhibit-changing-match-data t string-match] 7 (#$ . 124274)])
(put 'string-match-p 'byte-optimizer 'byte-compile-inline-expand)
#@402 Return non-nil if POS is in a normal subregexp context in REGEXP.
A subregexp context is one where a sub-regexp can appear.
A non-subregexp context is for example within brackets, or within a
repetition bounds operator `\=\{...\}', or right after a `\'.
If START is non-nil, it should be a position in REGEXP, smaller
than POS, and known to be in a subregexp context.

(fn REGEXP POS &optional START)
(defalias 'subregexp-context-p #[770 "\3001\301\206\302O\303\"\210\3040\207\211A@\305\235?\207" [(invalid-regexp) string-match 0 "" t ("Unmatched [ or [^" "Unmatched \\{" "Trailing backslash")] 7 (#$ . 124575)])
#@290 The default value of separators for `split-string'.

A regexp matching strings of whitespace.  May be locale-dependent
(as yet unimplemented).  Should not match non-breaking spaces.

Warning: binding this to a different value and using it as default is
likely to have undesired semantics.
(defconst split-string-default-separators "[ \f	\n
]+" (#$ . 125202))
#@1658 Split STRING into substrings bounded by matches for SEPARATORS.

The beginning and end of STRING, and each match for SEPARATORS, are
splitting points.  The substrings matching SEPARATORS are removed, and
the substrings between the splitting points are collected as a list,
which is returned.

If SEPARATORS is non-nil, it should be a regular expression matching text
which separates, but is not part of, the substrings.  If nil it defaults to
`split-string-default-separators', normally "[ \f\t\n\r\v]+", and
OMIT-NULLS is forced to t.

If OMIT-NULLS is t, zero-length substrings are omitted from the list (so
that for the default value of SEPARATORS leading and trailing whitespace
are effectively trimmed).  If nil, all zero-length substrings are retained,
which correctly parses CSV format, for example.

If TRIM is non-nil, it should be a regular expression to match
text to trim from the beginning and end of each substring.  If trimming
makes the substring empty, it is treated as null.

If you want to trim whitespace from the substrings, the reliably correct
way is using TRIM.  Making SEPARATORS match that whitespace gives incorrect
results when there is whitespace at the start or end of STRING.  If you
see such calls to `split-string', please fix them.

Note that the effect of `(split-string STRING)' is the same as
`(split-string STRING split-string-default-separators t)'.  In the rare
case that you wish to retain zero-length substrings when splitting on
whitespace, use `(split-string STRING split-string-default-separators)'.

Modifies the match data; use `save-match-data' if necessary.

(fn STRING &optional SEPARATORS OMIT-NULLS TRIM)
(defalias 'split-string #[1025 "\203
\202	\301?\206\302\303C\303C\303\211C\304\305
\2038\302\224U\2038GW\2038T\202:#\203j\fGW\203j\301\262\240\210\302\224\240\210\302\225\262\211\f\n\n&\210\202\240\210\fG\240\210\211\f\n\n&\210
\242\237\207" [split-string-default-separators t 0 nil #[1542 "\203\300\242#\211\242=\203\301\225\240\210\210\204$\242\242W\205[\242\242O\203H\300\302P\301#\211\203G\211GW\203G
\301O\262\210\204S\211G\301V\205Y

\242B\240\262
\207" [string-match 0 "\\'"] 11 "\n\n(fn STRING TRIM KEEP-NULLS THIS-START THIS-END LIST)"] string-match] 19 (#$ . 125570)])
#@387 Concatenate the STRINGS, adding the SEPARATOR (default " ").
This tries to quote the strings to avoid ambiguity such that
  (split-string-and-unquote (combine-and-quote-strings strs)) == strs
Only some SEPARATORs will work properly.

Note that this is not intended to protect STRINGS from
interpretation by shells, use `shell-quote-argument' for that.

(fn STRINGS &optional SEPARATOR)
(defalias 'combine-and-quote-strings #[513 "\211\206\300\301\302\303!Q\304\305\306\307\310\311!\312\"\313\314%#\207" [" " "[\\\"]" "\\|" regexp-quote mapconcat make-byte-code 257 "\301\300\"\203\302\303\304\305#\302Q\207\207" vconcat vector [string-match "\"" replace-regexp-in-string "[\\\"]" "\\\\\\&"] 6 "\n\n(fn STR)"] 11 (#$ . 127909)])
#@245 Split the STRING into a list of strings.
It understands Emacs Lisp quoting within STRING, such that
  (split-string-and-unquote (combine-and-quote-strings strs)) == strs
The SEPARATOR regexp defaults to "\s-+".

(fn STRING &optional SEPARATOR)
(defalias 'split-string-and-unquote #[513 "\211\206\300\301\302\"\211\204\303\304#\202:\305
\306=?\205%\303\306O\304#\307\"\211@\310A\311O\"B\262
\"\207" ["\\s-+" string-match "\"" split-string t append 0 read-from-string split-string-and-unquote nil] 12 (#$ . 128655)])
#@174 Replace FROMCHAR with TOCHAR in STRING each time it occurs.
Unless optional argument INPLACE is non-nil, return a new string.

(fn FROMCHAR TOCHAR STRING &optional INPLACE)
(defalias 'subst-char-in-string #[1027 "
G
\203\n\202
\300!
\301V\203)
S\262\211H=\203
\211I\210\202
\207" [copy-sequence 0] 9 (#$ . 129197)])
#@952 Replace all matches for REGEXP with REP in STRING.

Return a new string containing the replacements.

Optional arguments FIXEDCASE, LITERAL and SUBEXP are like the
arguments with the same names of function `replace-match'.  If START
is non-nil, start replacements at that index in STRING.

REP is either a string used as the NEWTEXT arg of `replace-match' or a
function.  If it is a function, it is called with the actual text of each
match, and its value is used as the replacement text.  When REP is called,
the match data are the result of matching REGEXP against a substring
of STRING, the same substring that is the actual text of the match which
is passed to REP as its argument.

To replace only the first match (if any), make REGEXP match up to \\='
and replace a sub-expression, e.g.
  (replace-regexp-in-string "\\(foo\\).*\\\='" "bar" " foo foo" nil nil 1)
    => " bar foo"

(fn REGEXP REP STRING &optional FIXEDCASE LITERAL SUBEXP START)
(defalias 'replace-regexp-in-string #[1795 "G
\206\301\302\211\211\211\303 \304\216W\203q\305
\f#\203q\301\224\262\301\225\262
\211U\2036T^\262
\305
\fO\211\262\"\210\306\f;\203O\f\202W\f\307\301\"!\f%OBB\262\211\262\202\nOB\262\310\311\237\"*\207" [save-match-data-internal 0 nil match-data #[0 "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3] string-match replace-match match-string apply concat] 19 (#$ . 129534)])
#@187 Return non-nil if PREFIX is a prefix of STRING.
If IGNORE-CASE is non-nil, the comparison is done without paying attention
to case differences.

(fn PREFIX STRING &optional IGNORE-CASE)
(defalias 'string-prefix-p #[770 "G\211GV?\205\300\301\301&\302=\207" [compare-strings 0 t] 12 (#$ . 130988)])
#@187 Return non-nil if SUFFIX is a suffix of STRING.
If IGNORE-CASE is non-nil, the comparison is done without paying
attention to case differences.

(fn SUFFIX STRING &optional IGNORE-CASE)
(defalias 'string-suffix-p #[770 "
GGZ\211\300Y\205\301\302\211\302&\303=\207" [0 compare-strings nil t] 12 (#$ . 131305)])
#@563 Return a string that can be safely inserted in left-to-right text.

Normally, inserting a string with right-to-left (RTL) script into
a buffer may cause some subsequent text to be displayed as part
of the RTL segment (usually this affects punctuation characters).
This function returns a string which displays as STR but forces
subsequent text to be displayed as left-to-right.

If STR contains any RTL character, this function returns a string
consisting of STR followed by an invisible left-to-right mark
(LRM) character.  Otherwise, it returns STR.

(fn STR)
(defalias 'bidi-string-mark-left-to-right #[257 "\211;\204\f\300\301\302D\"\210\303\304\"\203\211\305\306\307!\310\311#P\207\207" [signal wrong-type-argument stringp string-match "\\cR" propertize string 8206 invisible t] 6 (#$ . 131632)])
#@180 Return non-nil if STRING1 is greater than STRING2 in lexicographic order.
Case is significant.
Symbols are also allowed; their print names are used instead.

(fn STRING1 STRING2)
(defalias 'string-greaterp #[514 "\211\231\207" [] 4 (#$ . 132446)])
#@122 Form a regexp to find FILE in `load-history'.
FILE, a string, is described in the function `eval-after-load'.

(fn FILE)
(defalias 'load-history-regexp #[257 "\302
!\203\303
!\262
\302
!\203\304\202\305\306!\307!\203#\310\202+\311\312\306\313#\314Q\311\312\306	\313#\315\260\207" [load-suffixes jka-compr-load-suffixes file-name-absolute-p file-truename "\\`" "\\(\\`\\|/\\)" regexp-quote file-name-extension "" "\\(" mapconcat "\\|" "\\)?" "\\)?\\'"] 9 (#$ . 132702)])
#@117 Get the first elt of `load-history' whose car matches FILE-REGEXP.
Return nil if there isn't one.

(fn FILE-REGEXP)
(defalias 'load-history-filename-element #[257 "\211\205\211@\302 \303\216
\203,\211@\203\304@\"\204,
A\262
\205'
@\262
\202\f*\207" [load-history save-match-data-internal match-data #[0 "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3] string-match] 6 (#$ . 133191)])
(put 'eval-after-load 'lisp-indent-function 1)
#@1529 Arrange that if FILE is loaded, FORM will be run immediately afterwards.
If FILE is already loaded, evaluate FORM right now.
FORM can be an Elisp expression (in which case it's passed to `eval'),
or a function (in which case it's passed to `funcall' with no argument).

If a matching file is loaded again, FORM will be evaluated again.

If FILE is a string, it may be either an absolute or a relative file
name, and may have an extension (e.g. ".el") or may lack one, and
additionally may or may not have an extension denoting a compressed
format (e.g. ".gz").

When FILE is absolute, this first converts it to a true name by chasing
symbolic links.  Only a file of this name (see next paragraph regarding
extensions) will trigger the evaluation of FORM.  When FILE is relative,
a file whose absolute true name ends in FILE will trigger evaluation.

When FILE lacks an extension, a file name with any extension will trigger
evaluation.  Otherwise, its extension must match FILE's.  A further
extension for a compressed format (e.g. ".gz") on FILE will not affect
this name matching.

Alternatively, FILE can be a feature (i.e. a symbol), in which case FORM
is evaluated at the end of any file that `provide's this feature.
If the feature is provided when evaluating code not associated with a
file, FORM is evaluated immediately after the provide statement.

Usually FILE is just a library name like "font-lock" or a feature name
like `font-lock'.

This function makes or adds to an entry on `after-load-alist'.

(fn FILE FORM)
(defalias 'eval-after-load #[514 "
;\203\302\303!!\211\262\202
\304
\"\305!\203\202&\306\307\310E	\"
\2042C\262
B;\203=\311!\202@\312!\205E\211 9\204N
\202Z\313\314\315\316\317!\320\"\321$\211A\235\204f
C\244\210\210\207" [after-load-alist lexical-binding purecopy load-history-regexp assoc functionp eval lambda nil load-history-filename-element featurep make-byte-code 0 "	\204\300 \207	\302\303!\211\304\305\306\307\310\300#\311\"\312\313%M\210\314\315\316#\207" vconcat vector [load-file-name make-symbol "eval-after-load-helper" make-byte-code 257 "\211\301\232\205
\303\304\302\"\210\300 \207" vconcat vector [remove-hook after-load-functions] 4 "\n\n(fn FILE)" add-hook after-load-functions append] 11] 12 (#$ . 133667)])
(byte-code "\300\301\302\303#\300\207" [function-put eval-after-load compiler-macro eval-after-load--anon-cmacro] 4)
#@24 

(fn WHOLE FILE FORM)
(defalias 'eval-after-load--anon-cmacro #[771 "\211\242\300=\203\301\302\303A@EE\207\207" [quote eval-after-load lambda nil] 8 (#$ . 136087)])
#@266 Execute BODY after FILE is loaded.
FILE is normally a feature name, but it can also be a file name,
in case that file does not provide any feature.  See `eval-after-load'
for more details about the different forms of FILE and their semantics.

(fn FILE &rest BODY)
(defalias 'with-eval-after-load '(macro . #[385 "\300\301\302BBE\207" [eval-after-load lambda nil] 7 (#$ . 136265)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put with-eval-after-load lisp-indent-function 1 put edebug-form-spec t] 5)
#@137 Special hook run after loading a file.
Each function there is called with a single argument, the absolute
name of the file just loaded.
(defvar after-load-functions nil (#$ . 136794))
#@202 Evaluate all `eval-after-load' forms, if any, for ABS-FILE.
ABS-FILE, a string, should be the absolute true name of a file just loaded.
This function is called directly from the C code.

(fn ABS-FILE)
(defalias 'do-after-load-evaluation #[257 "\211\203+\211@\211@;\203$\211@\304\305\306#)\266\203\203$\307\310A\"\210
A\266\202\202
\210\311
\304\305\306#)\266\203\203\211\312
!\313\314\315\306\316\"O\"\317\320!\203\200\321\320J!\203\200\322\320J!\323\232\203\200\n;\203x\324\325\n\"\304\305\306#)\266\203\204\207\326\327\"\210\202\207\330\315\304\331$\210\266\332\333\"\207" [after-load-alist inhibit-changing-match-data byte-compile-current-file byte-compile-root-dir nil t string-match mapc funcall "/obsolete/\\([^/]*\\)\\'" file-name-nondirectory format "Package %s is obsolete!" 0 "\\.elc?\\>" boundp byte-compile--outbuffer bufferp buffer-name " *Compiler Output*" "/obsolete/[^/]*\\'" expand-file-name byte-compile-warn "%s" run-with-timer #[257 "\300\301\"\207" [message "%s"] 4 "\n\n(fn MSG)"] run-hook-with-args after-load-functions] 10 (#$ . 136985)])
#@195 Read the following input sexp, and run it whenever FILE is loaded.
This makes or adds to an entry on `after-load-alist'.
FILE should be the name of a library, with no directory name.

(fn FILE)
(defalias 'eval-next-after-load #[257 "\300
\301 \"\207" [eval-after-load read] 4 (#$ . 138090)])
(make-obsolete 'eval-next-after-load 'eval-after-load "23.2")
#@103 Display delayed warnings from `delayed-warnings-list'.
Used from `delayed-warnings-hook' (which see).
(defalias 'display-delayed-warnings #[0 "\237\211\203\211@\301\302\"\210
A\266\202\202\210\303\211\207" [delayed-warnings-list apply display-warning nil] 5 (#$ . 138451)])
#@156 Remove duplicates from `delayed-warnings-list'.
Collapse identical adjacent warnings into one (plus count).
Used from `delayed-warnings-hook' (which see).
(defalias 'collapse-delayed-warnings #[0 "\301\302\211\203<\211A\242\262
\211@\232\203T\262\202\301V\2034\211\303\304A@#AAB\241\210\301\262\211B\262\202
\237\211\207" [delayed-warnings-list 1 nil format "%s [%d times]"] 8 (#$ . 138739)])
#@221 Normal hook run to process and display delayed warnings.
By default, this hook contains functions to consolidate the
warnings listed in `delayed-warnings-list', display them, and set
`delayed-warnings-list' back to nil.
(defvar delayed-warnings-hook '(collapse-delayed-warnings display-delayed-warnings) (#$ . 139162))
#@166 Display a delayed warning.
Aside from going through `delayed-warnings-list', this is equivalent
to `display-warning'.

(fn TYPE MESSAGE &optional LEVEL BUFFER-NAME)
(defalias 'delay-warning #[1026 "FB\211\207" [delayed-warnings-list] 8 (#$ . 139488)])
#@151 Add ELEMENT to `buffer-invisibility-spec'.
See documentation for `buffer-invisibility-spec' for the kind of elements
that can be added.

(fn ELEMENT)
(defalias 'add-to-invisibility-spec #[257 "\301=\203	\301C\211B\211\207" [buffer-invisibility-spec t] 3 (#$ . 139753)])
#@63 Remove ELEMENT from `buffer-invisibility-spec'.

(fn ELEMENT)
(defalias 'remove-from-invisibility-spec #[257 ":\203\f\301
\"\202\302C\211\207" [buffer-invisibility-spec delete t] 4 (#$ . 140034)])
#@251 Evaluate BODY with syntax table of current buffer set to TABLE.
The syntax table of the current buffer is saved, BODY is evaluated, and the
saved table is restored, even in case of an abnormal exit.
Value is what BODY returns.

(fn TABLE &rest BODY)
(defalias 'with-syntax-table '(macro . #[385 "\300\301!\300\302!\303\304B\305BD\306\307\310DBB\311\312D\310DEEE\207" [make-symbol "table" "buffer" let ((syntax-table)) ((current-buffer)) unwind-protect progn set-syntax-table save-current-buffer set-buffer] 12 (#$ . 140244)]))
(byte-code "\300\301\302\303#\210\304\301\305\306#\300\207" [put with-syntax-table edebug-form-spec t function-put lisp-indent-function 1] 4)
#@160 Return a new syntax table.
Create a syntax table which inherits from OLDTABLE (if non-nil) or
from `standard-syntax-table' otherwise.

(fn &optional OLDTABLE)
(defalias 'make-syntax-table #[256 "\300\301\302\"\303
\206\f\304 \"\210\211\207" [make-char-table syntax-table nil set-char-table-parent standard-syntax-table] 5 (#$ . 140930)])
#@131 Return the raw syntax descriptor for the char after POS.
If POS is outside the buffer's accessible portion, return nil.

(fn POS)
(defalias 'syntax-after #[257 "\211eW\206	\211dY?\205)\205\301
\302\"\211:\203\211\202'\211\206$\302 fH\262
\207" [parse-sexp-lookup-properties get-char-property syntax-table] 4 (#$ . 141277)])
#@290 Return the code for the syntax class described by SYNTAX.

SYNTAX should be a raw syntax descriptor; the return value is a
integer which encodes the corresponding syntax class.  See Info
node `(elisp)Syntax Table Internals' for a list of codes.

If SYNTAX is nil, return nil.

(fn SYNTAX)
(defalias 'syntax-class #[257 "\211\205	\300
@\301\"\207" [logand 65535] 4 (#$ . 141618)])
#@128 Used in `forward-word-strictly' and `backward-word-strictly'
to countermand the effect of `find-word-boundary-function-table'.
(defvar word-move-empty-char-table nil (#$ . 142006))
#@471 Move point forward ARG words (backward if ARG is negative).
If ARG is omitted or nil, move point forward one word.
Normally returns t.
If an edge of the buffer or a field boundary is reached, point is left there
and the function returns nil.  Field boundaries are not noticed if
`inhibit-field-text-motion' is non-nil.

This function is like `forward-word', but it is not affected
by `find-word-boundary-function-table'.  It is also not interactive.

(fn &optional ARG)
(defalias 'forward-word-strictly #[256 "\302!\203\n\202\303\304!\211\211\206\305v)\207" [word-move-empty-char-table find-word-boundary-function-table char-table-p make-char-table nil 1] 3 (#$ . 142194)])
#@310 Move backward until encountering the beginning of a word.
With argument ARG, do this that many times.
If ARG is omitted or nil, move point backward one word.

This function is like `forward-word', but it is not affected
by `find-word-boundary-function-table'.  It is also not interactive.

(fn &optional ARG)
(defalias 'backward-word-strictly #[256 "\302!\203\n\202\303\304!\211\211\206\305[v)\207" [word-move-empty-char-table find-word-boundary-function-table char-table-p make-char-table nil 1] 3 (#$ . 142884)])
#@273 Move point to the end of the next sequence of whitespace chars.
Each such sequence may be a single newline, or a sequence of
consecutive space and/or tab characters.
With prefix argument ARG, do it ARG times if positive, or move
backwards ARG times if negative.

(fn ARG)
(defalias 'forward-whitespace #[257 "\300
!\203
\301\302\303\304$\207\211\305W\205.\306\302\303\304#\203'\305\224f\307=\204'\310\303x\210\211T\262
\202
\207" [natnump re-search-forward "[ 	]+\\|\n" nil move 0 re-search-backward 10 " 	"] 6 (#$ . 143415) "^p"])
#@283 Move point to the next position that is the end of a symbol.
A symbol is any sequence of characters that are in either the
word constituent or symbol constituent syntax class.
With prefix argument ARG, do it ARG times if positive, or move
backwards ARG times if negative.

(fn ARG)
(defalias 'forward-symbol #[257 "\300
!\203
\301\302\303\304$\207\211\305W\205&\306\302\303\304#\203\307\310!\210\211T\262
\202
\207" [natnump re-search-forward "\\(\\sw\\|\\s_\\)+" nil move 0 re-search-backward skip-syntax-backward "w_"] 6 (#$ . 143960) "^p"])
#@176 Move point past all characters with the same syntax class.
With prefix argument ARG, do it ARG times if positive, or move
backwards ARG times if negative.

(fn &optional ARG)
(defalias 'forward-same-syntax #[256 "\211\204\300\262
\211\301W\203\302\303`Sfz!!\210\211T\262
\202\211\301V\2052\304\303\305fz!!\210\211S\262
\202\207" [1 0 skip-syntax-backward char-to-string skip-syntax-forward nil] 4 (#$ . 144517) "^p"])
(defvar text-clone--maintaining nil)
#@175 Propagate the changes made under the overlay OL1 to the other clones.
This is used on the `modification-hooks' property of text clones.

(fn OL1 AFTER BEG END &optional LEN)
(defalias 'text-clone--maintain #[1284 "\205
?\205
	?\205
\303!\205
\304\305\"\203\306\202 \307\303!\\]\262\310!Z^\262X\205
\212\304\311\"\203\242\303!
\\\310!Z
b\210\312 \313\216\314\304	\311\"\315#\204i
\262\202\237\307\225
W\203\204\307\225^\262\316\303\n!\307\225\\#\210\307\224V\203\237\307\224]\262\316\307\224Z\310!#\210*\266\303!Z\310!Z{\315\211\304\n\317\"\211\203\366\211@\310
!\f=\204\356\211\203\356\320\262\303!\\\310!Zb\210\211`V\204\355\212c\210)\211`|\210\210\210
A\266\202\202\271\210\211\205\377\321\n!)\266\204)\262
\207" [undo-in-progress text-clone--maintaining save-match-data-internal overlay-start overlay-get text-clone-spreadp 1 0 overlay-end text-clone-syntax match-data #[0 "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3] re-search-forward t move-overlay text-clones nil delete-overlay] 16 (#$ . 144988)])
#@626 Create a text clone of START...END at point.
Text clones are chunks of text that are automatically kept identical:
changes done to one of the clones will be immediately propagated to the other.

The buffer's content at point is assumed to be already identical to
the one between START and END.
If SYNTAX is provided it's a regexp that describes the possible text of
the clones; the clone will be shrunk or killed if necessary to ensure that
its text matches the regexp.
If SPREADP is non-nil it indicates that text inserted before/after the
clone should be incorporated in the clone.

(fn START END &optional SPREADP SYNTAX)
(defalias 'text-clone-create #[1026 "`Z\\\203o\204eX\203\300\202\301\203(
dY\204(dY\203,\300\202-\301\302Z\\\303\304$\302`Z\\\303\304$

D\305\306\307#\210\203W\305\310\304#\210\203c\305\311	#\210\305\312\304#\210\305\313#\210\305\306\314#\210\203\200\305\310\304#\210\203\214\305\311	#\210\305\312\304#\210\305\313#\207" [0 1 make-overlay nil t overlay-put modification-hooks (text-clone--maintain) text-clone-spreadp text-clone-syntax evaporate text-clones (text-clone--maintain)] 14 (#$ . 146112)])
#@1358 Define a symbol to identify a mail-sending package for `mail-user-agent'.

SYMBOL can be any Lisp symbol.  Its function definition and/or
value as a variable do not matter for this usage; we use only certain
properties on its property list, to encode the rest of the arguments.

COMPOSEFUNC is program callable function that composes an outgoing
mail message buffer.  This function should set up the basics of the
buffer without requiring user interaction.  It should populate the
standard mail headers, leaving the `to:' and `subject:' headers blank
by default.

COMPOSEFUNC should accept several optional arguments--the same
arguments that `compose-mail' takes.  See that function's documentation.

SENDFUNC is the command a user would run to send the message.

Optional ABORTFUNC is the command a user would run to abort the
message.  For mail packages that don't have a separate abort function,
this can be `kill-buffer' (the equivalent of omitting this argument).

Optional HOOKVAR is a hook variable that gets run before the message
is actually sent.  Callers that use the `mail-user-agent' may
install a hook function temporarily on this hook variable.
If HOOKVAR is nil, `mail-send-hook' is used.

The properties used on SYMBOL are `composefunc', `sendfunc',
`abortfunc', and `hookvar'.

(fn SYMBOL COMPOSEFUNC SENDFUNC &optional ABORTFUNC HOOKVAR)
(defalias 'define-mail-user-agent #[1283 "\300\301#\210\300\302#\210\300\303\206\304#\210\300\305\206\306#\207" [put composefunc sendfunc abortfunc kill-buffer hookvar mail-send-hook] 9 (#$ . 147299)])
#@140 Print a trace of a single stack frame to `standard-output'.
EVALD, FUNC, ARGS, FLAGS are as in `mapbacktrace'.

(fn EVALD FUNC ARGS FLAGS)
(defalias 'backtrace--print-frame #[1028 "\301\302\303\"\203\f\304\202
\305!\210\203-\204-\306!\210
\203&\306!\210\2023\301\307!\210\2023\306B!\210\301\310!\207" [debugger-stack-frame-as-list princ plist-get :debug-on-exit "* " "  " prin1 "()" "\n"] 8 (#$ . 148878)])
#@106 Print a trace of Lisp function calls currently active.
Output stream used is value of `standard-output'.
(defalias 'backtrace #[0 "\206\302\303\304\305\306\"*\207" [print-level print-escape-control-characters 8 t mapbacktrace backtrace--print-frame backtrace] 3 (#$ . 149306)])
#@177 Collect all frames of current backtrace into a list.
If non-nil, BASE should be a function, and frames before its
nearest activation frames are discarded.

(fn &optional BASE)
(defalias 'backtrace-frames #[256 "\300C\301\302\303\304\305\306!\307\"\310\311%\206\312\"\210\211\242\237\207" [nil mapbacktrace make-byte-code 128 "\300
\300\242B\240\207" vconcat vector [] 4 "\n\n(fn &rest FRAME)" backtrace-frames] 9 (#$ . 149596)])
#@655 Return the function and arguments NFRAMES up from current execution point.
If non-nil, BASE should be a function, and NFRAMES counts from its
nearest activation frame.
If the frame has not evaluated the arguments yet (or is a special form),
the value is (nil FUNCTION ARG-FORMS...).
If the frame has evaluated its arguments and called its function already,
the value is (t FUNCTION ARG-VALUES...).
A &rest arg is represented as the tail of the list ARG-VALUES.
FUNCTION is whatever was supplied as car of evaluated list,
or a lambda expression for macro calls.
If NFRAMES is more than the number of frames, the value is nil.

(fn NFRAMES &optional BASE)
(defalias 'backtrace-frame #[513 "\300\301\206\302#\207" [backtrace-frame--internal #[1028 "BB\207" [] 7 "\n\n(fn EVALD FUNC ARGS _)"] backtrace-frame] 6 (#$ . 150037)])
#@367 Special hook called to skip special frames in `called-interactively-p'.
The functions are called with 3 arguments: (I FRAME1 FRAME2),
where FRAME1 is a "current frame", FRAME2 is the next frame,
I is the index of the frame after FRAME2.  It should return nil
if those frames don't seem special and otherwise, it should return
the number of frames to skip (minus 1).
(defvar called-interactively-p-functions nil (#$ . 150875))
(defconst internal--funcall-interactively (symbol-function 'funcall-interactively))
#@1424 Return t if the containing function was called by `call-interactively'.
If KIND is `interactive', then only return t if the call was made
interactively by the user, i.e. not in `noninteractive' mode nor
when `executing-kbd-macro'.
If KIND is `any', on the other hand, it will return t for any kind of
interactive call, including being called as the binding of a key or
from a keyboard macro, even in `noninteractive' mode.

This function is very brittle, it may fail to return the intended result when
the code is debugged, advised, or instrumented in some form.  Some macros and
special forms (such as `condition-case') may also sometimes wrap their bodies
in a `lambda', so any call to `called-interactively-p' from those bodies will
indicate whether that lambda (rather than the surrounding function) was called
interactively.

Instead of using this function, it is cleaner and more reliable to give your
function an extra optional argument whose `interactive' spec specifies
non-nil unconditionally ("p" is a good way to do this), or via
(not (or executing-kbd-macro noninteractive)).

The only known proper use of `interactive' for KIND is in deciding
whether to display a helpful message, or how to display it.  If you're
thinking of using it for any other purpose, it is quite likely that
you're making a mistake.  Think: what do you want to do when the
command is called from a keyboard macro?

(fn &optional KIND)
(defalias 'called-interactively-p #[256 "\211\303=\205\206	?\205
\304C\305C\305C\306\211#\210\211#\210\242\203-\242@\203\242A@\307>\204\310\311\242\242\242$\211\204G\305\202`\211\312=\203Q\313\202`\314\242\315#\240\210
#\262
\204\242\242B\211:\205
\211@\211:\203\355\211A\211:\203\274\211@\211\316\317!!\262
?\205\267A\211:\205\265\211@\211\313=\205\263
A\211:\205\261\211@\211\n\317!=\262
\205\257\313\262
\262
\262
\262
\262
\202\350A\211:\205\346\211@\211\313=\205\344
A\211:\205\342\211@\211\n\317!=\262
\205\340\313\262
\262
\262
\262
\262
\202

A\211:\205
\211@\211\313=\205

A\211:\205
\211@\211\n\317!=\262
\205
\313\262
\262
\262
\262
\262
\262
\266\204\207" [executing-kbd-macro noninteractive internal--funcall-interactively interactive 1 nil #[771 "

\242\240\210\211\300\242\301\"\240\210\211\242T\240\207" [backtrace-frame called-interactively-p] 7 "\n\n(fn I FRAME NEXTFRAME)"] (interactive-p 'byte-code) run-hook-with-args-until-success called-interactively-p-functions 0 t + -1 subrp indirect-function] 17 (#$ . 151393)])
(set-advertised-calling-convention 'called-interactively-p '(kind) "23.1")
#@960 Return t if the containing function was run directly by user input.
This means that the function was called with `call-interactively'
(which includes being called as the binding of a key)
and input is currently coming from the keyboard (not a keyboard macro),
and Emacs is not running in batch mode (`noninteractive' is nil).

The only known proper use of `interactive-p' is in deciding whether to
display a helpful message, or how to display it.  If you're thinking
of using it for any other purpose, it is quite likely that you're
making a mistake.  Think: what do you want to do when the command is
called from a keyboard macro or in batch mode?

To test whether your function was called with `call-interactively',
either (i) add an extra optional argument and give it an `interactive'
spec that specifies non-nil unconditionally (such as "p"); or (ii)
use `called-interactively-p'.

To test whether a function can be called interactively, use
`commandp'.
(defalias 'interactive-p #[0 "\300\301!\207" [called-interactively-p interactive] 2 (#$ . 154001)])
(make-obsolete 'interactive-p 'called-interactively-p "23.2")
#@22 

(fn KEYMAP SYMBOL)
(defalias 'internal-push-keymap #[514 "\211J
>?\205-\300J>\204$\301\302J\"\262
\211\211\300AB\241\266

L\210\211\211AB\241\262
\207" [add-keymap-witness make-composed-keymap nil] 7 (#$ . 155128)])
#@22 

(fn KEYMAP SYMBOL)
(defalias 'internal-pop-keymap #[514 "\211J
>\203\211\211\300A\"\241\266\211AA\211\203\301
!\205*
A@\302=\205*
L\262
\207" [delq keymapp add-keymap-witness] 8 (#$ . 155361)])
(byte-code "\300\301\302\303#\210\304\301\302\305#\207" [defalias set-temporary-overlay-map set-transient-map nil make-obsolete "24.4"] 4)
#@836 Set MAP as a temporary keymap taking precedence over other keymaps.
Normally, MAP is used only once, to look up the very next key.
However, if the optional argument KEEP-PRED is t, MAP stays
active if a key from MAP is used.  KEEP-PRED can also be a
function of no arguments: it is called from `pre-command-hook' and
if it returns non-nil, then MAP stays active.

Optional arg ON-EXIT, if non-nil, specifies a function that is
called, with no arguments, after MAP is deactivated.

This uses `overriding-terminal-local-map' which takes precedence over all other
keymaps.  As usual, if no match for a key is found in MAP, the normal key
lookup sequence then continues.

This returns an "exit function", which can be called with no argument
to deactivate this transient map, regardless of KEEP-PRED.

(fn MAP &optional KEEP-PRED ON-EXIT)
(defalias 'set-transient-map #[769 "\300\301!\302\303\304\305\306#\307\"\310$
\302\303\311\305\306\n\n#\312\"\313$M\210\314\315\"\210\316\317\"\210\207" [make-symbol "clear-transient-map" make-byte-code 0 "\303\300\304\"\210\305\306\302\"\210\301\205\301 \207" vconcat vector [internal-pop-keymap overriding-terminal-local-map remove-hook pre-command-hook] 3 "\3051A\301\204\f\306\2029\300A@=\204 \300AA>\203 \307\2029\301\307=\2037\310\300\311 \"\211\2052\f
=\262
\2029\301 ?\205?\302 0\207\312\313\"\210\306\207" [overriding-terminal-local-map this-command (debug error) nil t lookup-key this-command-keys-vector message "set-transient-map PCH: %S"] 4 add-hook pre-command-hook internal-push-keymap overriding-terminal-local-map] 14 (#$ . 155714)])
#@564 Report progress of an operation in the echo area.
REPORTER should be the result of a call to `make-progress-reporter'.

If REPORTER is a numerical progress reporter---i.e. if it was
 made using non-nil MIN-VALUE and MAX-VALUE arguments to
 `make-progress-reporter'---then VALUE should be a number between
 MIN-VALUE and MAX-VALUE.

If REPORTER is a non-numerical reporter, VALUE should be nil.

This function is relatively inexpensive.  If the change since
last update is too small or insufficient time has passed, it does
nothing.

(fn REPORTER &optional VALUE)
(defalias 'progress-reporter-update #[513 "\211\247\203\f\211@Y\205\300\"\207" [progress-reporter-do-update] 5 (#$ . 157334)])
(put 'progress-reporter-update 'byte-optimizer 'byte-compile-inline-expand)
#@1204 Return progress reporter object for use with `progress-reporter-update'.

MESSAGE is shown in the echo area, with a status indicator
appended to the end.  When you call `progress-reporter-done', the
word "done" is printed after the MESSAGE.  You can change the
MESSAGE of an existing progress reporter by calling
`progress-reporter-force-update'.

MIN-VALUE and MAX-VALUE, if non-nil, are starting (0% complete)
and final (100% complete) states of operation; the latter should
be larger.  In this case, the status message shows the percentage
progress.

If MIN-VALUE and/or MAX-VALUE is omitted or nil, the status
message shows a "spinning", non-numeric indicator.

Optional CURRENT-VALUE is the initial progress; the default is
MIN-VALUE.
Optional MIN-CHANGE is the minimal change in percents to report;
the default is 1%.
CURRENT-VALUE and MIN-CHANGE do not have any effect if MIN-VALUE
and/or MAX-VALUE are nil.

Optional MIN-TIME specifies the minimum interval time between
echo area updates (default is 0.2 seconds.)  If the OS is not
capable of measuring fractions of seconds, this parameter is
effectively rounded up.

(fn MESSAGE &optional MIN-VALUE MAX-VALUE CURRENT-VALUE MIN-CHANGE MIN-TIME)
(defalias 'make-progress-reporter #[1537 "\300\301\"\203
\302P\262\211\204\303\262
\206\304\305\306Y\205\"\307 \n\2036\310^\311]\2027\311&B\211\206C\211\247\203O\211@Y\205S\312\"\266\211\207" [string-match "[[:alnum:]]\\'" "..." 0.2 0 vector 0.02 float-time 50 1 progress-reporter-do-update] 14 (#$ . 158114)])
#@244 Report progress of an operation in the echo area unconditionally.

The first two arguments are the same as in `progress-reporter-update'.
NEW-MESSAGE, if non-nil, sets a new message for the reporter.

(fn REPORTER &optional VALUE NEW-MESSAGE)
(defalias 'progress-reporter-force-update #[769 "A
\203\211\300I\210\211\301H\203\211\301\302 I\210\303\"\207" [3 0 float-time progress-reporter-do-update] 7 (#$ . 159671)])
#@51 Characters to use for pulsing progress reporters.
(defvar progress-reporter--pulse-characters ["-" "\\" "|" "/"] (#$ . 160102))
#@23 

(fn REPORTER VALUE)
(defalias 'progress-reporter-do-update #[514 "
A\211\302H
\303H\304H\305H?\206#\306 Y\205#\302\307H\\I\203\207\203\207Z\310\245U\203:\302\202C\311Z\245!	\203S\n\312H\202T\303\\_\\^\240\210\250\203l	\313@!\240\210\205\202\211\302V\203~\314\315#\202\202\314\316\"\266\202\202\243\211\205\243\317@T\312\"\320
\240\210\314\321	H#)\262
\207" [message-log-max progress-reporter--pulse-characters 0 1 2 3 float-time 5 100.0 truncate 4 ceiling message "%s%d%%" "%s" mod nil "%s %s"] 15 (#$ . 160236)])
#@79 Print reporter's message followed by word "done" in echo area.

(fn REPORTER)
(defalias 'progress-reporter-done #[257 "\300\301A\302H\"\207" [message "%sdone" 3] 5 (#$ . 160816)])
#@530 Loop a certain number of times and report progress in the echo area.
Evaluate BODY with VAR bound to successive integers running from
0, inclusive, to COUNT, exclusive.  Then evaluate RESULT to get
the return value (nil if RESULT is omitted).

At each iteration MESSAGE followed by progress percentage is
printed in the echo area.  After the loop is finished, MESSAGE
followed by word "done" is printed.  This macro is a
convenience wrapper around `make-progress-reporter' and friends.

(fn (VAR COUNT [RESULT]) MESSAGE BODY...)
(defalias 'dotimes-with-progress-reporter '(macro . #[642 "\300\301!\300\302!\303A@\304D@D\305\nFDE\306\307\n@E\310	\311	\312@\313@DEEC\"BB\314D\315AABBBBB\207" [make-symbol "--dotimes-temp--" "--dotimes-temp2--" 0 let make-progress-reporter while < append progress-reporter-update setq 1+ progress-reporter-done nil] 19 (#$ . 161004)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put dotimes-with-progress-reporter lisp-indent-function 2 put edebug-form-spec ((symbolp form &optional form) form body)] 5)
#@122 Specify the string used to separate the version elements.

Usually the separator is ".", but it can be any other string.
(defconst version-separator "." (#$ . 162090))
#@983 Specify association between non-numeric version and its priority.

This association is used to handle version string like "1.0pre2",
"0.9alpha1", etc.  It's used by `version-to-list' (which see) to convert the
non-numeric part of a version string to an integer.  For example:

   String Version    Integer List Version
   "0.9snapshot"     (0  9 -4)
   "1.0-git"         (1  0 -4)
   "1.0.cvs"         (1  0 -4)
   "1.0pre2"         (1  0 -1 2)
   "1.0PRE2"         (1  0 -1 2)
   "22.8beta3"       (22 8 -2 3)
   "22.8 Beta3"      (22 8 -2 3)
   "0.9alpha1"       (0  9 -3 1)
   "0.9AlphA1"       (0  9 -3 1)
   "0.9 alpha"       (0  9 -3)

Each element has the following form:

   (REGEXP . PRIORITY)

Where:

REGEXP		regexp used to match non-numeric part of a version string.
		It should begin with the `^' anchor and end with a `$' to
		prevent false hits.  Letter-case is ignored while matching
		REGEXP.

PRIORITY	a negative integer specifying non-numeric priority of REGEXP.
(defconst version-regexp-alist '(("^[-._+ ]?snapshot$" . -4) ("^[-._+]$" . -4) ("^[-._+ ]?\\(cvs\\|git\\|bzr\\|svn\\|hg\\|darcs\\)$" . -4) ("^[-._+ ]?alpha$" . -3) ("^[-._+ ]?beta$" . -2) ("^[-._+ ]?\\(pre\\|rc\\)$" . -1)) (#$ . 162265))
#@1093 Convert version string VER into a list of integers.

The version syntax is given by the following EBNF:

   VERSION ::= NUMBER ( SEPARATOR NUMBER )*.

   NUMBER ::= (0|1|2|3|4|5|6|7|8|9)+.

   SEPARATOR ::= `version-separator' (which see)
	       | `version-regexp-alist' (which see).

The NUMBER part is optional if SEPARATOR is a match for an element
in `version-regexp-alist'.

Examples of valid version syntax:

   1.0pre2   1.0.7.5   22.8beta3   0.9alpha1   6.9.30Beta   2.4.snapshot   .5

Examples of invalid version syntax:

   1.0prepre2   1.0..7.5   22.8X3   alpha3.2

Examples of version conversion:

   Version String    Version as a List of Integers
   ".5"              (0 5)
   "0.9 alpha"       (0  9 -3)
   "0.9AlphA1"       (0  9 -3 1)
   "0.9snapshot"     (0  9 -4)
   "1.0-git"         (1  0 -4)
   "1.0.7.5"         (1  0  7 5)
   "1.0.cvs"         (1  0 -4)
   "1.0PRE2"         (1  0 -1 2)
   "1.0pre2"         (1  0 -1 2)
   "22.8 Beta3"      (22 8 -2 3)
   "22.8beta3"       (22 8 -2 3)

See documentation for `version-separator' and `version-regexp-alist'.

(fn VER)
(defalias 'version-to-list #[257 "\211;\204	\305\306!\210\211GGY\203 \211\307GO\230\203 \310
P\262
\311
\312\313\314#)\266\203\2045\305\315\"\210\316 \317\216\307\313\312\211\211\314\320#\211\262\203\330
U\203\330\321\307\225O!B\262\307\225\262\314\322#\211\262\203A
U\203A\307\225O\262\307\225\262
\230\204A\f\262
\211\203\240\314
@@\"\204\240\211A\262
\202\214\211\203\256\211@AB\262\202A\314\323\"\203\317GU\203\317\324\325\326\"\227\307H\327\330#B\262\202A\305\331\"\210\202A\237)\266\205*\207" [version-separator inhibit-changing-match-data save-match-data-internal case-fold-search version-regexp-alist error "Version must be a string" 0 "0" "^[0-9]" nil t string-match "Invalid version syntax: `%s' (must start with a number)" match-data #[0 "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3] "[0-9]+" string-to-number "[^0-9]+" "^[-._+ ]?\\([a-zA-Z]\\)$" - match-string 1 97 -1 "Invalid version syntax: `%s'"] 10 (#$ . 163493)])
#@348 Return t if L1, a list specification of a version, is lower than L2.

Note that a version specified by the list (1) is equal to (1 0),
(1 0 0), (1 0 0 0), etc.  That is, the trailing zeros are insignificant.
Also, a version given by the list (1) is higher than (1 -1), which in
turn is higher than (1 -2), which is higher than (1 -3).

(fn L1 L2)
(defalias 'version-list-< #[514 "
\203\211\203
@
@U\203
A\262\211A\262
\202
\203)\211\203)
@
@W\207
\2043\211\2043\300\207
\203=\301!\302W\207\302\301!W\207" [nil version-list-not-zero 0] 5 (#$ . 165617)])
#@346 Return t if L1, a list specification of a version, is equal to L2.

Note that a version specified by the list (1) is equal to (1 0),
(1 0 0), (1 0 0 0), etc.  That is, the trailing zeros are insignificant.
Also, a version given by the list (1) is higher than (1 -1), which in
turn is higher than (1 -2), which is higher than (1 -3).

(fn L1 L2)
(defalias 'version-list-= #[514 "
\203\211\203
@
@U\203
A\262\211A\262
\202
\203%\211\203%\300\207
\204.\211?\206=
\2038\301!\302U\207\301
!\302U\207" [nil version-list-not-zero 0] 4 (#$ . 166193)])
#@316 Return t if L1, a list specification of a version, is lower or equal to L2.

Note that integer list (1) is equal to (1 0), (1 0 0), (1 0 0 0),
etc.  That is, the trailing zeroes are insignificant.  Also, integer
list (1) is greater than (1 -1) which is greater than (1 -2)
which is greater than (1 -3).

(fn L1 L2)
(defalias 'version-list-<= #[514 "
\203\211\203
@
@U\203
A\262\211A\262
\202
\203)\211\203)
@
@W\207
\2042\211?\206A
\203<\300!\301X\207\301\300!X\207" [version-list-not-zero 0] 5 (#$ . 166759)])
#@141 Return the first non-zero element of LST, which is a list of integers.

If all LST elements are zeros or LST is nil, return zero.

(fn LST)
(defalias 'version-list-not-zero #[257 "\211\203\211@\300U\203\211A\262
\202\211\203\211@\207\300\207" [0] 3 (#$ . 167293)])
#@402 Return t if version V1 is lower (older) than V2.

Note that version string "1" is equal to "1.0", "1.0.0", "1.0.0.0",
etc.  That is, the trailing ".0"s are insignificant.  Also, version
string "1" is higher (newer) than "1pre", which is higher than "1beta",
which is higher than "1alpha", which is higher than "1snapshot".
Also, "-GIT", "-CVS" and "-NNN" are treated as snapshot versions.

(fn V1 V2)
(defalias 'version< #[514 "\300\301!\301!\"\207" [version-list-< version-to-list] 6 (#$ . 167573)])
#@414 Return t if version V1 is lower (older) than or equal to V2.

Note that version string "1" is equal to "1.0", "1.0.0", "1.0.0.0",
etc.  That is, the trailing ".0"s are insignificant.  Also, version
string "1" is higher (newer) than "1pre", which is higher than "1beta",
which is higher than "1alpha", which is higher than "1snapshot".
Also, "-GIT", "-CVS" and "-NNN" are treated as snapshot versions.

(fn V1 V2)
(defalias 'version<= #[514 "\300\301!\301!\"\207" [version-list-<= version-to-list] 6 (#$ . 168083)])
#@392 Return t if version V1 is equal to V2.

Note that version string "1" is equal to "1.0", "1.0.0", "1.0.0.0",
etc.  That is, the trailing ".0"s are insignificant.  Also, version
string "1" is higher (newer) than "1pre", which is higher than "1beta",
which is higher than "1alpha", which is higher than "1snapshot".
Also, "-GIT", "-CVS" and "-NNN" are treated as snapshot versions.

(fn V1 V2)
(defalias 'version= #[514 "\300\301!\301!\"\207" [version-list-= version-to-list] 6 (#$ . 168607)])
#@205 Alist giving the version of each versioned builtin package.
I.e. each element of the list is of the form (NAME . VERSION) where
NAME is the package name as a symbol, and VERSION is its version
as a list.
(defvar package--builtin-versions (byte-code "\301\302\303!BC!\207" [emacs-version purecopy emacs version-to-list] 4) (#$ . 169107))
#@12 

(fn DIR)
(defalias 'package--description-file #[257 "\300\301!!\302\303\"\203\304\305\"\202\211\262
\306P\207" [file-name-nondirectory directory-file-name string-match "\\([^.].*?\\)-\\([0-9]+\\(?:[.][0-9]+\\|\\(?:pre\\|beta\\|alpha\\)[0-9]+\\)*\\)" match-string 1 "-pkg.el"] 5 (#$ . 169451)])
#@142 Invoke BODY with MUTEX held, releasing MUTEX when done.
This is the simplest safe way to acquire and release a mutex.

(fn MUTEX &rest BODY)
(defalias 'with-mutex '(macro . #[385 "\300\301!\302
DC\303D\304\305B\306DEF\207" [make-symbol "mutex" let mutex-lock unwind-protect progn mutex-unlock] 10 (#$ . 169761)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put with-mutex lisp-indent-function 1 put edebug-form-spec t] 5)
#@631 Hash table mapping prefixes to the files in which they're used.
This can be used to automatically fetch not-yet-loaded definitions.
More specifically, if there is a value of the form (FILES...) for a string PREFIX
it means that the FILES define variables or functions with names that start
with PREFIX.

Note that it does not imply that all definitions starting with PREFIX can
be found in those files.  E.g. if prefix is "gnus-article-" there might
still be definitions of the form "gnus-article-toto-titi" in other files, which would
presumably appear in this table under another prefix such as "gnus-"
or "gnus-article-toto-".
(defvar definition-prefixes (make-hash-table :test 'equal) (#$ . 170215))
#@55 Register that FILE uses PREFIXES.

(fn FILE PREFIXES)
(defalias 'register-definition-prefixes #[514 "\211\211\205\211@\301
\302\"B#\210
A\266\202\202
\207" [definition-prefixes puthash gethash] 10 (#$ . 170925)])
#@22 Separator for menus.
(defconst menu-bar-separator '("--") (#$ . 171151))
(byte-code "\300\301\302\303 !!@!\203\304\305!\210\300\207" [hash-table-p read-from-string prin1-to-string make-hash-table provide hashtable-print-readable] 4)
#@301 Produce the canonical file name for FILE from its MSYS form.

On systems other than MS-Windows, just returns FILE.
On MS-Windows, converts /d/foo/bar form of file names
passed by MSYS Make into d:/foo/bar that Emacs can grok.

This function is called from lisp/Makefile and leim/Makefile.

(fn FILE)
(defalias 'unmsys--file-name #[257 "\301=\203\302\303\"\203\211\304\305O\306\305\307OQ\262
\207" [system-type windows-nt string-match "\\`/[a-zA-Z]/" 1 2 ":" nil] 6 (#$ . 171393)])