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



(byte-code "\300\301!\210\300\302!\210\300\303!\210\304\305\306\307\310\311%\210\312\313\314\315\316DD\317\320\321%\210\312\322\314\315\323DD\324\320\325\326\327&\207" [require backquote macroexp cconv custom-declare-group bytecomp nil "Emacs Lisp byte-compiler." :group lisp custom-declare-variable emacs-lisp-file-regexp funcall function #[0 "\300\207" ["\\.el\\'"] 1 #1=""] "Regexp which matches Emacs Lisp source files.\nIf you change this, you might want to set `byte-compile-dest-file-function'.\n(Note that the assumption of a \".elc\" suffix for compiled files\nis hard-coded in various places in Emacs.)" :type regexp byte-compile-dest-file-function #[0 "\300\207" [byte-compile--default-dest-file] 1 #1#] "Function for the function `byte-compile-dest-file' to call.\nIt should take one argument, the name of an Emacs Lisp source\nfile name, and return the name of the compiled file.\n(Note that the assumption that the source and compiled files\nare found in the same directory is hard-coded in various places in Emacs.)" (choice (const nil) function) :version "23.2"] 8)
#@17 

(fn FILENAME)
(defalias 'byte-compiler-base-file-name #[257 "\300
\301\"\211\203
\211\301\"\207
\207" [find-file-name-handler byte-compiler-base-file-name] 5 (#$ . 1167)])
(byte-code "\300\301!\203\302\303!\204\304\303\305\306!\"\210\202\307\301\310\"\210\300\207" [fboundp byte-compile-dest-file featurep bytecomp display-warning format-message "Changing `byte-compile-dest-file' is obsolete (as of 23.2);\nset `byte-compile-dest-file-function' instead." defalias #[257 "\206\301
!\207" [byte-compile-dest-file-function byte-compile--default-dest-file] 3 "Convert an Emacs Lisp source file name to a compiled file name.\nIf `byte-compile-dest-file-function' is non-nil, uses that\nfunction to do the work.  Otherwise, if FILENAME matches\n`emacs-lisp-file-regexp' (by default, files with the extension \".el\"),\nreplaces the matching part (and anything after it) with \".elc\";\notherwise adds \".elc\".\n\n(fn FILENAME)"]] 4)
#@17 

(fn FILENAME)
(defalias 'byte-compile--default-dest-file #[257 "\301\302!!\262
\303\"\203\211\304\211\224O\305P\207\211\305P\207" [emacs-lisp-file-regexp file-name-sans-versions byte-compiler-base-file-name string-match 0 ".elc"] 4 (#$ . 2115)])
(byte-code "\300\301\302\"\210\300\303\302\"\210\300\304\302\"\210\300\305\302\"\210\306\307\310\311\312DD\313\314\315%\210\306\316\310\311\317DD\320\314\321%\210\306\322\310\311\323DD\324\314\315%\210\306\325\310\311\326DD\327\330\331\314\315&\207" [autoload byte-compile-inline-expand "byte-opt" byte-optimize-one-form byte-optimize-lapcode byte-decompile-bytecode custom-declare-variable byte-compile-verbose funcall function #[0 "?\205	\nV\207" [noninteractive baud-rate search-slow-speed] 2 #1=""] "Non-nil means print messages describing progress of byte-compiler." :type boolean byte-optimize #[0 "\300\207" [t] 1 #1#] "Enable optimization in the byte compiler.\nPossible values are:\n  nil      - no optimization\n  t        - all optimizations\n  `source' - source-level optimizations only\n  `byte'   - code-level optimizations only" (choice (const :tag "none" nil) (const :tag "all" t) (const :tag "source-level" source) (const :tag "byte-level" byte)) byte-compile-delete-errors #[0 "\300\207" [nil] 1 #1#] "If non-nil, the optimizer may delete forms that may signal an error.\nThis includes variable references and calls to functions such as `car'." byte-compile-cond-use-jump-table #[0 "\300\207" [t] 1 #1#] "Compile `cond' clauses to a jump table implementation (using a hash-table)." :version "26.1"] 8)
#@462 If non-nil, compile function bodies so they load lazily.
They are hidden in comments in the compiled file,
and each one is brought into core when the
function is called.

To enable this option, make it a file-local variable
in the source file you want it to apply to.
For example, add  -*-byte-compile-dynamic: t;-*- on the first line.

When this option is true, if you load the compiled file and then move it,
the functions you loaded will not be able to run.
(defvar byte-compile-dynamic nil (#$ . 3699))
(make-obsolete-variable 'byte-compile-dynamic "not worthwhile any more." "27.1")
#@70 If non-nil, disable `print-circle' on printing a byte-compiled code.
(defvar byte-compile-disable-print-circle nil (#$ . 4293))
(byte-code "\300\301\302\303#\210\304\305\306\307\310DD\311\312\313%\207" [make-obsolete-variable byte-compile-disable-print-circle nil "24.1" custom-declare-variable byte-compile-dynamic-docstrings funcall function #[0 "\300\207" [t] 1 ""] "If non-nil, compile doc strings for lazy access.\nWe bury the doc strings of functions and variables inside comments in\nthe file, and bring them into core only when they are actually needed.\n\nWhen this option is true, if you load the compiled file and then move it,\nyou won't be able to find the documentation of anything in that file.\n\nTo disable this option for a certain file, make it a file-local variable\nin the source file.  For example, add this to the first line:\n  -*-byte-compile-dynamic-docstrings:nil;-*-\nYou can also set the variable globally.\n\nThis option is enabled by default because it reduces Emacs memory usage." :type boolean] 6)
#@41 Name of the byte-compiler's log buffer.
(defconst byte-compile-log-buffer "*Compile-Log*" (#$ . 5330))
#@137 Variables known to be declared as dynamic, for warning purposes.
Each element is (VAR . FILE), indicating that VAR is declared in FILE.
(defvar byte-compile--known-dynamic-vars nil (#$ . 5440))
#@48 All dynamic variable declarations seen so far.
(defvar byte-compile--seen-defvars nil (#$ . 5640))
(byte-code "\300\301\302\303\304DD\305\306\307%\210\300\310\302\303\311DD\312\306\313%\207" [custom-declare-variable byte-optimize-log funcall function #[0 "\300\207" [nil] 1 #1=""] "If non-nil, the byte-compiler will log its optimizations.\nIf this is `source', then only source-level optimizations will be logged.\nIf it is `byte', then only byte-level optimizations will be logged.\nThe information is logged to `byte-compile-log-buffer'." :type (choice (const :tag "none" nil) (const :tag "all" t) (const :tag "source-level" source) (const :tag "byte-level" byte)) byte-compile-error-on-warn #[0 "\300\207" [nil] 1 #1#] "If true, the byte-compiler reports warnings with `error'." boolean] 6)
#@67 The list of warning types used when `byte-compile-warnings' is t.
(defconst byte-compile-warning-types '(redefine callargs free-vars unresolved obsolete noruntime interactive-only make-local mapcar constants suspicious lexical lexical-dynamic docstrings) (#$ . 6441))
(byte-code "\301\302\303\304\305DD\306\307\310\311\312\313\314\315\316\"BBBE%\207" [byte-compile-warning-types custom-declare-variable byte-compile-warnings funcall function #[0 "\300\207" [t] 1 ""] "List of warnings that the byte-compiler should issue (t for all).\n\nElements of the list may be:\n\n  free-vars   references to variables not in the current lexical scope.\n  unresolved  calls to unknown functions.\n  callargs    function calls with args that don't match the definition.\n  redefine    function name redefined from a macro to ordinary function or vice\n              versa, or redefined to take a different number of arguments.\n  obsolete    obsolete variables and functions.\n  noruntime   functions that may not be defined at runtime (typically\n              defined only under `eval-when-compile').\n  interactive-only\n	      commands that normally shouldn't be called from Lisp code.\n  lexical     global/dynamic variables lacking a prefix.\n  lexical-dynamic\n              lexically bound variable declared dynamic elsewhere\n  make-local  calls to `make-variable-buffer-local' that may be incorrect.\n  mapcar      mapcar called for effect.\n  constants   let-binding of, or assignment to, constants/nonvariables.\n  docstrings  docstrings that are too wide (longer than\n              `byte-compile-docstring-max-column' or\n              `fill-column' characters, whichever is bigger).\n  suspicious  constructs that usually don't do what the coder wanted.\n\nIf the list begins with `not', then the remaining elements specify warnings to\nsuppress.  For example, (not mapcar) will suppress warnings about mapcar." :type choice (const :tag "All" t) set :menu-tag "Some" mapcar #[257 "\300
D\207" [const] 3 "\n\n(fn X)"]] 13)
#@71 Dynamically bound by `with-suppressed-warnings' to suppress warnings.
(defvar byte-compile--suppressed-warnings nil (#$ . 8472))
(put 'byte-compile-warnings 'safe-local-variable #[257 "\2119\206
\300\301\302\303\"\"?\207" [delq nil mapcar #[257 "\2119?\207" [] 2 "\n\n(fn X)"]] 6 "\n\n(fn V)"])
#@108 Return non-nil if WARNING is enabled, according to `byte-compile-warnings'.

(fn WARNING &optional SYMBOL)
(defalias 'byte-compile-warning-enabled-p #[513 "\302\211\203 \211@\211@=\203
A>\203\303\262
A\266\202\202\210\211?\205;	\303=\206;	@\304=\2038	>?\207	>\207" [byte-compile--suppressed-warnings byte-compile-warnings nil t not] 7 (#$ . 8776)])
#@311 Change `byte-compile-warnings' to disable WARNING.
If `byte-compile-warnings' is t, set it to `(not WARNING)'.
Otherwise, if the first element is `not', add WARNING, else remove it.
Normally you should let-bind `byte-compile-warnings' before calling this,
else the global value will be modified.

(fn WARNING)
(defalias 'byte-compile-disable-warning #[257 "\301=\203\f\302
D\202)@\302=\203%\211>\203\202)\303C\"\202)\304
\"\211\207" [byte-compile-warnings t not append delq] 4 (#$ . 9148)])
#@296 Change `byte-compile-warnings' to enable WARNING.
If `byte-compile-warnings' is t, do nothing.  Otherwise, if the
first element is `not', remove WARNING, else add it.
Normally you should let-bind `byte-compile-warnings' before calling this,
else the global value will be modified.

(fn WARNING)
(defalias 'byte-compile-enable-warning #[257 "\301=\206%@\302=\203\303
\"\202#\211>\203\202#\304C\"\211\207" [byte-compile-warnings t not delq append] 4 (#$ . 9661)])
#@61 List of commands that are not meant to be called from Lisp.
(defvar byte-compile-interactive-only-functions nil (#$ . 10144))
(make-obsolete-variable 'byte-compile-interactive-only-functions "use the `interactive-only' symbol property instead." "24.4")
#@59 List of variables that shouldn't be reported as obsolete.
(defvar byte-compile-not-obsolete-vars nil (#$ . 10403))
#@66 Global list of variables that shouldn't be reported as obsolete.
(defvar byte-compile-global-not-obsolete-vars nil (#$ . 10524))
#@59 List of functions that shouldn't be reported as obsolete.
(defvar byte-compile-not-obsolete-funcs nil (#$ . 10659))
(byte-code "\300\301\302\303\304DD\305\306\307%\207" [custom-declare-variable byte-compile-generate-call-tree funcall function #[0 "\300\207" [nil] 1 ""] "Non-nil means collect call-graph information when compiling.\nThis records which functions were called and from where.\nIf the value is t, compilation displays the call graph when it finishes.\nIf the value is neither t nor nil, compilation asks you whether to\ndisplay the graph.\n\nThe call tree only lists functions called, not macros used.  Those\nfunctions which the byte-code interpreter knows about directly (eq,\ncons, etc.) are not reported.\n\nThe call tree also lists those functions which are not known to be\ncalled (that is, to which no calls have been compiled).  Functions\nwhich can be invoked interactively are excluded from this list." :type (choice (const :tag "Yes" t) (const :tag "No" nil) (other :tag "Ask" lambda))] 6)
#@241 Alist of functions and their call tree.
Each element looks like

  (FUNCTION CALLERS CALLS)

where CALLERS is a list of functions that call FUNCTION, and CALLS
is a list of functions for which calls were generated while compiling
FUNCTION.
(defvar byte-compile-call-tree nil (#$ . 11680))
(byte-code "\300\301\302\303\304DD\305\306\307%\207" [custom-declare-variable byte-compile-call-tree-sort funcall function #[0 "\300\207" [name] 1 ""] "If non-nil, sort the call tree.\nThe values `name', `callers', `calls', `calls+callers'\nspecify different fields to sort on." :type (choice (const name) (const callers) (const calls) (const calls+callers) (const nil))] 6)
#@78 If non-nil, byte compile errors will be raised as signals instead of logged.
(defvar byte-compile-debug nil (#$ . 12350))
#@63 List of all jump tables used during compilation of this form.
(defvar byte-compile-jump-tables nil (#$ . 12478))
#@68 List of all constants encountered during compilation of this form.
(defvar byte-compile-constants nil (#$ . 12597))
#@68 List of all variables encountered during compilation of this form.
(defvar byte-compile-variables nil (#$ . 12719))
#@106 List of dynamic variables bound in the context of the current form.
This list lives partly on the stack.
(defvar byte-compile-bound-variables nil (#$ . 12842))
#@121 List of variables that have been treated as lexical.
Filled in `cconv-analyze-form' but initialized and consulted here.
(defvar byte-compile-lexical-variables nil (#$ . 13009))
#@74 List of variables declared as constants during compilation of this file.
(defvar byte-compile-const-variables nil (#$ . 13192))
#@123 Implement `eval-when-compile' and `eval-and-compile'.
Return the compile-time value of FORM.

(fn FORM NON-TOPLEVEL-CASE)
(defalias 'byte-compile-recurse-toplevel #[514 "\301\"\262
\242\302=\203\302\303\304\305\"A\"B\207\211!\207" [byte-compile-macro-environment macroexp-macroexpand progn mapcar make-closure #[257 "\301
\300\"\207" [V0 byte-compile-recurse-toplevel] 4 "\n\n(fn SUBFORM)"]] 7 (#$ . 13327)])
#@205 The default macro-environment passed to macroexpand by the compiler.
Placing a macro here will cause a macro to have different semantics when
expanded by the compiler as when expanded by the interpreter.
(defconst byte-compile-initial-macro-environment (byte-code "\300\301\302B\303\304B\305\306BF\207" [(declare-function . byte-compile-macroexpand-declare-function) eval-when-compile #[128 "\300C\301\302!\303\304\"\"\210\305
\242D\207" [nil byte-compile-recurse-toplevel macroexp-progn make-closure #[257 "	\n\300\303\304\305!!!\240*\207" [V0 byte-compile-unresolved-functions byte-compile-new-defuns byte-compile-eval byte-compile-top-level byte-compile-preprocess] 6 "\n\n(fn FORM)"] quote] 7 "\n\n(fn &rest BODY)"] eval-and-compile #[128 "\300\301!\302\"\207" [byte-compile-recurse-toplevel macroexp-progn #[257 "\302
\"\303
	\"\210\207" [macroexpand-all-environment lexical-binding macroexpand-all eval] 5 "\n\n(fn FORM)"]] 4 "\n\n(fn &rest BODY)"] with-suppressed-warnings #[385 "\302\"\303\304D\305\306B	\"E)\207" [byte-compile--suppressed-warnings macroexpand-all-environment append internal--with-suppressed-warnings quote macroexpand-all progn] 7 "\n\n(fn WARNINGS &rest BODY)"]] 5) (#$ . 13751))
#@169 Alist of macros defined in the file being compiled.
Each element looks like (MACRONAME . DEFINITION).  It is
(MACRONAME . nil) when a macro is redefined as a function.
(defvar byte-compile-macro-environment byte-compile-initial-macro-environment (#$ . 14978))
#@400 Alist of functions defined in the file being compiled.
This is so we can inline them when necessary.
Each element looks like (FUNCTIONNAME . DEFINITION).  It is
(FUNCTIONNAME . nil) when a function is redefined as a macro.
It is (FUNCTIONNAME . t) when all we know is that it was defined,
and we don't know the definition.  For an autoloaded function, DEFINITION
has the form (autoload . FILENAME).
(defvar byte-compile-function-environment nil (#$ . 15245))
#@473 Alist of undefined functions to which calls have been compiled.
Each element in the list has the form (FUNCTION POSITION . CALLS)
where CALLS is a list whose elements are integers (indicating the
number of arguments passed in the function call) or the constant t
if the function is called indirectly.
This variable is only significant whilst compiling an entire buffer.
Used for warnings when a function is not known to be defined or is later
defined with incorrect args.
(defvar byte-compile-unresolved-functions nil (#$ . 15711))
#@227 Alist of functions called that may not be defined when the compiled code is run.
Used for warnings about calling a function that is defined during compilation
but won't necessarily be defined when the compiled file is loaded.
(defvar byte-compile-noruntime-functions nil (#$ . 16250))
#@201 List of (runtime) functions defined in this compilation run.
This variable is used to qualify `byte-compile-noruntime-functions' when
outputting warnings about functions not being defined at runtime.
(defvar byte-compile-new-defuns nil (#$ . 16542))
#@34 The current lexical environment.
(defvar byte-compile--lexical-environment nil (#$ . 16798))
(defvar byte-compile-tag-number 0)
#@87 Alist describing contents to put in byte code string.
Each element is (INDEX . VALUE)
(defvar byte-compile-output nil (#$ . 16932))
#@35 Current depth of execution stack.
(defvar byte-compile-depth 0 (#$ . 17070))
#@35 Maximum depth of execution stack.
(defvar byte-compile-maxdepth 0 (#$ . 17153))
#@80 compiler-macro for inlining `byte-to-native-lambda-p'.

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

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

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

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

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

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

(fn CL-WHOLE &cl-quote &key BYTE-FUNC LAP)
(defalias 'make-byte-to-native-lambda--cmacro #[385 "\300
\301\"A@\300\302\"A@\211\2037\211@\303>\203 \211AA\262
\202
\304>A@\203.\305\262
\202
\306\307@\"\210\202
\210\310\311\312\305\305&\207" [plist-member :byte-func :lap (:byte-func :lap :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:byte-func :lap)" cl--defsubst-expand (byte-func lap) (cl-block make-byte-to-native-lambda (record 'byte-to-native-lambda byte-func lap))] 12 (#$ . 19772)])
(put 'make-byte-to-native-lambda 'compiler-macro 'make-byte-to-native-lambda--cmacro)
#@83 Constructor for objects of type `byte-to-native-lambda'.

(fn &key BYTE-FUNC LAP)
(defalias 'make-byte-to-native-lambda #[128 "\300
\301\"A@\300\302\"A@\211\2037\211@\303>\203 \211AA\262
\202
\304>A@\203.\305\262
\202
\306\307@\"\210\202
\210\310\311#\207" [plist-member :byte-func :lap (:byte-func :lap :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:byte-func :lap)" record byte-to-native-lambda] 7 (#$ . 20462)])
(byte-code "\300\301\302\303#\304\305\306\307\310\306\311\312\305\303&	\207" [function-put make-byte-to-native-lambda side-effect-free t cl-struct-define byte-to-native-lambda nil cl-structure-object record ((cl-tag-slot) (byte-func) (lap)) cl-struct-byte-to-native-lambda-tags] 11)
#@82 compiler-macro for inlining `byte-to-native-func-def-p'.

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

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

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

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

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

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

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

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

(fn CL-WHOLE &cl-quote &key NAME C-NAME BYTE-FUNC)
(defalias 'make-byte-to-native-func-def--cmacro #[385 "\300
\301\"A@\300\302\"A@\300\303\"A@\211\203=\211@\304>\203&\211AA\262
\202\305>A@\2034\306\262
\202\307\310@\"\210\202\210\311\312\313\306\306&\207" [plist-member :name :c-name :byte-func (:name :c-name :byte-func :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:name :c-name :byte-func)" cl--defsubst-expand (name c-name byte-func) (cl-block make-byte-to-native-func-def (record 'byte-to-native-func-def name c-name byte-func))] 14 (#$ . 24723)])
(put 'make-byte-to-native-func-def 'compiler-macro 'make-byte-to-native-func-def--cmacro)
#@93 Constructor for objects of type `byte-to-native-func-def'.

(fn &key NAME C-NAME BYTE-FUNC)
(defalias 'make-byte-to-native-func-def #[128 "\300
\301\"A@\300\302\"A@\300\303\"A@\211\203=\211@\304>\203&\211AA\262
\202\305>A@\2034\306\262
\202\307\310@\"\210\202\210\311\312$\207" [plist-member :name :c-name :byte-func (:name :c-name :byte-func :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:name :c-name :byte-func)" record byte-to-native-func-def] 9 (#$ . 25491)])
(byte-code "\300\301\302\303#\304\305\306\307\310\311\312\313\305\303&	\207" [function-put make-byte-to-native-func-def side-effect-free t cl-struct-define byte-to-native-func-def "Named function defined at top-level." cl-structure-object record nil ((cl-tag-slot) (name) (c-name) (byte-func)) cl-struct-byte-to-native-func-def-tags] 11)
#@83 compiler-macro for inlining `byte-to-native-top-level-p'.

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

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

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

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

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

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

(fn CL-WHOLE &cl-quote &key FORM LEXICAL)
(defalias 'make-byte-to-native-top-level--cmacro #[385 "\300
\301\"A@\300\302\"A@\211\2037\211@\303>\203 \211AA\262
\202
\304>A@\203.\305\262
\202
\306\307@\"\210\202
\210\310\311\312\305\305&\207" [plist-member :form :lexical (:form :lexical :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:form :lexical)" cl--defsubst-expand (form lexical) (cl-block make-byte-to-native-top-level (record 'byte-to-native-top-level form lexical))] 12 (#$ . 28981)])
(put 'make-byte-to-native-top-level 'compiler-macro 'make-byte-to-native-top-level--cmacro)
#@85 Constructor for objects of type `byte-to-native-top-level'.

(fn &key FORM LEXICAL)
(defalias 'make-byte-to-native-top-level #[128 "\300
\301\"A@\300\302\"A@\211\2037\211@\303>\203 \211AA\262
\202
\304>A@\203.\305\262
\202
\306\307@\"\210\202
\210\310\311#\207" [plist-member :form :lexical (:form :lexical :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:form :lexical)" record byte-to-native-top-level] 7 (#$ . 29683)])
(byte-code "\300\301\302\303#\304\305\306\307\310\311\312\313\305\303&	\207" [function-put make-byte-to-native-top-level side-effect-free t cl-struct-define byte-to-native-top-level "All other top-level forms." cl-structure-object record nil ((cl-tag-slot) (form) (lexical)) cl-struct-byte-to-native-top-level-tags] 11)
#@33 Non-nil while native compiling.
(defvar byte-native-compiling nil (#$ . 30475))
#@52 To spill default qualities from the compiled file.
(defvar byte-native-qualities nil (#$ . 30561))
#@64 Non-nil while producing at the same time byte and native code.
(defvar byte+native-compile nil (#$ . 30666))
#@42 Hash byte-code -> byte-to-native-lambda.
(defvar byte-to-native-lambdas-h nil (#$ . 30781))
#@26 List of top level forms.
(defvar byte-to-native-top-level-forms nil (#$ . 30879))
#@56 Temporary file containing the byte-compilation output.
(defvar byte-to-native-output-file nil (#$ . 30967))
#@42 To spill `overriding-plist-environment'.
(defvar byte-to-native-plist-environment nil (#$ . 31081))
#@66 An array containing byte-code names indexed by byte-code values.
(defvar byte-code-vector nil (#$ . 31187))
#@56 An array with the stack adjustment for each byte-code.
(defvar byte-stack+-info nil (#$ . 31301))
#@55 

(fn OPCODE STACK-ADJUST OPNAME &optional DOCSTRING)
(defalias 'byte-defop '(macro . #[1027 "\300\301N\206\302\300\301\303\304\305\"#\306\301N\206\302\306\301\303\304\305\"#
I\210\211I\266\211\2037\307\310\311QF\207\307E\207" [byte-code-vector tmp-compile-time-value put make-vector 256 nil byte-stack+-info defconst "Byte code opcode " "."] 11 (#$ . 31405)]))
(defalias 'byte-extrude-byte-code-vectors '(macro . #[0 "\300\301\211\302N\303\211\302N\257\304\301\302\305#\210\304\303\302\305#\210\207" [setq byte-code-vector tmp-compile-time-value byte-stack+-info put nil] 6]))
#@39 Byte code opcode for stack reference.
(defconst byte-stack-ref 0 (#$ . 32008))
#@42 Byte code opcode for variable reference.
(defconst byte-varref 8 (#$ . 32093))
#@42 Byte code opcode for setting a variable.
(defconst byte-varset 16 (#$ . 32178))
#@42 Byte code opcode for binding a variable.
(defconst byte-varbind 24 (#$ . 32264))
#@42 Byte code opcode for calling a function.
(defconst byte-call 32 (#$ . 32351))
#@50 Byte code opcode for unbinding special bindings.
(defconst byte-unbind 40 (#$ . 32435))
(defconst byte-pophandler 48)
(defconst byte-pushcatch 50)
(defconst byte-pushconditioncase 49)
(defconst byte-nth 56)
(defconst byte-symbolp 57)
(defconst byte-consp 58)
(defconst byte-stringp 59)
(defconst byte-listp 60)
(defconst byte-eq 61)
(defconst byte-memq 62)
(defconst byte-not 63)
(defconst byte-car 64)
(defconst byte-cdr 65)
(defconst byte-cons 66)
(defconst byte-list1 67)
(defconst byte-list2 68)
(defconst byte-list3 69)
(defconst byte-list4 70)
(defconst byte-length 71)
(defconst byte-aref 72)
(defconst byte-aset 73)
(defconst byte-symbol-value 74)
(defconst byte-symbol-function 75)
(defconst byte-set 76)
(defconst byte-fset 77)
(defconst byte-get 78)
(defconst byte-substring 79)
(defconst byte-concat2 80)
(defconst byte-concat3 81)
(defconst byte-concat4 82)
(defconst byte-sub1 83)
(defconst byte-add1 84)
(defconst byte-eqlsign 85)
(defconst byte-gtr 86)
(defconst byte-lss 87)
(defconst byte-leq 88)
(defconst byte-geq 89)
(defconst byte-diff 90)
(defconst byte-negate 91)
(defconst byte-plus 92)
(defconst byte-max 93)
(defconst byte-min 94)
(defconst byte-mult 95)
(defconst byte-point 96)
(defconst byte-goto-char 98)
(defconst byte-insert 99)
(defconst byte-point-max 100)
(defconst byte-point-min 101)
(defconst byte-char-after 102)
(defconst byte-following-char 103)
(defconst byte-preceding-char 104)
(defconst byte-current-column 105)
(defconst byte-indent-to 106)
(defconst byte-scan-buffer-OBSOLETE 107)
(defconst byte-eolp 108)
(defconst byte-eobp 109)
(defconst byte-bolp 110)
(defconst byte-bobp 111)
(defconst byte-current-buffer 112)
(defconst byte-set-buffer 113)
#@66 Byte code opcode to make a binding to record the current buffer.
(defconst byte-save-current-buffer 114 (#$ . 34136))
(defconst byte-set-mark-OBSOLETE 115)
(defconst byte-interactive-p-OBSOLETE 116)
(defconst byte-forward-char 117)
(defconst byte-forward-word 118)
(defconst byte-skip-chars-forward 119)
(defconst byte-skip-chars-backward 120)
(defconst byte-forward-line 121)
(defconst byte-char-syntax 122)
(defconst byte-buffer-substring 123)
(defconst byte-delete-region 124)
(defconst byte-narrow-to-region 125)
(defconst byte-widen 126)
(defconst byte-end-of-line 127)
#@88 Byte code opcode for reference to a constant with vector
index >= byte-constant-limit.
(defconst byte-constant2 129 (#$ . 34717))
#@42 Byte code opcode for unconditional jump.
(defconst byte-goto 130 (#$ . 34853))
#@53 Byte code opcode to pop value and jump if it's nil.
(defconst byte-goto-if-nil 131 (#$ . 34938))
#@57 Byte code opcode to pop value and jump if it's not nil.
(defconst byte-goto-if-not-nil 132 (#$ . 35041))
#@96 Byte code opcode to examine top-of-stack, jump and don't pop it if it's nil,
otherwise pop it.
(defconst byte-goto-if-nil-else-pop 133 (#$ . 35152))
#@100 Byte code opcode to examine top-of-stack, jump and don't pop it if it's non nil,
otherwise pop it.
(defconst byte-goto-if-not-nil-else-pop 134 (#$ . 35308))
#@65 Byte code opcode to pop a value and return it from `byte-code'.
(defconst byte-return 135 (#$ . 35471))
#@51 Byte code opcode to discard one value from stack.
(defconst byte-discard 136 (#$ . 35581))
#@53 Byte code opcode to duplicate the top of the stack.
(defconst byte-dup 137 (#$ . 35678))
#@74 Byte code opcode to make a binding to record the buffer, point and mark.
(defconst byte-save-excursion 138 (#$ . 35773))
#@75 Byte code opcode to make a binding to record entire window configuration.
(defconst byte-save-window-excursion-OBSOLETE 139 (#$ . 35900))
#@88 Byte code opcode to make a binding to record the current buffer clipping
restrictions.
(defconst byte-save-restriction 140 (#$ . 36044))
#@87 Byte code opcode for catch.  Takes, on stack, the tag and an expression for
the body.
(defconst byte-catch-OBSOLETE 141 (#$ . 36187))
#@93 Byte code opcode for unwind-protect.  Takes, on stack, an expression for
the unwind-action.
(defconst byte-unwind-protect 142 (#$ . 36327))
(defconst byte-condition-case-OBSOLETE 143)
(defconst byte-temp-output-buffer-setup-OBSOLETE 144)
(defconst byte-temp-output-buffer-show-OBSOLETE 145)
(defconst byte-unbind-all 146)
(defconst byte-set-marker 147)
(defconst byte-match-beginning 148)
(defconst byte-match-end 149)
(defconst byte-upcase 150)
(defconst byte-downcase 151)
(defconst byte-string= 152)
(defconst byte-string< 153)
(defconst byte-equal 154)
(defconst byte-nthcdr 155)
(defconst byte-elt 156)
(defconst byte-member 157)
(defconst byte-assq 158)
(defconst byte-nreverse 159)
(defconst byte-setcar 160)
(defconst byte-setcdr 161)
(defconst byte-car-safe 162)
(defconst byte-cdr-safe 163)
(defconst byte-nconc 164)
(defconst byte-quo 165)
(defconst byte-rem 166)
(defconst byte-numberp 167)
(defconst byte-integerp 168)
(defconst byte-listN 175)
(defconst byte-concatN 176)
(defconst byte-insertN 177)
(defconst byte-stack-set 178)
(defconst byte-stack-set2 179)
(defconst byte-discardN 182)
(defconst byte-discardN-preserve-tos byte-discardN)
#@119 Byte code opcode to take a hash table and a value from the stack, and jump to
the address the value maps to, if any..
(defconst byte-switch 183 (#$ . 37490))
#@47 Byte code opcode for reference to a constant.
(defconst byte-constant 192 (#$ . 37654))
#@63 Exclusive maximum index usable in the `byte-constant' opcode.
(defconst byte-constant-limit 64 (#$ . 37748))
#@42 List of byte-codes whose offset is a pc.
(defconst byte-goto-ops '(byte-goto byte-goto-if-nil byte-goto-if-not-nil byte-goto-if-nil-else-pop byte-goto-if-not-nil-else-pop byte-pushcatch byte-pushconditioncase) (#$ . 37863))
(defconst byte-goto-always-pop-ops '(byte-goto-if-nil byte-goto-if-not-nil))
(byte-code "\302\303\304\207" [byte-code-vector byte-stack+-info [byte-stack-ref nil nil nil nil nil nil nil byte-varref nil nil nil nil nil nil nil byte-varset nil nil nil nil nil nil nil byte-varbind nil nil nil nil nil nil nil byte-call nil nil nil nil nil nil nil byte-unbind nil nil nil nil nil nil nil byte-pophandler byte-pushconditioncase byte-pushcatch nil nil nil nil nil byte-nth byte-symbolp byte-consp byte-stringp byte-listp byte-eq byte-memq byte-not byte-car byte-cdr byte-cons byte-list1 byte-list2 byte-list3 byte-list4 byte-length byte-aref byte-aset byte-symbol-value byte-symbol-function byte-set byte-fset byte-get byte-substring byte-concat2 byte-concat3 byte-concat4 byte-sub1 byte-add1 byte-eqlsign byte-gtr byte-lss byte-leq byte-geq byte-diff byte-negate byte-plus byte-max byte-min byte-mult byte-point nil byte-goto-char byte-insert byte-point-max byte-point-min byte-char-after byte-following-char byte-preceding-char byte-current-column byte-indent-to byte-scan-buffer-OBSOLETE byte-eolp byte-eobp byte-bolp byte-bobp byte-current-buffer byte-set-buffer byte-save-current-buffer byte-set-mark-OBSOLETE byte-interactive-p-OBSOLETE byte-forward-char byte-forward-word byte-skip-chars-forward byte-skip-chars-backward byte-forward-line byte-char-syntax byte-buffer-substring byte-delete-region byte-narrow-to-region byte-widen byte-end-of-line nil byte-constant2 byte-goto byte-goto-if-nil byte-goto-if-not-nil byte-goto-if-nil-else-pop byte-goto-if-not-nil-else-pop byte-return byte-discard byte-dup byte-save-excursion byte-save-window-excursion-OBSOLETE byte-save-restriction byte-catch-OBSOLETE byte-unwind-protect byte-condition-case-OBSOLETE byte-temp-output-buffer-setup-OBSOLETE byte-temp-output-buffer-show-OBSOLETE byte-unbind-all byte-set-marker byte-match-beginning byte-match-end byte-upcase byte-downcase byte-string= byte-string< byte-equal byte-nthcdr byte-elt byte-member byte-assq byte-nreverse byte-setcar byte-setcdr byte-car-safe byte-cdr-safe byte-nconc byte-quo byte-rem byte-numberp byte-integerp nil nil nil nil nil nil byte-listN byte-concatN byte-insertN byte-stack-set byte-stack-set2 nil nil byte-discardN byte-switch nil nil nil nil nil nil nil nil byte-constant nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil] [1 nil nil nil nil nil nil nil 1 nil nil nil nil nil nil nil -1 nil nil nil nil nil nil nil -1 nil nil nil nil nil nil nil 0 nil nil nil nil nil nil nil 0 nil nil nil nil nil nil nil 0 -1 -1 nil nil nil nil nil -1 0 0 0 0 -1 -1 0 0 0 -1 0 -1 -2 -3 0 -1 -2 0 0 -1 -1 -1 -2 -1 -2 -3 0 0 -1 -1 -1 -1 -1 -1 0 -1 -1 -1 -1 1 nil 0 0 1 1 0 1 1 1 0 0 1 1 1 1 1 0 0 0 1 0 0 -1 -1 0 0 -1 -1 -1 1 0 nil 1 0 -1 -1 -1 -1 -1 -1 1 0 0 0 -1 -1 -2 0 -1 0 -2 0 0 0 0 -1 -1 -1 -1 -1 -1 -1 0 -1 -1 0 0 -1 -1 -1 0 0 nil nil nil nil nil nil nil nil nil -1 -1 nil nil nil -2 nil nil nil nil nil nil nil nil 1 nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil] nil] 1)
#@193 Push bytes onto BVAR, and increment CVAR by the number of bytes pushed.
BVAR and CVAR are variables which are updated after evaluating
all the arguments.

(fn BYTE1 BYTE2 ... BYTEn BVAR CVAR)
(defalias 'byte-compile-push-bytecodes '(macro . #[128 "\300
\301\"\302\301\"@\302!@\303A\204*\304\305\306\307@ED\310\311C\"BE\2023\312\313\314!BE\315GE\257\207" [butlast 2 last setq progn cl-assert <= 0 cons append nconc list reverse +] 12 (#$ . 41494)]))
#@144 Push OPCODE and the two-byte constant CONST2 onto BYTES, and add 3 to PC.
CONST2 may be evaluated multiple times.

(fn OPCODE CONST2 BYTES PC)
(defalias 'byte-compile-push-bytecode-const2 '(macro . #[1028 "\300\301\302BB\303\304BB\257\207" [byte-compile-push-bytecodes logand (255) ash (-8)] 10 (#$ . 41971)]))
#@70 Turn lapcode LAP into bytecode.  The lapcode is destroyed.

(fn LAP)
(defalias 'byte-compile-lapcode #[257 "\306C\307\211\211\211\211\211\203\211@\211@\262\211A\2629\204&\310\311\"\210\202
\312=\2036\242\240\210\202
\313=\203A\202DJ\262	>\203hA\307E\244\262\314	\242\\\240\210B\262\202
:\203xA\262\303=\204\204\303=\203\305\250\203\305\nW\203\251\306\\X\204\227\315\316!\210\\B\262\211\242T\240\210\202
\317\320\"\321\322\"\fE\244\262\314	\242\\\240\210\202

U\203\356\322V\203\356\317\320\"\321\322\"(E\244\262\314	\242\\\240\210\202
)Y\203
W\203
D\244\262\323	\242\\\240\210\202
U\203]
\313=\203
\324\202 
\306\325V\203D
\326\325\"D\244\262\323\n\242\\\240\210\325Z\262\202 
\326\"D\244\262\323\n\242\\\240\266\202
\204z
\306X\204k
\315\327!\210B\262\211\242T\240\210\202
*=\203\245
\306=\203\245
\330 \210\306+X\204\225
\315\331!\210+B\262\211\242T\240\210\202
\332W\203\312
\306\\X\204\270
\315\333!\210\\B\262\211\242T\240\210\202
\334W\203\345
\332\\D\244\262\323	\242\\\240\210\202
\317\320\"\321\322\"\335\\E\244\262\314	\242\\\240\210
A\266\202\202	\210\211\211\203>\211@
@@\240\210\211A\321	\242\322\"\240\210\211\317	\242\320\"\240\210\336\306@\322#\2047\310\337!\210
A\266\202\202\n\210,\211\203X\211@\340\341\342\n#\"\210
A\266\202\202A\210\343\344\237\"-\203o\345
\346\347\307\f#.#\210\207" [byte-discardN byte-goto-ops byte-constant-limit byte-constant byte-constant2 byte-stack-set 0 nil error "Non-symbolic opcode `%s'" TAG byte-discardN-preserve-tos 3 cl--assertion-failed (<= 0 (+ byte-constant off)) ash -8 logand 255 2 128 127 logior (<= 0 opcode) debug (<= 0 byte-dup) 6 (<= 0 (+ opcode off)) 256 7 <= "Bytecode overflow" maphash make-closure #[514 "\300
A@\240\210\302\300\242\301#\207" [V0 V1 puthash] 6 "\n\n(fn VALUE TAG)"] apply unibyte-string puthash record byte-to-native-lambda byte-stack-set2 byte-listN byte-stack-ref byte-dup byte-compile-jump-tables byte-native-compiling byte-to-native-lambdas-h] 14 (#$ . 42295)])
#@135 Eval FORM and mark the functions defined therein.
Each function's symbol gets added to `byte-compile-noruntime-functions'.

(fn FORM)
(defalias 'byte-compile-eval #[257 "	\304\n\"\305\306!\203\241	
\203i
=\204i
\211A\262\242\307\310@\"\204d
\211\203c\211@\211:\203D\211@\311=\203D\211AB\262\202\\\211:\203\\\211@\312>\203\\\211A>\204\\\211AB
A\266\202\202)\210\266\202\307
\203\237
=\204\237
\211A\262\242\2119\203\211\211>\204\211\211B\211:\203\233\211@\311=\203\233\211AB\262\210\202j\266\207" [load-history current-load-list lexical-binding byte-compile-noruntime-functions eval byte-compile-warning-enabled-p noruntime nil assoc t (autoload defun)] 12 (#$ . 44460)])
#@50 Evaluate FORM for `eval-and-compile'.

(fn FORM)
(defalias 'byte-compile-eval-before-compile #[257 "\302	\"\211=\204\211A\262
\202\210\207" [current-load-list lexical-binding eval] 6 (#$ . 45180)])
#@221 Return file name or buffer given by STR.
If STR is a "normal" filename, just return it.
If STR is something like "Buffer foo.el", return #<buffer foo.el>
(if it is still live) or the string "foo.el" otherwise.

(fn STR)
(defalias 'emacs-lisp-compilation-file-name-or-buffer #[257 "\300\301\"\203\302\303\304\"!\206\303\304\"\207\211\207" [string-match "Buffer \\(.*\\)\\'" get-buffer match-string-no-properties 1] 5 (#$ . 45393)])
#@111 The value for `compilation-parse-errors-filename-function' for when
we go into `emacs-lisp-compilation-mode'.
(defconst emacs-lisp-compilation-parse-errors-filename-function 'emacs-lisp-compilation-file-name-or-buffer (#$ . 45838))
(byte-code "\300\301\302\303\304DD\305\306\307\310\311&\207" [custom-declare-variable emacs-lisp-compilation-search-path funcall function #[0 "\300\207" [(nil)] 1 ""] "Directories to search for files named in byte-compile error messages.\nValue should be a list of directory names, not file names of\ndirectories.  The value nil as an element means the byte-compile\nmessage buffer `default-directory'." :version "27.1" :type (repeat (choice (const :tag "Default" nil) (string :tag "Directory")))] 8)
(defvar emacs-lisp-compilation-mode-map (byte-code "\300 \301
\302\303#\210\207" [make-sparse-keymap define-key "g" emacs-lisp-compilation-recompile] 5))
(defvar emacs-lisp-compilation--current-file nil)
(defvar emacs-lisp-compilation-mode-hook nil)
(byte-code "\300\301N\204\f\302\300\301\303#\210\304\305!\204\302\305\306\307#\210\300\207" [emacs-lisp-compilation-mode-hook variable-documentation put "Hook run after entering elisp-compile mode.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it.  (This is true for all hook variables.)" boundp emacs-lisp-compilation-mode-map definition-name emacs-lisp-compilation-mode] 4)
(defvar emacs-lisp-compilation-mode-map (make-sparse-keymap))
(byte-code "\301\302N\204\303\301\302\304\305!#\210\306\307!\204\303\307\310\311#\210\312\313 !\210\307\302N\204-\303\307\302\304\314!#\210\306\300!\204B\303\300\310\311#\210\315\316\300\317\"\210!\210\300\302N\204P\303\300\302\304\320!#\210\303\311\321\322#\207" [emacs-lisp-compilation-mode-abbrev-table emacs-lisp-compilation-mode-map variable-documentation put purecopy "Keymap for `emacs-lisp-compilation-mode'." boundp emacs-lisp-compilation-mode-syntax-table definition-name emacs-lisp-compilation-mode (lambda (#1=#:def-tmp-var) (defvar emacs-lisp-compilation-mode-syntax-table #1#)) make-syntax-table "Syntax table for `emacs-lisp-compilation-mode'." (lambda (#1#) (defvar emacs-lisp-compilation-mode-abbrev-table #1#)) define-abbrev-table nil "Abbrev table for `emacs-lisp-compilation-mode'." derived-mode-parent compilation-mode] 5)
#@286 The variant of `compilation-mode' used for emacs-lisp compilation buffers.

In addition to any hooks its parent mode might have run, this mode
runs the hook `emacs-lisp-compilation-mode-hook', as the final or
penultimate step during initialization.

\{emacs-lisp-compilation-mode-map}
(defalias 'emacs-lisp-compilation-mode #[0 "\306\300!\210\307\310 \210\311\312\310\313N\203\314\311\313\310\313N#\210\315!\204'\316\317 \"\210\320\f!\211\2035\211\321 =\203;\322\f\323 \"\210\210\324
\325\"\204R
=\204R\326
\325C#\210\327!\210\330\f!\210
\306\331!\210 \306\332!\210!\306\333!\210\334)\335\336!\207" [delay-mode-hooks major-mode mode-name emacs-lisp-compilation-mode-map emacs-lisp-compilation-mode-syntax-table emacs-lisp-compilation-mode-abbrev-table make-local-variable t compilation-mode emacs-lisp-compilation-mode "elisp-compile" mode-class put keymap-parent set-keymap-parent current-local-map char-table-parent standard-syntax-table set-char-table-parent syntax-table abbrev-table-get :parents abbrev-table-put use-local-map set-syntax-table compilation-parse-errors-filename-function compilation-search-path emacs-lisp-compilation--current-file nil run-mode-hooks emacs-lisp-compilation-mode-hook local-abbrev-table emacs-lisp-compilation-parse-errors-filename-function emacs-lisp-compilation-search-path] 5 (#$ . 48159) nil])
#@46 Recompile the previously byte-compiled file.
(defalias 'emacs-lisp-compilation-recompile #[0 "\204\301\302!\210;\204\301\303!\210\304!\207" [emacs-lisp-compilation--current-file error "No previously compiled file" "Only files can be recompiled" byte-compile-file] 2 (#$ . 49527) nil])
(defvar byte-compile-current-form nil)
(defvar byte-compile-dest-file nil)
(defvar byte-compile-current-file nil)
(defvar byte-compile-current-group nil)
(defvar byte-compile-current-buffer nil)
#@33 

(fn FORMAT-STRING &rest ARGS)
(defalias 'byte-compile-log '(macro . #[385 "\300\301\302\303\304\305\306\307\310\n\"BBDEF\207" [and byte-optimize (memq byte-optimize-log '(t source)) let ((print-escape-newlines t) (print-level 4) (print-length 4)) byte-compile-log-1 format-message mapcar #[257 "\2119\203	\300
D\207\207" [prin1-to-string] 3 "\n\n(fn X)"]] 13 (#$ . 50020)]))
#@15 

(fn STRING)
(defalias 'byte-compile-log-1 #[257 "rq\210\303db\210\304\305\211\"\210\n\203\306\307\"\202\310\311\"c*\207" [byte-compile-log-buffer inhibit-read-only noninteractive t byte-compile-warning-prefix nil message " %s" format "%s\n"] 4 (#$ . 50407)])
#@51 Character position we began the last `read' from.
(defvar byte-compile-read-position nil (#$ . 50682))
#@45 Last known character position in the input.
(defvar byte-compile-last-position nil (#$ . 50791))
#@17 

(fn ELT LIST)
(defalias 'byte-compile-delete-first #[514 "\211@=\203\n\211A\207\211
A\203
A@=\204
A\262\202
A\203*
\211AA\241\210\207" [] 5 (#$ . 50894)])
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put byte-compile-delete-first speed -1 put byte-optimizer byte-compile-inline-expand] 5)
#@37 

(fn SYM &optional ALLOW-PREVIOUS)
(defalias 'byte-compile-set-symbol-position #[513 "\205`	\303\n\236\262
\211\203G
A\\\211\n\211@=\203$\211A\266\202\202F\211
A\2039
A@=\2049
A\262\202%
A\203D
\211AA\241\210\266\202\211\205^\203U
	U\203
	V\205^\202\266\202\207" [byte-compile-read-position byte-compile-last-position read-symbol-positions-list nil] 9 (#$ . 51219)])
(defvar byte-compile-last-warned-form nil)
(defvar byte-compile-last-logged-file nil)
#@71 Directory relative to which file names in error messages are written.
(defvar byte-compile-root-dir nil (#$ . 51703))
#@27 

(fn FILE &optional DIR)
(defalias 'byte-compile-abbreviate-file #[513 "\300!\301\"\211GGW\203\207
\207" [abbreviate-file-name file-relative-name] 6 (#$ . 51827)])
#@20 

(fn LEVEL ENTRY)
(defalias 'byte-compile-warning-prefix #[514 "\306	\206\n;\203\307\310\311\"\"\2025\312!\203%\307\313\314!\"\2025\f;\2034\307\310\311\f\"\"\2025\315\203^
\250\203^rq\210\307\316\212b\210\317e\320 \"T)\212b\210iT)#)\202_\315\321=\203j\322\202p\206p\323\203{\232\203\210\203\216=\204\216\307\324\"c\210\203\231\307\325#c\210)\266\207" [inhibit-read-only byte-compile-root-dir default-directory byte-compile-current-file load-file-name byte-compile-read-position t format "%s:" byte-compile-abbreviate-file bufferp "Buffer %s:" buffer-name "" "%d:%d:" count-lines point-at-bol :end "end of data" "toplevel form" "\nIn %s:\n" "%s%s " byte-compile-current-buffer byte-compile-last-position byte-compile-current-form byte-compile-last-logged-file byte-compile-last-warned-form] 10 (#$ . 52004)])
#@21 

(fn &rest IGNORE)
(defalias 'byte-compile-warning-series #[128 "\300\207" [nil] 2 (#$ . 52879)])
(defalias 'byte-compile-log-file #[0 "	\232?\205\212\n?\205\212r\306!q\210db\210\307;\205\310!

\232\311\2031
\2041\312\313
\"c\210n\2048\314c\210\315 \262
\203[\316;\203L\317P\202Q\320\321!P\322\323 \314\261\210\202b\324\323 \314\261\210\203r
\204r\312\325
\"c\210\311\326\327!\204\200\330 \210\331 \210)\266\202)\207" [byte-compile-current-file byte-compile-last-logged-file noninteractive byte-compile-log-buffer inhibit-read-only default-directory get-buffer-create t file-name-directory nil format-message "Leaving directory `%s'\n" "\n" point-marker "\f\nCompiling " "file " "in buffer " buffer-name " at " current-time-string "\f\nCompiling internal form(s) at " "Entering directory `%s'\n" derived-mode-p compilation-mode emacs-lisp-compilation-mode compilation-forget-errors byte-compile-last-warned-form emacs-lisp-compilation--current-file] 8])
#@361 Function called when encountering a warning or error.
Called with arguments (STRING POSITION FILL LEVEL).  STRING is a
message describing the problem.  POSITION is a buffer position
where the problem was detected.  FILL is a prefix as in
`warning-fill-prefix'.  LEVEL is the level of the
problem (`:warning' or `:error').  POSITION, FILL and LEVEL may be
nil.
(defvar byte-compile-log-warning-function 'byte-compile--log-warning-for-byte-compile (#$ . 53877))
#@158 Log a byte-compilation warning.
STRING, FILL and LEVEL are as described in
`byte-compile-log-warning-function', which see.

(fn STRING &optional FILL LEVEL)
(defalias 'byte-compile-log-warning #[769 "	$\207" [byte-compile-log-warning-function byte-compile-last-position] 8 (#$ . 54344)])
#@373 Log a message STRING in `byte-compile-log-buffer'.
Also log the current function and file if not already done.  If
FILL is non-nil, set `warning-fill-prefix' to four spaces.  LEVEL
is the warning level (`:warning' or `:error').  Do not call this
function directly; use `byte-compile-warn' or
`byte-compile-report-error' instead.

(fn STRING &optional POSITION FILL LEVEL)
(defalias 'byte-compile--log-warning-for-byte-compile #[1025 "\304\305\205\306\307\310$+\207" [warning-fill-prefix warning-type-format warning-prefix-function byte-compile-log-buffer byte-compile-warning-prefix "" "    " display-warning bytecomp] 9 (#$ . 54643)])
#@105 Issue a byte compiler warning; use (format-message FORMAT ARGS...) for message.

(fn FORMAT &rest ARGS)
(defalias 'byte-compile-warn #[385 "\301\302#\262\203\303\304\"\207\305\306\307#\207" [byte-compile-error-on-warn apply format-message error "%s" byte-compile-log-warning t :warning] 6 (#$ . 55295)])
#@69 Warn that SYMBOL (a variable or function) is obsolete.

(fn SYMBOL)
(defalias 'byte-compile-warn-obsolete #[257 "\301\302\"\205.\211\303N\304\206\305N\203\306\202\307#
\205$>?\205,\310\311\"\266\202\207" [byte-compile-not-obsolete-funcs byte-compile-warning-enabled-p obsolete byte-obsolete-info macroexp--obsolete-warning byte-obsolete-variable "function" "variable" byte-compile-warn "%s"] 6 (#$ . 55613)])
#@247 Report Lisp error in compilation.
ERROR-INFO is the error data, in the form of either (ERROR-SYMBOL . DATA)
or STRING.  If FILL is non-nil, set `warning-fill-prefix' to four spaces
when printing the error message.

(fn ERROR-INFO &optional FILL)
(defalias 'byte-compile-report-error #[513 "\301\302;\203\f\202\303!\304#\207" [byte-compiler-error-flag t byte-compile-log-warning error-message-string :error] 6 (#$ . 56046)])
#@21 

(fn NAME MACRO-P)
(defalias 'byte-compile-fdefinition #[514 "\211\203\202		
\236A\211\206\241\2119\203;\303
!\203;\211K9\2044\211K:\2044\204;\304
K!\203;\211K\262
\202\305
9\203L\303!\203L
K\202M
\n\306#\211<\203f\203`\307\310E\202\235\310
D\202\235\204t\304!\203t
\202\235
:\204}\311\202\235
@\307=\203\211
A\202\235\203\221\311\202\235
@\312=\203\234\311\202\235
\262
\262
\207" [byte-compile-macro-environment byte-compile-function-environment advertised-signature-table fboundp byte-code-function-p gethash t macro lambda nil autoload] 9 (#$ . 56484)])
#@16 

(fn ARGLIST)
(defalias 'byte-compile-arglist-signature #[257 "\211<\203[\300\301\211\203H@\302=\203
\204A\300\262\202A@\303=\2032A\203A\304\262
\301\262\202A
\203=
T\262\202AT\262A\262\202
?\205Y\203X\\\202YB\207\305\207" [0 nil &optional &rest t (0)] 7 (#$ . 57089)])
#@10 

(fn F)
(defalias 'byte-compile--function-signature #[257 "\211\242\300=\203\211A\262
\301
!\203\211\211\302H\302H\262
\262
\202\211\242\303=\203+\304
A@!\207\3051C\306
!\211A\247\203<\211\202?\211@C\262
0\207\210\307\207" [macro advice--p 2 declared byte-compile-arglist-signature (error) func-arity (0)] 4 (#$ . 57398)])
#@16 

(fn OLD NEW)
(defalias 'byte-compile-arglist-signatures-congruent-p #[514 "\211@@V\206!
A\204\211A\206!\211A\205!
A\205!\211AAW?\207" [] 4 (#$ . 57738)])
#@18 

(fn SIGNATURE)
(defalias 'byte-compile-arglist-signature-string #[257 "\211A\204\300\301@\"\207\211@
AU\203\300\302@\"\207\300\303@A#\207" [format "%d+" "%d" "%d-%d"] 5 (#$ . 57908)])
#@20 

(fn F NARGS DEF)
(defalias 'byte-compile-function-warn #[771 "\304!\210\305N\203\306\307\"\203\310!\210\211\204\311!\203&>?\206P	=\206P\n\236\211\203F
AA>\206N\211AAAB\241\202NE\nB\211\262
\207" [byte-compile-noruntime-functions byte-compile-current-form byte-compile-unresolved-functions byte-compile-last-position byte-compile-set-symbol-position byte-obsolete-info byte-compile-warning-enabled-p obsolete byte-compile-warn-obsolete fboundp] 7 (#$ . 58108)])
#@43 

(fn NAME ACTUAL-ARGS MIN-ARGS MAX-ARGS)
(defalias 'byte-compile-emit-callargs-warn #[1028 "\300!\210\301\302\211\303U\203\304\202\305W\203\306\202 \307\310B!&\207" [byte-compile-set-symbol-position byte-compile-warn "%s called with %d argument%s, but %s %s" 1 "" "s" "requires" "accepts only" byte-compile-arglist-signature-string] 13 (#$ . 58605)])
#@83 Check that the call in FORM matches that allowed by BYTECODE.

(fn FORM BYTECODE)
(defalias 'byte-compile--check-arity-bytecode #[514 "\300
!\2056\301\302!\2056
AG\303!\211@
A\247\205
AW\204,\211\2054
V\2054\304@$\266\204\207" [byte-code-function-p byte-compile-warning-enabled-p callargs func-arity byte-compile-emit-callargs-warn] 11 (#$ . 58982)])
#@13 

(fn FORM)
(defalias 'byte-compile-callargs-warn #[257 "\300
@\301\"\206
\300
@\302\"\211\203\303
!\202$\304@K!\205$\305@K!AG
\243\2036
A\247\2046
\301\241\210
\203W\211@W\204M
A\203W\211AV\203W\306@@A$\210\307!\210\310@AG#\207" [byte-compile-fdefinition nil t byte-compile--function-signature subrp subr-arity byte-compile-emit-callargs-warn byte-compile-format-warn byte-compile-function-warn] 9 (#$ . 59355)])
#@260 Warn if FORM is `format'-like with inconsistent args.
Applies if head of FORM is a symbol with non-nil property
`byte-compile-format-like' and first arg is a constant string.
Then check the number of format fields matches the number of
extra args.

(fn FORM)
(defalias 'byte-compile-format-warn #[257 "\211@9\205t\211A@;\205t\211@\300N\205t\301\302\303\"r\211q\210\304\305\"\216
A@c\210eb\210\306\211\307\310\311\303#\203[\312u\210\311f\313=\204U\314\315!\203L\316\317\320!\321\"\202N
T\262\211]\262
\311u\210\202+\262
*\262

G\322Z\211U?\205r\323\324@$\266\202\207" [byte-compile-format-like generate-new-buffer " *temp*" t make-closure #[0 "\301\300!\205	\302\300!\207" [V0 buffer-name kill-buffer] 2] 0 re-search-forward "%." nil -1 37 looking-at "\\([0-9]+\\)\\$" string-to-number match-string 1 10 2 byte-compile-warn "`%s' called with %d args to fill %d format field(s)"] 8 (#$ . 59800)])
(byte-code "\300\211\203\211@\301
\302\303#\210
A\266\202\202
\207" [(format message error) put byte-compile-format-like t] 6)
#@13 

(fn FORM)
(defalias 'byte-compile-nogroup-warn #[257 "\211AAAA
A@\211\242\302=\205`@\303=\203$\304\305\"\204$\306\307A@\"\210@\310>\205,?\205`@\311=\203=\211\312\232\204P\304\313\"\204P\306\314@\315\236AA@#\210	\205`@\311=\205`\211A@\211\207" [byte-compile-current-group byte-compile-current-file quote custom-declare-variable plist-get :type byte-compile-warn "defcustom for `%s' fails to specify type" (custom-declare-face custom-declare-variable) custom-declare-group 'emacs :group "%s for `%s' fails to specify containing group" ((custom-declare-group . defgroup) (custom-declare-face . defface) (custom-declare-variable . defcustom))] 7 (#$ . 60848)])
#@28 

(fn NAME ARGLIST MACROP)
(defalias 'byte-compile-arglist-warn #[771 "\236\302\211\211\211\203\203\303\304	\"\210\305\"\305\306\"\262AA\203\2149\203=\307\310\"\311=\203=\303\312	\"\210\313!\262\314\315AA!\316\"\262@\262\237@\262

@W\204jA\203\214\211AV\203\214\317!\210\303\320	\321!\322\232\203\202\323\202\203\324\321B!%\210\266\325\"
\205\232	\236A\211\203\251\2119\203\251\325
\302\"\262
\205\355
\306=?\205\355\326!\313!\327\"?\205\353\317!\210\303\330\203\322\331\202\323\332	\321!\333\232\203\344\334\202\345\335\321!&\266\202\207" [byte-compile-unresolved-functions byte-compile-initial-macro-environment nil byte-compile-warn "macro `%s' defined too late" delq t function-get byte-optimizer byte-compile-inline-expand "defsubst `%s' was used before it was defined" byte-compile-arglist-signature sort copy-sequence < byte-compile-set-symbol-position "%s being defined to take %s%s, but was previously called with %s" byte-compile-arglist-signature-string (1 . 1) " arg" " args" byte-compile-fdefinition byte-compile--function-signature byte-compile-arglist-signatures-congruent-p "%s %s used to take %s %s, now takes %s" "macro" "function" (1 . 1) "argument" "arguments"] 16 (#$ . 61534)])
#@245 Substitution width used in `byte-compile--wide-docstring-p'.
This is a heuristic for guessing the width of a documentation
string: `byte-compile--wide-docstring-p' assumes that any
`substitute-command-keys' command substitutions are this long.
(defvar byte-compile--wide-docstring-substitution-len 3 (#$ . 62824))
#@257 Return t if string DOCSTRING is wider than COL.
Ignore all `substitute-command-keys' substitutions, except for
the `\\=[command]' ones that are assumed to be of length
`byte-compile--wide-docstring-substitution-len'.  Also ignore
URLs.

(fn DOCSTRING COL)
(defalias 'byte-compile--wide-docstring-p #[514 "\301\302\303T\304^\"\305\306\307\305\310\311\312\"	##\"\207" [byte-compile--wide-docstring-substitution-len string-match format "^.\\{%d,\\}$" 65535 replace-regexp-in-string "https?://.*\\|\\\\\\(?:=\\|<[^>]*>\\|{[^}]*}\\)\\|^([]&/:[[:word:]-]+\\(?: \\(?:\\(?:\\s_\\|[#&-)./:=?[-^[:word:]-]\\)+\\|([^)]*)\\)\\)+)" "" "\\\\\\[[^]]*]" make-string 120] 12 (#$ . 63145)])
(byte-code "\300\301\302\303\304DD\305\306\307\310\311\312\313\314\315&\207" [custom-declare-variable byte-compile-docstring-max-column funcall function #[0 "\300\207" [80] 1 ""] "Recommended maximum width of doc string lines.\nThe byte-compiler will emit a warning for documentation strings\ncontaining lines wider than this.  If `fill-column' has a larger\nvalue, it will override this variable." :group bytecomp :type integer :safe integerp :version "28.1"] 12)
#@179 Warn if documentation string of FORM is too wide.
It is too wide if it has any lines longer than the largest of
`fill-column' and `byte-compile-docstring-max-column'.

(fn FORM)
(defalias 'byte-compile-docstring-length-warn #[257 "\302\303!\203y	]\304\211\211@\211\305\267\210\202<@\262A@\262\3068\266\202\202<\307\262\3108;\2056\3108\266\202\202<\210
:\203M
@\311=\203M
A@\262
\203X\312\313\"\202Y\307\262\203w\211\203w\211;\203w\314
\"\203w\315\316$\210\266\207" [byte-compile-docstring-max-column fill-column byte-compile-warning-enabled-p docstrings nil #s(hash-table size 8 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (defvaralias 21 defvar 21 define-abbrev-table 21 defconst 21 defalias 21 custom-declare-variable 21 autoload 21 lambda 39)) 3 "" 2 quote format " `%s'" byte-compile--wide-docstring-p byte-compile-warn "%s%s docstring wider than %s characters"] 10 (#$ . 64294)])
(defalias 'byte-compile-warn-about-unresolved-functions #[0 "\304\305!\2036\306	\211\2034\211@\211@\211\n>\204,
A@\307\310!\203&\311\202'\312@\"\210)\210
A\266\202\202	\210)\313\207" [byte-compile-current-form byte-compile-unresolved-functions byte-compile-new-defuns byte-compile-last-position byte-compile-warning-enabled-p unresolved :end byte-compile-warn fboundp "the function `%s' might not be defined at runtime." "the function `%s' is not known to be defined." nil] 6])
#@19 

(fn &rest BODY)
(defalias 'byte-compile-close-variables '(macro . #[128 "\300\301\302\303B\304BBE\207" [let ((byte-compile-macro-environment (copy-alist byte-compile-initial-macro-environment)) (byte-compile--outbuffer nil) (overriding-plist-environment nil) (byte-compile-function-environment nil) (byte-compile-bound-variables nil) (byte-compile-lexical-variables nil) (byte-compile-const-variables nil) (byte-compile-free-references nil) (byte-compile-free-assignments nil) (byte-compile-verbose byte-compile-verbose) (byte-optimize byte-optimize) (byte-compile-dynamic byte-compile-dynamic) (byte-compile-dynamic-docstrings byte-compile-dynamic-docstrings) (byte-compile-warnings byte-compile-warnings) (current-load-list (list nil))) prog1 progn ((when byte-native-compiling (setq byte-to-native-plist-environment overriding-plist-environment)))] 6 (#$ . 65729)]))
(put 'byte-compile-close-variables 'edebug-form-spec t)
#@19 

(fn &rest BODY)
(defalias 'displaying-byte-compile-warnings '(macro . #[128 "\300\301\302\303BBD\304B\305BB\207" [let* --displaying-byte-compile-warnings-fn lambda nil ((warning-series-started (and (markerp warning-series) (eq (marker-buffer warning-series) (get-buffer byte-compile-log-buffer))))) ((if (or (eq warning-series 'byte-compile-warning-series) warning-series-started) (let (tem) (setq tem (byte-compile-log-file)) (unless warning-series-started (setq warning-series (or tem 'byte-compile-warning-series))) (if byte-compile-debug (funcall --displaying-byte-compile-warnings-fn) (condition-case error-info (funcall --displaying-byte-compile-warnings-fn) (error (byte-compile-report-error error-info))))) (let ((warning-series (or (byte-compile-log-file) 'byte-compile-warning-series))) (if byte-compile-debug (funcall --displaying-byte-compile-warnings-fn) (condition-case error-info (funcall --displaying-byte-compile-warnings-fn) (error (byte-compile-report-error error-info)))))))] 6 (#$ . 66664)]))
(put 'displaying-byte-compile-warnings 'edebug-form-spec '(def-body))
#@146 Recompile every `.el' file in DIRECTORY that already has a `.elc' file.
Files in subdirectories of DIRECTORY are processed also.

(fn DIRECTORY)
(defalias 'byte-force-recompile #[257 "\300
\301\302#\207" [byte-recompile-directory nil t] 5 (#$ . 67758) "DByte force recompile (directory): "])
#@844 Recompile every `.el' file in DIRECTORY that needs recompilation.
This happens when a `.elc' file exists but is older than the `.el' file.
Files in subdirectories of DIRECTORY are processed also.

If the `.elc' file does not exist, normally this function *does not*
compile the corresponding `.el' file.  However, if the prefix argument
ARG is 0, that means do compile all those files.  A nonzero
ARG means ask the user, for each such `.el' file, whether to
compile it.  A nonzero ARG also means ask about each subdirectory
before scanning it.

If the third argument FORCE is non-nil, recompile every `.el' file
that already has a `.elc' file.

This command will normally not follow symlinks when compiling
files.  If FOLLOW-SYMLINKS is non-nil, symlinked `.el' files will
also be compiled.

(fn DIRECTORY &optional ARG FORCE FOLLOW-SYMLINKS)
(defalias 'byte-recompile-directory #[1025 "CC\211\242\203\211\305\242!\240\210\204\306\307\310\311\"\"\210\312 \210r\313	!q\210\314\242!\315\316!\2043\317 \210\nCC\n\320C\320C\320C\320C\307C\310\321\n\n\f&\322!\205h\323!\324	!=\325=\204r\211\203\240\307\326 \262

\204\201\211\206\200\325\f\203\214 \266\202\304\3271\230 0\266\202\304\330
!\266\202\304\326 \206\246\325\f\203\261
 \210\202\301\3311\274
 0\210\202\301\330
!\266)\266\332\333\242\242\334U\203\323\335\202\324\336\242\320V\203\345\337\340	\242\"\202\346\335	\242\320V\203\367\337\341\242\"\202\370\335\242\334V\203	
\337\342	\242\"\202\n
\335&)\266\207)\207" [noninteractive byte-compile-log-buffer default-directory warning-series byte-compile-debug prefix-numeric-value save-some-buffers nil make-closure #[0 "\303 \211\205	
\304\305\306#)\266\203\205\307
\300\242\"\207" [V0 emacs-lisp-file-regexp inhibit-changing-match-data buffer-file-name nil t string-match file-in-directory-p] 8] force-mode-line-update get-buffer-create expand-file-name derived-mode-p compilation-mode emacs-lisp-compilation-mode 0 #[0 "\304\242\205\331\300\304\242@\240\210\312\313\300\242\"\210\314\300\242\315\"\211\203\317\211@\316
!\317!\203^\211\320\235\204\307\211\321H\322=\204\307\303\204=\323!\204\307\301\242\203R\301\242\321=\204R\324\325\326Q!\203\307\304\211\242C\244\240\266\202\310\327\"\203\307\330!\203\307\327\331\"\204\307\332!\204\307
\333\300\242!\235\204\307\334\302\301\242#\211\335\267\202\242\305\211\242T\240\266\202\251\307\211\242T\240\266\202\251\306\211\242T\240\266\204\264\312\313\300\242\"\210\311\242\300\242=\204\307\311\300\242\240\210\310\211\242T\240\210\210
A\266\202\202\210\304\211\242A\240\210\202\207" [V0 V1 V2 V3 V4 V5 V6 V7 V8 V9 message "Checking %s..." directory-files t file-name-nondirectory file-directory-p ("RCS" "CVS") 0 46 file-symlink-p y-or-n-p "Check " "? " string-match file-readable-p "\\`\\.#" auto-save-file-name-p dir-locals--all-files byte-recompile-file #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (no-byte-compile 142 t 152)) emacs-lisp-file-regexp noninteractive] 7] markerp marker-buffer get-buffer byte-compile-warning-series byte-compile-log-file (error) byte-compile-report-error (error) message "Done (Total of %d file%s compiled%s%s%s)" 1 "" "s" format ", %d failed" ", %d skipped" " in %d directories"] 25 (#$ . 68057) "DByte recompile directory: \nP"])
#@181 Non-nil to prevent byte-compiling of Emacs Lisp code.
This is normally set in local file variables at the end of the elisp file:

;; Local Variables:
;; no-byte-compile: t
;; End:
(defvar no-byte-compile nil (#$ . 71446))
#@742 Recompile FILENAME file if it needs recompilation.
This happens when its `.elc' file is older than itself.

If the `.elc' file exists and is up-to-date, normally this function
*does not* compile FILENAME.  If the prefix argument FORCE is non-nil,
however, it compiles FILENAME even if the destination already
exists and is up-to-date.

If the `.elc' file does not exist, normally this function *does not*
compile FILENAME.  If optional argument ARG is 0, it compiles
the input file even if the `.elc' file does not exist.
Any other non-nil value of ARG means to ask the user.

If compilation is needed, this functions returns the result of
`byte-compile-file'; otherwise it returns `no-byte-compile'.

(fn FILENAME &optional FORCE ARG LOAD)
(defalias 'byte-recompile-file #[1025 "\302!\303!
\203\304!\203\204.\305
\"\202+\203A\306=\204.\307\310\311Q!\203A\203;	\204;\312\313\"\210\314
!\202B\315\203X\316\203U\304!\203U\202V!\210\207" [noninteractive byte-compile-verbose byte-compile-dest-file expand-file-name file-exists-p file-newer-than-file-p 0 y-or-n-p "Compile " "? " message "Compiling %s..." byte-compile-file no-byte-compile load] 10 (#$ . 71675) (byte-code "\302\211\203\303\304!\203\305!\262\306!\262
\307	\203 \310\202!\311\302$	D\207" [buffer-file-name current-prefix-arg nil derived-mode-p emacs-lisp-mode file-name-nondirectory file-name-directory read-file-name "Byte compile file: " "Byte recompile file: "] 8)])
(set-advertised-calling-convention 'byte-recompile-file '(filename &optional force arg) "28.1")
#@13 

(fn FILE)
(defalias 'byte-compile--load-dynvars #[257 "\211\205D\211\300\232?\205D\301\302\303\"r\211q\210\304\305\"\216\306!\210eb\210\307\211\3101/\311p!\211\2620\2023\210\202>\203>\211B\262\202!
\266\202*\262
\207" ["" generate-new-buffer " *temp*" t make-closure #[0 "\301\300!\205	\302\300!\207" [V0 buffer-name kill-buffer] 2] insert-file-contents nil (error) read] 6 (#$ . 73253)])
#@40 Depth of a recursive byte compilation.
(defvar byte-compile-level 0 (#$ . 73663))
#@317 Compile a file of Lisp code named FILENAME into a file of byte code.
The output file's name is generated by passing FILENAME to the
function `byte-compile-dest-file' (which see).
The value is non-nil if there were no errors, nil if errors.

See also `emacs-lisp-byte-compile-and-load'.

(fn FILENAME &optional LOAD)
(defalias 'byte-compile-file #[513 "\306!\262\204,\307\306!!\211\203+\310
!\203+\311\312\313\314!\"!\203+r\211q\210\315 \210)\210\316
\316\317\316\320\321\322!!\316\211\211\211\211@AB\303\n!\262r\323\324C\325U\203c\326\202h\312\327C\"P!\211\262q\210\330 \210\316D\331\317!\210\332\n!\210E\333=\204\216\334E!\335=\203\222\331\316!\210	\336\337!\340\316FG
H\341\342\"\216\343\337\344\"\210\345\346!\210\317&\347\317!\210*\316IH\262\f+\266\350\351!\204\315\345\351!\210\316)\352\n!J)r
q\2100)\203
\203

\353!\203

\354\355\356!\357\360\"#\210\3611
\362!0\210\202

\210\360\202\267K\203
\354\363\"\210rCTC\364!*\262
\n?\205\267K\203,
\354\365\"\210\366!\210r\211q\210\203)L\203G
L\203)M\203)db\210\367c\210\370!\203\306
\370\352\306!!!\203\306
\333N\371\370!\205j
\306!!\372 \373
\374\"\373\375\"\341\376\"OBO

U\204\214
\377\201R#\210\201Sed\316\201T%\210L\203\247
BP\202\260
\201U\317#\210*\266\204)L\204)\354\201V\"\210\202)\370!\203\333N\372 \341\201W\"\216\201X\373\372 \375\"!\210\201Sed\316\201T%\210)\210)\204)\354\201V\"\210\202)\353!\201Y
\203\201Z\202\201[\201\\\203 \201]\202#\201^E\"\266\366p!\210)Q\203OQ\317=\204F\311\312\201_\f\"!\203O\212\201`\n!\210)\321\201a!\211\203\252\211\326\232\204\252
\203\252\201bP\354\201c\"\210\201d\201e\317\"r\211q\210\341\201f\"\216\201g
!\211\203\236\211@\312\201hB\"c\210
A\266\202\202\206\210\201Sed#\210*\266\210\203\266\201i!\210\317.\207" [noninteractive byte-compile-last-logged-file byte-compiler-error-flag byte-compile-dest-file byte-compile--known-dynamic-vars byte-compile--seen-defvars expand-file-name get-file-buffer buffer-modified-p y-or-n-p format "Save buffer %s first? " buffer-name save-buffer nil t byte-compile--load-dynvars getenv "EMACS_DYNVARS_FILE" get-buffer-create " *Compiler Input*" 0 "" "-%s" erase-buffer set-buffer-multibyte insert-file-contents no-conversion coding-system-type 5 default-value major-mode :safe make-closure #[0 "\301\302\300\"\207" [V0 set-default major-mode] 3] set-default emacs-lisp-mode make-local-variable delay-mode-hooks normal-mode local-variable-p lexical-binding file-name-directory file-exists-p message "%s deleted because of `no-byte-compile: %s'" byte-compile-abbreviate-file buffer-local-value no-byte-compile (error) delete-file "Compiling %s..." byte-compile-from-buffer "Compiling %s...done" kill-buffer "\n" file-writable-p make-temp-file default-file-modes logand 384 438 #[0 "\3011	\302\300!0\207\210\303\207" [V0 (error) delete-file nil] 2] set-file-modes set-auto-coding-for-load byte-compile-current-group byte-compile-current-file byte-compile-level buffer-file-coding-system last-coding-system-used enable-local-eval enable-local-variables buffer-file-name buffer-read-only default-directory byte-compile-verbose byte-native-compiling byte+native-compile coding-system-for-write kill-emacs-hook byte-to-native-output-file byte-compile-generate-call-tree nofollow write-region 1 rename-file "Wrote %s" #[0 "\301\300!\207" [V0 set-default-file-modes] 2] set-default-file-modes signal file-error file-missing "Opening output file" "Cannot overwrite file" "Directory not writable or nonexistent" "Report call tree for %s? " display-call-tree "EMACS_GENERATE_DYNVARS" ".dynvars" "Generating %s" generate-new-buffer " *temp*" #[0 "\301\300!\205	\302\300!\207" [V0 buffer-name kill-buffer] 2] delete-dups "%S\n" load] 20 (#$ . 73752) (byte-code "\302
\203\303\304!\203\305!\262
\306	\203\307\202\310\302$	D\207" [buffer-file-name current-prefix-arg nil derived-mode-p emacs-lisp-mode file-name-directory read-file-name "Byte compile and load file: " "Byte compile file: "] 7)])
(set-advertised-calling-convention 'byte-compile-file '(filename) "28.1")
#@171 Compile and evaluate the current top-level form.
Print the result in the echo area.
With argument ARG, insert value in current buffer after the form.

(fn &optional ARG)
(defalias 'compile-defun #[256 "\212\306 \210\307 \210pp`\211\310\311p\312\313\314!\205(\315!\316!=\317=\2043\211\203c\312\320 \262

\204C\211\206A\317\203M \202\\\3211W 0\202\\\322
!\262
\262
\266\202\202\207\320 \206i\317\203u
 \202\204\3231
 0\202\204\322
!\262
)\266\202*\"
\203\235\324\325!\210\326
p\"\210\327c\202\243\324\330\331!\"-\262
)\207" [byte-compile-current-file byte-compile-current-buffer byte-compile-read-position byte-compile-last-position byte-compile-last-warned-form read-symbol-positions-list end-of-defun beginning-of-defun nothing eval nil #[0 "\301\302\303p!\"!\207" [byte-compile-read-position byte-compile-sexp eval-sexp-add-defvars read] 4] markerp marker-buffer get-buffer byte-compile-warning-series byte-compile-log-file (error) byte-compile-report-error (error) message "Compiling from buffer... done." prin1 "\n" "%s" prin1-to-string read-with-symbol-positions warning-series byte-compile-log-buffer byte-compile-debug lexical-binding] 9 (#$ . 77941) "P"])
#@17 

(fn INBUFFER)
(defalias 'byte-compile-from-buffer #[257 "\211\306\211\211\211\211\211\211\211\211\307\211\211\306\306 !\"#$\310%!\306\211\211\211\211\211\211\211&'()*\306C+*)('&,-./01234r\311\3125\313X\203o\314\202u\315\3165S\"P!\2113q\210\317\320!\210\321 \210\306 )\322\3236!\205\230\3246!\3257!=6\326=\204\243\211\203\325\306\327 \262

\204\263\211\206\261\32668\203\300!\266\202\375\3301\315!0\266\202\375\331
!\266\202\375\327 \206\333\32668\203\351
!\210\202\372\3321\365
!0\210\202\372\331
!\266)\26639\203
2:.\207" [read-symbol-positions-list read-with-symbol-positions byte-compile-output byte-compile-maxdepth byte-compile-depth byte-compile-tag-number nil 0 copy-alist get-buffer-create " *Compiler Output*" 1 "" format "-%s" set-buffer-multibyte t erase-buffer #[257 "r\211q\210\203
\306	\"\210eb\210\307\211\307
\203G\310BB\311	BB\312\nBB\313BB\314\fBB\315\307w\210g\316U\203W\317y\210\202Gm\204|`\211\307\320
!\321 \211\203r\322\323\"\210\324!\210)\266\202G\325 \210d\326 )\207" [byte-compile-current-file byte-compile--outbuffer byte-compile-unresolved-functions byte-compile-noruntime-functions byte-compile-new-defuns byte-native-compiling byte-compile-insert-header nil native-comp-speed native-comp-debug native-comp-compiler-options native-comp-driver-options no-native-compile " 	\n\f" 59 1 read byte-run--unescaped-character-literals-warning byte-compile-warn "%s" byte-compile-toplevel-file-form byte-compile-flush-pending byte-compile-warn-about-unresolved-functions byte-native-qualities byte-compile-read-position byte-compile-last-position lread--unescaped-character-literals] 7 "\n\n(fn INBUFFER)"] markerp marker-buffer get-buffer byte-compile-warning-series byte-compile-log-file (error) byte-compile-report-error (error) byte-compile-variables byte-compile-constants byte-compile-jump-tables print-level print-length case-fold-search float-output-format byte-compile-last-position byte-compile-read-position byte-compile-current-buffer byte-compile-initial-macro-environment byte-compile-verbose byte-optimize byte-compile-dynamic byte-compile-dynamic-docstrings byte-compile-warnings current-load-list byte-compile-free-assignments byte-compile-free-references byte-compile-const-variables byte-compile-lexical-variables byte-compile-bound-variables byte-compile-function-environment overriding-plist-environment byte-compile--outbuffer byte-compile-macro-environment byte-compile-level warning-series byte-compile-log-buffer byte-compile-debug byte-native-compiling byte-to-native-plist-environment] 17 (#$ . 79158)])
#@98 Insert a header at the start of OUTBUFFER.
Call from the source buffer.

(fn FILENAME OUTBUFFER)
(defalias 'byte-compile-insert-header #[514 "	rq\210eb\210\305\n\306U\203S\202\211\307V\203\"\211\310W\204&\311\312!\210\211\262
\313\314\315\f\316\317\320\267\202>\321\202H\322\202H\203G\323\202H\324\325\203R\326\202S\327\330\261\f)\207" [byte-compile-dynamic byte-optimize emacs-minor-version emacs-major-version emacs-version ";ELC" 0 13 128 cl--assertion-failed (and (> version 13) (< version 128)) "\n" ";;; Compiled\n" ";;; in Emacs version " "\n" ";;; with" #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (source 54 byte 58)) " source-level optimization only" " byte-level optimization only" " all optimizations" "out optimization" ".\n" ";;; Function definitions are lazy-loaded.\n" "" "\n\n"] 16 (#$ . 81857)])
#@13 

(fn FORM)
(defalias 'byte-compile-output-file-form #[257 "\203\f\306\307	#\nB\310\311\211\310\211?\211\242\312>\203;\313
8;\203;\314\311\211\315\311@\316>&\202H\317\320\"\210\321
\"\210\311.\207" [byte-native-compiling lexical-binding byte-to-native-top-level-forms byte-compile-disable-print-circle print-circle print-gensym record byte-to-native-top-level t nil (defvar defvaralias defconst autoload custom-declare-variable) 3 byte-compile-output-docform ("\n(" 3 ")") (defvaralias autoload custom-declare-variable) princ "\n" prin1 print-quoted print-level print-length print-escape-newlines byte-compile--outbuffer] 9 (#$ . 82744)])
#@585 Print a form with a doc string.  INFO is (prefix doc-index postfix).
If PREFACE and NAME are non-nil, print them too,
before INFO and the FORM but after the doc string itself.
If SPECINDEX is non-nil, it is the index in FORM
of the function bytecode string.  In that case,
we output that argument and the following argument
(the constants vector) together, for lazy loading.
QUOTED says that we have to put a quote before the
list that represents a doc string reference.
`defvaralias', `autoload' and `custom-declare-variable' need that.

(fn PREFACE NAME INFO FORM SPECINDEX QUOTED)
(defalias 'byte-compile-output-docform #[1542 "r	q\210\306A@\307Y\203E
\203E\310c\210\311A@8\306\"\262
A@8;\203EA@8G\307V\203EA@8\307H\312=\203E\211[\262
\313\306\307\313\306\211\313\211\n?
\n\203m\nc\210\314\n	\"\210@c\210\314@	\"\210A\211\262	\203
\211T\262
\315c\210\247\203\317\211U\203\317\306C\316!\203\250\317\320\321\"\"\210\211\242?\262
\203\317\311@	A@B\313\"\322\323\324\"	\"\210A\262	
T\266\202\202y\211	A@U\203	
\203\361\322\323\203\347\325\202\350\326\"	\"\210\202y\306`T\314	@	\"\210b\210\327c\210db\210)\202y\314@	\"\210\202y.\266\3308c\266)\210\306\207" [byte-compile-dynamic-docstrings byte-compile--outbuffer byte-compile-disable-print-circle print-circle print-gensym print-quoted nil 0 "\n" byte-compile-output-as-comment 42 t prin1 " " hash-table-p maphash make-closure #[514 "\211\205\300\301\240\207" [V0 t] 4 "\n\n(fn K V)"] princ format "(#$ . %d) nil" "'(#$ . %d)" "(#$ . %d)" "\\\n" 2 print-level print-length print-escape-newlines print-number-table print-continuous-numbering] 17 (#$ . 83417)])
#@31 

(fn FORM &optional HANDLER)
(defalias 'byte-compile-keep-pending #[513 "\303>\203\f\304\305\"\262\211\2031\305
\242\306>\203\"\307\n\233\203\"\310 \210\211!\210	\203-\311 \210)\2026\312\305\"\210\313\207" [byte-optimize byte-compile--for-effect byte-compile-output (t source) byte-optimize-one-form t (fset defalias) 300 byte-compile-flush-pending byte-compile-discard byte-compile-form nil] 5 (#$ . 85118)])
(defalias 'byte-compile-flush-pending #[0 "\205/\306\307\310\"\211\242\311=\203\312\313A\"\210\202 \211\203 \313
!\210\314\211\315\211\314\211\211\262
\207" [byte-compile-output byte-compile-constants byte-compile-variables byte-compile-depth byte-compile-maxdepth byte-compile-jump-tables byte-compile-out-toplevel t file progn mapc byte-compile-output-file-form nil 0] 5])
#@34 

(fn FORM &optional FOR-EFFECT)
(defalias 'byte-compile-preprocess #[513 "\302\"\262	\203\303!\207
\207" [byte-compile-macro-environment lexical-binding macroexpand-all cconv-closure-convert] 5 (#$ . 85935)])
#@23 

(fn TOP-LEVEL-FORM)
(defalias 'byte-compile-toplevel-file-form #[257 "\300
\301\"\207" [byte-compile-recurse-toplevel #[257 "\301\302\303\304\"!)\207" [byte-compile-current-form nil byte-compile-file-form byte-compile-preprocess t] 5 "\n\n(fn FORM)"]] 4 (#$ . 86157)])
#@13 

(fn FORM)
(defalias 'byte-compile-file-form #[257 "\300
:\203&
@9\203&
@\301N\211\262\203&\211!\211\262\205)\302 \210\303!\207\304!\207" [nil byte-hunk-handler byte-compile-flush-pending byte-compile-output-file-form byte-compile-keep-pending] 4 (#$ . 86436)])
(put 'autoload 'byte-hunk-handler 'byte-compile-file-form-autoload)
#@13 

(fn FORM)
(defalias 'byte-compile-file-form-autoload #[257 "\211\211A\211\262\203\303
@!\204
\211?\262
\203%\304\3058!\306>\203%\304
!\210\211A@\211:\203u\211\242\211\307=\203t
\243\211:\203s\211\242\2119\203r
\243\211\204q\310!\204Z
\311AABBB
	>\203j\312	\"\266\202v\312\n\236\n\"\210\210\210\210\210\313
8;\203\203\211\314!\210\207\315
\316\"\207" [byte-compile-function-environment byte-compile-noruntime-functions byte-compile-unresolved-functions macroexp-const-p eval 5 (t macro) quote fboundp autoload delq 3 byte-compile-docstring-length-warn byte-compile-keep-pending byte-compile-normal-call] 9 (#$ . 86782)])
(byte-code "\300\301\302\303#\210\300\304\302\303#\207" [put defvar byte-hunk-handler byte-compile-file-form-defvar defconst] 4)
#@12 

(fn SYM)
(defalias 'byte-compile--check-prefixed-var #[257 "\2119\205\300\301\302!\"?\205\303\304\"\205\305\306\"\207" [string-match "[-*/:$]" symbol-name byte-compile-warning-enabled-p lexical byte-compile-warn "global/dynamic var `%s' lacks a prefix"] 5 (#$ . 87566)])
#@12 

(fn SYM)
(defalias 'byte-compile--declare-var #[257 "\303
!\210\211>\203\304
\"\305\306\"\203\307\310\"\210\211	B\211\nB\211\207" [byte-compile-lexical-variables byte-compile-bound-variables byte-compile--seen-defvars byte-compile--check-prefixed-var delq byte-compile-warning-enabled-p lexical byte-compile-warn "Variable `%S' declared after its first use"] 4 (#$ . 87854)])
#@13 

(fn FORM)
(defalias 'byte-compile-file-form-defvar #[257 "\211A@\301
!\210
@\302=\203\211B\210\211AA?\205\211@\303=?\205?\304
!\210\305
8:\203>\306
!\262
\211AA\307\3058\310\311#\240\210\211\207" [byte-compile-const-variables byte-compile--declare-var defconst defvar byte-compile-docstring-length-warn 2 copy-sequence byte-compile-top-level nil file] 6 (#$ . 88249)])
(byte-code "\300\301\302\303#\210\300\304\302\303#\207" [put define-abbrev-table byte-hunk-handler byte-compile-file-form-defvar-function defvaralias] 4)
#@13 

(fn FORM)
(defalias 'byte-compile-file-form-defvar-function #[257 "\301
A@\211:\203D\211\242\211\302=\203;
\243\211:\2032\211\242
\243\211\204(!\266\202J\303
!\266\202J\303
!\266\202J\303
!\266\202J\303
!\266\211:\203\234\211\242\211\304=\203\233
\243\211:\203\232\211\243\211:\203\231\211\242\211:\203\230\211\242\211\302=\203\227
\243\211:\203\226\211\242
\243\211\204\224
>\203\224\305\306!\203\224\307\310\"\210\266\210\210\210\210\210\210\311
!\210\312
!\207" [byte-compile-bound-variables #[257 "\211\205\300
!\207" [byte-compile--declare-var] 3 "\n\n(fn NAME)"] quote nil defvaralias byte-compile-warning-enabled-p suspicious byte-compile-warn "Alias for `%S' should be declared before its referent" byte-compile-docstring-length-warn byte-compile-keep-pending] 12 (#$ . 88789)])
(put 'custom-declare-variable 'byte-hunk-handler 'byte-compile-file-form-custom-declare-variable)
#@13 

(fn FORM)
(defalias 'byte-compile-file-form-custom-declare-variable #[257 "\300\301!\203\n\302
!\210\303
!\207" [byte-compile-warning-enabled-p callargs byte-compile-nogroup-warn byte-compile-file-form-defvar-function] 3 (#$ . 89717)])
(put 'require 'byte-hunk-handler 'byte-compile-file-form-require)
#@13 

(fn FORM)
(defalias 'byte-compile-file-form-require #[257 "\302\303A\"\304\211\305\306\"\210\262\307@B\262

\203'\211@\235\204'
A\262\202
\203L
@\211\203K\211@\211:\203D\211@\310>\203D\211A	B
A\266\202\202-\210\266\311
\312\"\207" [load-history byte-compile-new-defuns mapcar eval nil apply require provide (defun t) byte-compile-keep-pending byte-compile-normal-call] 8 (#$ . 90028)])
(byte-code "\300\301\302\303#\210\300\304\302\303#\207" [put progn byte-hunk-handler byte-compile-file-form-progn prog1] 4)
#@13 

(fn FORM)
(defalias 'byte-compile-file-form-progn #[257 "\300\301A\"\210\302\207" [mapc byte-compile-file-form nil] 4 (#$ . 90564)])
(put 'with-no-warnings 'byte-hunk-handler 'byte-compile-file-form-with-no-warnings)
#@13 

(fn FORM)
(defalias 'byte-compile-file-form-with-no-warnings #[257 "\301\302\303A\"\210)\301\207" [byte-compile-warnings nil mapc byte-compile-file-form] 4 (#$ . 90790)])
(put 'internal--with-suppressed-warnings 'byte-hunk-handler 'byte-compile-file-form-with-suppressed-warnings)
#@13 

(fn FORM)
(defalias 'byte-compile-file-form-with-suppressed-warnings #[257 "\301
A@A@\"\302\303AA\"\210)\304\207" [byte-compile--suppressed-warnings append mapc byte-compile-file-form nil] 4 (#$ . 91081)])
(put 'make-obsolete 'byte-hunk-handler 'byte-compile-file-form-make-obsolete)
#@13 

(fn FORM)
(defalias 'byte-compile-file-form-make-obsolete #[257 "\300
!\301\302\303\304A\"\"\210\207" [byte-compile-keep-pending apply make-obsolete mapcar eval] 7 (#$ . 91376)])
(put 'eval 'byte-hunk-handler 'byte-compile-file-form-eval)
#@13 

(fn FORM)
(defalias 'byte-compile-file-form-eval #[257 "\211A@\242\301=\203\302
8\232\203\211A@A@\207\303
!\207" [lexical-binding quote 2 byte-compile-keep-pending] 3 (#$ . 91624)])
#@391 Process a `defalias' for NAME.
If MACRO is non-nil, the definition is known to be a macro.
ARGLIST is the list of arguments, if it was recognized or t otherwise.
BODY of the definition, or t if not recognized.
Return non-nil if everything went as planned, or nil to imply that it decided
not to take responsibility for the actual compilation of the code.

(fn NAME MACRO ARGLIST BODY REST)
(defalias 'byte-compile-file-form-defmumble #[1285 "\203\306\202	\307\203\307\202\306J\236J\236\310	!\210	B\n\203<\236\204<\311\211EB\312\313\n\"\203M\314	\n#\210\f\203\\\315\316
\206X\317#\210\204f<\203\353\211\203\207\312\313\n\"\203\2000\236\204\200\320\321\n\"\210\211\311\241\210\202\353
\203\256\312\313\n\"\203\3530\236\204\353\320\322	\203\246\323\202\247\324#\210\202\353K\242\203\273\325\202\274\326=\203\353\312\313\n\"\203\342\320\327	\203\323\324\202\324\323\203\337\323\202\340\324$\210	CJBL\210<\203
@;\203
\243\2429\203
\243\242\203
\243\243\242;\203
\320\330\n\"\210<\2045
\2041
<\203*
\331D\202+
\332BB\311\202\333
\333B\332\"\203U
\203N
	0\236\204`

\241\210\202`
\nBJBL\210?\205\331
\334 \210\335
\332\";\204t
\336\202u
\3371\203\245
	\203\231
\340\341\fD\341\326BD\342BBB2\343\344#\266\202\202\240
\343\345\f\311$3B3\346\347\f\f\203\266
\350\351BB\202\273
\352\353BB\354\311\":?\205\315
4\205\315
\355\311&\266\356\3575\"\210\332\262
)\207" [byte-compile-current-form byte-compile-new-defuns byte-compile-generate-call-tree byte-compile-call-tree byte-compile-verbose byte-compile-current-file byte-compile-macro-environment byte-compile-function-environment byte-compile-set-symbol-position nil byte-compile-warning-enabled-p redefine byte-compile-arglist-warn message "Compiling %s... (%s)" "" byte-compile-warn "`%s' defined multiple times, as both function and macro" "%s `%s' defined multiple times in this file" "macro" "function" lambda macro "%s `%s' being redefined as a %s" "probable `\"' without `\\' in doc string of %s" declared t byte-compile-lambda byte-compile-flush-pending documentation -1 4 defalias quote (nil) record byte-to-native-top-level byte-to-native-func-def byte-compile-output-docform "\n(defalias '" " '(macro . #[" ("])") " #[" ("]") append 1 princ ")" byte-compile-initial-macro-environment byte-native-compiling lexical-binding byte-to-native-top-level-forms byte-compile-dynamic byte-compile--outbuffer] 18 (#$ . 91820)])
#@200 Print Lisp object EXP in the output file, inside a comment.
Return the file (byte) position it will have.
If QUOTED is non-nil, print with quoting; otherwise, print without quoting.

(fn EXP QUOTED)
(defalias 'byte-compile-output-as-comment #[514 "rq\210`\301c\210
\203\302\"\210\202\303\"\210\211b\210\304\305\306\307#\203-\310\311\307\211#\210\202\211b\210\304\312\306\307#\203A\310\313\307\211#\210\2020\211b\210\304\314\306\307#\203U\310\315\307\211#\210\202Ddb\210\314c\210\211b\210\316\317\320\321d!\321!Z\"\261\210\321`!eZTdb\210\262
)\207" [byte-compile--outbuffer " " prin1 princ search-forward "
" nil t replace-match "

" "" "
0" "" "
_" "#@" format "%d" position-bytes] 9 (#$ . 94347)])
#@137 Return an expression which will evaluate to a function value FUN.
FUN should be either a `lambda' value or a `closure' value.

(fn FUN)
(defalias 'byte-compile--reify-function #[257 "\300
\242\211\301=\203\243\211\242
\243\302
#\207\243\211\242
\243\211\242
\243#\207" [#[771 "\300\211@;\203\211A\262\242C\262@\242\301=\203#\211A\262\242B\262\211\203Q\211@\211:\203=\211@\302ADDB\262\202J\211\303=\204J\304
DB\262
A\266\202\202$\210\211\204`\305\306\"BB\207\307
\305\306\"BBE\207" [nil interactive quote t defvar lambda append let] 12 "\n\n(fn ENV ARGS BODY)"] lambda nil] 12 (#$ . 95073)])
#@134 If FORM is a symbol, byte-compile its function definition.
If FORM is a lambda or a macro, byte-compile it as a function.

(fn FORM)
(defalias 'byte-compile #[257 "\303\304!\205\305!\306	!=\307=\204\211\203<\310\311 \262

\204'\211\206&\307\n\203/!\207\31218!0\207\313
!\207\311 \206B\307\n\203M
!\202]\3141X
!0\202]\313
!\262
)\207" [warning-series byte-compile-log-buffer byte-compile-debug #[257 "\306!\307\211\211\211\211\211\211\211	\n\f
\307C\2119\2039\211K\202:\211\211\242\310=\211\203F
A\262\311!\203^\312\3139\203W\202X\314\"\210
\202\257\3079\204k\242\315=\203y@\315=\316!\262\317\262
\320!\262\321\307\322#\2629\203\220\322\317\"\262\211\203\232\322\317\"\262
\203\243\310B\2629\203\254M\210\262
)\266\202\203\273.\207" [byte-compile-initial-macro-environment byte-compile-verbose byte-optimize byte-compile-dynamic byte-compile-dynamic-docstrings byte-compile-warnings copy-alist nil macro byte-code-function-p message "Function %s is already compiled" "provided" closure byte-compile--reify-function t byte-compile-preprocess byte-compile-top-level eval current-load-list byte-compile-free-assignments byte-compile-free-references byte-compile-const-variables byte-compile-lexical-variables byte-compile-bound-variables byte-compile-function-environment overriding-plist-environment byte-compile--outbuffer byte-compile-macro-environment lexical-binding byte-native-compiling byte-to-native-plist-environment] 16 "\n\n(fn FORM)"] markerp marker-buffer get-buffer byte-compile-warning-series nil byte-compile-log-file (error) byte-compile-report-error (error)] 7 (#$ . 95717)])
#@37 Compile and return SEXP.

(fn SEXP)
(defalias 'byte-compile-sexp #[257 "\303\304!\205\305!\306	!=\307=\204\211\203<\310\311 \262

\204'\211\206&\307\n\203/!\207\31218!0\207\313
!\207\311 \206B\307\n\203M
!\202]\3141X
!0\202]\313
!\262
)\207" [warning-series byte-compile-log-buffer byte-compile-debug #[257 "\306!\307\211\211\211\211\211\211\211	\n\f
\307C\n\f
\310\311!!\2039.\207" [byte-compile-initial-macro-environment byte-compile-verbose byte-optimize byte-compile-dynamic byte-compile-dynamic-docstrings byte-compile-warnings copy-alist nil byte-compile-top-level byte-compile-preprocess current-load-list byte-compile-free-assignments byte-compile-free-references byte-compile-const-variables byte-compile-lexical-variables byte-compile-bound-variables byte-compile-function-environment overriding-plist-environment byte-compile--outbuffer byte-compile-macro-environment byte-native-compiling byte-to-native-plist-environment] 16 "\n\n(fn SEXP)"] markerp marker-buffer get-buffer byte-compile-warning-series nil byte-compile-log-file (error) byte-compile-report-error (error)] 7 (#$ . 97417)])
#@47 Check lambda-list LIST for errors.

(fn LIST)
(defalias 'byte-compile-check-lambda-list #[257 "\301
\205\263
@\2119\203\302
!\210\2119\203J\211\303
\304>\206E\305!\206E\211\205E
>\206E\306!\205E\3071C
\211JL\210\3010\266\202\202G\210\303\266\202\203S\310\311\"\266\202\254\211\312\267\202\216A\204b\310\313!\210AA\203l\310\314!\210A@\315>\203\253\310\316A@\"\266\202\254\317A>\203\253\310\320!\266\202\254\211>\203\246\321\322\323!\"\204\246\324\325\"\266\202\254\211B\262\210
A\262\202
\207" [byte-compile-const-variables nil byte-compile-set-symbol-position t (nil t) keywordp boundp (setting-constant) error "Invalid lambda variable %s" #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (&rest 89 &optional 127)) "&rest without variable name" "Garbage following &rest VAR in lambda-list" (&optional &rest) "%s following &rest in lambda-list" &optional "Duplicate &optional" string-match "\\`_" symbol-name byte-compile-warn "repeated variable %s in lambda-list"] 7 (#$ . 98583)])
#@83 Return a list of the variables in the lambda argument list ARGLIST.

(fn ARGLIST)
(defalias 'byte-compile-arglist-vars #[257 "\300\301\300\302\"\"\207" [remq &rest &optional] 6 (#$ . 99650)])
#@75 Return a new lexical environment for a lambda expression FORM.

(fn ARGS)
(defalias 'byte-compile-make-lambda-lexenv #[257 "\300\301\211\203\211@\211BB\262T\262
A\266\202\202\210
\207" [nil 0] 7 (#$ . 99849)])
#@16 

(fn ARGLIST)
(defalias 'byte-compile-make-args-desc #[257 "\300\301\300\203@\302>\204T\262A\262\202\262@\303=\203=A\262\203=@\304=\204=
T\262A\262\202'\203D\305\262
\306V\203N\307\310!\207\311\312\313\"\312\314\"#\207" [0 nil (&optional &rest) &optional &rest 1 127 byte-compile-report-error "Too many (>127) mandatory arguments" logior ash 8 7] 10 (#$ . 100075)])
#@20 

(fn VAR CONTEXT)
(defalias 'byte-compile--warn-lexical-dynamic #[514 "\301\302\"\205\303\304\305\306\307\310\311\n\"\"\312#$\207" [byte-compile--known-dynamic-vars byte-compile-warning-enabled-p lexical-dynamic byte-compile-warn "`%s' lexically bound in %s here but declared dynamic in: %s" mapconcat identity mapcan make-closure #[257 "\300
@=\205\n\211AC\207" [V0] 3 "\n\n(fn V)"] ", "] 12 (#$ . 100481)])
#@447 Byte-compile a lambda-expression and return a valid function.
The value is usually a compiled function but may be the original
lambda-expression.
When ADD-LAMBDA is non-nil, the symbol `lambda' is added as head
of the list FUN and `byte-compile-set-symbol-position' is not called.
Use this feature to avoid calling `byte-compile-set-symbol-position'
for symbols generated by the byte compiler itself.

(fn FUN &optional ADD-LAMBDA RESERVED-CSTS)
(defalias 'byte-compile-lambda #[769 "
\203\f\306B\262\202\242\306=\204\307\310\"\210\311\306!\210\312!\210\313A@!\210A@\314
!\315?\2053
	\"AA\211@;\205J\211@
A\203J
A\262\316\236\317\203l\211\203k\211@\211\n\236\203d\320
\306\"\210
A\266\202\202S\210
\203\334\311\316!\210
@=\203A\262
A:\203\320\321\322AA\"\204\225\323\324\325!\"\210
AA\262

A@\326
!
\242\327>\203\273
A:\203\264
A\262\202\247
@\262\202\240
\242\330=\203\306\203\313\316
D\262\266\202\334
A\203\334\323\331\325!\"\210\326\332B\317\306\205\352\333	!%\211\242\334=\204\370\335\336!\210\337\340\203
\341	!\202
\315A\203
\203
\342	
\"C\202*
\204'
\205*
C\203;
\343	A@	\"C\202E
\205E
A@C##\203f
\344A@\f\"\345
!
>\204`
\346\347\350D\"\210\211\351I\266\211\262
\262
)\207" [lexical-binding byte-compile-bound-variables byte-compile--known-dynamic-vars byte-native-compiling byte-to-native-lambdas-h cl-struct-byte-to-native-lambda-tags lambda error "Not a lambda list: %S" byte-compile-set-symbol-position byte-compile-docstring-length-warn byte-compile-check-lambda-list byte-compile-arglist-vars append interactive nil byte-compile--warn-lexical-dynamic seq-every-p symbolp byte-compile-warn "malformed interactive specc: %s" prin1-to-string byte-compile-top-level (let let* progn save-excursion) list "malformed interactive spec: %s" progn byte-compile-make-lambda-lexenv byte-code cl--assertion-failed (eq 'byte-code (car-safe compiled)) apply make-byte-code byte-compile-make-args-desc help-add-fundoc-usage vector gethash type-of signal wrong-type-argument byte-to-native-lambda 1] 19 (#$ . 100906)])
(defvar byte-compile-reserved-constants 0)
(defalias 'byte-compile-constants-vector #[0 "S	\237\n\237\303\211\304\303\204\203n
@\262
\203`
W\203`@\247\2035@W\204Y\305\306!\210\202Y@@\236\211\262\203I@A\241\210\202Y@T\211\262	\241\210@B\262A\262\202
A\262\262\262\202\n\307\310\311\312\"\237\"\207" [byte-compile-reserved-constants byte-compile-variables byte-compile-constants nil (5 63 255 65535 65535) cl--assertion-failed (< (car rest) byte-compile-reserved-constants) apply vector mapcar car] 12])
#@67 

(fn FORM &optional FOR-EFFECT OUTPUT-TYPE LEXENV RESERVED-CSTS)
(defalias 'byte-compile-top-level #[1281 "\306\211\307\211\211\206\307\306\211\310>\203,\311\"\262\242\312=\203AAA\204AA@\262\202,\203Z\313=\203ZG\211\307V\203Z\314\315 !\210\316\"\210\317\".\n\207" [byte-compile-jump-tables byte-compile-output byte-compile-reserved-constants byte-compile--lexical-environment byte-compile-maxdepth byte-compile-depth nil 0 (t source) byte-optimize-one-form progn lambda byte-compile-out-tag byte-compile-make-tag byte-compile-form byte-compile-out-toplevel byte-compile-tag-number byte-compile-variables byte-compile-constants byte-compile--for-effect byte-optimize lexical-binding] 16 (#$ . 103563)])
#@41 

(fn &optional FOR-EFFECT OUTPUT-TYPE)
(defalias 'byte-compile-out-toplevel #[512 "
\203=@@\305=\203A\202=\306\307	\236?\205;\310	!\211\2036\211@@9\2046\211@@\247\2046\211A\262
\202\211@@\262
!\210\311\312\313\"\210\237\n\314>\203O\315!\307
\316=?\307\211\316=\204y
\317=\203f\320\202g\321\233\204y
\322\236\204y
\312\236\211\262\203y

\310!>A\237\262@@\323>\203\361@A@\262@@\324=\203\350
:\204\331
9\203\350
\307
\325>\206\324\326!\206\324\211\205\324
>\206\324\327!\205\324\3301\322
\211JL\210\3070\266\202\202\326\210\331\266\202\204\350\203u
\332D
B\211\262\202k


B\211\262\202k
\203u
\333\233\204u
@@\334N\211\262\203u
A\203.
\317=\203u
AA\203u
\335
G@A\"\203u
A@@\305=\203u
A\262\307\262\211\237\262

\336=\203U
\211@\242\332=\203U
\211@A@9\203U
\211@A@
AB\202X


BC\262
\317=\204n
\337\307\340\341@A\"\"?\203u
A\262\202\204\203\203
\342 \343\344!\fF\207\211A\203\215
\345
\237B\207\211@\207" [byte-compile-output byte-compile-constants byte-optimize byte-compile-const-variables byte-compile-maxdepth byte-discard byte-compile-push-constant nil reverse byte-compile-out byte-return 0 (t byte) byte-optimize-lapcode lambda file 50 8 TAG (byte-varref byte-constant) byte-constant (nil t) keywordp boundp (setting-constant) t quote 3 byte-opcode-invert eql funcall delq mapcar consp byte-compile-constants-vector byte-code byte-compile-lapcode progn] 11 (#$ . 104321)])
#@34 

(fn BODY &optional FOR-EFFECT)
(defalias 'byte-compile-top-level-body #[513 "\300\301B\302#\262
\242\301=\203
A\207
\205
C\207" [byte-compile-top-level progn t] 6 (#$ . 105774)])
#@27 

(fn FN FILE &rest ARGS)
(defalias 'byte-compile-macroexpand-declare-function #[642 "\211:\205\211@<\236\211\203(
\203#\303\304!\203#\305@\306#\210\202(\307
\"\2034\310@D\2025\311B	B\266\307\n\"\312\313BBB!\207" [byte-compile-unresolved-functions byte-compile-function-environment byte-compile-noruntime-functions byte-compile-warning-enabled-p callargs byte-compile-arglist-warn nil delq declared t macroexpand declare-function] 9 (#$ . 105968)])
(set-advertised-calling-convention 'byte-compile-macroexpand-declare-function '(fn file &optional arglist fileonly) nil)
#@34 

(fn FORM &optional FOR-EFFECT)
(defalias 'byte-compile-form #[513 "\211
:\204n
9\203A
\306
\307>\206<\310!\206<\211\205<
	>\206<\311!\205<\3121:
\211JL\210\3060\266\202\202>\210\313\266\202\203Q
9\203J\314!\210\315!\210\202\260
\203g\n\203g
9\203b\314!\210\306\202\260
\316!\210\202\260

@9\203{

@\211\317N
\320N\206\202
>\321>\203\302A\211:\203\301\211\242\211:\203\300\211\242\211\322=\203\277
\243\211:\203\276\211\242
\243\211\204\274
\f>\203\274\323\324\325#!\210\266\210\210\210\210\326>\203\332A\242\211\242\322=\203\331\327
A@\306\"\210\210\330\331!\203
\306
\307>\206
\310!\206
\211\205

	>\206
\311!\205
\3121

\211JL\210\3060\266\202\202
\210\313\266\202\203
\332\333\"\210\330\320\"\203G
\211\203G
\332\334;\2037
\335\336\337!\"\202E
\313=\204D
\324\340\"\202E
\341#\210@K\242\342=\203[
\323\335\343@#!\210
\203s
\344!\203s

\345=\204s

!\266\202\260
\346!\266\202\260
\347@!\203\217

\350>\203\217
\351!\210\202\260

@\242\352=\203\254

\353!\211\262=\204\254
\354\"\210\306\202\260
\346!\210\205\266
\355 )\207" [byte-compile--for-effect byte-compile-const-variables byte-compile-delete-errors byte-compile-interactive-only-functions byte-compile-lexical-variables byte-optimize nil (nil t) keywordp boundp (setting-constant) t byte-compile-set-symbol-position byte-compile-constant byte-compile-variable-ref byte-compile interactive-only (set symbol-value run-hooks add-hook remove-hook run-hook-with-args run-hook-with-args-until-success run-hook-with-args-until-failure) quote byte-compile-report-error format-message "%s cannot use lexical var `%s'" (add-hook remove-hook) byte-compile-check-variable byte-compile-warning-enabled-p suspicious byte-compile-warn "`%s' called as a function" "`%s' is for interactive use only%s" format "; %s" substitute-command-keys "; use `%s' instead." "." macro "`%s' defined after use in %S (missing `require' of a library file?)" functionp cl-byte-compile-compiler-macro byte-compile-normal-call byte-code-function-p (t lap) byte-compile-unfold-bcf lambda macroexp--unfold-lambda byte-compile-form byte-compile-discard] 16 (#$ . 106568)])
#@13 

(fn FORM)
(defalias 'byte-compile-normal-call #[257 "\211@9\203\302\303@\"\203\211@\304>\203\305
!\210\306
!\210\203%\307
!\210	\203?\211@\310=\203?\302\310\211\"\203?\311\310!\210\312\313!\210\314
@!\210\315\316A\"\210\317\320AG\"\207" [byte-compile-generate-call-tree byte-compile--for-effect byte-compile-warning-enabled-p callargs (custom-declare-group custom-declare-variable custom-declare-face) byte-compile-nogroup-warn byte-compile-callargs-warn byte-compile-annotate-call-tree mapcar byte-compile-set-symbol-position byte-compile-warn "`mapcar' called for effect; use `mapc' or `dolist' instead" byte-compile-push-constant mapc byte-compile-form byte-compile-out byte-call] 4 (#$ . 108751)])
#@22 

(fn LAP END-DEPTH)
(defalias 'byte-compile-inline-lapcode #[514 "\303 \304\211\211\211\211C\304\211\203\270\211@\211@\305=\203=\211\242\235\204%\211\235\2036\2030A\304\241\210\304\262\306
!\210\202\261\211@	>\203k\262\211A\262\307
@A\"\210\203\261\211AB\262\211AA\304\241\210\304\262\202\261\211@\310=\203\203\311Z\312\"\210\307\313\n\"\210\202\261\211@\314=\203\233\nB\312\262\315\316\317\"\"\210\211@\320=\205\245\211A@\262\262\321
@A\"\210
A\266\202\202\210\306!\207" [byte-compile-depth byte-goto-ops byte-compile-jump-tables byte-compile-make-tag nil TAG byte-compile-out-tag byte-compile-goto byte-return byte-compile-discard t byte-goto byte-switch maphash make-closure #[514 "\300
\300\242B\240\207" [V0] 5 "\n\n(fn K TAG)"] byte-constant byte-compile-out] 15 (#$ . 109475)])
#@48 Inline call to byte-code-functions.

(fn FORM)
(defalias 'byte-compile-unfold-bcf #[257 "\211@\211\302H	
\247\205\303\304\"AG\305\211\306!\210\307\310H\311H\312#\262
\313
\236\2035\314!\202)
\315\316	A\"\210\204\215<\204I\317\320!\210\203\203@\211\321\267\202tA\262\210\202I\311G_T\262A@B\262\305\262\210\202I\211A\262\242B\262\210\202I\204\215\311G_\262\211\\X\203\264T\311\245Z\302\211W\203\257\305\322\305!\266\211T\262
\202\234\266\202

\323\310\"\302U\203\320\324\325\326\n\"!\210\327\311\245Z!\210\202

S\311\245Z\211\302V\204\351\317\330\331\305E$\210\211\332W\203\373\333\334SH\302\"\266\202

\333\335\"\266\315\336\"\210\337
T\"\210
\203
\333\340G\"\210	T=\204(
\317\341\342\305	D$\210\305)\207" [byte-compile-bound-variables byte-compile-depth 0 ash -7 nil fetch-bytecode byte-decompile-bytecode-1 1 2 t byte-switch byte-compile-normal-call mapc byte-compile-form cl--assertion-failed (listp fargs) #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (&optional 85 &rest 94)) byte-compile-push-constant logand byte-compile-report-error format "Too many arguments for inlined function %S" byte-compile-discard (> n 0) "problem: fmax2=%S alen=%S n=%S" 5 byte-compile-out [byte-list1 byte-list2 byte-list3 byte-list4] byte-listN byte-compile-dynamic-variable-bind byte-compile-inline-lapcode byte-unbind (eq byte-compile-depth (1+ start-depth)) "Wrong depth start=%s end=%s"] 16 (#$ . 110322)])
#@81 Do various error checks before a use of the variable VAR.

(fn VAR ACCESS-TYPE)
(defalias 'byte-compile-check-variable #[514 "
9\203	\304!\210
9\203C
\305
\306>\206>\307!\206>\211\205>
>\206>\310!\205>\3111<
\211JL\210\3050\266\202\202@\210\312\266\202\203j\313\3149\205K\"\205\247\315
\316=\203Z\317\202[\3209\203d\321\202e\322\323!#\207
\324N\211\205\237	>?\205\237\n>?\205\237>?\205\237\211A@\211\325\267\202\234\326=?\202\235\326=\202\235\312\262
\262
\205\247\327!\207" [byte-compile-const-variables byte-compile-not-obsolete-vars byte-compile-global-not-obsolete-vars byte-compile-lexical-variables byte-compile-set-symbol-position nil (nil t) keywordp boundp (setting-constant) t byte-compile-warning-enabled-p constants byte-compile-warn let-bind "attempt to let-bind %s `%s'" "variable reference to %s `%s'" "constant" "nonvariable" prin1-to-string byte-obsolete-variable #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (set 143 get 150)) reference byte-compile-warn-obsolete] 7 (#$ . 111846)])
#@20 

(fn BASE-OP VAR)
(defalias 'byte-compile-dynamic-variable-op #[514 "\211\236\211\204
C\262
\211B\301\"\207" [byte-compile-variables byte-compile-out] 6 (#$ . 112932)])
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put byte-compile-dynamic-variable-op speed -1 put byte-optimizer byte-compile-inline-expand] 5)
#@85 Generate code to bind the lexical variable VAR to the top-of-stack value.

(fn VAR)
(defalias 'byte-compile-dynamic-variable-bind #[257 "\302
\303\"\210\211B\304
\211	\236\211\204
C\262
\211	B\305\"\207" [byte-compile-bound-variables byte-compile-variables byte-compile-check-variable let-bind byte-varbind byte-compile-out] 7 (#$ . 113273)])
#@203 Warn if symbol VAR refers to a free variable.
VAR must not be lexically bound.
If optional argument ASSIGNMENT is non-nil, this is treated as an
assignment (i.e. `setq').

(fn VAR &optional ASSIGNMENT)
(defalias 'byte-compile-free-vars-warn #[513 "\303\304\"?\206\305!\206
>\206

\203	\202\n>?\205S\306!
\203.\307\202/\310\311!\312\313\203@\314P\202A\315$\266\211\203N
	B\211\207
\nB\211\207" [byte-compile-bound-variables byte-compile-free-assignments byte-compile-free-references byte-compile-warning-enabled-p free-vars boundp prin1-to-string "assignment" "reference" help-uni-confusable-suggestions byte-compile-warn "%s to free variable `%s'%s" "\n  " ""] 11 (#$ . 113630)])
#@77 Generate code to push the value of the variable VAR on the stack.

(fn VAR)
(defalias 'byte-compile-variable-ref #[257 "\302
\303\"\210\211\236\211\203\304
A!\207\305!\210\306\211	\236\211\204&
C\262
\211	B\307\"\207" [byte-compile--lexical-environment byte-compile-variables byte-compile-check-variable reference byte-compile-stack-ref byte-compile-free-vars-warn byte-varref byte-compile-out] 8 (#$ . 114344)])
#@78 Generate code to set the variable VAR from the top-of-stack value.

(fn VAR)
(defalias 'byte-compile-variable-set #[257 "\302
\303\"\210\211\236\211\203\304
A!\207\305\306\"\210\307\211	\236\211\204'
C\262
\211	B\310\"\207" [byte-compile--lexical-environment byte-compile-variables byte-compile-check-variable assign byte-compile-stack-set byte-compile-free-vars-warn t byte-varset byte-compile-out] 8 (#$ . 114772)])
#@14 

(fn CONST)
(defalias 'byte-compile-get-constant '(macro . #[257 "\300\301\302D\303\304\305\306\301\307\310\nE\311BBE\312BBB\313\314BBF\315\316\317\320\321D\322BBEDE\207" [or if stringp let (result) dolist (elt byte-compile-constants) equal-including-properties (car elt) ((setq result elt)) (result) assoc (byte-compile-constants #'eql) car setq byte-compile-constants cons list (byte-compile-constants)] 12 (#$ . 115205)]))
#@14 

(fn CONST)
(defalias 'byte-compile-constant #[257 "\203\302\211\207\211\2119\203\303
!\210\304\305;\203;\302	\211\2034\211@\306
@\"\203-\211\262
A\266\202\202\210\211\262
\202@\307	\310#\206JC	B\211@\"\207" [byte-compile--for-effect byte-compile-constants nil byte-compile-set-symbol-position byte-compile-out byte-constant equal-including-properties assoc eql] 10 (#$ . 115643)])
#@14 

(fn CONST)
(defalias 'byte-compile-push-constant #[257 "\2119\203	\301
!\210\302\303;\2032\304\211\203+\211@\305
@\"\203$\211\262
A\266\202\202\210\211\262
\2027\306\307#\206ACB\211@\"\207" [byte-compile-constants byte-compile-set-symbol-position byte-compile-out byte-constant nil equal-including-properties assoc eql] 9 (#$ . 116052)])
#@521 Add a compiler-form for FUNCTION.
If function is a symbol, then the variable "byte-SYMBOL" must name
the opcode to be used.  If function is a list, the first element
is the function and the second element is the bytecode-symbol.
The second element may be nil, meaning there is no opcode.
COMPILE-HANDLER is the function to use to compile this byte-op, or
may be the abbreviations 0, 1, 2, 2-and, 3, 0-1, 1-2, 1-3, or 2-3.
If it is nil, then the handler is "byte-compile-SYMBOL."

(fn FUNCTION &optional COMPILE-HANDLER)
(defalias 'byte-defop-compiler '(macro . #[513 "\3009\203\301\302\303!P!\262
\202A@\262
@\262\304\305D\306\305\307\236A\2064\2064\301\310\303	!P!DF
\203T\311
\304\305D\312\305DF\304\305D\313\305\nDFF\207\207" [nil intern "byte-" symbol-name put quote 'byte-compile ((0 . byte-compile-no-args) (1 . byte-compile-one-arg) (2 . byte-compile-two-args) (2-and . byte-compile-and-folded) (3 . byte-compile-three-args) (0-1 . byte-compile-zero-or-one-arg) (1-2 . byte-compile-one-or-two-args) (2-3 . byte-compile-two-or-three-args) (1-3 . byte-compile-one-to-three-args)) "byte-compile-" progn 'byte-opcode 'byte-opcode-invert] 12 (#$ . 116417)]))
#@43 

(fn FUNCTION &optional COMPILE-HANDLER)
(defalias 'byte-defop-compiler-1 '(macro . #[513 "\300\301DE\207" [byte-defop-compiler nil] 5 (#$ . 117607)]))
(byte-code "\300\301\302\303#\210\300\304\302\305#\210\300\306\302\305#\210\300\307\302\305#\210\300\310\302\305#\210\300\311\302\305#\210\300\312\302\313#\210\300\314\302\313#\210\300\315\302\313#\210\300\316\302\313#\210\300\317\302\320#\210\300\321\322\323#\210\300\321\324\325#\210\300\325\302\321#\210\300\326\322\323#\210\300\326\324\327#\210\300\327\302\326#\210\300\330\322\323#\210\300\330\324\331#\210\300\331\302\330#\210\300\332\322\323#\210\300\332\324\333#\210\300\333\302\332#\210\300\334\322\323#\210\300\334\324\335#\210\300\335\302\334#\210\300\336\322\323#\210\300\336\324\337#\210\300\337\302\336#\210\300\340\322\323#\210\300\340\324\341#\210\300\341\302\340#\210\300\342\322\323#\210\300\342\324\343#\210\300\343\302\342#\210\300\344\322\323#\210\300\344\324\345#\210\300\345\302\344#\210\300\346\322\323#\210\300\346\324\347#\210\300\347\302\346#\210\300\350\322\323#\210\300\350\324\351#\210\300\351\302\350#\210\300\352\322\323#\210\300\352\324\353#\210\300\353\302\352#\210\300\354\322\355#\210\300\354\324\356#\210\300\356\302\354#\210\300\357\322\355#\210\300\357\324\360#\210\300\360\302\357#\210\300\361\322\355#\210\300\361\324\362#\210\300\362\302\361#\210\300\363\322\364#\210\300\363\324\365#\210\300\365\302\363#\210\300\366\322\364#\210\300\366\324\367#\210\300\367\302\366#\210\300\370\322\364#\210\300\370\324\371#\210\300\371\302\370#\210\300\372\322\364#\210\300\372\324\373#\210\300\373\302\372#\210\300\374\322\364#\210\300\374\324\375#\210\300\375\302\374#\210\300\376\322\364#\210\300\376\324\375#\210\300\375\302\376#\210\300\377\322\364#\210\300\377\324\201@#\210\300\201@\302\377#\210\300\201A\322\364#\210\300\201A\324\201B#\210\300\201B\302\201A#\210\300\201C\322\364#\210\300\201C\324\201D#\210\300\201D\302\201C#\210\300\201E\322\364#\210\300\201E\324\201F#\210\300\201F\302\201E#\210\300\201G\322\364#\210\300\201G\324\201H#\210\300\201H\302\201G#\210\300\201I\322\364#\210\300\201I\324\201J#\210\300\201J\302\201I#\210\300\201K\322\364#\210\300\201K\324\201L#\210\300\201L\302\201K#\210\300\201M\322\364#\210\300\201M\324\201N#\210\300\201N\302\201M#\210\300\201O\322\355#\210\300\201O\324\201P#\210\300\201P\302\201O#\210\300\201Q\322\364#\210\300\201Q\324\201R#\210\300\201R\302\201Q#\210\300\201S\322\355#\210\300\201S\324\201T#\210\300\201T\302\201S#\210\300\201U\322\364#\210\300\201U\324\201V#\210\300\201V\302\201U#\210\300\201W\322\364#\210\300\201W\324\201X#\210\300\201X\302\201W#\210\300\201Y\322\364#\210\300\201Y\324\201Z#\210\300\201Z\302\201Y#\210\300\201[\322\364#\210\300\201[\324\201\\#\210\300\201\\\302\201[#\210\300\201]\322\364#\210\300\201]\324\201^#\210\300\201^\302\201]#\210\300\201_\322\364#\210\300\201_\324\201`#\210\300\201`\302\201_#\210\300\201a\322\201b#\210\300\201a\324\201c#\210\300\201c\302\201a#\210\300\201d\322\201b#\210\300\201d\324\201e#\210\300\201e\302\201d#\210\300\201f\322\201g#\210\300\201f\324\201h#\210\300\201h\302\201f#\210\300\201i\322\201g#\210\300\201i\324\201j#\210\300\201j\302\201i#\210\300\201k\322\201g#\210\300\201k\324\201l#\210\300\201l\302\201k#\210\300\201m\322\201g#\210\300\201m\324\201n#\210\300\201n\302\201m#\210\300\201o\322\201g#\210\300\201o\324\201p#\210\300\201p\302\201o#\210\300\201q\322\201r#\210\300\201q\324\201s#\210\300\201s\302\201q#\210\300\201t\322\201r#\210\300\201t\324\201u#\210\300\201u\302\201t#\210\300\201v\322\201r#\210\300\201v\324\201w#\210\300\201w\302\201v#\210\300\201x\322\201r#\210\300\201x\324\201y#\210\300\201y\302\201x#\210\300\201z\322\201r#\210\300\201z\324\201{#\210\300\201{\302\201z#\210\300\201|\322\201g#\210\300\201|\324\201}#\210\300\201}\302\201|#\210\300\201~\322\201g#\210\300\201~\324\201#\210\300\201\302\201~#\210\300\201\200\322\201\201#\210\300\201\200\324\201\202#\210\300\201\202\302\201\200#\210\300\201\203\322\201\204#\210\300\201\203\324\201\205#\210\300\201\205\302\201\203#\210\300\201\206\322\201\204#\210\300\201\206\324\201\205#\210\300\201\205\302\201\206#\210\300\201\207\322\364#\210\300\201\207\324\201\210#\210\300\201\210\302\201\207#\210\300\201\211\322\364#\210\300\201\211\324\201\212#\210\300\201\212\302\201\211#\210\300\201\213\322\364#\210\300\201\213\324\201\214#\210\300\201\214\302\201\213#\210\300\201\215\322\364#\210\300\201\215\324\201\216#\210\300\201\216\302\201\215#\210\300\201\217\322\201g#\210\300\201\217\324\201\220#\210\300\201\220\302\201\217#\210\300\201\221\322\201g#\210\300\201\221\324\201\222#\210\300\201\222\302\201\221#\210\300\201\223\322\201g#\210\300\201\223\324\201\220#\210\300\201\220\302\201\223#\210\300\201\224\322\201g#\210\300\201\224\324\201\222#\210\300\201\222\302\201\224#\210\300\201\225\322\201g#\210\300\201\225\324\201\226#\210\300\201\226\302\201\225#\210\300\201\227\322\201g#\210\300\201\227\324\201\230#\210\300\201\230\302\201\227#\210\300\201\231\322\201g#\210\300\201\231\324\201\232#\210\300\201\232\302\201\231#\210\300\201\233\322\201g#\210\300\201\233\324\201\234#\210\300\201\234\302\201\233#\210\300\201\235\322\201g#\210\300\201\235\324\201\236#\210\300\201\236\302\201\235#\210\300\201\237\322\201g#\210\300\201\237\324\201\240#\210\300\201\240\302\201\237#\210\300\201\241\322\201g#\210\300\201\241\324\201\242#\210\300\201\242\302\201\241#\210\300\201\243\322\201g#\210\300\201\243\324\201\240#\210\300\201\240\302\201\243#\210\300\201\244\322\201g#\210\300\201\244\324\201\242#\210\300\201\242\302\201\244#\210\300\201\245\322\201g#\210\300\201\245\324\201\246#\210\300\201\246\302\201\245#\210\300\201\247\322\201g#\210\300\201\247\324\201\250#\210\300\201\250\302\201\247#\210\300\201\251\322\201g#\210\300\201\251\324\201\252#\210\300\201\252\302\201\251#\210\300\201\253\322\201g#\210\300\201\253\324\201\254#\210\300\201\254\302\201\253#\210\300\201\255\322\201\256#\210\300\201\255\324\201\257#\210\300\201\257\302\201\255#\210\300\201\260\322\201\261#\210\300\201\260\324\201\262#\210\300\201\262\302\201\260#\210\300\201\263\322\201\261#\210\300\201\263\324\201\264#\210\300\201\264\302\201\263#\210\300\201\265\322\201\266#\210\300\201\265\324\201\267#\210\300\201\267\302\201\265#\210\300\201\270\322\201\266#\210\300\201\270\324\201\271#\210\300\201\271\302\201\270#\210\300\201\272\322\201\273#\207" [put byte-call byte-opcode-invert funcall byte-list1 list byte-list2 byte-list3 byte-list4 byte-listN byte-concat2 concat byte-concat3 byte-concat4 byte-concatN byte-insertN insert point byte-compile byte-compile-no-args byte-opcode byte-point point-max byte-point-max point-min byte-point-min following-char byte-following-char preceding-char byte-preceding-char current-column byte-current-column eolp byte-eolp eobp byte-eobp bolp byte-bolp bobp byte-bobp current-buffer byte-current-buffer widen byte-widen end-of-line byte-compile-zero-or-one-arg byte-end-of-line forward-char byte-forward-char forward-line byte-forward-line symbolp byte-compile-one-arg byte-symbolp consp byte-consp stringp byte-stringp listp byte-listp not byte-not null car byte-car cdr byte-cdr length byte-length symbol-value byte-symbol-value symbol-function byte-symbol-function 1+ byte-add1 1- byte-sub1 goto-char byte-goto-char char-after byte-char-after set-buffer byte-set-buffer forward-word byte-forward-word char-syntax byte-char-syntax nreverse byte-nreverse car-safe byte-car-safe cdr-safe byte-cdr-safe numberp byte-numberp integerp byte-integerp skip-chars-forward byte-compile-one-or-two-args byte-skip-chars-forward skip-chars-backward byte-skip-chars-backward eq byte-compile-two-args byte-eq memq byte-memq cons byte-cons aref byte-aref set byte-set = byte-compile-and-folded byte-eqlsign < byte-lss > byte-gtr <= byte-leq >= byte-geq get byte-get nth byte-nth substring byte-compile-one-to-three-args byte-substring move-marker byte-compile-two-or-three-args byte-set-marker set-marker match-beginning byte-match-beginning match-end byte-match-end upcase byte-upcase downcase byte-downcase string= byte-string= string< byte-string< string-equal string-lessp equal byte-equal nthcdr byte-nthcdr elt byte-elt member byte-member assq byte-assq rplaca byte-setcar rplacd byte-setcdr setcar setcdr buffer-substring byte-buffer-substring delete-region byte-delete-region narrow-to-region byte-narrow-to-region % byte-rem aset byte-compile-three-args byte-aset max byte-compile-min-max byte-max min byte-min + byte-compile-variadic-numeric byte-plus * byte-mult interactive byte-compile-noop] 4)
#@15 

(fn FORM N)
(defalias 'byte-compile-subr-wrong-args #[514 "\300@!\210\301\302@AGAG\303U\203\304\202\305%\210\306!\207" [byte-compile-set-symbol-position byte-compile-warn "`%s' called with %d arg%s, but requires %s" 1 "" "s" byte-compile-normal-call] 8 (#$ . 126465)])
#@13 

(fn FORM)
(defalias 'byte-compile-no-args #[257 "\211G\300U\204\f\301
\302\"\207\303
@\304N\305\"\207" [1 byte-compile-subr-wrong-args "none" byte-compile-out byte-opcode 0] 4 (#$ . 126752)])
#@13 

(fn FORM)
(defalias 'byte-compile-one-arg #[257 "\211G\300U\204\f\301
\302\"\207\303
A@!\210\304
@\305N\306\"\207" [2 byte-compile-subr-wrong-args 1 byte-compile-form byte-compile-out byte-opcode 0] 4 (#$ . 126953)])
#@13 

(fn FORM)
(defalias 'byte-compile-two-args #[257 "\211G\300U\204\f\301
\302\"\207\303
A@!\210\303\3028!\210\304
@\305N\306\"\207" [3 byte-compile-subr-wrong-args 2 byte-compile-form byte-compile-out byte-opcode 0] 4 (#$ . 127179)])
#@112 Compile calls to functions like `<='.
These implicitly `and' together a bunch of two-arg bytecodes.

(fn FORM)
(defalias 'byte-compile-and-folded #[257 "\211G\211\300W\203\301\302A@\303BB!\207\211\300U\203\304!\207\305\306\307AA\">\204<\301\310@A@\3118E@AABE!\207\312!\207" [3 byte-compile-form progn (t) byte-compile-two-args nil mapcar macroexp-copyable-p and 2 byte-compile-normal-call] 8 (#$ . 127422)])
#@13 

(fn FORM)
(defalias 'byte-compile-three-args #[257 "\211G\300U\204\f\301
\302\"\207\303
A@!\210\303\3048!\210\303\3028!\210\305
@\306N\307\"\207" [4 byte-compile-subr-wrong-args 3 byte-compile-form 2 byte-compile-out byte-opcode 0] 4 (#$ . 127851)])
#@13 

(fn FORM)
(defalias 'byte-compile-zero-or-one-arg #[257 "\211G\211\300U\203\301\302\303\"!\207\211\304U\203\301!\207\305\306\"\207" [1 byte-compile-one-arg append (nil) 2 byte-compile-subr-wrong-args "0-1"] 6 (#$ . 128112)])
#@13 

(fn FORM)
(defalias 'byte-compile-one-or-two-args #[257 "\211G\211\300U\203\301\302\303\"!\207\211\304U\203\301!\207\305\306\"\207" [2 byte-compile-two-args append (nil) 3 byte-compile-subr-wrong-args "1-2"] 6 (#$ . 128352)])
#@13 

(fn FORM)
(defalias 'byte-compile-two-or-three-args #[257 "\211G\211\300U\203\301\302\303\"!\207\211\304U\203\301!\207\305\306\"\207" [3 byte-compile-three-args append (nil) 4 byte-compile-subr-wrong-args "2-3"] 6 (#$ . 128593)])
#@13 

(fn FORM)
(defalias 'byte-compile-one-to-three-args #[257 "\211G\211\300U\203\301\302\303\"!\207\211\304U\203\301\302\305\"!\207\211\306U\203&\301!\207\307\310\"\207" [2 byte-compile-three-args append (nil nil) 3 (nil) 4 byte-compile-subr-wrong-args "1-3"] 6 (#$ . 128838)])
#@13 

(fn FORM)
(defalias 'byte-compile-noop #[257 "\300\301!\207" [byte-compile-constant nil] 3 (#$ . 129130)])
#@284 Output byte codes to discard the NUM entries at the top of the stack.
NUM defaults to 1.
If PRESERVE-TOS is non-nil, preserve the top-of-stack value, as if it were
popped before discarding the num values, and then pushed back again after
discarding.

(fn &optional NUM PRESERVE-TOS)
(defalias 'byte-compile-discard #[512 "
\204\f\211\204\f\301\302!\207
\204\303\262\211\203(
\304V\203(\305ZS!\210
S\262
\304V\2059\301\302!\210
S\262\202(\207" [byte-compile-depth byte-compile-out byte-discard 1 0 byte-compile-stack-set] 5 (#$ . 129246)])
#@82 Output byte codes to push the value at stack position STACK-POS.

(fn STACK-POS)
(defalias 'byte-compile-stack-ref #[257 "
TZ\211\301U\203\302\303!\207\302\304\"\207" [byte-compile-depth 0 byte-compile-out byte-dup byte-stack-ref] 5 (#$ . 129804)])
#@87 Output byte codes to store the TOS value at stack position STACK-POS.

(fn STACK-POS)
(defalias 'byte-compile-stack-set #[257 "\301\302TZ\"\207" [byte-compile-depth byte-compile-out byte-stack-set] 5 (#$ . 130063)])
(byte-code "\300\301\302\303#\210\300\304\302\305#\207" [put internal-make-closure byte-compile byte-compile-make-closure internal-get-closed-var byte-compile-get-closed-var] 4)
#@67 Byte-compile the special `internal-make-closure' form.

(fn FORM)
(defalias 'byte-compile-make-closure #[257 "\203\301\211\207\211A@\3028\3038\304\233\305\306BB\301G#G\307V\204-\204-\310\311!\210\312
!\2047\310\313!\210\314\203A;\203\212\315\316\317\307GS\"\"\315\320\321\"\317\304GS\"\"\322\323\307H\324H\325	\302H\"\303H\203{AB\202}&\320
	BB\266\203\202\300\323\326\307HD\326\324HD\325\327	B\326\302HDE\303\315\330\"\233\203\271\211@	AABB\202\272\211\262
BBBB!\207" [byte-compile--for-effect nil 2 3 4 byte-compile-lambda lambda 0 cl--assertion-failed (or (> (length env) 0) docstring-exp) byte-code-function-p (byte-code-function-p fun) byte-compile-form mapcar #[257 "\300\301\302\"!\207" [intern format "V%d"] 5 "\n\n(fn I)"] number-sequence make-closure #[257 "\300
H\207" [V0] 3 "\n\n(fn I)"] apply make-byte-code 1 vconcat quote vector #[257 "\300
D\207" [quote] 3 "\n\n(fn X)"]] 17 (#$ . 130465)])
#@69 Byte-compile the special `internal-get-closed-var' form.

(fn FORM)
(defalias 'byte-compile-get-closed-var #[257 "\203\301\211\207\302\303A@\"\207" [byte-compile--for-effect nil byte-compile-out byte-constant] 4 (#$ . 131437)])
#@13 

(fn FORM)
(defalias 'byte-compile-variadic-numeric #[257 "\211G\211\300\267\2023\301\302!!\207\303A@!\210\301\304!\210\305\306\307N\310\"\207\303A@!\210\303\3118!\210\305@\307N\310\"\207\312!\207" [#s(hash-table size 3 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (1 8 2 14 3 31)) byte-compile-constant eval byte-compile-form 1 byte-compile-out * byte-opcode 0 2 byte-compile-normal-call] 5 (#$ . 131676)])
#@50 Byte-compile calls to `min' or `max'.

(fn FORM)
(defalias 'byte-compile-min-max #[257 "\211A\203	\300
!\207\301
!\207" [byte-compile-variadic-numeric byte-compile-normal-call] 3 (#$ . 132117)])
(byte-code "\300\301\302\303#\210\300\301\304\305#\210\300\305\306\301#\210\300\307\302\310#\210\300\307\304\311#\210\300\311\306\307#\210\300\312\302\313#\210\300\312\304\314#\210\300\314\306\312#\210\300\315\302\316#\210\300\315\304\317#\210\300\317\306\315#\210\300\320\302\321#\210\300\320\304\322#\210\300\322\306\320#\210\300\323\302\324#\210\300\323\304\325#\210\300\325\306\323#\210\300\326\302\327#\210\300\326\304\330#\210\300\330\306\326#\210\300\331\302\327#\210\300\331\304\330#\210\300\330\306\331#\210\300\332\302\333#\210\300\332\304\334#\210\300\334\306\332#\210\300\335\302\336#\210\300\337\302\340#\210\300\337\304\341#\210\300\341\306\337#\210\300\342\302\343#\210\300\342\304\344#\210\300\344\306\342#\210\300\345\302\346#\210\300\345\304\347#\210\300\347\306\345#\207" [put char-before byte-compile byte-compile-char-before byte-opcode byte-char-before byte-opcode-invert backward-char byte-compile-backward-char byte-backward-char backward-word byte-compile-backward-word byte-backward-word list byte-compile-list byte-list concat byte-compile-concat byte-concat fset byte-compile-fset byte-fset indent-to-column byte-compile-indent-to byte-indent-to indent-to insert byte-compile-insert byte-insert function byte-compile-function-form - byte-compile-minus byte-diff / byte-compile-quo byte-quo nconc byte-compile-nconc byte-nconc] 4)
#@13 

(fn FORM)
(defalias 'byte-compile-char-before #[257 "\211G\300U\204\211G\301U\203\211A@\204\302\303!\207\211G\301U\203;\302\304A@\247\203/A@S\2028\305\306A@\307BBDD!\207\310
\311\"\207" [1 2 byte-compile-form (char-after (1- (point))) char-after 1- or ((point)) byte-compile-subr-wrong-args "0-1"] 7 (#$ . 133677)])
#@13 

(fn FORM)
(defalias 'byte-compile-backward-char #[257 "\211G\300U\204\211G\301U\203\211A@\204\302\303!\207\211G\301U\203;\302\304A@\247\203/A@[\2028\305\306A@\307BBDD!\207\310
\311\"\207" [1 2 byte-compile-form (forward-char -1) forward-char - or (1) byte-compile-subr-wrong-args "0-1"] 7 (#$ . 134013)])
#@13 

(fn FORM)
(defalias 'byte-compile-backward-word #[257 "\211G\300U\204\211G\301U\203\211A@\204\302\303!\207\211G\301U\203;\302\304A@\247\203/A@[\2028\305\306A@\307BBDD!\207\310
\311\"\207" [1 2 byte-compile-form (forward-word -1) forward-word - or (1) byte-compile-subr-wrong-args "0-1"] 7 (#$ . 134338)])
#@13 

(fn FORM)
(defalias 'byte-compile-list #[257 "\211AG\211\300U\203
\301\302!\207\211\303W\203!\304\305A\"\210\306\307SH\300\"\207\211\310W\2032\304\305A\"\210\306\311\"\207\312!\207" [0 byte-compile-constant nil 5 mapc byte-compile-form byte-compile-out [byte-list1 byte-list2 byte-list3 byte-list4] 256 byte-listN byte-compile-normal-call] 5 (#$ . 134663)])
#@13 

(fn FORM)
(defalias 'byte-compile-concat #[257 "\211AG\300
W\203\211\301W\203\302\303A\"\210\304\305\306ZH\307\"\207\211\307U\203(\303\310!\207\211\311W\2039\302\303A\"\210\304\312\"\207\313!\207" [1 5 mapc byte-compile-form byte-compile-out [byte-concat2 byte-concat3 byte-concat4] 2 0 "" 256 byte-concatN byte-compile-normal-call] 6 (#$ . 135037)])
#@13 

(fn FORM)
(defalias 'byte-compile-minus #[257 "\211G\300U\204\301
!\207\302
A@!\210\303\304\305\"\207" [2 byte-compile-variadic-numeric byte-compile-form byte-compile-out byte-negate 0] 4 (#$ . 135407)])
#@13 

(fn FORM)
(defalias 'byte-compile-quo #[257 "\211G\300U\203\301
!\207\302
!\207" [3 byte-compile-two-args byte-compile-normal-call] 3 (#$ . 135621)])
#@13 

(fn FORM)
(defalias 'byte-compile-nconc #[257 "\211G\211\300U\203\f\301\302!\207\211\303U\203\304A@!\207\304A\211\262@!\210
A\211\262\2056\304@!\210\305\306\307\"\210\202!\207" [1 byte-compile-constant nil 2 byte-compile-form byte-compile-out byte-nconc 0] 5 (#$ . 135781)])
#@13 

(fn FORM)
(defalias 'byte-compile-fset #[257 "\300
8\301
\242\302=\203D
A@\211\262\242\303=\203D
AA\262
\211@;\203&\211A\262
\211@\242\304=\2032\211A\262
\211@:\203D\211@@\305=\204D\306\307!\210\266\310
!\207" [2 nil quote lambda interactive byte-code byte-compile-warn "A quoted lambda form is the second argument of `fset'.  This is probably\n     not what you want, as that lambda cannot be compiled.  Consider using\n     the syntax #'(lambda (...) ...) instead." byte-compile-two-args] 5 (#$ . 136074)])
#@13 

(fn FORM)
(defalias 'byte-compile-function-form #[257 "\211A@\2119\203\300\301\"\203\302
\303\304\305\"#\210\306
\242\307=\203&\310!\202'
!\207" [byte-compile-warning-enabled-p callargs byte-compile-function-warn t byte-compile-fdefinition nil byte-compile-constant lambda byte-compile-lambda] 8 (#$ . 136599)])
#@13 

(fn FORM)
(defalias 'byte-compile-indent-to #[257 "\211G\211\300U\203\301A@!\210\302\303\304\"\207\211\305U\203\306!\207\307\310\"\207" [2 byte-compile-form byte-compile-out byte-indent-to 0 3 byte-compile-normal-call byte-compile-subr-wrong-args "1-2"] 5 (#$ . 136928)])
#@13 

(fn FORM)
(defalias 'byte-compile-insert #[257 "\211A\204	\300\301!\207\211G\302X\203(\303\304A\"\210\211AA\203#\305\306AG\"\207\305\307\310\"\207\311\312\313AA\">\2037\314
!\207\211A\211\262\205T\304
@!\210\305\307\310\"\210\211A\2037\315 \210\2027\207" [byte-compile-constant nil 256 mapc byte-compile-form byte-compile-out byte-insertN byte-insert 0 t mapcar consp byte-compile-normal-call byte-compile-discard] 5 (#$ . 137215)])
(byte-code "\300\301\302\303#\210\300\304\302\305#\207" [put setq byte-compile byte-compile-setq quote byte-compile-quote] 4)
#@13 

(fn FORM)
(defalias 'byte-compile-setq #[257 "\211A\211G\301
\302\"\302U\203&\303\304\305\306!@\"!\210\307\310\311\312\313DDE\"\210\202U
\203P
\203U\307A@!\210\204C
AA\204C\314\315\316\"\210\317@!\210
AA\262\202*\307\320\"\210\320\211\207" [byte-compile--for-effect logand 1 byte-compile-report-error format-message "missing value for `%S' at end of setq" last byte-compile-form signal 'wrong-number-of-arguments quote setq byte-compile-out byte-dup 0 byte-compile-variable-set nil] 9 (#$ . 137793)])
(put 'set-default 'byte-compile 'byte-compile-set-default)
#@13 

(fn FORM)
(defalias 'byte-compile-set-default #[257 "\211\243\242\211\242\301=\203e\211A\242\2119\203G\211\302
\303>\206B\304!\206B\211\205B
>\206B\305!\205B\3061@
\211JL\210\3070\266\202\202D\210\302\266\202\203d\310\3119\205O\"\203d\312\3139\203^\314\202_\315\316!#\210\210\317!\207" [byte-compile-const-variables quote t (nil t) keywordp boundp (setting-constant) nil byte-compile-warning-enabled-p constants byte-compile-warn "variable assignment to %s `%s'" "constant" "nonvariable" prin1-to-string byte-compile-normal-call] 8 (#$ . 138377)])
#@13 

(fn FORM)
(defalias 'byte-compile-quote #[257 "\300
A@!\207" [byte-compile-constant] 3 (#$ . 138955)])
#@34 

(fn BODY &optional FOR-EFFECT)
(defalias 'byte-compile-body #[513 "
A\203\300@\301\"\210
A\262\202\300@\"\207" [byte-compile-form t] 5 (#$ . 139066)])
#@13 

(fn BODY)
(defalias 'byte-compile-body-do-effect #[257 "\301
\"\210\302\211\207" [byte-compile--for-effect byte-compile-body nil] 4 (#$ . 139233)])
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put byte-compile-body-do-effect speed -1 put byte-optimizer byte-compile-inline-expand] 5)
#@13 

(fn FORM)
(defalias 'byte-compile-form-do-effect #[257 "\301
\"\210\302\211\207" [byte-compile--for-effect byte-compile-form nil] 4 (#$ . 139544)])
(byte-code "\300\301\302\303#\304\301\305\306#\210\304\307\310\311#\210\304\312\310\311#\210\304\313\310\314#\210\304\315\310\316#\210\304\317\310\320#\210\304\321\310\322#\210\304\323\310\324#\210\304\325\310\326#\210\304\327\310\330#\210\304\331\310\332#\210\304\333\310\332#\210\304\334\310\335#\207" [function-put byte-compile-form-do-effect speed -1 put byte-optimizer byte-compile-inline-expand inline byte-compile byte-compile-progn progn prog1 byte-compile-prog1 if byte-compile-if cond byte-compile-cond and byte-compile-and or byte-compile-or while byte-compile-while funcall byte-compile-funcall let byte-compile-let let* ignore byte-compile-ignore] 5)
#@13 

(fn FORM)
(defalias 'byte-compile-progn #[257 "\211A\301
\"\210\302\211\207" [byte-compile--for-effect byte-compile-body nil] 5 (#$ . 140366)])
#@13 

(fn FORM)
(defalias 'byte-compile-prog1 #[257 "\211A@\301
\"\210\302\211\266\303
AA\304\"\207" [byte-compile--for-effect byte-compile-form nil byte-compile-body t] 5 (#$ . 140520)])
#@25 

(fn COND DISCARD TAG)
(defalias 'byte-compile-goto-if '(macro . #[771 "\300\301\301\302BB\301\303BBFE\207" [byte-compile-goto if ('byte-goto-if-not-nil 'byte-goto-if-not-nil-else-pop) ('byte-goto-if-nil 'byte-goto-if-nil-else-pop)] 10 (#$ . 140713)]))
#@13 

(fn FORM)
(defalias 'byte-compile-ignore #[257 "\211A\211\203\211@\300
\301\"\210
A\266\202\202\210\300\302!\207" [byte-compile-form t nil] 6 (#$ . 140978)])
#@64 

(fn CONDITION-PARAM PRED-LIST &optional ONLY-IF-NOT-PRESENT)
(defalias 'byte-compile-find-bound-condition #[770 "\300\211\242>\203C\202\242\301=\205A\211\211\203K\211@\211\242>\203D\211A@\211\262\242\302=\203DA@\236\204D\211A@A@B\262
A\266\202\202\210\207" [nil and quote] 10 (#$ . 141148)])
#@539 Execute forms in BODY, potentially guarded by CONDITION.
CONDITION is a variable whose value is a test in an `if' or `cond'.
BODY is the code to compile in the first arm of the if or the body of
the cond clause.  If CONDITION's value is of the form (fboundp \='foo)
or (boundp \='foo), the relevant warnings from BODY about foo's
being undefined (or obsolete) will be suppressed.

If CONDITION's value is (not (featurep \='emacs)) or (featurep \='xemacs),
that suppresses all warnings during execution of BODY.

(fn CONDITION &rest BODY)
(defalias 'byte-compile-maybe-guarded '(macro . #[385 "\300\301\302\303BBD\304\302\305BBD\306BB\307\310\311\312BB\313BBF\207" [let* fbound-list byte-compile-find-bound-condition ('(fboundp functionp) byte-compile-unresolved-functions) bound-list ('(boundp default-boundp local-variable-p)) ((new-bound-list (delq nil (mapcar (lambda (s) (if (memq s byte-compile-bound-variables) nil s)) bound-list))) (byte-compile-bound-variables (append new-bound-list byte-compile-bound-variables))) (mapc #'byte-compile--check-prefixed-var new-bound-list) unwind-protect let ((byte-compile-not-obsolete-vars (append byte-compile-not-obsolete-vars bound-list)) (byte-compile-not-obsolete-funcs (append byte-compile-not-obsolete-funcs fbound-list))) ((dolist (fbound fbound-list) (when fbound (setq byte-compile-unresolved-functions (delq (assq fbound byte-compile-unresolved-functions) byte-compile-unresolved-functions)))))] 9 (#$ . 141475)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put byte-compile-maybe-guarded lisp-indent-function 1 put edebug-form-spec t] 5)
#@13 

(fn FORM)
(defalias 'byte-compile-if #[257 "\305
A@!\210\211A@\306 \307\233\204Z\310\203\311\202\312\"\210\313\314	#\313\315\"\316\317\320\321\"\"\322
\n\"\323\324\"\210\325\326\"\216\322\"\322\f\"\305\3278\"\210,\266\330
!\266\202\334\306 \310\311\"\210\313\314	#\313\315\"\316\317\320\331\"\"\322
\n\"\323\324\"\210\325\332\"\216\322\"\322\f\"\305\3278\"\210,\266\310\333\"\210\330
!\210\313\334D\314	#\313\334D\315\"\316\317\320\335\"\"\322
\n\"\323\324\"\210\325\336\"\216\322\"\322\f\"\337AAA\"\210,\266\330!\266\317\211\207" [byte-compile--for-effect byte-compile-unresolved-functions byte-compile-bound-variables byte-compile-not-obsolete-vars byte-compile-not-obsolete-funcs byte-compile-form byte-compile-make-tag 3 byte-compile-goto byte-goto-if-nil byte-goto-if-nil-else-pop byte-compile-find-bound-condition (fboundp functionp) (boundp default-boundp local-variable-p) delq nil mapcar #[257 "\211>?\205\211\207" [byte-compile-bound-variables] 3 "\n\n(fn S)"] append mapc byte-compile--check-prefixed-var make-closure #[0 "\300\211\205\211@\211\203\302
	\236	\"
A\266\202\202
\207" [V0 byte-compile-unresolved-functions delq] 5] 2 byte-compile-out-tag #[257 "\211>?\205\211\207" [byte-compile-bound-variables] 3 "\n\n(fn S)"] #[0 "\300\211\205\211@\211\203\302
	\236	\"
A\266\202\202
\207" [V0 byte-compile-unresolved-functions delq] 5] byte-goto not #[257 "\211>?\205\211\207" [byte-compile-bound-variables] 3 "\n\n(fn S)"] #[0 "\300\211\205\211@\211\203\302
	\236	\"
A\266\202\202
\207" [V0 byte-compile-unresolved-functions delq] 5] byte-compile-body] 11 (#$ . 143097)])
#@18 

(fn OBJ1 OBJ2)
(defalias 'byte-compile--cond-vars #[514 "
9\203\300
!\203
\301!B\206#\2119\205#\300!\205#\211\301!B\207" [macroexp-const-p eval] 5 (#$ . 144777)])
#@75 Most specific common test of `eq', `eql' and `equal'.

(fn TEST-1 TEST-2)
(defalias 'byte-compile--common-test #[514 "
\300=\204\f\211\300=\203\300\207
\301=\204\211\301=\203\301\207\302\207" [equal eql eq] 4 (#$ . 144958)])
#@421 Find a switch corresponding to a prefix of CLAUSES, or nil if none.
Return (TAIL VAR TEST CASES), where:
  TAIL is the remaining part of CLAUSES after the switch, including
  any default clause,
  VAR is the variable being switched on,
  TEST is the equality test (`eq', `eql' or `equal'),
  CASES is a list of (VALUES . BODY) where VALUES is a list of values
    corresponding to BODY (always non-empty).

(fn CLAUSES)
(defalias 'byte-compile--cond-switch-prefix #[257 "\300\211\211\301@\211:\205k
\211\242\211:\205i
\211\242\211\302\267\202f

\243\211:\205}\211\242
\243\211:\205{\211\242
\243\211?\205y\243\303\"\211@
A
\205u
=\204O
?\205u
\262\304
\"\262
\211\235\204t\211B\262\211C\206n\305BB\262\306\266\203\262
\266\202\266\202\262
\202g

\243\211:\205\321\211\242\2119\205\317
\243\211?\205\315\243	=\204\246?\205\313\262	\304\301\"\262\300\n>\204\312\300\nB\262\n\300C
\206\304\307BB\262\306\262
\262
\262
\262
\202g

\243\211:\205a
\211\242
\243\211:\205_
\211\242
\243\211?\205]
\2439\205[
=\204
\n?\205[
\310!\205[
\211\205[
\311!\312
!\205Y
\262\f\304	\313\236A\"\262\300
\211\203B
\211@\n
\"\204;
\211B\262
A\266\202\202'
\210\211\203W
\314
\"\262\211\237BB\262\210\306\262
\262
\266\202\266\202\262
\202g
\300\262
\262
\262
\203w
A\262\202G\315V\205\205
\237F\207" [nil eq #s(hash-table size 8 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (equal 26 eql 26 eq 26 null 130 not 130 member 214 memql 214 memq 214)) byte-compile--cond-vars byte-compile--common-test (t) t (t) macroexp-const-p eval proper-list-p ((memq . eq) (memql . eql) (member . equal)) append 1] 21 (#$ . 145197)])
#@67 Generate code for SWITCH, ending at DONETAG.

(fn SWITCH DONETAG)
(defalias 'byte-compile-cond-jump-table #[514 "
@A@\3038\304\211\211\211\211\305\306\307\310	\"\"\311\312	\313\314\315&\262\210\316 \262
\317!\210\320!\210\321\322!\210\323\324\"\210)\211\203\233\211@\316 \262\211@\262\211A\262\325!\210\211\203i\211@\326
#\210
A\266\202\202T\210\211
\327	\"\210
U\204\205
TU\204\205\330\331!\210\323\324\"\210\fA\304\241\210)\266
A\266\202\202=\210\325
!\210\nB\211\207" [byte-compile-depth byte-compile--for-effect byte-compile-jump-tables 2 nil apply + mapcar #[257 "\211@G\207" [] 2 "\n\n(fn CASE)"] make-hash-table :test :purecopy t :size byte-compile-make-tag byte-compile-variable-ref byte-compile-push-constant byte-compile-out byte-switch byte-compile-goto byte-goto byte-compile-out-tag puthash byte-compile-body cl--assertion-failed (or (= byte-compile-depth init-depth) (= byte-compile-depth (1+ init-depth)))] 18 (#$ . 146905)])
#@16 

(fn CLAUSES)
(defalias 'byte-compile-cond #[257 "\306 \307\211A\262\203\267\205\310!\211\203%\311
A\"\210\211@\262\210\202@\262
@\312=\204?
@\242\313=\203J
@\243\242\203J\312B\262\307\262\202\257A\203\257\314@!\210
A\204i\315	\203b\316\202c\317\"\210\202\257\306 \262\315\320\"\210\321@\322\n#\321@\323\"\324\307\325\326\"\"\327
\"\330\331\"\210\332\333\"\216\327\f\"\327
\"\334A	\"\210,\266\315\335\"\210\336!\210A\262\210\202\211@
A\203\331\211\312=\204\331\314
!\210\315	\203\321\320\202\322\337\"\210
A\262\321
\322\n#\321\323\"\324\307\325\340\"\"\327
\"\330\331\"\210\332\341\"\216\327\f\"\327
\"\334
	\"\210\307\211\266,\266\336!\207" [byte-compile-cond-use-jump-table byte-compile--for-effect byte-compile-unresolved-functions byte-compile-bound-variables byte-compile-not-obsolete-vars byte-compile-not-obsolete-funcs byte-compile-make-tag nil byte-compile--cond-switch-prefix byte-compile-cond-jump-table t quote byte-compile-form byte-compile-goto byte-goto-if-not-nil byte-goto-if-not-nil-else-pop byte-goto-if-nil byte-compile-find-bound-condition (fboundp functionp) (boundp default-boundp local-variable-p) delq mapcar #[257 "\211>?\205\211\207" [byte-compile-bound-variables] 3 "\n\n(fn S)"] append mapc byte-compile--check-prefixed-var make-closure #[0 "\300\211\205\211@\211\203\302
	\236	\"
A\266\202\202
\207" [V0 byte-compile-unresolved-functions delq] 5] byte-compile-body byte-goto byte-compile-out-tag byte-goto-if-nil-else-pop #[257 "\211>?\205\211\207" [byte-compile-bound-variables] 3 "\n\n(fn S)"] #[0 "\300\211\205\211@\211\203\302
	\236	\"
A\266\202\202
\207" [V0 byte-compile-unresolved-functions delq] 5]] 12 (#$ . 147894)])
#@13 

(fn FORM)
(defalias 'byte-compile-and #[257 "\301 
A\211\204\302\303
\"\210\304\211\207\305
\"\207" [byte-compile--for-effect byte-compile-make-tag t byte-compile-form nil byte-compile-and-recursion] 7 (#$ . 149649)])
#@21 

(fn REST FAILTAG)
(defalias 'byte-compile-and-recursion #[514 "
A\203I\305@!\210\306\203\307\202\310\"\210\311@\312	#\311@\313\"\314\315\316\317\"\"\320
\n\"\321\322\"\210\323\324\"\216\320\"\320\f\"\325A\",\207
@\305
\"\210\315\211\266\326
!\207" [byte-compile--for-effect byte-compile-unresolved-functions byte-compile-bound-variables byte-compile-not-obsolete-vars byte-compile-not-obsolete-funcs byte-compile-form byte-compile-goto byte-goto-if-nil byte-goto-if-nil-else-pop byte-compile-find-bound-condition (fboundp functionp) (boundp default-boundp local-variable-p) delq nil mapcar #[257 "\211>?\205\211\207" [byte-compile-bound-variables] 3 "\n\n(fn S)"] append mapc byte-compile--check-prefixed-var make-closure #[0 "\300\211\205\211@\211\203\302
	\236	\"
A\266\202\202
\207" [V0 byte-compile-unresolved-functions delq] 5] byte-compile-and-recursion byte-compile-out-tag] 9 (#$ . 149880)])
#@13 

(fn FORM)
(defalias 'byte-compile-or #[257 "\301 
A\211\204\302\303
\"\210\302\211\207\304
\"\207" [byte-compile--for-effect byte-compile-make-tag nil byte-compile-form byte-compile-or-recursion] 7 (#$ . 150821)])
#@20 

(fn REST WINTAG)
(defalias 'byte-compile-or-recursion #[514 "
A\203M\305@!\210\306\203\307\202\310\"\210\311\312@D\313	#\311\312@D\314\"\315\316\317\320\"\"\321
\n\"\322\323\"\210\324\325\"\216\321\"\321\f\"\326A\",\207
@\305
\"\210\316\211\266\327
!\207" [byte-compile--for-effect byte-compile-unresolved-functions byte-compile-bound-variables byte-compile-not-obsolete-vars byte-compile-not-obsolete-funcs byte-compile-form byte-compile-goto byte-goto-if-not-nil byte-goto-if-not-nil-else-pop byte-compile-find-bound-condition not (fboundp functionp) (boundp default-boundp local-variable-p) delq nil mapcar #[257 "\211>?\205\211\207" [byte-compile-bound-variables] 3 "\n\n(fn S)"] append mapc byte-compile--check-prefixed-var make-closure #[0 "\300\211\205\211@\211\203\302
	\236	\"
A\266\202\202
\207" [V0 byte-compile-unresolved-functions delq] 5] byte-compile-or-recursion byte-compile-out-tag] 9 (#$ . 151048)])
#@13 

(fn FORM)
(defalias 'byte-compile-while #[257 "\301 \301 \302
!\210\303A@!\210\304\203\305\202\306\"\210\307AA\310\"\210\304\311\"\210\302!\210\312\211\207" [byte-compile--for-effect byte-compile-make-tag byte-compile-out-tag byte-compile-form byte-compile-goto byte-goto-if-nil byte-goto-if-nil-else-pop byte-compile-body t byte-goto nil] 6 (#$ . 152008)])
#@13 

(fn FORM)
(defalias 'byte-compile-funcall #[257 "\211A\203\301\302A\"\210\303\304AAG\"\207\305\306\307!!\210\302\310\"\207" [byte-compile--for-effect mapc byte-compile-form byte-compile-out byte-call byte-compile-report-error format-message "`funcall' called with no arguments" (signal 'wrong-number-of-arguments '(funcall 0))] 4 (#$ . 152385)])
#@134 Emit byte-codes to push the initialization value for CLAUSE on the stack.
Return the offset in the form (VAR . OFFSET).

(fn CLAUSE)
(defalias 'byte-compile-push-binding-init #[257 "\211:\203\n\211@\202\211\211B:\203\301A@!\210\207\302\303!\210\207" [byte-compile-depth byte-compile-form byte-compile-push-constant nil] 5 (#$ . 152745)])
#@12 

(fn VAR)
(defalias 'byte-compile-not-lexical-var-p #[257 "\2119?\206\301
!\206\211>\206\211\302>\206\303
!\207" [byte-compile-bound-variables special-variable-p (nil t) keywordp] 3 (#$ . 153097)])
#@272 Emit byte-codes to bind VAR and update `byte-compile--lexical-environment'.
INIT-LEXENV should be a lexical-environment alist describing the
positions of the init value that have been pushed on the stack.
Return non-nil if the TOS value was popped.

(fn VAR INIT-LEXENV)
(defalias 'byte-compile-bind #[514 "\203\303!\204

\236	B
\n\236\203\304\305\"\210\306\207
	\236\203-\307	\236	\"\202

@@=\203;\310!\210\311\207

\236A\312
!\210\310!\266\306\207" [lexical-binding byte-compile--lexical-environment byte-compile--known-dynamic-vars byte-compile-not-lexical-var-p byte-compile--warn-lexical-dynamic let nil remq byte-compile-dynamic-variable-bind t byte-compile-stack-ref] 5 (#$ . 153312)])
#@493 Emit byte-codes to unbind the variables bound by CLAUSES.
CLAUSES is a `let'-style variable binding list.  INIT-LEXENV should be a
lexical-environment alist describing the positions of the init value that
have been pushed on the stack.  If PRESERVE-BODY-VALUE is true,
then an additional value on the top of the stack, above any lexical binding
slots, is preserved, so it will be on the top of the stack after all
binding slots have been popped.

(fn CLAUSES INIT-LEXENV PRESERVE-BODY-VALUE)
(defalias 'byte-compile-unbind #[771 "\301\211\203#\211@\211:\203\211@\202\211\236\204T\262
A\266\202\202\210\211\301U\204/\302\303\"\210\210
\2059\304G\"\207" [byte-compile--lexical-environment 0 byte-compile-out byte-unbind byte-compile-discard] 8 (#$ . 154031)])
#@61 Generate code for the `let' or `let*' form FORM.

(fn FORM)
(defalias 'byte-compile-let #[257 "\211A@\304@\305=\211\203\"\211\203!\211@\306
!B\262
A\266\202\202
\210	\211\2030\307!\2021\211\203a\211@\204B\306
!B\262\211:\203L\211@\202M\211\310
\"\203YA\262\210
A\266\202\2021\210\nAA\311
\"\210\304\211\266\n
=\204\201\n
T=\204\201\312\313!\210\314\nV#\262
*\207" [byte-compile-bound-variables byte-compile--lexical-environment byte-compile-depth byte-compile--for-effect nil let byte-compile-push-binding-init reverse byte-compile-bind byte-compile-body cl--assertion-failed (or (eq byte-compile-depth init-stack-depth) (eq byte-compile-depth (1+ init-stack-depth))) byte-compile-unbind] 10 (#$ . 154813)])
(byte-code "\300\301\302\303#\210\300\304\302\303#\210\300\305\302\303#\210\300\301\306\307#\210\300\304\306\310#\210\300\305\306\311#\207" [put /= byte-compile byte-compile-negated atom nlistp byte-compile-negated-op = consp listp] 4)
#@13 

(fn FORM)
(defalias 'byte-compile-negated #[257 "\301
!\302
\"\210\303\211\207" [byte-compile--for-effect byte-compile-negation-optimizer byte-compile-form nil] 5 (#$ . 155799)])
#@13 

(fn FORM)
(defalias 'byte-compile-negation-optimizer #[257 "\300
@!\210\301
@\302N\206\303\304@\"ABD\207" [byte-compile-set-symbol-position not byte-compile-negated-op error "Compiler error: `%s' has no `byte-compile-negated-op' property"] 5 (#$ . 155988)])
(byte-code "\300\301\302\303#\210\300\304\302\305#\210\300\306\302\307#\210\300\310\302\311#\210\300\312\302\313#\210\300\314\302\315#\207" [put catch byte-compile byte-compile-catch unwind-protect byte-compile-unwind-protect condition-case byte-compile-condition-case save-excursion byte-compile-save-excursion save-current-buffer byte-compile-save-current-buffer save-restriction byte-compile-save-restriction] 4)
#@13 

(fn FORM)
(defalias 'byte-compile-catch #[257 "\300
A@!\210\301 \302\303\"\210\304AA\305\"\210\306\307!\210\310
!\207" [byte-compile-form byte-compile-make-tag byte-compile-goto byte-pushcatch byte-compile-body nil byte-compile-out byte-pophandler byte-compile-out-tag] 5 (#$ . 156674)])
#@13 

(fn FORM)
(defalias 'byte-compile-unwind-protect #[257 "\301
AA\211:\203@\211\242\211\302=\2038
\243\211:\2030\211\242
\243\211\204(\303!\266\202E!\266\202E!\266\202E!\266\202E

!\266\304\305\306\"\210\211A@\303
\"\210\307\211\266\304\310\311\"\207" [byte-compile--for-effect #[257 "\300\301\302\303BBD!\207" [byte-compile-form function lambda nil] 6 "\n\n(fn HANDLERS)"] :fun-body byte-compile-form byte-compile-out byte-unwind-protect 0 nil byte-unbind 1] 9 (#$ . 156972)])
#@13 

(fn FORM)
(defalias 'byte-compile-condition-case #[257 "\211A@\3018\302\233\303\236\211\203\304
\"\202\305\306\"\307 \310\311!\2109\204/\312\313	\"\210\314!\211\203s\211@\211A@\211:\204D\211C\262
\211\211\203`\211@\211\203T\2119\204Y\312\315\"\210
A\266\202\202E\210\316
!\266\317\320@\"\210
A\266\202\2022\210\321!\210
\211\203\215\211@\210\322\323\324!\210
A\266\202\202z\210\325\203\233\211	A\"\210\317\326\"\210\203\334\211A\262\242T\327
\211A\262\242!\210\211\203\313\211@\210\322\323\324!\210
A\266\202\202\270\210
\nA\"\210\317\326\"\266\202\240\327!\207" [byte-compile-depth 2 3 :success remq mapcar #[257 "\300 
B\207" [byte-compile-make-tag] 3 "\n\n(fn CLAUSE)"] byte-compile-make-tag byte-compile-set-symbol-position condition-case byte-compile-warn "`%s' is not a variable-name or nil (in condition-case)" reverse "`%S' is not a condition name (in condition-case)" byte-compile-push-constant byte-compile-goto byte-pushconditioncase byte-compile-form nil byte-compile-out byte-pophandler #[514 "	
\204\304 \210\202 \n\203
SB	B\202 \305!\210\306
!\210
?\2068\n\2034\304\307\310\"\2028\311\312\307\"*\207" [byte-compile-bound-variables byte-compile--lexical-environment lexical-binding byte-compile-depth byte-compile-discard byte-compile-dynamic-variable-bind byte-compile-body 1 preserve-tos byte-compile-out byte-unbind] 5 "\n\n(fn VAR BODY)"] byte-goto byte-compile-out-tag] 17 (#$ . 157480)])
#@13 

(fn FORM)
(defalias 'byte-compile-save-excursion #[257 "\211A\242\242\301=\203\302\303\301\"\203\304\305!\210\306\307\310\"\210\211A\311
\"\210\312\211\266\306\313\314\"\207" [byte-compile--for-effect set-buffer byte-compile-warning-enabled-p suspicious byte-compile-warn "Use `with-current-buffer' rather than save-excursion+set-buffer" byte-compile-out byte-save-excursion 0 byte-compile-body nil byte-unbind 1] 5 (#$ . 158964)])
#@13 

(fn FORM)
(defalias 'byte-compile-save-restriction #[257 "\301\302\303\"\210\211A\304
\"\210\305\211\266\301\306\307\"\207" [byte-compile--for-effect byte-compile-out byte-save-restriction 0 byte-compile-body nil byte-unbind 1] 5 (#$ . 159411)])
#@13 

(fn FORM)
(defalias 'byte-compile-save-current-buffer #[257 "\301\302\303\"\210\211A\304
\"\210\305\211\266\301\306\307\"\207" [byte-compile--for-effect byte-compile-out byte-save-current-buffer 0 byte-compile-body nil byte-unbind 1] 5 (#$ . 159668)])
(byte-code "\300\301\302\303#\210\300\304\302\303#\210\300\305\302\306#\210\300\307\302\310#\210\300\311\302\312#\207" [put defvar byte-compile byte-compile-defvar defconst autoload byte-compile-autoload lambda byte-compile-lambda-form make-obsolete-variable byte-compile-make-obsolete-variable] 4)
#@13 

(fn FORM)
(defalias 'byte-compile-make-obsolete-variable #[257 "\211A@\242\301=\203\211A@A@B\302
!\207" [byte-compile-global-not-obsolete-vars quote byte-compile-normal-call] 3 (#$ . 160230)])
(defconst byte-compile-tmp-var (make-symbol "def-tmp-var"))
#@13 

(fn FORM)
(defalias 'byte-compile-defvar #[257 "\211A@9\203\"\304\305\306A@!\"\204\"\307\310A@\"\203\"\311\312A@\"\210\313
!\210\211@
A@\3148\3158\316!\210G\317V\204H\320=\203kAA\204kAG\311\321\211\322U\203Z\323\202[\324\314W\203e\325\202f\326\327&\266B\320=\203y	B\211\203\211\211;\204\211\311\330$\210AA\203\247\331\332\333\nC\n\315\f\233BBBEDE\202\271\320=\203\266\334\332DD\202\271\332D\335
\"\210\336\211\207" [byte-compile-bound-variables byte-compile-const-variables byte-compile-tmp-var byte-compile--for-effect string-match "[-*/:$]" symbol-name byte-compile-warning-enabled-p lexical byte-compile-warn "global/dynamic var `%s' lacks a prefix" byte-compile-docstring-length-warn 2 3 byte-compile-set-symbol-position 4 defconst "`%s' called with %d argument%s, but %s %s" 1 "" "s" "requires" "accepts only" "2-3" "third arg to `%s %s' is not a string: %s" funcall quote lambda eval byte-compile-form nil] 14 (#$ . 160495)])
#@13 

(fn FORM)
(defalias 'byte-compile-autoload #[257 "\300\301!\210\302
A@!\2031\302\3038!\2031\304\3038!\305>\2031\306\304A@!!\2041\307\310\304A@!\"\210\311
!\207" [byte-compile-set-symbol-position autoload macroexp-const-p 5 eval (t macro) fboundp byte-compile-warn "The compiler ignores `autoload' except at top level.  You should\n     probably put the autoload of the macro `%s' at top-level." byte-compile-normal-call] 5 (#$ . 161490)])
#@13 

(fn FORM)
(defalias 'byte-compile-lambda-form #[257 "\300\301!\210\302\303!\207" [byte-compile-set-symbol-position lambda error "`lambda' used as function name is invalid"] 3 (#$ . 161945)])
(put 'defalias 'byte-hunk-handler 'byte-compile-file-form-defalias)
#@13 

(fn FORM)
(defalias 'byte-compile-file-form-defalias #[257 "\302\211\211:\203D\211\243\211:\203<\211\242\211:\2034\211\242\211\303=\203,
\243\211:\203$\211\242
\243\211\204\243\211:\203\211\242
\243\304\n!\210\305:\203\370
\242\211\306\267\202\342
\243\211:\203?
\211\242\211:\203(
\211\242\211\303=\203

\243\211:\203\370\211\242\211\307=\203\340
\243\211\204\310\243\211:\203\260\211\242
\243\211\204\232\310%\262
\266\202\202\303\302
\262
\302\f%\266\204\202\303\302\262
\302\n%\266\202\262
\202\333\302\n\262
\302	
%\266\202\262
\202\363\302	\262
\302\f%\266\202\262
\202
\302\262
\302%\266\202\262
\202#
\302\262
\302
\n%\266\202\262
\202:
\302\262
\302\f	%\266\202\262
\202P
\302\262
\302%\266\202\262
\202\363
\243\211:\203\314
\211\242\211:\203\265
\211\242\211\307=\203\235

\243\243\211\204\207
\310%\262
\266\202\202\260
\302	\262
\302\f%\266\204\202\260
\302\262
\302
\n%\266\202\262
\202\307
\302\262
\302\f	%\266\202\262
\202\335
\302\262
\302%\266\202\262
\202\363
\302\262
\302\n%\266\202\262
\202	\302\262
\302
	%\266\202\262
\266\202\202\311!\262
\266\202\202'\311!\266\202\202'\311!\262
\202/\311!\262
\2027\311!\262
\202?\311!\262
\202G\311
!*\207" [byte-compile-free-assignments byte-compile-free-references nil quote byte-compile-docstring-length-warn #[1285 "\300:\203`\242\211\301>\203O\243\211:\203>\211\242
\243\211\204-\n\n\n\n\n&\207\302&\207\302					&\207\302&\207\302
&\207" [#[1542 "\300\301&
:\203O
\242\211\302\267\202H\243\211:\203+\211\242
\243\"\207\303\211\"\207\243\211:\203A\211\242\303\"\207\303\211\"\207\303\211\"\207\303\211\"\207" [make-closure #[514 "\306\301\304\302%?\205+\304\203(\303\204\307\310\301\"\210\202(\307\311\301\"\210\301\312\303!B
B\313\300!\207" [V0 V1 V2 V3 V4 byte-compile-macro-environment byte-compile-file-form-defmumble message "Macro %s unrecognized, won't work in file" "Macro %s partly recognized, trying our luck" eval byte-compile-keep-pending] 8 "\n\n(fn ARGLIST BODY)"] #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (lambda 27 internal-make-closure 50)) t] 14 "\n\n(fn FORM NAME REST FUN MACRO LAM)"] #'quote nil] 18 "\n\n(fn FORM NAME REST FUN MACRO)"] #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (cons 76 quote 341)) macro t byte-compile-keep-pending] 29 (#$ . 162212)])
(put 'with-no-warnings 'byte-compile 'byte-compile-no-warnings)
#@13 

(fn FORM)
(defalias 'byte-compile-no-warnings #[257 "\301\302\303AB!)\207" [byte-compile-warnings nil byte-compile-form progn] 4 (#$ . 164927)])
(put 'internal--with-suppressed-warnings 'byte-compile 'byte-compile-suppressed-warnings)
#@13 

(fn FORM)
(defalias 'byte-compile-suppressed-warnings #[257 "\301
A@A@\"\302\303AA!!)\207" [byte-compile--suppressed-warnings append byte-compile-form macroexp-progn] 4 (#$ . 165172)])
(put 'make-variable-buffer-local 'byte-compile 'byte-compile-make-variable-buffer-local)
#@13 

(fn FORM)
(defalias 'byte-compile-make-variable-buffer-local #[257 "\211\243\242\242\300=\203\301\302!\203\303\304!\210\305
!\207" [quote byte-compile-warning-enabled-p make-local byte-compile-warn "`make-variable-buffer-local' not called at toplevel" byte-compile-normal-call] 3 (#$ . 165457)])
(put 'make-variable-buffer-local 'byte-hunk-handler 'byte-compile-form-make-variable-buffer-local)
#@13 

(fn FORM)
(defalias 'byte-compile-form-make-variable-buffer-local #[257 "\300
\301\"\207" [byte-compile-keep-pending byte-compile-normal-call] 4 (#$ . 165864)])
(put 'make-local-variable 'byte-compile 'byte-compile-make-local-variable)
#@13 

(fn FORM)
(defalias 'byte-compile-make-local-variable #[257 "\211:\203;\211\243\211:\203:\211\242\211:\2039\211\242\211\300=\2038
\243\211:\2037\211\242
\243\211\2045\243\211\2044\301!\210\210\266\210\210\210\210\302
!\207" [quote byte-compile--declare-var byte-compile-normal-call] 10 (#$ . 166108)])
(byte-code "\300\301\302\303#\210\300\304\302\303#\207" [put function-put byte-hunk-handler byte-compile-define-symbol-prop define-symbol-prop] 4)
#@13 

(fn FORM)
(defalias 'byte-compile-define-symbol-prop #[257 "\211:\203\315\211\242
\243\211:\203\311\211\242
\243\211:\203\305\211\242
\243\211:\203\300\211\242
\243\211\203-\301	!\207\302!\203\273\302!\203\273\302!\204x
:\203\273
\242\211\303=\205s\243\211:\205q\211\242\211:\205o\211\242\211\304=\205m\243\211?\205k\305\262
\262
\262
\262
\262
\203\273\306!\210\307!\210\307!\210\310\305\"\310\305\"\302!\203\234\310\305\"\202\241\311A@!\312\"BBBB\306
!\210\313\314\315\"\266\f\316\207\301	!\207\301!\207\301!\207\301!\207\301
!\207" [overriding-plist-environment byte-compile-keep-pending macroexp-const-p function lambda t byte-compile-push-constant byte-compile-form eval byte-compile-lambda alist-get byte-compile-out byte-call 3 nil] 18 (#$ . 166575)])
(defalias 'byte-compile-make-tag #[0 "\301T\211D\207" [byte-compile-tag-number TAG] 3])
#@12 

(fn TAG)
(defalias 'byte-compile-out-tag #[257 "\211B\211AA\203#	\203\211AA	U\204\302\303A@\"\210\211AA\211\207\211A	\241\207" [byte-compile-output byte-compile-depth error "Compiler bug: depth conflict at tag %d"] 4 (#$ . 167480)])
#@19 

(fn OPCODE TAG)
(defalias 'byte-compile-goto #[514 "

BB\211A	>\203\nS\202\n\241\210
\303=?\205\nS\211\207" [byte-compile-output byte-goto-always-pop-ops byte-compile-depth byte-goto] 5 (#$ . 167730)])
#@129 Return the amount by which an operation adjusts the stack.
OP and OPERAND are as passed to `byte-compile-out'.

(fn OP OPERAND)
(defalias 'byte-compile-stack-adjustment #[514 "
\301>\203	\211[\207JH\206\302
Z\207" [byte-stack+-info (byte-call byte-discardN byte-discardN-preserve-tos) 1] 4 (#$ . 167951)])
#@29 

(fn OP &optional OPERAND)
(defalias 'byte-compile-out #[513 "

BB
\303=\203\304\211\207	\305\"\\\211\n]\211\207" [byte-compile-output byte-compile-depth byte-compile-maxdepth byte-return nil byte-compile-stack-adjustment] 7 (#$ . 168268)])
#@13 

(fn FORM)
(defalias 'byte-compile-annotate-call-tree #[257 "\302
@\236\211\262\203	
A@>\204(\211A	A@B\240\210\202(
@	C\302EB	\236\211\262\203E
@\3038>\206O\211AA@\3038B\240\207	\302@CEB\211\207" [byte-compile-call-tree byte-compile-current-form nil 2] 6 (#$ . 168525)])
#@630 Display a call graph of a specified file.
This lists which functions have been called, what functions called
them, and what functions they call.  The list includes all functions
whose definitions have been compiled in this Emacs session, as well as
all functions called by those functions.

The call graph does not include macros, inline functions, or
primitives that the byte-code interpreter knows about directly
(`eq', `cons', etc.).

The call tree also lists those functions which are not known to be called
(that is, to which no calls have been compiled), and which cannot be
invoked interactively.

(fn &optional FILENAME)
(defalias 'display-call-tree #[256 "\306\307!\210r\310\311!q\210p\312 \210
\313\211\314\211\314\315 \210\316\317!\210+\211@\311q\210\315 \210\306\320A\"\210\321B\204@\206O\322\202OB;\203KB\202O\323B!\324\325A!\326\261\210A\203\327CA\330\267\202w\331\202|\332\202|\333\202|\334\202|\335\336A\"\"C\306\307!\210Cp\313\211\211\211\203\216
\337@@\"\210@A@\262\340@8\262
\341\342@@\211\262!\204\275\204\271\343\202\"
\344\202\"
\345K\211\262!\203\313\346\202\"
9\203\330\347\350\"\202\"
\351!\203\342\352\202\"
:\204\353\353\202\"
@\354=\203\n
\351A!\204
\355AAA\236\203
\356\202\"
\357\202\"
\355AA\236\203
\360\202\"
@\361=\203!
\362\202\"
\322\347\363GGGG\\$\364\261\210
\203b
\365c\210`\262\366@\203L
\367\370\371#\202M
\372\261\210\366D\373`\"\210)i\374U\204b
\364c\210\211\203\207
\375c\210`\262\366\367\370\371#\261\210\366D\373`\"\210)i\374U\204\207
\364c\210A\262\202\212\306\376!\210C\262\313\211\203@A@\204\370
@@\211\262\203\370
\377\314\"\262
\211\242\354=\203\311
\211\243\242\361=\203\311
\211A\262
\201E
!\204\370
\377\313\"\262
\211\242\354=\203\353
\211\243\242\361=\203\353
\211A\262
\201F
!\204\370
B\262A\262\202\230

\203\201GD\201Hc\210`\262\367\370\237\371#c\210\373`\"\210)\266\306\201I!\201J!\210)\207" [default-directory buffer-read-only buffer-file-name buffer-undo-list inhibit-modification-hooks inhibit-read-only message "Generating call tree..." get-buffer-create "*Call-Tree*" kill-all-local-variables nil t erase-buffer run-hooks temp-buffer-setup-hook "Generating call tree... (sorting on %s)" "Call tree for " "???" buffer-name " sorted on " prin1-to-string ":\n\n" sort #s(hash-table size 4 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (callers 103 calls 107 calls+callers 111 name 115)) #[514 "
A@G
A@GW\207" #1=[] 4 "\n\n(fn X Y)"] #[514 "\3008G\3008GW\207" [2] 5 "\n\n(fn X Y)"] #[514 "
A@G\3008G\\
A@G\3008G\\W\207" [2] 6 "\n\n(fn X Y)"] #[514 "
@
@\231\207" #1# 4 "\n\n(fn X Y)"] error "`byte-compile-call-tree-sort': `%s' - unknown sort mode" prin1 2 "	" fboundp " <top level>" " <not defined>" subrp " <subr>" format " ==> %s" byte-code-function-p "<compiled function>" "<malformed function>" macro byte-code " <compiled macro>" " <macro>" "<compiled lambda>" lambda "<function>" " (%d callers + %d calls = %d)" "\n" "  called by:\n" "    " mapconcat symbol-name ", " "<top level>" fill-region-as-paragraph 0 "  calls:\n" "Generating call tree...(finding uncalled functions...)" byte-compile-fdefinition standard-output byte-compile-call-tree-sort byte-compile-current-file byte-compile-call-tree fill-prefix functionp commandp "  " "Noninteractive functions not known to be called:\n  " "Generating call tree...done." internal-temp-output-buffer-show] 18 (#$ . 168823) nil])
#@157 Like `byte-compile-file' but doesn't recompile if already up to date.
Use this from the command line, with `-batch';
it won't work in an interactive Emacs.
(defalias 'batch-byte-compile-if-not-done #[0 "\300\301!\207" [batch-byte-compile t] 2 (#$ . 172320)])
#@607 Run `byte-compile-file' on the files remaining on the command line.
Use this from the command line, with `-batch';
it won't work in an interactive Emacs.

Each file is processed even if an error occurred previously.  If
a file name denotes a directory, all Emacs Lisp source files in
that directory (that have previously been compiled) will be
recompiled if newer than the compiled files.  In this case,
NOFORCE is ignored.

For example, invoke "emacs -batch -f batch-byte-compile $emacs/ ~/*.el".

If NOFORCE is non-nil, don't recompile a file that seems to be
already up-to-date.

(fn &optional NOFORCE)
(defalias 'batch-byte-compile #[256 "\204\305\306!\210\307\211\307\203\223\310\311@!!\203i\307\211\312@!\211\203d\211@\313\f\"\203]\314
!\204]\311
@\"\211\262\203]\315!\211\262\203]\316!\203]\317\"\203]\320!\204]\321\262
A\266\202\202 \266\202\214
\203\202@\315
!\316
!?\206}\317\"\266\202\203\214\320@!\204\214\321\262
A\211\204\322
\203\234\323\202\235\324!\207" [noninteractive attempt-stack-overflow-recovery attempt-orderly-shutdown-on-fatal-signal command-line-args-left emacs-lisp-file-regexp error "`batch-byte-compile' is to be used only with -batch" nil file-directory-p expand-file-name directory-files string-match auto-save-file-name-p byte-compile-dest-file file-exists-p file-newer-than-file-p batch-byte-compile-file t kill-emacs 1 0] 10 (#$ . 172586)])
#@13 

(fn FILE)
(defalias 'batch-byte-compile-file #[257 "\206	\n\203\303
!\202d\3041K\3051 \303
!00\202d0\306
A\203+\307\202,\310@\311N\312A!$\210\313!\314
!\203D\315
!\210\210\316\262
\202d\306
A\203U\307\202V\310@\311N\312A!$\210\316\262
)\207" [byte-compile-root-dir default-directory debug-on-error byte-compile-file (error) (file-error) message ">>Error occurred processing %s: %s (%s)" ">>Error occurred processing %s: %s" error-message prin1-to-string byte-compile-dest-file file-exists-p delete-file nil] 8 (#$ . 174013)])
#@81 Reload any Lisp file that was changed since Emacs was dumped.
Use with caution.
(defalias 'byte-compile-refresh-preloaded #[0 "@\302\303!\203\304\303 8A\206\305
!\211\203\306
!\204\"\307\310\"\207\311	!\211\205o\211@\211@\262
\312\313\"\203<\211\314\315O\262
\316
!\203h\317
\"\203h\320
!\321\235\204h\307\322\320!\"\210\3231g\324
\325\326\327$0\210\202h\210
A\266\202\202%\207" [command-line-args load-history fboundp pdumper-stats 2 executable-find file-exists-p message "Can't find %s to refresh preloaded Lisp files" reverse string-match "elc\\'" 0 -1 file-readable-p file-newer-than-file-p file-name-nondirectory ("pcase.el" "bytecomp.el" "macroexp.el" "cconv.el" "byte-opt.el" "comp.el") "Reloading stale %s" (error) load noerror nil nosuffix] 9 (#$ . 174570)])
#@379 Run `byte-recompile-directory' on the dirs remaining on the command line.
Must be used only with `-batch', and kills Emacs on completion.
For example, invoke `emacs -batch -f batch-byte-recompile-directory .'.

Optional argument ARG is passed as second argument ARG to
`byte-recompile-directory'; see there for its possible values
and corresponding effects.

(fn &optional ARG)
(defalias 'batch-byte-recompile-directory #[256 "\204\304\305!\210\306\211\204\307\203#\310@\"\210A\211\204\311\312!\207" [noninteractive attempt-stack-overflow-recovery attempt-orderly-shutdown-on-fatal-signal command-line-args-left error "batch-byte-recompile-directory is to be used only with -batch" nil (".") byte-recompile-directory kill-emacs 0] 5 (#$ . 175365)])
(byte-code "\300\301\302\303#\210\304\305!\210\304\306!\207" [put featurep compiler-macro #[642 "
\300\235\203\n\301!\207\207" [('xemacs 'sxemacs 'emacs) eval] 5 "\n\n(fn FORM FEATURE &rest IGNORE)"] provide byte-compile bytecomp] 4)
(defalias 'byte-compile-report-ops #[0 "\306\307!\204\n\310\311!\210r\312\313!q\210p\314 \210
\315\211\316\211\316\317 \210\320\321!\210+\211 \313q\210\322\315\211\211\323W\205\237!\322HH\262\315\262
\262\315\262

\"W\203`\324\325\"\262
\324\326\"\262\202q
#Y\203q
#Z\262
#\262$H\262\327\330\"c\210\331!c\210\211\203\216\332\333!\334\261\210\335j\210\333!\336\261\210T\262\2023\266\204\337!\210)\207" [default-directory buffer-read-only buffer-file-name buffer-undo-list inhibit-modification-hooks inhibit-read-only boundp byte-metering-on error "You must build Emacs with -DBYTE_CODE_METER to use this" get-buffer-create "*Meter*" kill-all-local-variables nil t erase-buffer run-hooks temp-buffer-setup-hook 0 256 logand 7 248 format "%-4d" symbol-name " [" int-to-string "]" 40 "\n" internal-temp-output-buffer-show standard-output byte-code-meter byte-nth byte-constant byte-code-vector] 10])
(byte-code "\300\301\302\303#\210\304\301!\207" [make-obsolete-variable bytecomp-load-hook "use `with-eval-after-load' instead." "28.1" run-hooks] 4)