%PDF- %PDF-
Mini Shell

Mini Shell

Direktori : /usr/local/share/emacs/27.2/lisp/emacs-lisp/
Upload File :
Create Path :
Current File : //usr/local/share/emacs/27.2/lisp/emacs-lisp/bytecomp.elc

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

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

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

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


(byte-code "\300\301!\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" [#1="\\.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" [nil] 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\"\202\207" [find-file-name-handler byte-compiler-base-file-name] 5 (#$ . 1460)])
(byte-code "\300\301!\203\302\303!\204\304\303\305\306!\"\210\202\307\301\310\"\210\311\312\313\"\210\311\314\313\"\210\311\315\313\"\210\311\316\313\"\210\311\317\313\"\210\320\321\322\323\324DD\325\326\327%\210\320\330\322\323\331DD\332\326\333%\210\320\334\322\323\335DD\336\326\327%\210\320\337\322\323\340DD\341\342\343\326\327&\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 "\203!\207\302\303!!\262\304	\"\203\305\306\211\224#\307P\207\211\307P\207" [byte-compile-dest-file-function emacs-lisp-file-regexp file-name-sans-versions byte-compiler-base-file-name string-match substring 0 ".elc"] 5 "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)"] autoload byte-compile-inline-expand "byte-opt" byte-optimize-form byte-optimize-lapcode byte-compile-unfold-lambda byte-decompile-bytecode custom-declare-variable byte-compile-verbose funcall function #[0 "?\205	\nV\207" [noninteractive baud-rate search-slow-speed] 2] "Non-nil means print messages describing progress of byte-compiler." :type boolean byte-optimize #[0 "\300\207" [t] 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] "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] "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 (#$ . 3874))
(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 (#$ . 4468))
(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*" (#$ . 5502))
(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] "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] "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 cl-functions interactive-only make-local mapcar constants suspicious lexical) (#$ . 6297))
(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  cl-functions    calls to runtime functions (as distinguished from macros and\n                  aliases) from the old CL package (not the newer cl-lib).\n  interactive-only\n	      commands that normally shouldn't be called from Lisp code.\n  lexical     global/dynamic variables lacking a prefix.\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  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 "\300D\207" [const] 3 "\n\n(fn X)"]] 13)
#@71 Dynamically bound by `with-suppressed-warnings' to suppress warnings.
(defvar byte-compile--suppressed-warnings nil (#$ . 8205))
(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@=\203A>\203\303\262A\266\202\202\210\211?\205=	\303=\206=	@\304=\203:	>?\202=	>\207" [byte-compile--suppressed-warnings byte-compile-warnings nil t not] 7 (#$ . 8509)])
#@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\302D\202)@\302=\203%\211>\203\202)\303C\"\202)\304\"\211\207" [byte-compile-warnings t not append delq] 4 (#$ . 8883)])
#@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 (#$ . 9396)])
#@61 List of commands that are not meant to be called from Lisp.
(defvar byte-compile-interactive-only-functions nil (#$ . 9879))
(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 (#$ . 10137))
#@66 Global list of variables that shouldn't be reported as obsolete.
(defvar byte-compile-global-not-obsolete-vars nil (#$ . 10258))
#@59 List of functions that shouldn't be reported as obsolete.
(defvar byte-compile-not-obsolete-funcs nil (#$ . 10393))
(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 (#$ . 11411))
(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 (#$ . 12078))
#@63 List of all jump tables used during compilation of this form.
(defvar byte-compile-jump-tables nil (#$ . 12206))
#@68 List of all constants encountered during compilation of this form.
(defvar byte-compile-constants nil (#$ . 12325))
#@68 List of all variables encountered during compilation of this form.
(defvar byte-compile-variables nil (#$ . 12447))
#@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 (#$ . 12570))
#@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 (#$ . 12737))
#@74 List of variables declared as constants during compilation of this file.
(defvar byte-compile-const-variables nil (#$ . 12920))
#@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\306\307\310!\311\"\312\313%A\"B\207\211!\207" [byte-compile-macro-environment macroexp-macroexpand progn mapcar make-byte-code 257 "\301\300\"\207" vconcat vector [byte-compile-recurse-toplevel] 4 "\n\n(fn SUBFORM)"] 10 (#$ . 13055)])
#@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\305\306\307!\310\"\311\312%\"\210\313\242D\207" [nil byte-compile-recurse-toplevel macroexp-progn make-byte-code 257 "	\n\300\303\304\305!!!\240*\207" vconcat vector [byte-compile-unresolved-functions byte-compile-new-defuns byte-compile-eval byte-compile-top-level byte-compile-preprocess] 6 "\n\n(fn FORM)" quote] 10 "\n\n(fn &rest BODY)"] eval-and-compile #[128 "\300\301!\302\"\207" [byte-compile-recurse-toplevel macroexp-progn #[257 "\302\"\303	\"\210\211\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) (#$ . 13518))
#@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 (#$ . 14788))
#@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 (#$ . 15055))
#@236 Alist of undefined functions to which calls have been compiled.
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 (#$ . 15521))
#@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 (#$ . 15823))
#@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 (#$ . 16115))
#@34 The current lexical environment.
(defvar byte-compile--lexical-environment nil (#$ . 16371))
(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 (#$ . 16505))
#@35 Current depth of execution stack.
(defvar byte-compile-depth 0 (#$ . 16643))
#@35 Maximum depth of execution stack.
(defvar byte-compile-maxdepth 0 (#$ . 16726))
#@66 An array containing byte-code names indexed by byte-code values.
(defvar byte-code-vector nil (#$ . 16812))
#@56 An array with the stack adjustment for each byte-code.
(defvar byte-stack+-info nil (#$ . 16926))
#@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 (#$ . 17030)]))
(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 (#$ . 17633))
#@42 Byte code opcode for variable reference.
(defconst byte-varref 8 (#$ . 17718))
#@42 Byte code opcode for setting a variable.
(defconst byte-varset 16 (#$ . 17803))
#@42 Byte code opcode for binding a variable.
(defconst byte-varbind 24 (#$ . 17889))
#@42 Byte code opcode for calling a function.
(defconst byte-call 32 (#$ . 17976))
#@50 Byte code opcode for unbinding special bindings.
(defconst byte-unbind 40 (#$ . 18060))
(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 (#$ . 19761))
(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 (#$ . 20342))
#@42 Byte code opcode for unconditional jump.
(defconst byte-goto 130 (#$ . 20478))
#@53 Byte code opcode to pop value and jump if it's nil.
(defconst byte-goto-if-nil 131 (#$ . 20563))
#@57 Byte code opcode to pop value and jump if it's not nil.
(defconst byte-goto-if-not-nil 132 (#$ . 20666))
#@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 (#$ . 20777))
#@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 (#$ . 20933))
#@65 Byte code opcode to pop a value and return it from `byte-code'.
(defconst byte-return 135 (#$ . 21096))
#@51 Byte code opcode to discard one value from stack.
(defconst byte-discard 136 (#$ . 21206))
#@53 Byte code opcode to duplicate the top of the stack.
(defconst byte-dup 137 (#$ . 21303))
#@74 Byte code opcode to make a binding to record the buffer, point and mark.
(defconst byte-save-excursion 138 (#$ . 21398))
#@75 Byte code opcode to make a binding to record entire window configuration.
(defconst byte-save-window-excursion-OBSOLETE 139 (#$ . 21525))
#@88 Byte code opcode to make a binding to record the current buffer clipping restrictions.
(defconst byte-save-restriction 140 (#$ . 21669))
#@87 Byte code opcode for catch.  Takes, on stack, the tag and an expression for the body.
(defconst byte-catch 141 (#$ . 21812))
#@93 Byte code opcode for unwind-protect.  Takes, on stack, an expression for the unwind-action.
(defconst byte-unwind-protect 142 (#$ . 21943))
(defconst byte-condition-case 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 (#$ . 23097))
#@47 Byte code opcode for reference to a constant.
(defconst byte-constant 192 (#$ . 23261))
#@63 Exclusive maximum index usable in the `byte-constant' opcode.
(defconst byte-constant-limit 64 (#$ . 23355))
#@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) (#$ . 23470))
(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 byte-unwind-protect byte-condition-case 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 (#$ . 27083)]))
#@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 (#$ . 27560)]))
#@67 Turns lapcode 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\203W\203D\244\262\323	\242\\\240\210\202U\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\210A\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!\210A\266\202\202\n\210.\211\203a\211@\340\341\342\343\344\345
\"\346\"\332\347%\"\210A\266\202\202A\210\350\351\237\"\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-byte-code 514 "\300A@\240\210\302\300\242\301#\207" vconcat vector [puthash] "\n\n(fn VALUE TAG)" apply unibyte-string byte-stack-set2 byte-listN byte-stack-ref byte-dup byte-compile-jump-tables] 17 (#$ . 27884)])
#@59 Return non-nil if FILE is one of the CL files.

(fn FILE)
(defalias 'byte-compile-cl-file-p #[257 "\211;\205\300\301\302!\"\207" [string-match "^cl\\.el" file-name-nondirectory] 5 (#$ . 29959)])
#@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 "	\305\n\"\306\307!\203\241	\203i=\204i\211A\262\242\310\311@\"\204d\211\203c\211@\211:\203D\211@\312=\203D\211AB\262\202\\\211:\203\\\211@\313>\203\\\211A>\204\\\211ABA\266\202\202)\210\266\202\310\203\237=\204\237\211A\262\242\2119\203\211\211>\204\211\211B\211:\203\233\211@\312=\203\233\211AB\262\210\202j\266\306\314!\203\311\f\204\310\211\203\310\211=\204\310\315\211A\262\242@!\203\250\316 \210\202\250\210\207" [load-history current-load-list lexical-binding byte-compile-noruntime-functions byte-compile-cl-functions eval byte-compile-warning-enabled-p noruntime nil assoc t (autoload defun) cl-functions byte-compile-cl-file-p byte-compile-find-cl-functions] 12 (#$ . 30164)])
#@50 Evaluate FORM for `eval-and-compile'.

(fn FORM)
(defalias 'byte-compile-eval-before-compile #[257 "\302	\"\211=\204\211@\303\232\203\304\305!\210\211A\262\202\210\207" [current-load-list lexical-binding eval (require . cl) byte-compile-disable-warning cl-functions] 6 (#$ . 31087)])
#@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 (#$ . 31389)])
#@109 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 (#$ . 31834))
(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\211\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 (#$ . 34154) 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 (#$ . 35522) 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	\300D\207\207" [prin1-to-string] 3 "\n\n(fn X)"]] 13 (#$ . 36015)]))
#@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 (#$ . 36402)])
#@51 Character position we began the last `read' from.
(defvar byte-compile-read-position nil (#$ . 36677))
#@45 Last known character position in the input.
(defvar byte-compile-last-position nil (#$ . 36786))
#@17 

(fn ELT LIST)
(defalias 'byte-compile-delete-first #[514 "\211@=\203\n\211A\207\211A\203A@=\204A\262\202A\203*\211AA\241\210\211\207" [] 5 (#$ . 36889)])
(put 'byte-compile-delete-first 'byte-optimizer 'byte-compile-inline-expand)
#@37 

(fn SYM &optional ALLOW-PREVIOUS)
(defalias 'byte-compile-set-symbol-position #[513 "\205`	\303\n\236\262\211\203GA\\\211\n\211@=\203$\211A\266\202\202F\211A\2039A@=\2049A\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 (#$ . 37144)])
(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 (#$ . 37628))
#@27 

(fn FILE &optional DIR)
(defalias 'byte-compile-abbreviate-file #[513 "\300!\301\"\211GGW\203\211\202\207" [abbreviate-file-name file-relative-name] 6 (#$ . 37752)])
#@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 (#$ . 37935)])
#@21 

(fn &rest IGNORE)
(defalias 'byte-compile-warning-series #[128 "\300\207" [nil] 2 (#$ . 38809)])
(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 (#$ . 39807))
#@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 (#$ . 40274)])
#@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 (#$ . 40573)])
#@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 (#$ . 41225)])
#@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 (#$ . 41543)])
#@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 (#$ . 41976)])
#@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;\304K!\203;\211K\262\202\3059\203L\303!\203LK\202M\n\306#\211<\203f\203`\307\310E\202\235\310D\202\235\204t\304!\203t\202\235:\204}\311\202\235@\307=\203\211A\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 (#$ . 42414)])
#@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 (#$ . 43019)])
#@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+\304A@!\207\3051C\306!\211A\247\203<\211\202?\211@C\2620\207\210\307\207" [macro advice--p 2 declared byte-compile-arglist-signature (error) func-arity (0)] 4 (#$ . 43328)])
#@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 (#$ . 43668)])
#@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 (#$ . 43838)])
#@20 

(fn F NARGS DEF)
(defalias 'byte-compile-function-warn #[771 "\303!\210\304N\203\305\306\"\203\307!\210\211\204\310!\203&>?\206O	=\206O\n\236\211\203FA>\206M\211\211AB\241\262\202MD\nB\211\262\207" [byte-compile-noruntime-functions byte-compile-current-form byte-compile-unresolved-functions byte-compile-set-symbol-position byte-obsolete-info byte-compile-warning-enabled-p obsolete byte-compile-warn-obsolete fboundp] 8 (#$ . 44038)])
#@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\2036A\247\2046\301\241\210\203v\211@W\204MA\203v\211AV\203v\306@!\210\307\310@\211\311U\203a\312\202b\313@W\203n\314\202o\315\316!&\210\317!\210\320@AG#\207" [byte-compile-fdefinition nil t byte-compile--function-signature subrp subr-arity 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 byte-compile-format-warn byte-compile-function-warn] 12 (#$ . 44513)])
#@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\205z\211A@;\205z\211@\300N\205z\301\302!r\211q\210\303\304\305\306\307!\310\"\311$\216A@c\210eb\210\304\211\312\313\314\315#\203a\316u\210\314f\317=\204[\320\321!\203R\322\323\324!\325\"\202TT\262\211]\262\314u\210\2021\262*\262G\311Z\211U?\205x\326\327@$\266\202\207" [byte-compile-format-like generate-new-buffer " *temp*" make-byte-code 0 "\301\300!\205	\302\300!\207" vconcat vector [buffer-name kill-buffer] 2 re-search-forward "%." nil t -1 37 looking-at "\\([0-9]+\\)\\$" string-to-number match-string 1 10 byte-compile-warn "`%s' called with %d args to fill %d format field(s)"] 8 (#$ . 45166)])
(byte-code "\300\211\203\211@\301\302\303#\210A\266\202\202\207" [(format message error) put byte-compile-format-like t] 6)
#@13 

(fn FORM)
(defalias 'byte-compile-nogroup-warn #[257 "\211AAAAA@\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 (#$ . 46238)])
#@28 

(fn NAME ARGLIST MACROP)
(defalias 'byte-compile-arglist-warn #[771 "\236\302\211\211\211\203\203\303\304	\"\210\305\"\305\306\"\262A\203\2129\203<\307\310\"\311=\203<\303\312	\"\210\313!\262\314\315A!\316\"\262@\262\237@\262@W\204hA\203\212\211AV\203\212\317!\210\303\320	\321!\322\232\203\200\323\202\201\324\321B!%\210\266\325\"\205\230	\236A\211\203\247\2119\203\247\325\302\"\262\205\353\306=?\205\353\326!\313!\327\"?\205\351\317!\210\303\330\203\320\331\202\321\332	\321!\333\232\203\342\334\202\343\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 (#$ . 46924)])
#@34 List of functions defined in CL.
(defvar byte-compile-cl-functions nil (#$ . 48211))
(defalias 'byte-compile-find-cl-functions #[0 "?\2058	\211\2056\211@\302@!\203/\211A\211\203.\211@\211\242\303>\203'\211ABA\266\202\202\210A\266\202\202\262\207" [byte-compile-cl-functions load-history byte-compile-cl-file-p (autoload defun)] 6])
#@70 Warn if FORM is a call of a function from the CL package.

(fn FORM)
(defalias 'byte-compile-cl-warn #[257 "\211\242\203\211>\203\211\301>\204\302\303\"\210\210\207" [byte-compile-cl-functions (cl--block-wrapper cl--block-throw multiple-value-call nth-value copy-seq first second rest endp cl-member cl--defsubst-expand cl-struct-setf-expander macroexpand cl--compiling-file) byte-compile-warn "function `%s' from cl package called at runtime"] 5 (#$ . 48565)])
#@23 

(fn STR1 STRN SYMS)
(defalias 'byte-compile-print-syms #[771 "\211\203\n\302@\303\"\210\211A\203f\204f\211G\304\203a\305\211A\262\242!\262\306G\307#\262\310\311\312	!\2067p\"SW\203L\313\205F\314R\262\202\315\205U\314R\262\211G\316\\\262\202\317\320\"\207\211A\203u\317\321\322\305\323##\207\211\205~\317@\"\207" [noninteractive byte-compile-log-buffer byte-compile-set-symbol-position t nil symbol-name + 2 buffer-local-value fill-column get-buffer " " "," "\n    " 4 byte-compile-warn "%s" "%s %s" mapconcat ", "] 11 (#$ . 49042)])
(defalias 'byte-compile-warn-about-unresolved-functions #[0 "\303\304!\203F\305\306\211	\211\2036\211@\211@\262\211\n>\204/\307!\203*\211B\262\202/\211B\262A\266\202\202\f\210\310\311\312#\210\310\313\314#\210)\266\306\207" [byte-compile-current-form byte-compile-unresolved-functions byte-compile-new-defuns byte-compile-warning-enabled-p unresolved :end nil fboundp byte-compile-print-syms "the function `%s' might not be defined at runtime." "the following functions might not be defined at runtime:" "the function `%s' is not known to be defined." "the following functions are not known to be defined:"] 7])
#@19 

(fn &rest BODY)
(defalias 'byte-compile-close-variables '(macro . #[128 "\300\301BB\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))] 4 (#$ . 50254)]))
(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))))) ((byte-compile-find-cl-functions) (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 (#$ . 51032)]))
(put 'displaying-byte-compile-warnings 'edebug-form-spec t)
#@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 (#$ . 52149) "DByte force recompile (directory): "])
#@681 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.

(fn DIRECTORY &optional ARG FORCE)
(defalias 'byte-recompile-directory #[769 "CC\242\203\305\242!\240\210\204'\306\307\310\311\312\313\314!\315\"\316$\"\210\317 \210r\320	!q\210\321\242!\322\323!\204;\324 \210\nCC\n\311C\311C\311C\311C\307C\310\311\325\313\314\f




&	\326\"\327$\330!\205u\331!\332	!=\333 \210\334=\204\202\211\203\257\307\335 \262\204\221\211\206\220\334\f\203\233 \210\202\253\3361\245 0\202\252\337!\262\210\210\202\321\335 \206\265\334\f\203\300 \210\202\320\3401\312 0\202\317\337!\262\210)\266\341\342\242\242\343U\203\342\344\202\343\345\242\311V\203\364\346\347	\242\"\202\365\344	\242\311V\203\346\350\242\"\202\344\242\343V\203\346\351	\242\"\202\344&)\266\207)\207" [noninteractive byte-compile-log-buffer default-directory warning-series byte-compile-debug prefix-numeric-value save-some-buffers nil make-byte-code 0 "\303 \211\205	\304\305\306#)\266\203\205\307\300\242\"\207" vconcat vector [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 "\303\242\205\323\300\303\242@\240\210\311\312\300\242\"\210\313\300\242!\211\203\311\211@\314\300\242\"\315!\203Z\316\235\204\301\317H\320=\204\301\321!\204\301\301\242\203O\301\242\317=\204O\322\323\324Q!\203\301\303\211\242C\244\240\210\202\301\325\"\203\301\326!\203\301\325\327\"\204\301\330!\204\301\331!\230\204\301\332\302\301\242#\211\333\267\202\234\304\211\242T\240\210\202\242\306\211\242T\240\210\202\242\305\211\242T\240\210\210\204\256\311\312\300\242\"\210\310\242\300\242=\204\301\310\300\242\240\210\307\211\242T\240\210\210A\266\202\202\210\303\211\242A\240\210\202\207" [message "Checking %s..." directory-files expand-file-name 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 file-name-nondirectory byte-recompile-file #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (no-byte-compile 138 t 147)) emacs-lisp-file-regexp dir-locals-file noninteractive] 7 markerp marker-buffer get-buffer byte-compile-find-cl-functions 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"] 26 (#$ . 52448) "DByte recompile directory: \nP"])
#@182 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 (#$ . 55712))
#@813 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 optional argument LOAD is non-nil, loads the file after compiling.

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!\304!\203\204*\305\"\202'\203>\306=\204*\307\310\311Q!\203>\2037	\2047\312\313\"\210\314\"\202Q\203P\315\304!\203M\202N!\210\316\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 load no-byte-compile] 10 (#$ . 55942) (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)])
#@40 Depth of a recursive byte compilation.
(defvar byte-compile-level 0 (#$ . 57483))
#@347 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).
With prefix arg (noninteractively: 2nd arg), LOAD the file after compiling.
The value is non-nil if there were no errors, nil if errors.

(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\211\211\211\302!\262r\320\321@\322U\203R\323\202W\312\324@\"P!\211\262q\210\325 \210\316A\326\317!\210\327!\210B\330=\204}\331B!\332=\203\201\326\316!\210\333\334!\335\316CDE\336\322\337\340\341!\342\"\343$\216\344\334\345\"\210\346\347!\210\317'\350\317!\210*\316FE\262\n+\266\351\352!\204\303\346\352!\210\316*\353!G)rq\2101)\203\372\354!\203\366\355\356\357!\360\361\"#\210\3621\361\363!0\202\365\210\202\366\210\361\202\357H\203\355\364	\"\210\316Ir@T@\365!*\262I?\205\357H\203%\355\366	\"\210\367!\210r\211q\210db\210\370c\210\371!\203\224\330J\372\306!!\373 \374\375\"\374\376\"\336\322\377\340\341!\201M\"\201N$KBKU\204m\201O\"\210\201Ped\316\201Q%\210\201R\317#\210*\266\204\275\355\201S\"\210\202\275\354!\201T\203\244\201U\202\247\201V\201W\203\264\201X\202\267\201YE\"\266\367p!\210)L\203\343L\317=\204\332\311\312\201Z\n\"!\203\343\212\201[!\210)\203\356\201\\!\210\317,\207" [noninteractive byte-compile-last-logged-file byte-compile-dest-file set-auto-coding-for-load byte-compile-current-group byte-compile-current-file expand-file-name get-file-buffer buffer-modified-p y-or-n-p format "Save buffer %s first? " buffer-name save-buffer nil t 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-byte-code "\301\302\300\"\207" vconcat vector [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 "\3011	\302\300!0\207\210\303\207" 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-compiler-error-flag coding-system-for-write kill-emacs-hook byte-compile-generate-call-tree [(error) delete-file nil] 2 set-file-modes write-region 1 rename-file "Wrote %s" signal file-error file-missing "Opening output file" "Cannot overwrite file" "Directory not writable or nonexistent" "Report call tree for %s? " display-call-tree load] 18 (#$ . 57572) (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)])
#@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 \210\320=\2046\211\203d\312\321 \262\204F\211\206D\320\203P \202_\3221Z 0\202_\323!\262\262\202\206\321 \206j\320\203v \202\205\3241\200 0\202\205\323!\262)\266\202*\"\203\236\325\326!\210\327p\"\210\330c\202\244\325\331\332!\"-\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-find-cl-functions 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 (#$ . 60885) "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'()*++*)(',-./01234r\311\3125\313X\203k\314\202q\315\3165S\"P!\2113q\210\317\320!\210\321 \210\306!)\322\3236!\205\224\3246!\3257!=\326 \2106\327=\204\242\211\203\323\306\330 \262\204\262\211\206\260\32768\203\276!\210\202\317\3311\311!0\202\316\332!\262\210\210\202\371\330 \206\331\32768\203\347!\210\202\370\3331\362!0\202\367\332!\262\210)\2663.\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\310\307w\210g\311U\203&\312y\210\202m\204J`\211\307\313!\314 \211\203@\315\316\"\210\317!\210)\266\202\320 \210d\321 \210)\205`r	q\210\322!)\207" [byte-compile-current-file byte-compile--outbuffer byte-compile-unresolved-functions byte-compile-noruntime-functions byte-compile-new-defuns byte-compile-read-position byte-compile-insert-header nil " 	\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-compile-fix-header byte-compile-last-position lread--unescaped-character-literals] 7 "\n\n(fn INBUFFER)"] markerp marker-buffer get-buffer byte-compile-find-cl-functions 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 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] 17 (#$ . 62135)])
#@91 If the current buffer has any multibyte characters, insert a version test.

(fn FILENAME)
(defalias 'byte-compile-fix-header #[257 "d\300d!W\205Geb\210\301\302!\210\303 d}\210\301\304!\210\305 \210e`}\210`\306\307ed|\210\310\311\312\313\314\315\"\316\314\317	\"\261\210dZ\262db\210~\210\320!\266\203\207" [position-bytes search-forward "\n;;; This file uses" line-beginning-position ";;;;;;;;;;" beginning-of-line "23" nil ";;; This file contains utf-8 non-ASCII characters,\n" ";;; and so cannot be loaded into Emacs 22 or earlier.\n" "(and (boundp 'emacs-version)\n" "     (< (aref emacs-version (1- (length emacs-version))) ?A)\n" format "     (string-lessp emacs-version \"%s\")\n" "     (error \"`%s' was compiled for " "Emacs %s or later\" #$))\n\n" delete-char] 13 (#$ . 64609)])
#@98 Insert a header at the start of OUTBUFFER.
Call from the source buffer.

(fn FILENAME OUTBUFFER)
(defalias 'byte-compile-insert-header #[514 "	\nrq\210eb\210\304\305\306\307\310\311\312\313\267\202!\314\202+\315\202+\203*\316\202+\317\320\2035\321\2026\322\323\203@\324\202A\325\326\327\330\331\332\261)\207" [byte-compile-dynamic-docstrings byte-compile-dynamic byte-optimize emacs-version ";ELC" 23 "\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 25 byte 29)) " source-level optimization only" " byte-level optimization only" " all optimizations" "out optimization" ".\n" ";;; Function definitions are lazy-loaded.\n" "" "\n;;; This file uses " "dynamic docstrings, first added in Emacs 19.29" "opcodes that do not exist in Emacs 18" ".\n\n" ";;; This file does not contain utf-8 non-ASCII characters,\n" ";;; and so can be loaded in Emacs versions earlier than 23.\n\n" ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;\n" ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;\n\n"] 23 (#$ . 65410)])
#@13 

(fn FORM)
(defalias 'byte-compile-output-file-form #[257 "\306\307\211\306\211?\211\242\310>\203,\3118;\203,\312\307\211\313\307@\314>&\2029\315\316\"\210\317\"\210\307.\207" [byte-compile-disable-print-circle print-circle print-gensym print-quoted print-level print-length 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-escape-newlines byte-compile--outbuffer] 9 (#$ . 66585)])
#@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\"\262A@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\330\211U\203\330\306C\316\"!\203\261\317\320\321\322\323\324!\325\"\326\327%\"\"\210\211\242?\262\203\330\311@	A@B\313\"\330\331\332\"	\"\210A\262	T\266\202\202y\211	A@U\203\203\372\330\331\203\360\333\202\361\334\"	\"\210\202y\306!`T\314	@	\"\210b\210\335c\210db\210)\202y\314@	\"\210\202y.\266\3368c\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-byte-code 514 "\211\205\300\301\240\207" vconcat vector [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] 19 (#$ . 67131)])
#@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-form t (fset defalias) 300 byte-compile-flush-pending byte-compile-discard byte-compile-form nil] 5 (#$ . 68873)])
(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])
(defvar byte-compile-force-lexical-warnings nil)
#@34 

(fn FORM &optional FOR-EFFECT)
(defalias 'byte-compile-preprocess #[513 "\303\"\262	\203\304!\207\n\203\305!\207\207" [byte-compile-macro-environment lexical-binding byte-compile-force-lexical-warnings macroexpand-all cconv-closure-convert cconv-warnings-only] 5 (#$ . 69735)])
#@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 (#$ . 70031)])
#@13 

(fn FORM)
(defalias 'byte-compile-file-form #[257 "\300:\203(@9\203(@\301N\211\262\203(\211!\211\262\205+\302 \210\303!\202+\304!\207" [nil byte-hunk-handler byte-compile-flush-pending byte-compile-output-file-form byte-compile-keep-pending] 4 (#$ . 70310)])
(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@\211\307=\203tA\211:\203s\211@\2119\203rA\211\204q\310!\204[\211\311AABBB\211	>\203i\312	\"\202p\312\n\236\n\"\210\210\210\210\210\210\3138;\203~\207\314\315\"\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-keep-pending byte-compile-normal-call] 10 (#$ . 70658)])
(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--declare-var #[257 "\2119\203\302\303\304!\"\204\305\306\"\203\307\310\"\210\211>\203*\311\"\307\312\"\210\211	B\211\207" [byte-compile-lexical-variables byte-compile-bound-variables string-match "[-*/:$]" symbol-name byte-compile-warning-enabled-p lexical byte-compile-warn "global/dynamic var `%s' lacks a prefix" delq "Variable `%S' declared after its first use"] 5 (#$ . 71385)])
#@13 

(fn FORM)
(defalias 'byte-compile-file-form-defvar #[257 "\211A@\301!\210@\302=\203\211B\210\211AA?\205\211@\303=?\205;\3048:\203:\305!\262\211AA\306\3048\307\310#\240\210\211\207" [byte-compile-const-variables byte-compile--declare-var defconst defvar 2 copy-sequence byte-compile-top-level nil file] 6 (#$ . 71826)])
(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 "\211A@\301:\203@@\211\302=\2038A\211:\2030\211@A\211\204'!\210\202+\303!\210\266\2024\303!\210\210\202<\303!\210\210\202D\211\303!\210\266\211:\203\232\211@\211\304=\203\231A\211:\203\230\211A\211:\203\227\211@\211:\203\226\211@\211\302=\203\225A\211:\203\224\211@A\211\204\222\211>\203\221\305\306!\203\221\307\310\"\210\210\266\210\210\210\210\210\210\311!\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-keep-pending] 13 (#$ . 72321)])
(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 (#$ . 73184)])
(put 'require 'byte-hunk-handler 'byte-compile-file-form-require)
#@13 

(fn FORM)
(defalias 'byte-compile-file-form-require #[257 "\303\304A\"\305\211\306\307\"\210\262\310@B\262\203(\211@\235\204(A\262\202\203M@\211\203L\211@\211:\203E\211@\311>\203E\211A	BA\266\202\202.\210\312\313!\203\210@\314\235\203e\315\316!\210\317\313!\210\202\210\262\n\204\210\203\210=\204\210\320\211A\262\242@!\203h\321 \210\202h\266\322\323\"\207" [load-history byte-compile-new-defuns byte-compile-cl-functions mapcar eval nil apply require provide (defun t) byte-compile-warning-enabled-p cl-functions ("cl" cl) byte-compile-warn "cl package required at runtime" byte-compile-disable-warning byte-compile-cl-file-p byte-compile-find-cl-functions byte-compile-keep-pending byte-compile-normal-call] 9 (#$ . 73495)])
(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 (#$ . 74396)])
(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 (#$ . 74622)])
(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 "\301A@A@\"\302\303AA\"\210)\304\207" [byte-compile--suppressed-warnings append mapc byte-compile-file-form nil] 4 (#$ . 74913)])
(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 (#$ . 75208)])
(put 'eval 'byte-hunk-handler 'byte-compile-file-form-eval)
#@13 

(fn FORM)
(defalias 'byte-compile-file-form-eval #[257 "\211A@\242\300=\203\211A@A@\207\301!\207" [quote byte-compile-keep-pending] 3 (#$ . 75456)])
#@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\354\211\203\207\312\313\n\"\203\200*\236\204\200\320\321\n\"\210\211\311\241\210\202\354\203\256\312\313\n\"\203\354*\236\204\354\320\322	\203\246\323\202\247\324#\210\202\354K\242\203\273\325\202\274\326=\203\354\312\313\n\"\203\342\320\327	\203\323\324\202\324\323\203\337\323\202\340\324$\210	\311BJBL\210<\203@;\203\243\2429\203\243\242\203\243\243\242;\203\320\330\n\"\210<\2046\2042<\203+\331D\202,\332BB\311\202\254\333B\332\"\203V\203O	*\236\204a\241\210\202a\nBJBL\210?\205\252\334 \210\335\332\";\204u\336\202v\337\340\341\f\f\203\207\342\343BB\202\214\344\345BB\346\311\":?\205\236+\205\236\347\311&\266\350\351,\"\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 byte-compile-output-docform "\n(defalias '" " '(macro . #[" ("])") " #[" ("]") append 1 princ ")" byte-compile-initial-macro-environment byte-compile-dynamic byte-compile--outbuffer] 18 (#$ . 75617)])
#@204 Print Lisp object EXP in the output file, inside a comment,
and 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\322\321`!e\323#db\210\262)\207" [byte-compile--outbuffer " " prin1 princ search-forward "" nil t replace-match "" "" "0" "" "_" "#@" format "%d" position-bytes - -1] 9 (#$ . 77898)])
#@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@\211\301=\203A\211@A\302#\266\203\202+A\211@A\211@A#\266\205\207" [#[771 "\300\211@;\203\211A\262\242B\262@\242\301=\203$\211A\262\242B\262\211\203Z\211@\211:\203E\211@>\204S\211@\302ADDB\262\202S\211\303=\204S\304DB\262A\266\202\202%\210\211\204k\305\306\"BB\202z\305\306\307\237	BBC\"BB\207" [nil interactive quote t defvar lambda append let] 12 "\n\n(fn ENV BODY ARGS)"] lambda nil] 12 (#$ . 78640)])
#@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 \210\310=\204\211\203I\311\312 \262\204*\211\206)\310\n\2034!\202D\3131?!0\202D\314!\262\262\202k\312 \206O\310\n\203Z!\202j\3151e!0\202j\314!\262)\207" [warning-series byte-compile-log-buffer byte-compile-debug #[257 "\306!\307\211\211\211\211\211\211\211	\n\f
\2119\2035\211K\2026\211\211\242\310=\211\203BA\262\311!\203Z\312\3139\203S\202T\314\"\210\202\2339\204f\242\315=\203q@\315=\316!\262\317!\262\320\307\321#\2629\203\210\321\322\"\262\211\203\221\310B\2629\203\232M\210)\266\202.\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 byte-compile-preprocess byte-compile-top-level eval t 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] 15 "\n\n(fn FORM)"] markerp marker-buffer get-buffer byte-compile-find-cl-functions byte-compile-warning-series nil byte-compile-log-file (error) byte-compile-report-error (error)] 7 (#$ . 79295)])
#@37 Compile and return SEXP.

(fn SEXP)
(defalias 'byte-compile-sexp #[257 "\303\304!\205\305!\306	!=\307 \210\310=\204\211\203I\311\312 \262\204*\211\206)\310\n\2034!\202D\3131?!0\202D\314!\262\262\202k\312 \206O\310\n\203Z!\202j\3151e!0\202j\314!\262)\207" [warning-series byte-compile-log-buffer byte-compile-debug #[257 "\306!\307\211\211\211\211\211\211\211	\n\f
\n\f
\310\311!!.\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 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] 15 "\n\n(fn SEXP)"] markerp marker-buffer get-buffer byte-compile-find-cl-functions byte-compile-warning-series nil byte-compile-log-file (error) byte-compile-report-error (error)] 7 (#$ . 80912)])
#@47 Check lambda-list LIST for errors.

(fn LIST)
(defalias 'byte-compile-check-lambda-list #[257 "\301\205\233@\2119\203\302!\210\2119\203H\211\303\304>\206C\305!\206C\211\205C>\206C\306!\205C\3071A\211JL\210\3010\202C\210\303\266\202\203P\310\311\"\210\202\223\211\312\267\202\200AA\203`\310\313!\210A@\314>\203\223\310\315A@\"\210\202\223\316A>\203\223\310\317!\210\202\223\211>\203\216\320\321\"\210\202\223\211B\262\210A\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 86 &optional 114)) "Garbage following &rest VAR in lambda-list" (&optional &rest) "%s following &rest in lambda-list" &optional "Duplicate &optional" byte-compile-warn "repeated variable %s in lambda-list"] 7 (#$ . 82042)])
#@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 (#$ . 82989)])
#@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\262A\266\202\202\210\207" [nil 0] 7 (#$ . 83188)])
#@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\203P\307\310!\202[\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 (#$ . 83414)])
#@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\302B\262\202\242\302=\204\303\304\"\210\305\302!\210\306A@!\210A@\307!\310?\205/	\"AA\211@;\205F\211@A\203FA\262\311\236\211\203\261\305\311!\210\211@=\203\\A\262\211A:\203\245\211AA\203o\312\313\314!\"\210\211A@\315!\242\316>\203\220A:\203\211A\262\202|@\262\202u\242\317=\203\233\203\240\311D\262\266\202\261\211A\203\261\312\313\314!\"\210\315\320B\321\302\205\277\322!\n%\211\242\323=\204\315\324\325!\210\326\327\203\332\330!\202\334\310A\203\362\n\203\362\331\f\"C\202\377\204\374\205\377C\205	A@C##\262)\207" [lexical-binding byte-compile-bound-variables lambda error "Not a lambda list: %S" byte-compile-set-symbol-position byte-compile-check-lambda-list byte-compile-arglist-vars append interactive byte-compile-warn "malformed interactive spec: %s" prin1-to-string byte-compile-top-level (let let* progn save-excursion) list progn nil 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] 17 (#$ . 83822)])
(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\202A\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-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 (#$ . 85988)])
#@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=\204w\317=\203f\320\202g\321\233\204w\322\236\204w\312\236\211\262\203w\310!>A\237\262@@\323>\203\357@A@\262@@\324=\203\346:\204\3279\203\346\307\325>\206\322\326!\206\322\211\205\322>\206\322\327!\205\322\3301\320\211JL\210\3070\202\322\210\331\266\202\204\346\203s\332DB\211\262\202iB\211\262\202i\203s\333\233\204s@@\334N\211\262\203sA\203,\317=\203sAA\203s\335G@A\"\203sA@@\305=\203sA\262\307\262\211\237\262\336=\203S\211@\242\332=\203S\211@A@9\203S\211@A@AB\202VBC\262\317=\204l\337\307\340\341@A\"\"?\203sA\262\202\204\203\205\342 \343\344!\fF\262\202\223\211A\203\221\345\237B\202\223\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 (#$ . 86741)])
#@34 

(fn BODY &optional FOR-EFFECT)
(defalias 'byte-compile-top-level-body #[513 "\300\301B\302#\262\242\301=\203A\207\205C\207" [byte-compile-top-level progn t] 6 (#$ . 88200)])
#@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 (#$ . 88393)])
(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:\204l9\203?\306\307>\206:\310!\206:\211\205:	>\206:\311!\205:\31218\211JL\210\3060\202:\210\313\266\202\203O9\203H\314!\210\315!\210\202\270\203e\n\203e9\203`\314!\210\306\202\270\316!\210\202\270@9\203\203@\211\317N\320N\206\200>\321>\203\302A\211:\203\301\211@\211:\203\300\211@\211\322=\203\277A\211:\203\276\211@A\211\204\274\211\f\236\203\273\323\324\325\f#!\210\210\266\210\210\210\210\326>\203\332A\242\211\242\322=\203\331\327A@\306\"\210\210\330\331!\203\306\307>\206\310!\206\211\205	>\206\311!\205\3321\f\211JL\210\3060\202\210\313\266\202\203\333\334\"\210\330\320\"\203E\211\203E\333\335;\2035\336\337\340!\"\202C\313=\204B\324\341\"\202C\342#\210@K\242\343=\203Y\323\336\344@#!\210\203p\345!\203p\346=\204p!\210\202t\347!\210\330\350!\203~\351!\210\266\202\270\352@!\203\227
\353>\203\227\354!\210\202\270@\242\355=\203\264\356!\211\262=\204\264\357\"\210\306\202\270\347!\210\205\276\360 )\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 (setting-constant) byte-compile-warn "`%s' called as a function" "`%s' is for interactive use only%s" format "; %s" substitute-command-keys "; use `%s' instead." "." macro "Forgot to expand macro %s in %S" functionp cl-byte-compile-compiler-macro byte-compile-normal-call cl-functions byte-compile-cl-warn byte-code-function-p (t lap) byte-compile-unfold-bcf lambda byte-compile-unfold-lambda byte-compile-form byte-compile-discard] 17 (#$ . 88992)])
#@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 (#$ . 91204)])
#@22 

(fn LAP END-DEPTH)
(defalias 'byte-compile-inline-lapcode #[514 "\303 \304\211\211\211\211C\304\211\203\300\211@\211@\305=\203=\211\242\235\204%\211\235\2036\2030A\304\241\210\304\262\306!\210\202\271\211@	>\203k\262\211A\262\307@A\"\210\203\271\211AB\262\211AA\304\241\210\304\262\202\271\211@\310=\203\203\311Z\312\"\210\307\313\n\"\210\202\271\211@\314=\203\243\nB\312\262\315\316\317\320\321\322	!\323\"\324\325%\"\210\211@\326=\205\255\211A@\262\262\327@A\"\210A\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-byte-code 514 "\300\300\242B\240\207" vconcat vector [] 5 "\n\n(fn K TAG)" byte-constant byte-compile-out] 18 (#$ . 91927)])
#@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\213<\204I\317\320!\210\203\201@\211\321\267\202rA\262\202}\311G_T\262A@B\262\305\262\202}\211A\262\242B\262\210\202I\204\213\311G_\262\211\\X\203\262T\311\245Z\302\211W\203\255\211\322\305!\266\211T\262\202\232\266\202\376\323\310\"\302U\203\316\324\325\326\n\"!\210\327\311\245Z!\210\202\376S\311\245Z\211\302V\204\347\317\330\331\305E$\210\211\332W\203\370\333\334SH\302\"\210\202\375\333\335\"\210\210\315\336\"\210\337T\"\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 93)) 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 (#$ . 92811)])
#@81 Do various error checks before a use of the variable VAR.

(fn VAR ACCESS-TYPE)
(defalias 'byte-compile-check-variable #[514 "9\203	\303!\2109\203A\304\305>\206<\306!\206<\211\205<>\206<\307!\205<\3101:\211JL\210\3040\202<\210\311\266\202\203h\312\3139\205I\"\205\236\314\315=\203X\316\202Y\3179\203b\320\202c\321\322!#\207\323N\211\205\226	>?\205\226\n>?\205\226\211A@\211\324\267\202\223\325=?\202\224\325=\202\224\311\262\262\205\236\326!\207" [byte-compile-const-variables byte-compile-not-obsolete-vars byte-compile-global-not-obsolete-vars 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 134 get 141)) reference byte-compile-warn-obsolete] 7 (#$ . 94337)])
#@20 

(fn BASE-OP VAR)
(defalias 'byte-compile-dynamic-variable-op #[514 "\211\236\211\204C\262\211B\301\"\207" [byte-compile-variables byte-compile-out] 6 (#$ . 95370)])
(put 'byte-compile-dynamic-variable-op 'byte-optimizer 'byte-compile-inline-expand)
#@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\204C\262\211	B\305\"\207" [byte-compile-bound-variables byte-compile-variables byte-compile-check-variable let-bind byte-varbind byte-compile-out] 7 (#$ . 95636)])
#@77 Generate code to push the value of the variable VAR on the stack.

(fn VAR)
(defalias 'byte-compile-variable-ref #[257 "\304\305\"\210\211\236\211\203\306A!\202^\307\310\"\203G\311!\204G	>\204G\n>\204G\312!\313!\314\315\203?\316P\202@\317#\266\nB\320\211\236\211\204XC\262\211B\321\"\266\203\207" [byte-compile--lexical-environment byte-compile-bound-variables byte-compile-free-references byte-compile-variables byte-compile-check-variable reference byte-compile-stack-ref byte-compile-warning-enabled-p free-vars boundp prin1-to-string help-uni-confusable-suggestions byte-compile-warn "reference to free variable `%s'%s" "\n  " "" byte-varref byte-compile-out] 9 (#$ . 95991)])
#@78 Generate code to set the variable VAR from the top-of-stack value.

(fn VAR)
(defalias 'byte-compile-variable-set #[257 "\304\305\"\210\211\236\211\203\306A!\202^\307\310\"\203G\311!\204G	>\204G\n>\204G\312!\313!\314\315\203?\316P\202@\317#\266\nB\320\211\236\211\204XC\262\211B\321\"\266\203\207" [byte-compile--lexical-environment byte-compile-bound-variables byte-compile-free-assignments byte-compile-variables byte-compile-check-variable assign byte-compile-stack-set byte-compile-warning-enabled-p free-vars boundp prin1-to-string help-uni-confusable-suggestions byte-compile-warn "assignment to free variable `%s'%s" "\n  " "" byte-varset byte-compile-out] 9 (#$ . 96711)])
#@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) assq (byte-compile-constants) car setq byte-compile-constants cons list (byte-compile-constants)] 12 (#$ . 97431)]))
#@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\262A\266\202\202\210\211\262\202>	\236\206HC	B\211@\"\207" [byte-compile--for-effect byte-compile-constants nil byte-compile-set-symbol-position byte-compile-out byte-constant equal-including-properties] 10 (#$ . 97861)])
#@14 

(fn CONST)
(defalias 'byte-compile-push-constant #[257 "\2119\203	\301!\210\302\303;\2032\304\211\203+\211@\305@\"\203$\211\262A\266\202\202\210\211\262\2025\236\206?CB\211@\"\207" [byte-compile-constants byte-compile-set-symbol-position byte-compile-out byte-constant nil equal-including-properties] 9 (#$ . 98254)])
#@504 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, 3, 0-1, or 1-2.
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\203V\311\304\305D\312\305DF\304\305D\313\305\nDFF\202W\211\262\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)) "byte-compile-" progn 'byte-opcode 'byte-opcode-invert] 12 (#$ . 98603)]))
#@43 

(fn FUNCTION &optional COMPILE-HANDLER)
(defalias 'byte-defop-compiler-1 '(macro . #[513 "\300\301DE\207" [byte-defop-compiler nil] 5 (#$ . 99747)]))
(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\261#\210\300\201\265\324\201\266#\210\300\201\266\302\201\265#\210\300\201\267\322\201\261#\210\300\201\267\324\201\270#\210\300\201\270\302\201\267#\210\300\201\271\322\201\272#\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 1-3 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-associative byte-max min byte-min + 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 (#$ . 108551)])
#@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 (#$ . 108838)])
#@13 

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

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

(fn FORM)
(defalias 'byte-compile-three-args #[257 "\211G\300U\204\f\301\302\"\207\303A@!\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 (#$ . 109943)])
#@13 

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

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

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

(fn FORM)
(defalias 'byte-compile-noop #[257 "\300\301!\207" [byte-compile-constant nil] 3 (#$ . 110942)])
#@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!\210S\262\304V\2059\301\302!\210S\262\202(\207" [byte-compile-depth byte-compile-out byte-discard 1 0 byte-compile-stack-set] 5 (#$ . 111058)])
#@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!\202\302\304\"\207" [byte-compile-depth 0 byte-compile-out byte-dup byte-stack-ref] 5 (#$ . 111616)])
#@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 (#$ . 111877)])
(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\315\316\307HD\316\317HD\320\321	B\316\302HDE\303\322\323\"\233\203g\211@	AABB\202h\211\262BBBB!\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 make-byte-code quote 1 vconcat vector mapcar #[257 "\300D\207" [quote] 3 "\n\n(fn X)"]] 15 (#$ . 112279)])
#@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 (#$ . 112937)])
#@13 

(fn FORM)
(defalias 'byte-compile-associative #[257 "\211A\203X\211@\300N\301\302GW\203#\303\300N\304\300ND>\203#\305!\202W\306A!\262\307@!\210\211A\262\211\204>\310\262\303\300N\262\211\211\205U\211@\307!\210\311\312\"\210A\266\202\202?\262\207\313\314!!\207" [byte-opcode nil 3 + * byte-compile-normal-call copy-sequence byte-compile-form (0) byte-compile-out 0 byte-compile-constant eval] 8 (#$ . 113176)])
(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\341\302\342#\210\300\341\304\343#\210\300\343\306\341#\210\300\344\302\345#\210\300\344\304\346#\210\300\346\306\344#\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-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 (#$ . 114921)])
#@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 (#$ . 115257)])
#@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 (#$ . 115582)])
#@13 

(fn FORM)
(defalias 'byte-compile-list #[257 "\211AG\211\300U\203\301\302!\202;\211\303W\203%\304\305A\"\210\306\307SH\300\"\202;\211\310W\2038\304\305A\"\210\306\311\"\202;\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 (#$ . 115907)])
#@13 

(fn FORM)
(defalias 'byte-compile-concat #[257 "\211AG\300W\203 \211\301W\203 \302\303A\"\210\304\305\306ZH\307\"\202B\211\307U\203,\303\310!\202B\211\311W\203?\302\303A\"\210\304\312\"\202B\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 (#$ . 116287)])
#@13 

(fn FORM)
(defalias 'byte-compile-minus #[257 "\211G\211\300U\203\301\302!\202=\211\303U\203!\304A@!\210\305\306\302\"\202=\211\307U\203:\304A@!\210\304\3038!\210\305\310\302\"\202=\311!\207" [1 byte-compile-constant 0 2 byte-compile-form byte-compile-out byte-negate 3 byte-diff byte-compile-normal-call] 5 (#$ . 116663)])
#@13 

(fn FORM)
(defalias 'byte-compile-quo #[257 "\211G\211\300W\203\301\302\"\202\211\303U\203\304!\202\305!\207" [2 byte-compile-subr-wrong-args "1 or more" 3 byte-compile-two-args byte-compile-normal-call] 5 (#$ . 117006)])
#@13 

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

(fn FORM)
(defalias 'byte-compile-fset #[257 "\3008\301\242\302=\203DA@\211\262\242\303=\203DAA\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 (#$ . 117543)])
#@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 (#$ . 118068)])
#@13 

(fn FORM)
(defalias 'byte-compile-indent-to #[257 "\211G\211\300U\203\301A@!\210\302\303\304\"\202%\211\305U\203!\306!\202%\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 (#$ . 118397)])
#@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 (#$ . 118688)])
(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\204CAA\204C\314\315\316\"\210\317@!\210AA\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 (#$ . 119266)])
(put 'set-default 'byte-compile 'byte-compile-set-default)
#@13 

(fn FORM)
(defalias 'byte-compile-set-default #[257 "\211\243\242\211\242\301=\203c\211A\242\2119\203E\211\302\303>\206@\304!\206@\211\205@>\206@\305!\205@\3061>\211JL\210\3070\202@\210\302\266\202\203b\310\3119\205M\"\203b\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 (#$ . 119850)])
#@13 

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

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

(fn BODY)
(defalias 'byte-compile-body-do-effect #[257 "\301\"\210\302\211\207" [byte-compile--for-effect byte-compile-body nil] 4 (#$ . 120699)])
(put 'byte-compile-body-do-effect 'byte-optimizer 'byte-compile-inline-expand)
#@13 

(fn FORM)
(defalias 'byte-compile-form-do-effect #[257 "\301\"\210\302\211\207" [byte-compile--for-effect byte-compile-form nil] 4 (#$ . 120936)])
(byte-code "\300\301\302\303#\210\300\304\305\306#\210\300\307\305\306#\210\300\310\305\311#\210\300\312\305\313#\210\300\314\305\315#\210\300\316\305\317#\210\300\320\305\321#\210\300\322\305\323#\210\300\324\305\325#\210\300\326\305\327#\210\300\330\305\327#\207" [put byte-compile-form-do-effect 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*] 4)
#@13 

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

(fn FORM)
(defalias 'byte-compile-prog1 #[257 "\211A@\301\"\210\302\211\266\303AA\304\"\207" [byte-compile--for-effect byte-compile-form nil byte-compile-body t] 5 (#$ . 121825)])
#@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 (#$ . 122018)]))
#@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\262A\266\202\202\210\207" [nil and quote] 10 (#$ . 122283)])
#@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\311BB\312BBE\207" [let* fbound-list byte-compile-find-bound-condition ('(fboundp functionp) byte-compile-unresolved-functions) bound-list ('(boundp default-boundp local-variable-p)) ((byte-compile-bound-variables (append bound-list byte-compile-bound-variables))) 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)))))] 8 (#$ . 122610)]))
(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 "\305A@!\210\211A@\306 \307\233\204U\310\203\311\202\312\"\210\313\314	#\313\315\"\316\n\"\317\320\321\322\323!\324\"\325$\216\316\"\316\f\"\305\3268\"\210,\266\327!\210\202\317\306 \310\311\"\210\313\314	#\313\315\"\316\n\"\317\320\321\322\323!\330\"\325$\216\316\"\316\f\"\305\3268\"\210,\266\310\331\"\210\327!\210\313\332D\314	#\313\332D\315\"\316\n\"\317\320\321\322\323!\333\"\325$\216\316\"\316\f\"\334AAA\"\210,\266\327!\266\266\335\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) append make-byte-code 0 "\300\211\205\211@\211\203\302	\236	\"A\266\202\202\207" vconcat vector [byte-compile-unresolved-functions delq] 5 2 byte-compile-out-tag [byte-compile-unresolved-functions delq] byte-goto not [byte-compile-unresolved-functions delq] byte-compile-body nil] 12 (#$ . 124056)])
#@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 (#$ . 125279)])
#@74 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 (#$ . 125460)])
#@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:\205&\211@\211:\205$\211@\211\302\267\202!A\211:\205\205\211@A\211:\205\203\211@A\211?\205\201A\211	\303\"\211@A\205{=\204U?\205{\262\304\"\262\211\235\204z\211B\262\211C\206t\305BB\262\306\266\203\266\204\262\266\202\266\202\262\202\"A\211:\205\211@A\211:\205\211@A\211?\205A\211	9\205=\204\276?\205\307!\205\205\310!\311!\205\262\304\312\236A\"\262\300\211\203\372\211@\"\204\363\211B\262A\266\202\202\340\210\211\203\313\"\262\211\237BB\262\210\306\262\266\204\262\266\202\266\202\262\202\"\300\262\262\262\2032A\262\202G\314V\205@\237F\207" [nil eq #s(hash-table size 6 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (equal 26 eql 26 eq 26 member 138 memql 138 memq 138)) byte-compile--cond-vars byte-compile--common-test (t) t macroexp-const-p eval proper-list-p ((memq . eq) (memql . eql) (member . equal)) append 1] 25 (#$ . 125698)])
#@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#\210A\266\202\202T\210\211\327	\"\210U\204\205TU\204\205\330\331!\210\323\324\"\210\fA\304\241\210)\266A\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 (#$ . 127188)])
#@16 

(fn CLAUSES)
(defalias 'byte-compile-cond #[257 "\306 \307\211A\262\203\262\205\310!\211\203$\311A\"\210\211@\262\202\256@\262@\312=\204>@\242\313=\203I@\243\242\203I\312B\262\307\262\202\252A\203\252\314@!\210A\204h\315	\203a\316\202b\317\"\210\202\252\306 \262\315\320\"\210\321@\322\n#\321@\323\"\324\"\325\326\327\330\331!\332\"\333$\216\324\f\"\324
\"\334A	\"\210,\266\315\335\"\210\336!\210A\262\210\202\211@A\203\324\211\312=\204\324\314!\210\315	\203\314\320\202\315\337\"\210A\262\321\322\n#\321\323\"\324\"\325\326\327\330\331!\340\"\333$\216\324\f\"\324
\"\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) append make-byte-code 0 "\300\211\205\211@\211\203\302	\236	\"A\266\202\202\207" vconcat vector [byte-compile-unresolved-functions delq] 5 byte-compile-body byte-goto byte-compile-out-tag byte-goto-if-nil-else-pop [byte-compile-unresolved-functions delq]] 13 (#$ . 128177)])
#@13 

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

(fn REST FAILTAG)
(defalias 'byte-compile-and-recursion #[514 "A\203E\305@!\210\306\203\307\202\310\"\210\311@\312	#\311@\313\"\314\n\"\315\316\317\320\321!\322\"\323$\216\314\"\314\f\"\324A\",\207@\305\"\210\325\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) append make-byte-code 0 "\300\211\205\211@\211\203\302	\236	\"A\266\202\202\207" vconcat vector [byte-compile-unresolved-functions delq] 5 byte-compile-and-recursion nil byte-compile-out-tag] 10 (#$ . 129874)])
#@13 

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

(fn REST WINTAG)
(defalias 'byte-compile-or-recursion #[514 "A\203I\305@!\210\306\203\307\202\310\"\210\311\312@D\313	#\311\312@D\314\"\315\n\"\316\317\320\321\322!\323\"\324$\216\315\"\315\f\"\325A\",\207@\305\"\210\326\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) append make-byte-code 0 "\300\211\205\211@\211\203\302	\236	\"A\266\202\202\207" vconcat vector [byte-compile-unresolved-functions delq] 5 byte-compile-or-recursion nil byte-compile-out-tag] 10 (#$ . 130921)])
#@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 (#$ . 131753)])
#@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 (#$ . 132130)])
#@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\202 \302\303!\210\207" [byte-compile-depth byte-compile-form byte-compile-push-constant nil] 5 (#$ . 132490)])
#@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 (#$ . 132844)])
#@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\302!\204\236	B\303\207	\236\203\"\304	\236	\"\202@@=\2030\305!\210\306\207\236A\307!\210\305!\266\303\207" [lexical-binding byte-compile--lexical-environment byte-compile-not-lexical-var-p nil remq byte-compile-dynamic-variable-bind t byte-compile-stack-ref] 5 (#$ . 133059)])
#@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\262A\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 (#$ . 133679)])
#@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\262A\266\202\202
\210	\211\2030\307!\2021\211\203a\211@\204B\306!B\262\211:\203L\211@\202M\211\310\"\203YA\262\210A\266\202\2021\210\nAA\311\"\210\304\211\266\n=\204\201\nT=\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 (#$ . 134461)])
(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 (#$ . 135447)])
#@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 (#$ . 135636)])
(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)
#@54 If nil, use new byte codes introduced in Emacs-24.4.
(defvar byte-compile--use-old-handlers nil (#$ . 136322))
#@13 

(fn FORM)
(defalias 'byte-compile-catch #[257 "\301A@!\210\204 \302 \303\304\"\210\305AA\306\"\210\307\310!\210\311!\207\211AA\312:\203f@\211\313=\203^A\211:\203V\211@A\211\204L\301\314\315E!\266\202Q!\210\266\202Z!\210\210\202b!\210\210\202j\211!\210\266\307\316\317\"\207" [byte-compile--use-old-handlers 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 #[257 "\301\302\303B\"!\207" [byte-compile--for-effect byte-compile-push-constant byte-compile-top-level progn] 5 "\n\n(fn BODY)"] :fun-body list 'funcall byte-catch 0] 12 (#$ . 136439)])
#@13 

(fn FORM)
(defalias 'byte-compile-unwind-protect #[257 "\211AA\302:\203P@\211\303=\203HA\211:\203@\211@A\211\2046\304\203/\305\211\306ED\2020!\266\202;!\210\266\202D!\210\210\202L!\210\210\202T\211!\210\266\307\310\311\"\210\211A@\304	\"\210\312\211\266\307\313\314\"\207" [byte-compile--use-old-handlers byte-compile--for-effect #[257 "\203\301\302\303\"!\207\304\305\306\307BBD!\207" [byte-compile--use-old-handlers byte-compile-push-constant byte-compile-top-level-body t byte-compile-form function lambda nil] 6 "\n\n(fn HANDLERS)"] :fun-body byte-compile-form list 'funcall byte-compile-out byte-unwind-protect 0 nil byte-unbind 1] 13 (#$ . 137124)])
#@13 

(fn FORM)
(defalias 'byte-compile-condition-case #[257 "\203\301!\207\302!\207" [byte-compile--use-old-handlers byte-compile-condition-case--old byte-compile-condition-case--new] 3 (#$ . 137825)])
#@13 

(fn FORM)
(defalias 'byte-compile-condition-case--old #[257 "\211A@C\211\242\302=\242\203\211\204\242B\202\303\304!\210\2429\204*\305\306\242\"\210\211\2034\307\310!\240\210\311\242!\210\211\203J\312\313\314\3158E!\210\202S\311\316\3158	\"!\210\317\320\321\322\323\324\"\325\"\326\327%AAA\"\203u\312\313B!\210\202y\311!\210\210\330\331\332\")\207" [byte-compile-bound-variables byte-compile--for-effect :fun-body byte-compile-set-symbol-position condition-case byte-compile-warn "`%s' is not a variable-name or nil (in condition-case)" make-symbol "err" byte-compile-push-constant byte-compile-form list 'funcall 2 byte-compile-top-level mapcar make-byte-code 257 "\211@\2119\204/\211<\203*\303\211\203#\211@\2119\204\304\262A\266\202\202\210\211\262\204/\305\306\"\210\301\203E\307\310D\307\311A@\310\300\242DFE\202L\211\312A\n\"B\207" vconcat vector [byte-compile--for-effect t nil byte-compile-warn "`%S' is not a condition name or list of such (in condition-case)" list quote 'funcall byte-compile-top-level-body] 9 "\n\n(fn CLAUSE)" byte-compile-out byte-condition-case 0] 11 (#$ . 138035)])
#@13 

(fn FORM)
(defalias 'byte-compile-condition-case--new #[257 "\211A@\3048\305\306\307\233\"\310 \311\312!\2109\204\313\314\"\210\315!\211\203c\211@\211A@\211:\2044\211C\262\211\211\203P\211@\211\203D\2119\204I\313\316\"\210A\266\202\2025\210\317!\266\320\321@\"\210A\266\202\202\"\210\322!\210\211\203z\211@\323\324!\210A\266\202\202i\210\320\325\"\210\203\356\211A\262\242	\nT\326\211A\262\242!\210\211\203\254\211@\323\324!\210A\266\202\202\233\210\204\267\327 \210\202\312\203\305SB\nB\202\312\330!\210\331A!\210\203\344\203\337\327\332\333\"\210\202\344\323\334\332\"\210\320\325\"\210*\210\202\200\326!\207" [byte-compile-depth byte-compile-bound-variables byte-compile--lexical-environment lexical-binding 2 mapcar #[257 "\300 B\207" [byte-compile-make-tag] 3 "\n\n(fn CLAUSE)"] 3 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 byte-compile-out byte-pophandler byte-goto byte-compile-out-tag byte-compile-discard byte-compile-dynamic-variable-bind byte-compile-body 1 preserve-tos byte-unbind] 14 (#$ . 139190)])
#@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 (#$ . 140524)])
#@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 (#$ . 140971)])
#@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 (#$ . 141228)])
(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 (#$ . 141790)])
(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\211@A@\3138\3148\315!\210G\316V\204D\317=\203gAA\204gAG\311\320\211\321U\203V\322\202W\323\313W\203a\324\202b\325\326&\266B\317=\203u	B\211\203\205\211;\204\205\311\327$\210AA\203\243\330\331\332\nC\n\314\f\233BBBEDE\202\265\317=\203\262\333\331DD\202\265\331D\334\"\210\335\211\262\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" 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 (#$ . 142055)])
#@13 

(fn FORM)
(defalias 'byte-compile-autoload #[257 "\300\301!\210\302A@!\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 (#$ . 143010)])
#@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 (#$ . 143465)])
(put 'defalias 'byte-hunk-handler 'byte-compile-file-form-defalias)
#@13 

(fn FORM)
(defalias 'byte-compile-file-form-defalias #[257 "\302\211\211:\203\331\211A\211:\203\321\211@\211:\203\311\211@\211\303=\203\301A\211:\203\271\211@A\211\204\260A\211:\203\247\211@A\211\304:\203\225@\211\305\267\202\206A\211:\203\211@\211:\203\370\211@\211\303=\203\350A\211:\203\330\211@\211\306=\203\307A\211\204\266A\211:\203\245\211@A\211\204\224\n\307%\202\240\n\302%\266\202\202\261
\f\302%\262\202\302\f\302%\262\202\323\n\302
%\262\202\343\n	\302\f%\262\202\363	\302%\262\202\302\n%\262\202\302	%\262\202\220A\211:\203v\211@\211:\203f\211@\211\306=\203VAA\211\204E\n\307%\202Q\n\302
%\266\202\202a	\302%\262\202q\302\n%\262\202\201\302	%\262\202\220\302%\262\202\236\211\302%\262\266\203\266\202\202\253\310!\262\202\264\310!\266\202\202\274\310!\262\202\304\310!\262\202\314\310!\262\202\324\310!\262\202\334\310!*\207" [byte-compile-free-assignments byte-compile-free-references nil quote #[1285 "\300:\203h@\211\301>\203UA\211:\203B\211@A\211\204/\n\n\n\n\n&\202=\n\n\n\n\n\302&\266\202\202P\302&\262\202c\302&\262\202v\211\302&\207" [#[1542 "\300\301\302\303\304\n\n\n\n\n%\305\"\306\307%:\203c@\211\310\267\202ZA\211:\2036\211@A\"\266\202\202:\311\211\"\262\202^A\211:\203Q\211@\311\"\262\202U\311\211\"\262\202^\311\211\"\262\202g\211\311\211\"\207" [make-byte-code 514 "\306\302\303\301%?\205+\303\203(\304\204\307\310\302\"\210\202(\307\311\302\"\210\302\312\304!B
B\313\300!\207" vconcat vector [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 BODY ARGLIST)" #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (lambda 34 internal-make-closure 63)) t] 16 "\n\n(fn FORM REST NAME MACRO FUN LAM)"] #'quote nil] 17 "\n\n(fn FORM REST NAME MACRO FUN)"] #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (cons 75 quote 280)) macro t byte-compile-keep-pending] 30 (#$ . 143732)])
(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 (#$ . 146153)])
(put 'internal--with-suppressed-warnings 'byte-compile 'byte-compile-suppressed-warnings)
#@13 

(fn FORM)
(defalias 'byte-compile-suppressed-warnings #[257 "\301A@A@\"\302\303AA!!)\207" [byte-compile--suppressed-warnings append byte-compile-form macroexp-progn] 4 (#$ . 146398)])
(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 (#$ . 146683)])
(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 (#$ . 147090)])
(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\341\211@A\211:\203\335\211@A\211:\203\325\211@A\211:\203\314\211@A\211\204x\301!\205s\301!\205s\301!\206s:\205s@\211\302=\205qA\211:\205o\211@\211:\205m\211@\211\303=\205kA\211?\205i\304\262\262\262\262\262\266\203\204\305	!\202\307\n\306!\210\307!\210\307!\210\310!\310!\301!\203\245\310!\202\253\311A@!\312\"BBBB\306!\210\313\314\315\"\210\316\266\203\266\204\266\202\202\320\305!\266\202\202\330\305!\266\202\202\340\305!\207\305!\207" [overriding-plist-environment macroexp-const-p function lambda t byte-compile-keep-pending byte-compile-push-constant byte-compile-form eval byte-compile-lambda alist-get byte-compile-out byte-call 3 nil] 22 (#$ . 147406)])
(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 (#$ . 148310)])
#@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 (#$ . 148560)])
#@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\302Z\207" [byte-stack+-info (byte-call byte-discardN byte-discardN-preserve-tos) 1] 4 (#$ . 148781)])
#@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 (#$ . 149098)])
#@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\203G@\3038>\206Q\211AA@\3038B\240\202Q	\302@CEB\211\207" [byte-compile-call-tree byte-compile-current-form nil 2] 6 (#$ . 149355)])
#@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\370B\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@GA@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 (#$ . 149655) 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 (#$ . 153152)])
#@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\262A\266\202\202 \266\202\214\203\202@\315!\316!?\206}\317\"\266\202\203\214\320@!\204\214\321\262A\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 (#$ . 153418)])
#@13 

(fn FILE)
(defalias 'batch-byte-compile-file #[257 "\206	\n\203\303!\202d\3041K\3051 \303!00\202d0\306A\203+\307\202,\310@\311N\312A!$\210\313!\314!\203D\315!\210\210\316\262\202d\306A\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 (#$ . 154845)])
#@81 Reload any Lisp file that was changed since Emacs was dumped.
Use with caution.
(defalias 'byte-compile-refresh-preloaded #[0 "@\302!\211\203\303!\204\304\305\"\202i\306	!\211\205g\211@\211@\262\307\310\"\2031\311\312\313#\262\314!\203`\315\"\203`\316!\317\235\204`\304\320\316!\"\210\3211[\322\323\324\325$0\202_\210\202`\210A\266\202\202\262\207" [command-line-args load-history executable-find file-executable-p message "Can't find %s to refresh preloaded Lisp files" reverse string-match "elc\\'" substring 0 -1 file-readable-p file-newer-than-file-p file-name-nondirectory ("pcase.el" "bytecomp.el" "macroexp.el" "cconv.el" "byte-opt.el") "Reloading stale %s" (error) load noerror nil nosuffix] 9 (#$ . 155402)])
#@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 (#$ . 156158)])
(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])
(run-hooks 'bytecomp-load-hook)

Zerion Mini Shell 1.0