;ELC
;;; Compiled by mockbuild@buildfarm06-new.corp.cloudlinux.com on Fri Oct 11 10:05:23 2024
;;; from file /builddir/build/BUILD/emacs-24.3/lisp/emacs-lisp/bytecomp.el
;;; in Emacs version 24.3
;;; 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!\204\306\307!\210\310\311\312\313\314\315%\210\316\317\320\321\322DD\323\314\311\324\325&\210\316\326\320\321\327DD\330\314\311\324\331\332\333&	\207" [require backquote macroexp cconv fboundp defsubst load "byte-run" custom-declare-group bytecomp nil "Emacs Lisp byte-compiler." :group lisp custom-declare-variable emacs-lisp-file-regexp funcall function #[0 "\300\207" ["\\.el\\'"] 1 "\\.el\\'\n\n(fn)"] "Regexp which matches Emacs Lisp source files.\nIf you change this, you might want to set `byte-compile-dest-file-function'." :type regexp byte-compile-dest-file-function #[0 "\300\207" [nil] 1 "\n\n(fn)"] "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." (choice (const nil) function) :version "23.2"] 10)
(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 "\n\n(fn FILENAME)"])
(byte-code "\300\301!\204\302\301\303\"\210\304\305\306\"\210\304\307\306\"\210\304\310\306\"\210\304\311\306\"\210\304\312\306\"\210\313\314\315\316\317DD\320\321\322\323\324&\210\313\325\315\316\326DD\327\321\322\323\330&\210\313\331\315\316\332DD\333\321\322\323\324&\207" [fboundp byte-compile-dest-file defalias #[257 "\203
!\207\302\303!!\262
\304	\"\203\211\305\211\224O\306P\207\211\306P\207" [byte-compile-dest-file-function emacs-lisp-file-regexp file-name-sans-versions byte-compiler-base-file-name string-match 0 ".elc"] 4 "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'),\nadds `c' to it; otherwise 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 "\n\n(fn)"] "Non-nil means print messages describing progress of byte-compiler." :group bytecomp :type boolean byte-optimize #[0 "\300\207" [t] 1 "\n\n(fn)"] "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 "\n\n(fn)"] "If non-nil, the optimizer may delete forms that may signal an error.\nThis includes variable references and calls to functions such as `car'."] 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 (#$ . 3475))
#@70 If non-nil, disable `print-circle' on printing a byte-compiled code.
(defvar byte-compile-disable-print-circle nil (#$ . 3988))
(byte-code "\300\301\302\303#\210\304\305\306\307\310DD\311\312\313\314\315&\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 "\n\n(fn)"] "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." :group bytecomp :type boolean] 8)
#@41 Name of the byte-compiler's log buffer.
(defconst byte-compile-log-buffer "*Compile-Log*" (#$ . 5058))
(byte-code "\300\301\302\303\304DD\305\306\307\310\311&\210\300\312\302\303\313DD\314\306\307\310\315&\207" [custom-declare-variable byte-optimize-log funcall function #[0 "\300\207" [nil] 1 "\n\n(fn)"] "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'." :group bytecomp :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 "\n\n(fn)"] "If true, the byte-compiler reports warnings with `error'." boolean] 8)
#@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) (#$ . 5907))
(byte-code "\301\302\303\304\305DD\306\307\310\311\312\313\314\315\316\317\320\"BBBE&\210\321\302\322\323#\207" [byte-compile-warning-types custom-declare-variable byte-compile-warnings funcall function #[0 "\300\207" [t] 1 "\n\n(fn)"] "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 from the CL package (as\n		  distinguished from macros and aliases).\n  interactive-only\n	      commands that normally shouldn't be called from Lisp code.\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." :group bytecomp :type choice (const :tag "All" t) set :menu-tag "Some" mapcar #[257 "\300
D\207" [const] 3 "\n\n(fn X)"] put 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)"]] 15)
#@91 Return non-nil if WARNING is enabled, according to `byte-compile-warnings'.

(fn WARNING)
(defalias 'byte-compile-warning-enabled-p #[257 "\301=\206@\302=\203\211>?\207\211>\207" [byte-compile-warnings t not] 3 (#$ . 7915)])
#@311 Change `byte-compile-warnings' to disable WARNING.
If `byte-compile-warnings' is t, set it to `(not WARNING)'.
Otherwise, if the first element is `not', add WARNING, else remove it.
Normally you should let-bind `byte-compile-warnings' before calling this,
else the global value will be modified.

(fn WARNING)
(defalias 'byte-compile-disable-warning #[257 "\301=\203\f\302
D\202)@\302=\203%\211>\203\202)\303C\"\202)\304
\"\211\207" [byte-compile-warnings t not append delq] 4 (#$ . 8155)])
#@298 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 (#$ . 8668)])
#@61 List of commands that are not meant to be called from Lisp.
(defvar byte-compile-interactive-only-functions '(beginning-of-buffer end-of-buffer replace-string replace-regexp insert-file insert-buffer insert-file-literally previous-line next-line goto-line comint-run delete-backward-char) (#$ . 9153))
#@59 List of variables that shouldn't be reported as obsolete.
(defvar byte-compile-not-obsolete-vars nil (#$ . 9461))
#@66 Global list of variables that shouldn't be reported as obsolete.
(defvar byte-compile-global-not-obsolete-vars nil (#$ . 9581))
#@59 List of functions that shouldn't be reported as obsolete.
(defvar byte-compile-not-obsolete-funcs nil (#$ . 9715))
(byte-code "\300\301\302\303\304DD\305\306\307\310\311&\207" [custom-declare-variable byte-compile-generate-call-tree funcall function #[0 "\300\207" [nil] 1 "\n\n(fn)"] "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 display\nthe graph.\n\nThe call tree only lists functions called, not macros used. Those functions\nwhich the byte-code interpreter knows about directly (eq, cons, etc.) are\nnot reported.\n\nThe call tree also lists those functions which are not known to be called\n(that is, to which no calls have been compiled).  Functions which can be\ninvoked interactively are excluded from this list." :group bytecomp :type (choice (const :tag "Yes" t) (const :tag "No" nil) (other :tag "Ask" lambda))] 8)
#@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 (#$ . 10767))
(byte-code "\300\301\302\303\304DD\305\306\307\310\311&\207" [custom-declare-variable byte-compile-call-tree-sort funcall function #[0 "\300\207" [name] 1 "\n\n(fn)"] "If non-nil, sort the call tree.\nThe values `name', `callers', `calls', `calls+callers'\nspecify different fields to sort on." :group bytecomp :type (choice (const name) (const callers) (const calls) (const calls+callers) (const nil))] 8)
(defvar byte-compile-debug nil)
#@68 List of all constants encountered during compilation of this form.
(defvar byte-compile-constants nil (#$ . 11502))
#@68 List of all variables encountered during compilation of this form.
(defvar byte-compile-variables nil (#$ . 11624))
#@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 (#$ . 11747))
#@74 List of variables declared as constants during compilation of this file.
(defvar byte-compile-const-variables nil (#$ . 11913))
#@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 '((declare-function . byte-compile-macroexpand-declare-function) (eval-when-compile lambda (&rest body) (list 'quote (byte-compile-eval (byte-compile-top-level (byte-compile-preprocess (cons 'progn body)))))) (eval-and-compile lambda (&rest body) (byte-compile-eval-before-compile (cons 'progn body)) (cons 'progn body))) (#$ . 12048))
#@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 (#$ . 12644))
#@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 (#$ . 12911))
#@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 (#$ . 13377))
#@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 (#$ . 13679))
#@34 The current lexical environment.
(defvar byte-compile--lexical-environment nil (#$ . 13970))
(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 (#$ . 14104))
#@35 Current depth of execution stack.
(defvar byte-compile-depth 0 (#$ . 14242))
#@35 Maximum depth of execution stack.
(defvar byte-compile-maxdepth 0 (#$ . 14325))
#@66 An array containing byte-code names indexed by byte-code values.
(defvar byte-code-vector nil (#$ . 14411))
#@56 An array with the stack adjustment for each byte-code.
(defvar byte-stack+-info nil (#$ . 14525))
(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 "\n\n(fn OPCODE STACK-ADJUST OPNAME &optional DOCSTRING)"]))
(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 "\n\n(fn)"]))
#@39 Byte code opcode for stack reference.
(defconst byte-stack-ref 0 (#$ . 15228))
#@42 Byte code opcode for variable reference.
(defconst byte-varref 8 (#$ . 15313))
#@42 Byte code opcode for setting a variable.
(defconst byte-varset 16 (#$ . 15398))
#@42 Byte code opcode for binding a variable.
(defconst byte-varbind 24 (#$ . 15484))
#@42 Byte code opcode for calling a function.
(defconst byte-call 32 (#$ . 15571))
#@50 Byte code opcode for unbinding special bindings.
(defconst byte-unbind 40 (#$ . 15655))
(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 (#$ . 17260))
(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 (#$ . 17841))
#@42 Byte code opcode for unconditional jump.
(defconst byte-goto 130 (#$ . 17977))
#@53 Byte code opcode to pop value and jump if it's nil.
(defconst byte-goto-if-nil 131 (#$ . 18062))
#@57 Byte code opcode to pop value and jump if it's not nil.
(defconst byte-goto-if-not-nil 132 (#$ . 18165))
#@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 (#$ . 18276))
#@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 (#$ . 18432))
#@65 Byte code opcode to pop a value and return it from `byte-code'.
(defconst byte-return 135 (#$ . 18595))
#@51 Byte code opcode to discard one value from stack.
(defconst byte-discard 136 (#$ . 18705))
#@53 Byte code opcode to duplicate the top of the stack.
(defconst byte-dup 137 (#$ . 18802))
#@74 Byte code opcode to make a binding to record the buffer, point and mark.
(defconst byte-save-excursion 138 (#$ . 18897))
#@75 Byte code opcode to make a binding to record entire window configuration.
(defconst byte-save-window-excursion-OBSOLETE 139 (#$ . 19024))
#@88 Byte code opcode to make a binding to record the current buffer clipping restrictions.
(defconst byte-save-restriction 140 (#$ . 19168))
#@87 Byte code opcode for catch.  Takes, on stack, the tag and an expression for the body.
(defconst byte-catch 141 (#$ . 19311))
#@93 Byte code opcode for unwind-protect.  Takes, on stack, an expression for the unwind-action.
(defconst byte-unwind-protect 142 (#$ . 19442))
(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)
#@47 Byte code opcode for reference to a constant.
(defconst byte-constant 192 (#$ . 20595))
#@63 Exclusive maximum index usable in the `byte-constant' opcode.
(defconst byte-constant-limit 64 (#$ . 20689))
#@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) (#$ . 20804))
(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 nil nil nil 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 nil 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 nil nil nil 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 nil 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)
#@231 Push BYTE... onto BYTES, and increment PC by the number of bytes pushed.
ARGS is of the form (BYTE... BYTES PC), where BYTES and PC are variable names.
BYTES and PC are updated after evaluating all the arguments.

(fn &rest ARGS)
(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 (#$ . 24334)]))
#@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) lsh (-8)] 10 (#$ . 24849)]))
#@67 Turns lapcode into bytecode.  The lapcode is destroyed.

(fn LAP)
(defalias 'byte-compile-lapcode #[257 "\306\307\211\211\211\211\211\203\356
\211@\211@\262\211A\2629\204%\310\311\"\210\202\347
\312=\2034\240\210\202\347
\313=\203?\202BJ\262	>\203cA\307E\244\262\314\\\262B\262\202\347
:\203sA\262\303=\204\303=\203\275\250\203\275\nW\203\244\306\\X\204\224\315\316\317C\"\210\\B\262T\262\202\347
\320\321\"\322\323\"\fE\244\262\314\\\262\202\347

U\203\343\323V\203\343\320\321\"\322\323\"\"E\244\262\314\\\262\202\347
#Y\203
W\203
D\244\262\324\\\262\202\347
U\203I
\313=\203
\325\202
\306\326V\2033
\327
\326\"D\244\262\324	\\\262	\326Z\262\202
\327\"D\244\262\324	\\\262	\210\202\347
\204f
\306X\204Y
\315\316\330C\"\210B\262T\262\202\347
$=\203\221
\306=\203\221
\331 \210\306%X\204\203
\315\316\332C\"\210%B\262T\262\202\347
\333W\203\266
\306\\X\204\246
\315\316\334C\"\210\\B\262T\262\202\347
\335W\203\316
\333\\D\244\262\324\\\262\202\347
\320\321\"\322\323\"\336\\E\244\262\314\\\262
A\266\202\202\210\211\211\203\"\211@\211&\211@@)\262\211A\322	\323\"\240\210\211\320	\321\"\240\210\211@\323V\203\310\337!\210
A\266\202\202\360
\210\340\341\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 signal cl-assertion-failed (<= 0 (+ byte-constant off)) lsh -8 logand 255 2 128 127 logior (<= 0 opcode) debug (<= 0 byte-dup) 6 (<= 0 (+ opcode off)) 256 7 "Bytecode overflow" apply unibyte-string byte-stack-set2 byte-listN byte-stack-ref byte-dup x] 13 (#$ . 25173)])
#@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 (#$ . 26962)])
#@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\256	
\203v
=\204v
\211A\262@\310\311@\"\204q\306\312!\2035\313@!\204q
\211\203p\211@\211:\203Q\211@\314=\203Q\211AB\262\202i\211:\203i\211@\315>\203i\211A>\204i\211AB
A\266\202\2026\210\266\202\310
\203\254
=\204\254
\211A\262@\2119\203\226\211>\204\226\211B\211:\203\250\211@\314=\203\250\211AB\262\210\202w\266\306\312!\203\326\f\204\325\211\203\325\211=\204\325\313
\211A\262@@!\203\265\316 \210\202\265\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 cl-functions byte-compile-cl-file-p t (autoload defun) byte-compile-find-cl-functions] 12 (#$ . 27167)])
#@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 (#$ . 28105)])
(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)
(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 mapcar #[257 "\2119\203	\300
D\207\207" [prin1-to-string] 3 "\n\n(fn X)"]] 13 "\n\n(fn FORMAT-STRING &rest ARGS)"]))
(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 "\n\n(fn STRING)"])
#@51 Character position we began the last `read' from.
(defvar byte-compile-read-position nil (#$ . 29225))
#@45 Last known character position in the input.
(defvar byte-compile-last-position nil (#$ . 29334))
(defalias 'byte-compile-delete-first #[514 "\211@=\203\n\211A\207\211
A\203\"
\211A@)=\204\"
A\262\202
A\2030
\211\211AA)\241\210\211\207" [x] 6 "\n\n(fn ELT LIST)"])
(put 'byte-compile-delete-first 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'byte-compile-set-symbol-position #[513 "\205e\304\211	\262\n\236\262
\211\203P
A\\\211\n\211@=\203'\211A\266\202\202O\211
A\203?
\211A@)=\204?
A\262\202(
A\203M
\211\211AA)\241\210\266\202\203Z
	U\203
	V\205c\202\266\202\207" [byte-compile-read-position byte-compile-last-position read-symbol-positions-list x nil] 9 "\n\n(fn SYM &optional ALLOW-PREVIOUS)"])
(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 (#$ . 30174))
(defalias 'byte-compile-abbreviate-file #[513 "\300!\301\"\211GGW\203\211\202
\207" [abbreviate-file-name file-relative-name] 6 "\n\n(fn FILE &optional DIR)"])
(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 "\n\n(fn LEVEL ENTRY)"])
(defalias 'byte-compile-warning-series #[128 "\300\207" [nil] 2 "\n\n(fn &rest IGNORE)"])
(defalias 'byte-compile-log-file #[0 "	\232?\205\206\n?\205\206r\306!q\210db\210\307\205\310!

\232\311\2030
\2040\312\313
\"c\210n\2047\314c\210\315 \262
\203Z\316;\203K\317P\202P\320\321!P\322\323 \314\261\210\202a\324\323 \314\261\210\203q
\204q\312\325
\"c\210\311\326\327!\204\327 \210\330 \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 "Leaving directory `%s'\n" "\n" point-marker "\f\nCompiling " "file " "buffer " buffer-name " at " current-time-string "\f\nCompiling no file at " "Entering directory `%s'\n" derived-mode-p compilation-mode compilation-forget-errors byte-compile-last-warned-form] 8 "\n\n(fn)"])
(defalias 'byte-compile-log-warning #[769 "\305\306\205\307\310\311\312\f$,\207" [inhibit-read-only warning-fill-prefix warning-type-format warning-prefix-function byte-compile-log-buffer byte-compile-warning-prefix "" "    " t display-warning bytecomp] 8 "\n\n(fn STRING &optional FILL LEVEL)"])
#@97 Issue a byte compiler warning; use (format 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 error "%s" byte-compile-log-warning t :warning] 6 (#$ . 32532)])
#@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 (#$ . 32834)])
#@83 Report Lisp error in compilation.  ERROR-INFO is the error data.

(fn ERROR-INFO)
(defalias 'byte-compile-report-error #[257 "\301\302\303!\304\305#\207" [byte-compiler-error-flag t byte-compile-log-warning error-message-string nil :error] 5 (#$ . 33264)])
(defalias 'byte-compile-fdefinition #[514 "\211\203\202		
\236A\211\206\241\2119\203;\303
!\203;\211K9\2044\211K:\2044\204;\304
K!\203;\211K\262
\202\305
9\203L\303!\203L
K\202M
\n\306#\211<\203f\203`\307\310E\202\235\310
D\202\235\204t\304!\203t
\202\235
:\204}\311\202\235
@\307=\203\211
A\202\235\203\221\311\202\235
@\312=\203\234\311\202\235
\262
\262
\207" [byte-compile-macro-environment byte-compile-function-environment advertised-signature-table fboundp byte-code-function-p gethash t macro lambda nil autoload] 9 "\n\n(fn NAME MACRO-P)"])
(defalias 'byte-compile-arglist-signature #[257 "\211\250\203\300
\301\"\302\300\303\"!\205\304\305\"B\207\211<\203s\306\307\211\203`@\310=\2035
\204Y\306\262\202Y@\311=\203JA\203Y\312\262
\307\262\202Y
\203U
T\262\202YT\262A\262\202 
?\205q\203p\\\202qB\207\313\207" [logand 127 zerop 128 lsh -8 0 nil &optional &rest t (0)] 7 "\n\n(fn ARGLIST)"])
(defalias 'byte-compile-arglist-signatures-congruent-p #[514 "\211@@V\206!
A\204\211A\206!\211A\205!
A\205!\211AAW?\207" [] 4 "\n\n(fn OLD NEW)"])
(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 "\n\n(fn SIGNATURE)"])
(defalias 'byte-compile-callargs-warn #[257 "\303
@\304\"\206
\303
@\305\"\211\203I\211\305=\204I\211\242\306=\203*\211\243\242\307=\203*\211A\262
\310
\242\311>\2038
A@\202E\312!\203D
\313H\202E\314!\202]\315@!\205]\316@K!\205]\317@K!AG
\243\203o
A\247\204o
\304\241\210
\203\257\211@W\204\206
A\203\257\211AV\203\257\320@!\210\321\322@\211\323U\203\232\324\202\233\325@W\203\247\326\202\250\327\330!&\210\331!\210\204\276\315@!\203\306@>?\206\362@	=\206\362@\n\236AG
\203\350\211A>\206\360

AB\241\202\360@
D\nB\211\266\202\207" [byte-compile-noruntime-functions byte-compile-current-form byte-compile-unresolved-functions byte-compile-fdefinition nil t macro lambda byte-compile-arglist-signature (declared lambda) byte-code-function-p 0 (&rest def) fboundp 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] 12 "\n\n(fn FORM)"])
#@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\205g\211A@;\205g\211@\300N\205g\301\302!r\211q\210\303\304\305\306\307\310!\311\"\312\313%DC\216
A@c\210eb\210\305\314\315\316\317#\203M\305\224Tf\320=\2045\211T\262
\2025\211\262
*\262

G\312Z\211U?\205e\321\322@$\266\202\207" [byte-compile-format-like generate-new-buffer " *temp*" funcall make-byte-code 0 "\301\300!\205	\302\300!\207" vconcat vector [buffer-name kill-buffer] 2 "\n\n(fn)" re-search-forward "%." nil t 37 byte-compile-warn "`%s' called with %d args to fill %d format field(s)"] 9 (#$ . 35893)])
(byte-code "\300\211\203\211@\301
\302\303#\210
A\266\202\202
\207" [(format message error) put byte-compile-format-like t] 6)
(defalias 'byte-compile-nogroup-warn #[257 "\211@\303>\205?\205i\211AAAA
\211A@)\211\242\304=\203M@\305=\203+\211\306\232\204M\307\310\"\204M\211:\203M\211@\304=\203M\311\312@\313\236A\211A@)#\210\n\205g@\305=\205g\211\242\304=\205g\211\211A@)\211\266\202\207" [byte-compile-current-group x byte-compile-current-file (custom-declare-face custom-declare-variable) quote custom-declare-group 'emacs plist-get :group byte-compile-warn "%s for `%s' fails to specify containing group" ((custom-declare-group . defgroup) (custom-declare-face . defface) (custom-declare-variable . defcustom))] 8 "\n\n(fn FORM)"])
(defalias 'byte-compile-arglist-warn #[771 "\302\"
\205\f\236A\211\203\2119\203\302
\303\"\262
\203\330
\304=\204\330
\242\305=\2038
\243\242\306=\2038
A\262\307\310:\203\216@A
\306=\203^\211:\203Y\211@\211\211\262
\262
\202\211 \202\211
\311=\204i \202\211\211:\203\207\211A\211:\203\200\211@\211\211\262
\262
\202\202 \262
\202\211 \266\202\202\234\312!\203\232\313H\202\234\211 \262
!\307!\314\"?\205\323\315!\210\316\317\203\272\320\202\273\321	\322!\323\232\203\314\324\202\315\325\322!&\266\202\202O
	\236\303\211\211\211\205M
	9\203\371\326\n\327\"\330=\203\371\316\331\"\210\307	!\262\332\333A!\334\"\262@\262\237@\262

@W\204%
A\203G
\211AV\203G
\315\n!\210\316\335\322!\336\232\203=
\337\202>
\340\322B!%\210\341	\"\211\266\205\207" [byte-compile-initial-macro-environment byte-compile-unresolved-functions byte-compile-fdefinition nil t macro lambda byte-compile-arglist-signature #[0 "\300\207" [(&rest def)] 1 "\n\n(fn)"] closure byte-code-function-p 0 byte-compile-arglist-signatures-congruent-p byte-compile-set-symbol-position byte-compile-warn "%s %s used to take %s %s, now takes %s" "macro" "function" byte-compile-arglist-signature-string (1 . 1) "argument" "arguments" function-get byte-optimizer byte-compile-inline-expand "defsubst `%s' was used before it was defined" sort copy-sequence < "%s being defined to take %s%s, but was previously called with %s" (1 . 1) " arg" " args" delq] 18 "\n\n(fn NAME ARGLIST MACROP)"])
#@34 List of functions defined in CL.
(defvar byte-compile-cl-functions nil (#$ . 39031))
(defalias 'byte-compile-find-cl-functions #[0 "?\2058	\211\2056\211@\302
@!\203/\211A\211\203.\211@\211\242\303>\203'\211AB
A\266\202\202\210
A\266\202\202\262
\207" [byte-compile-cl-functions load-history byte-compile-cl-file-p (autoload defun)] 6 "\n\n(fn)"])
#@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-macroexpand-all cl--compiling-file) byte-compile-warn "function `%s' from cl package called at runtime"] 5 (#$ . 39396)])
(defalias 'byte-compile-print-syms #[771 "\211\203\n\302
@\303\"\210\211A\203]\204]
\211G\304\203X\305\211A\262@!\262
\306G\307#\262
	SW\203C\310\205=\311R\262\202\312\205L\311R\262\211G\313\\\262\202\314\315\"\207\211A\203l\314\316\317\305\320##\207\211\205u\314@\"\207" [noninteractive fill-column byte-compile-set-symbol-position t nil symbol-name + 2 " " "," "\n    " 4 byte-compile-warn "%s" "%s %s" mapconcat ", "] 10 "\n\n(fn STR1 STRN SYMS)"])
(defalias 'byte-compile-warn-about-unresolved-functions #[0 "\302\303!\203C\304\305\211\305\262	\211\2033\211@\211@\262
\306
!\203'\211B\262\202,\211B\262
A\266\202\202\210\307\310\311#\210\307\312\313#\210)\266\305\207" [byte-compile-current-form byte-compile-unresolved-functions 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 "\n\n(fn)"])
(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) (byte-compile-function-environment nil) (byte-compile-bound-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 "\n\n(fn &rest BODY)"]))
(put 'byte-compile-close-variables 'edebug-form-spec t)
(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 "\n\n(fn &rest BODY)"]))
(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 (#$ . 42785) "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
@\203
\306@!\240\210\204\307 \210\310 \210r\311	!q\210\312
@!\313=\204.\313 \210\nCC\n\314C\314C\314C\314C\315C\315\262\316\314\317\320\321\f




&	\322\"\323\324%\325\f!\205l\326\f!\327	!=\330 \210\f\331=\204y\211\203\257\315\332 \262

\204\210\211\206\207\331
\203\222 \210\202\253\333\334\316\314\335\320\321	!\336\"\337\324%D\340\334\341\333EDC\217\210\210\202\332\332 \206\265\331
\203\300
 \210\202\331\342\334\316\314\335\320\321!\336\"\337\324%D\340\334\343\342EDC\217\210)\266\344\345@@\337U\203\353\346\202\354\347@\314V\203\375\350\351	@\"\202\376\346	@\314V\203
\350\352@\"\202
\346@\337V\203!
\350\353	@\"\202\"
\346&)\266\207)\207" [noninteractive byte-compile-log-buffer default-directory major-mode warning-series byte-compile-debug prefix-numeric-value save-some-buffers force-mode-line-update get-buffer-create expand-file-name compilation-mode 0 nil make-byte-code "\303@\205\322\300\303@@\240\210\311\312\300@\"\210\313\300@!\211\203\310\211@\314
\300@\"
\315\235\204Z
\316H\317=\204Z\320
!\203Z\321
!\204Z\301@\203O\301@\316=\204O\322\323\324Q!\203\300\303\211@C\244\240\210\202\300\325\"\203\300\326
!\203\300\327
!\204\300\330!\230\204\300\331
\302\301@#\211\332=\203\214\304\211@T\240\210\202\241\211\333=\203\233\306\211@T\240\210\202\241\305\211@T\240\210\210\204\255\311\312\300@\"\210\310@\300@=\204\300\310\300@\240\210\307\211@T\240\210\210
A\266\202\202\210\303\211@A\240\210\202\207" vconcat vector [message "Checking %s..." directory-files expand-file-name ("RCS" "CVS") 0 46 file-directory-p file-symlink-p y-or-n-p "Check " "? " string-match file-readable-p auto-save-file-name-p file-name-nondirectory byte-recompile-file no-byte-compile t emacs-lisp-file-regexp dir-locals-file noninteractive] 7 "\n\n(fn)" markerp marker-buffer get-buffer byte-compile-find-cl-functions byte-compile-warning-series byte-compile-log-file #1=#:err funcall "\300 \207" [] 1 error #[257 "\300
!\207" [byte-compile-report-error] 3 "\n\n(fn ERROR-INFO)"] #2=#:err #[257 "\300
!\207" [byte-compile-report-error] 3 "\n\n(fn ERROR-INFO)"] message "Done (Total of %d file%s compiled%s%s%s)" "" "s" format ", %d failed" ", %d skipped" " in %d directories"] 26 (#$ . 43084) "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 (#$ . 46131))
#@812 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 (#$ . 46361) (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)])
#@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\316C\316\211\211\316\262\316\262\316\262\302	!\240\210@r\320\321!\211\262q\210\322 \210\316@\323\317!\210\324!\210A\325=\204x\326A!\327=\203|\323\316!\210\330\331!\332\316BC
D\316\262\333\334\335\336\337\340!\341\"\342\343%DC\216\344\331\345\"\210\346\317!\210)\316ED\262\n+\266\347\350!\204\277\351\350!\210\316(\352!F)r
q\2100)\203

\353@!\203\375\354\355\356@!\357\360\"#\210\361\333\334\335\362\337\340	!\363\"\364\343%D\365\333\366\361EDC\217\210\360\202\327
G\203\f
\354\367	\"\210\316Hr\370!)\262
H?\205\327
G\203'
\354\371	\"\210\372!\210r\211q\210db\210\373c\210\374@!\203\204
\325I\375@!\334\335\376\337\340!\377\"\201N\343%JBJK\201O>\203b
\317L\201Ped\316\201Q%\210\201R
@\317#\210\354\201S@\"\210*\210\202\244
\201T\201U\201V\353@!\203\233
\201W\202\236
\201X@E\"\210\372p!\210)M\203\312
M\317=\204\301
\311\312\201Y\n\"!\203\312
\212\201Z!\210)\203\326
\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*" erase-buffer set-buffer-multibyte insert-file-contents no-conversion coding-system-type 5 default-value major-mode :safe funcall make-byte-code 0 "\301\302\300\"\207" vconcat vector [set-default major-mode] 3 "\n\n(fn)" set-default emacs-lisp-mode normal-mode local-variable-p lexical-binding make-local-variable 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 #1=#:err "\301\300@!\207" [delete-file] 2 error #[257 "\300\207" [nil] 2 "\n\n(fn IGNORED)"] "Compiling %s..." byte-compile-from-buffer "Compiling %s...done" kill-buffer "\n" file-writable-p make-temp-name "\301\302\303\304\305\306\307\300!\310\"\311\312%D\313\302\314\301EDC\217\207" [#2=#:err funcall make-byte-code 0 "\301\300!\207" vconcat vector [delete-file] 2 "\n\n(fn)" error #[257 "\300\207" [nil] 2 "\n\n(fn IGNORED)"]] 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 system-type buffer-file-type byte-compile-generate-call-tree 8 (ms-dos 'windows-nt) write-region 1 rename-file "Wrote %s" signal file-error "Opening output file" "cannot overwrite file" "directory not writable or nonexistent" "Report call tree for %s? " display-call-tree load] 17 (#$ . 47902) (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 and load file: " "Byte compile file: "] 8)])
#@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 \210\310p`\211\311\312p\310&\313\314'!\205(\315'!\316(!=\317 \210'\320=\2046\211\203m\310\321 \262

\204F\211\206D\320')\203P \202h\322\323\324\325\326\327\330	!\331\"\332\333%D\334\323\335\322EDC\217\262
\202\230\321 \206s\320')\203
 \202\227\336\323\324\325\326\327\330!\331\"\332\333%D\334\323\337\336EDC\217)\266\202**\"
\203\260\340\341!\210\342
p\"\210\343c\202\266\340\344\345!\"-\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 nil nothing eval #[0 "\300\301p!!\207" [byte-compile-sexp read] 3 "\n\n(fn)"] markerp marker-buffer get-buffer byte-compile-find-cl-functions byte-compile-warning-series byte-compile-log-file #1=#:err funcall make-byte-code 0 "\300 \207" vconcat vector [] 1 "\n\n(fn)" error #[257 "\300
!\207" [byte-compile-report-error] 3 "\n\n(fn ERROR-INFO)"] #2=#:err #[257 "\300
!\207" [byte-compile-report-error] 3 "\n\n(fn ERROR-INFO)"] 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] 14 (#$ . 51405) "P"])
(defalias 'byte-compile-from-buffer #[257 "\211\306\211\211\211\211\211\211\211\307\211\211\306
\306$%&'()*+,\310-!\306\211\211\211\211\211./012210/.3456789r\311\312!\2118q\210\313\314!\210\315 \210\306()\316\307\317\320\321!\322\"\323\324%\325:!\205\204\326:!\327;!=\330 \210:\331=\204\222\211\203\312\306\332 \262

\204\242\211\206\240\331:<\203\255 \210\202\306\333\334\316\307\335\320\321	!\336\"\337\324%D\340\334\341\333EDC\217\210\210\202\367\332 \206\320\331:<\203\335
 \210\202\366\342\334\316\307\335\320\321!\336\"\337\324%D\340\334\343\342EDC\217\210)\2668.\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*" set-buffer-multibyte t erase-buffer make-byte-code "r\300q\210	\203
\306	\n\"\210eb\210\307\310\307w\210\311\312!\203\"\313y\210\202m\204B`\211\307\314\300!\2039\315\316!\210\317
!\210)\210\202\320 \210d\321 \210)	\205Wr\nq\210\322	!)\207" vconcat vector [byte-compile-current-file byte-compile--outbuffer byte-compile-unresolved-functions byte-compile-read-position byte-compile-last-position byte-compile-insert-header nil " 	\n\f" looking-at ";" 1 read byte-compile-warn "!! The file uses old-style backquotes !!\nThis functionality has been obsolete for more than 10 years already\nand will be removed soon.  See (elisp)Backquote in the manual." byte-compile-toplevel-file-form byte-compile-flush-pending byte-compile-warn-about-unresolved-functions byte-compile-fix-header old-style-backquotes] 4 "\n\n(fn)" markerp marker-buffer get-buffer byte-compile-find-cl-functions byte-compile-warning-series byte-compile-log-file #1=#:err funcall "\300 \207" [] 1 error #[257 "\300
!\207" [byte-compile-report-error] 3 "\n\n(fn ERROR-INFO)"] #2=#:err #[257 "\300
!\207" [byte-compile-report-error] 3 "\n\n(fn ERROR-INFO)"] byte-compile-variables byte-compile-constants 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-bound-variables byte-compile-function-environment byte-compile--outbuffer byte-compile-macro-environment warning-series byte-compile-log-buffer byte-compile-debug] 16 "\n\n(fn INBUFFER)"])
#@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\262
db\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 (#$ . 55488)])
#@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\305\306\307\310\311\303!\203\206\312 \313\314 Q\315\316 \317\320
\317\321\f\317\322\323=\2035\324\202J\325=\203@\326\202J\203I\327\202J\330\331\203T\332\202U\333\334\203_\335\202`\336\337\340\341\342\343\261)\207" [byte-compile-dynamic-docstrings byte-compile-dynamic byte-optimize user-mail-address emacs-version ";ELC" 23 "\n" ";;; Compiled by " boundp user-login-name "@" system-name " on " current-time-string "\n" ";;; from file " ";;; in Emacs version " ";;; with" source " source-level optimization only" byte " 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"] 30 (#$ . 56289)])
(defalias 'byte-compile-output-file-form #[257 "\306\307\211\306\211?\211\242\310>\203,\311
8;\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 "\n\n(fn FORM)"])
#@585 Print a form with a doc string.  INFO is (prefix doc-index postfix).
If PREFACE and NAME are non-nil, print them too,
before INFO and the FORM but after the doc string itself.
If SPECINDEX is non-nil, it is the index in FORM
of the function bytecode string.  In that case,
we output that argument and the following argument
(the constants vector) together, for lazy loading.
QUOTED says that we have to put a quote before the
list that represents a doc string reference.
`defvaralias', `autoload' and `custom-declare-variable' need that.

(fn PREFACE NAME INFO FORM SPECINDEX QUOTED)
(defalias 'byte-compile-output-docform #[1542 "r	q\210\306A@\307Y\203E
\203E\310c\210\311A@8\306\"\262
A@8;\203EA@8G\307V\203EA@8\307H\312=\203E\211[\262
\203Tc\210\313	\"\210@c\210\314\306\307\314\306\211\314\211\n? !
\"\306\262#\306\262\313@	\"\210A\211\262	\203!
\211T\262
\315c\210\247\203\335\211U\203\335\306C\316\"!\203\266\317\320\321\322\323\324!\325\"\326\327%\"\"\210\211@?\262
\203\335\311@	A@B\314\"\330\331\332\"	\"\210A\262	
T\266\202\202~\211	A@U\203
\203\377\330\331\203\365\333\202\366\334\"	\"\210\202~\306!`T\313	@	\"\210b\210\335c\210db\210)\202~\313@	\"\210\202~.\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 prin1 t " " 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 (#$ . 58075)])
(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 "\n\n(fn FORM &optional HANDLER)"])
(defalias 'byte-compile-flush-pending #[0 "\205-\305\306\307\"\211\242\310=\203\311\312A\"\210\202 \211\203 \312
!\210\313\211\314\211\313\211\262
\207" [byte-compile-output byte-compile-constants byte-compile-variables byte-compile-depth byte-compile-maxdepth byte-compile-out-toplevel t file progn mapc byte-compile-output-file-form nil 0] 5 "\n\n(fn)"])
(defalias 'byte-compile-preprocess #[513 "\302\"\262	\203\303!\207
\207" [byte-compile-macro-environment lexical-binding macroexpand-all cconv-closure-convert] 5 "\n\n(fn FORM &optional FOR-EFFECT)"])
(defalias 'byte-compile-toplevel-file-form #[257 "\301\302\303\304\"!)\207" [byte-compile-current-form nil byte-compile-file-form byte-compile-preprocess t] 5 "\n\n(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 "\n\n(fn FORM)"])
(put 'autoload 'byte-hunk-handler 'byte-compile-file-form-autoload)
(defalias 'byte-compile-file-form-autoload #[257 "\211\211A\211\262\203\303
@!\204
\211?\262
\203#\304\3058!\203#\304
!\210\211A@:\203g\211A@@\306=\203g\211A@A:\203g\211A@A@9\203g\211A@A@\307AABBB\211A@A@	>\204g\310
A@A@\n\236\n\"\311
8;\203o\207\312
\313\"\207" [byte-compile-function-environment byte-compile-noruntime-functions byte-compile-unresolved-functions macroexp-const-p eval 5 quote autoload delq 3 byte-compile-keep-pending byte-compile-normal-call] 4 "\n\n(fn FORM)"])
(byte-code "\300\301\302\303#\210\300\304\302\303#\207" [put defvar byte-hunk-handler byte-compile-file-form-defvar defconst] 4)
(defalias 'byte-compile-file-form-defvar #[257 "\211A@9\203\303\304\305A@!\"\204\306\307!\203\310\311A@\"\210\211A@B\211@\312=\2032\211A@	B\211\211AA)?\205@\211@\313=?\205]\314
8:\203\\\315
!\262
\211AA\316\3148\317\320#\240\210\211\207" [byte-compile-bound-variables byte-compile-const-variables x string-match "[-*/:$]" symbol-name byte-compile-warning-enabled-p lexical byte-compile-warn "global/dynamic var `%s' lacks a prefix" defconst defvar 2 copy-sequence byte-compile-top-level nil file] 6 "\n\n(fn FORM)"])
(put 'define-abbrev-table 'byte-hunk-handler 'byte-compile-file-form-define-abbrev-table)
(defalias 'byte-compile-file-form-define-abbrev-table #[257 "\211A\242\242\302=\203\211\211A@)A\242	B\303
!\207" [x byte-compile-bound-variables quote byte-compile-keep-pending] 3 "\n\n(fn FORM)"])
(put 'custom-declare-variable 'byte-hunk-handler 'byte-compile-file-form-custom-declare-variable)
(defalias 'byte-compile-file-form-custom-declare-variable #[257 "\301\302!\203\n\303
!\210\211A@A@B\304
!\207" [byte-compile-bound-variables byte-compile-warning-enabled-p callargs byte-compile-nogroup-warn byte-compile-keep-pending] 3 "\n\n(fn FORM)"])
(put 'require 'byte-hunk-handler 'byte-compile-file-form-require)
(defalias 'byte-compile-file-form-require #[257 "\302\303A\"\304\305\306\"\210\307\310!\203G@\311\235\203$\312\313!\210\314\310!\210\202G\262
	\204G\211\203G\211=\204G\315
\211A\262@@!\203'\316 \210\202'\266\317
\320\"\207" [load-history byte-compile-cl-functions mapcar eval nil apply require 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] 7 "\n\n(fn FORM)"])
(byte-code "\300\301\302\303#\210\300\304\302\303#\210\300\305\302\303#\207" [put progn byte-hunk-handler byte-compile-file-form-progn prog1 prog2] 4)
(defalias 'byte-compile-file-form-progn #[257 "\300\301A\"\210\302\207" [mapc byte-compile-file-form nil] 4 "\n\n(fn FORM)"])
(put 'with-no-warnings 'byte-hunk-handler 'byte-compile-file-form-with-no-warnings)
(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 "\n\n(fn FORM)"])
(put 'eval 'byte-hunk-handler 'byte-compile-file-form-eval)
(defalias 'byte-compile-file-form-eval #[257 "\211A@\242\300=\203\211A@A@\207\301
!\207" [quote byte-compile-keep-pending] 3 "\n\n(fn FORM)"])
#@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	\2037\n\236\2047\311\211E\nB\312\313!\203F\314	\n#\210\203U\315\316\f\206Q\317#\210\204_<\203\344\211\203}\312\313!\203v
\236\204v\320\321\n\"\210\211\311\241\210\202\344
\203\241\312\313!\203\344
\236\204\344\320\322	\203\231\323\202\232\324#\210\202\344\325	!\203\344K\242\203\265\326\202\266\327=\203\344\312\313!\203\332\320\330	\203\313\324\202\314\323\203\327\323\202\330\324$\210	\311BJBL\210<\203\n
@;\203\n
\243\2429\203\n
\243\242\203\n
\243\243\242;\203\n
\320\331\n\"\210<\204.
\204*
<\203#
\332D\202$
\333BB\311\202\242
\334B\333\"\203M
\203F
	
\236\204X

\241\210\202X
\nBJBL\210?\205\240
\335 \210@;\204k
\336\202l
\337\340\341\f\f\203}
\342\343BB\202\202
\344\345BB\346\311\":?\205\224
*\205\224
\347\311&\266\350\351+\"\210\333\262
)\207" [byte-compile-current-form byte-compile-generate-call-tree byte-compile-call-tree byte-compile-verbose byte-compile-current-file byte-compile-initial-macro-environment 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" fboundp 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 -1 4 byte-compile-output-docform "\n(defalias '" " '(macro . #[" ("])") " #[" ("]") append 1 princ ")" byte-compile-dynamic byte-compile--outbuffer] 18 (#$ . 64506)])
#@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 (#$ . 66734)])
#@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
@A
\301=\203\211@
A\302#\266\202\202)\211@
A\211@
A#\266\204\207" [#[771 "\300\211\2036\211@\211:\203\"\211@>\204/\211@\301ADDB\262\202/\211\302=\204/\303
DB\262
A\266\202\202\210\211\204C\304BB\202M\304\305\237BBE\207" [nil quote t defvar lambda let] 9 "\n\n(fn ENV BODY ARGS)"] lambda nil] 12 (#$ . 67476)])
#@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\305\306\307!\310\"\311\312%\313!\205\314!\315	!=\316 \210\317=\204&\211\203[\320\321 \262

\2045\211\2064\317\n\203> \202V\322\323\303\304\324\306\307	!\325\"\326\312%D\327\323\330\322EDC\217\262
\202\204\321 \206a\317\n\203k
 \202\203\331\323\303\304\324\306\307!\325\"\326\312%D\327\323\332\331EDC\217)\207" [warning-series byte-compile-log-buffer byte-compile-debug make-byte-code 0 "\306	!\307\211\211\211\211\211\n\f
\3009\2037\310\300!\2058\300K\2028\300\211\242\311=\211\203D
A\262\312!\203\\\313\314\3009\203U\300\202V\315\"\210
\202\263\3009\203x
\242\316>\204m\317\320\"\210\321!\262
@\322=
\242\323=\204\204\317\320\"\210\324!\262
\242\325=\203\231
\211 A@)\262\326!\262\211\203\247\311B\262\3009\203\262\300M\202\263
)\266\202.\f\207" vconcat vector [byte-compile-initial-macro-environment byte-compile-verbose byte-optimize byte-compile-dynamic byte-compile-dynamic-docstrings copy-alist nil fboundp macro byte-code-function-p message "Function %s is already compiled" "provided" (closure lambda) error "Don't know how to compile %S" byte-compile--reify-function closure lambda byte-compile-preprocess function byte-compile-lambda byte-compile-warnings byte-compile-free-assignments byte-compile-free-references byte-compile-const-variables byte-compile-bound-variables byte-compile-function-environment byte-compile--outbuffer byte-compile-macro-environment lexical-binding x] 13 "\n\n(fn)" markerp marker-buffer get-buffer byte-compile-find-cl-functions byte-compile-warning-series nil byte-compile-log-file #1=#:err funcall "\300 \207" [] 1 error #[257 "\300
!\207" [byte-compile-report-error] 3 "\n\n(fn ERROR-INFO)"] #2=#:err #[257 "\300
!\207" [byte-compile-report-error] 3 "\n\n(fn ERROR-INFO)"]] 12 (#$ . 68015)])
#@37 Compile and return SEXP.

(fn SEXP)
(defalias 'byte-compile-sexp #[257 "\303\304\305\306\307!\310\"\311\312%\313!\205\314!\315	!=\316 \210\317=\204&\211\203[\320\321 \262

\2045\211\2064\317\n\203> \202V\322\323\303\304\324\306\307	!\325\"\326\312%D\327\323\330\322EDC\217\262
\202\204\321 \206a\317\n\203k
 \202\203\331\323\303\304\324\306\307!\325\"\326\312%D\327\323\332\331EDC\217)\207" [warning-series byte-compile-log-buffer byte-compile-debug make-byte-code 0 "\306	!\307\211\211\211\211\211\n\f
\n\n\f
\310\311\300!!.\f\207" vconcat vector [byte-compile-initial-macro-environment byte-compile-verbose byte-optimize byte-compile-dynamic byte-compile-dynamic-docstrings copy-alist nil byte-compile-top-level byte-compile-preprocess byte-compile-warnings byte-compile-free-assignments byte-compile-free-references byte-compile-const-variables byte-compile-bound-variables byte-compile-function-environment byte-compile--outbuffer byte-compile-macro-environment] 12 "\n\n(fn)" markerp marker-buffer get-buffer byte-compile-find-cl-functions byte-compile-warning-series nil byte-compile-log-file #1=#:err funcall "\300 \207" [] 1 error #[257 "\300
!\207" [byte-compile-report-error] 3 "\n\n(fn ERROR-INFO)"] #2=#:err #[257 "\300
!\207" [byte-compile-report-error] 3 "\n\n(fn ERROR-INFO)"]] 12 (#$ . 70010)])
#@47 Check lambda-list LIST for errors.

(fn LIST)
(defalias 'byte-compile-check-lambda-list #[257 "\302
\205\244
@\2119\203\303
!\210\2119\203P\211\304
\305>\206K\306!\206K\211\205K
>\206K\307!\205K\310\311\312\313\314\315\316!\317\"\320\321%D\322\311\323\310EDC\217\266\202\203X\324\325\"\210\202\234\211\326=\203wA\204g\324\327!\210\211AA)\203\234\324\330!\210\202\234\211\331=\203\211A\204\234\324\332!\210\202\234\211>\203\227\333\334\"\210\202\234\211B\262\210
A\262\202
\207" [byte-compile-const-variables x nil byte-compile-set-symbol-position t (nil t) keywordp boundp #1=#:err funcall make-byte-code 0 "\300\211JL\210\301\207" vconcat vector [nil] 2 "\n\n(fn)" setting-constant #[257 "\300\207" [t] 2 "\n\n(fn IGNORED)"] error "Invalid lambda variable %s" &rest "&rest without variable name" "Garbage following &rest VAR in lambda-list" &optional "Variable name missing after &optional" byte-compile-warn "repeated variable %s in lambda-list"] 14 (#$ . 71368)])
#@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 (#$ . 72377)])
#@75 Return a new lexical environment for a lambda expression FORM.

(fn FORM)
(defalias 'byte-compile-make-lambda-lexenv #[257 "\301
\211A@)!\302\303\211\203#\211@\211BB\262T\262
A\266\202\202\210
\262
\262
\207" [x byte-compile-arglist-vars nil 0] 9 (#$ . 72576)])
(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 lsh 8 7] 10 "\n\n(fn ARGLIST)"])
#@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?\205.\310!	\"AA\211@;\205E\211@
A\203E
A\262\311\236\211\203\260\305\311!\210\211@=\203[A\262\211A:\203\244\211AA\203n\312\313\314!\"\210\211A@\315
!
\242\316>\203\217
A:\203\210
A\262\202{
@\262\202t
\242\317=\203\232\203\237\311
D\262\266\202\260\211A\203\260\312\313\314!\"\210\315\320B\321\302\205\276\322!	%\211\242\323=\204\316\324\325\326C\"\210\327\330\203\333\331!\202\335\307A\203\362\332\333!\210\334\"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 append byte-compile-arglist-vars 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 signal cl-assertion-failed (eq 'byte-code (car-safe compiled)) apply make-byte-code byte-compile-make-args-desc require help-fns help-add-fundoc-usage] 16 (#$ . 73247)])
(defvar byte-compile-reserved-constants 0)
(defalias 'byte-compile-constants-vector #[0 "S	\237\n\237\303\211\304\303\204\203p
@\262
\203b
W\203b@\247\2037@W\204[\305\306\307C\"\210\202[@@\236\211\262\203K@A\241\210\202[@T\211\262	\241\210@B\262A\262\202
A\262\262\262\202\n\310\311\312\313\"\237\"\207" [byte-compile-reserved-constants byte-compile-variables byte-compile-constants nil (5 63 255 65535 65535) signal cl-assertion-failed (< (car rest) byte-compile-reserved-constants) apply vector mapcar car] 12 "\n\n(fn)"])
(defalias 'byte-compile-top-level #[1281 "\306\211\307\211\211\206\307\306\310>\203)\311\"\262\242\312=\203>AA\204>A@\262\202)\203W\313=\203W\nG\211\307V\203W\314\315 !\210\316\"\210\317\".	\207" [byte-compile-output byte-compile-reserved-constants byte-compile--lexical-environment byte-compile-maxdepth byte-compile-depth byte-compile-tag-number 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-variables byte-compile-constants byte-compile--for-effect byte-optimize lexical-binding] 15 "\n\n(fn FORM &optional FOR-EFFECT OUTPUT-TYPE LEXENV RESERVED-CSTS)"])
(defalias 'byte-compile-out-toplevel #[512 "
\203F@@\306=\203A\202F\307\310	\236?\205D\311	!\211\203<\211\211@@)9\204<\211\211@@)\247\204<\211A\262
\202\211\211@@)\262
!\210\312\313\314\"\210\237\315>\203X\316!\310
\317=?\310\211\317=\204v
\320=\203o\321\202p\322\233\204v
\323\236\204v
\313\236\211\262\203v

\311!>A\237\262@@\324>\203
@A@\262@@\325=\203\367
:\204\350
9\203\367
\310
\326>\206\343\327!\206\343\211\205\343
\f>\206\343\330!\205\343\331\332\333\314\334\335\336!\337\"\340\341%D\342\332\343\331EDC\217\266\202\204\367\203r
\344D
B\211\262\202h


B\211\262\202h
\203r
\345\233\204r
@@\346N\211\262\203r
A\2033
\347>\203r
AA\203r
A@@\306=\203r
A\262\310\262\211\237\262

\332=\203R
\211@\242\344=\203R
\211@A@
AB\202U


BC\262
\320=\204k
\350\310\351\352@A\"\"?\203r
A\262\202\215\203\204
\353 \354\355!
F\262
\202\222
\211A\203\220
\356
\237B\202\222
\211@\207" [byte-compile-output byte-compile-constants x 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 #1=#:err funcall make-byte-code "\300\211JL\210\301\207" vconcat vector [nil] 2 "\n\n(fn)" setting-constant #[257 "\300\207" [t] 2 "\n\n(fn IGNORED)"] quote 3 byte-opcode-invert (file progn t) delq mapcar consp byte-compile-constants-vector byte-code byte-compile-lapcode progn] 16 "\n\n(fn &optional FOR-EFFECT OUTPUT-TYPE)"])
(defalias 'byte-compile-top-level-body #[513 "\300\301B\302#\262
\242\301=\203
A\207
\205
C\207" [byte-compile-top-level progn t] 6 "\n\n(fn BODY &optional FOR-EFFECT)"])
(defalias 'byte-compile-macroexpand-declare-function #[642 "
:\203
@<\203\302@D\202\303BB\304	\"\305\306BBB!\207" [byte-compile-function-environment byte-compile-noruntime-functions declared t delq macroexpand declare-function] 8 "\n\n(fn FN FILE &rest ARGS)"])
(defalias 'byte-compile-form #[513 "\211
:\204t
9\203G
\305
\306>\206B\307!\206B\211\205B
	>\206B\310!\205B\311\312\313\314\315\316\317!\320\"\321\322%D\323\312\324\311EDC\217\266\202\203W
9\203P\325!\210\326!\210\202J
\203m\n\203m
9\203h\325!\210\305\202J
\327!\210\202J

@9\203

@\211\330N
\305
\306>\206\265\307!\206\265\211\205\265
	>\206\265\310!\205\265\331\312\313\314\315\316\317!\332\"\321\322%D\323\312\333\331EDC\217\266\202\203\277\334\335\"\210\336\337!\203\320
>\203\320\334\340\"\210\341@!\203\353@K\242\342=\203\353\343\344\345@\"\305\346#\210\211\203
\347
!\203
\211\350=\204
\211!\210\202
\351!\210\336\352!\203
\353!\210\266\202J
\354@!\203)
\f\355>\203)
\356!\210\202J

@\242\357=\203F

\360!\211\262=\204F
\361\"\210\305\202J
\351!\210\205P
\362 )\207" [byte-compile--for-effect byte-compile-const-variables byte-compile-delete-errors byte-compile-interactive-only-functions byte-optimize nil (nil t) keywordp boundp #1=#:err funcall make-byte-code 0 "\300\211JL\210\301\207" vconcat vector [nil] 2 "\n\n(fn)" setting-constant #[257 "\300\207" [t] 2 "\n\n(fn IGNORED)"] byte-compile-set-symbol-position byte-compile-constant byte-compile-variable-ref byte-compile #2=#:err [nil] #[257 "\300\207" [t] 2 "\n\n(fn IGNORED)"] byte-compile-warn "`%s' called as a function" byte-compile-warning-enabled-p interactive-only "`%s' used from Lisp code\nThat command is designed for interactive use only" fboundp macro byte-compile-log-warning format "Forgot to expand macro %s" :error 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] 14 "\n\n(fn FORM &optional FOR-EFFECT)"])
(defalias 'byte-compile-normal-call #[257 "\302\303!\203'\211@9\203'\211@\304>\203\305
!\210\211@\306N\203#\307
@!\210\310
!\210\203/\311
!\210	\203H\211@\312=\203H\302\312!\203H\313\312!\210\314\315!\210\316
@!\210\317\320A\"\210\321\322AG\"\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-obsolete-info byte-compile-warn-obsolete 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 "\n\n(fn FORM)"])
(defalias 'byte-compile-inline-lapcode #[514 "\302 \211\203L\211@\211@\303=\203\304
!\210\202E\211@>\203(\305
@A\"\210\202E\211@\306=\203>\307	Z\310\"\210\305\311\"\210\202E\312
@A\"\210
A\266\202\202\210\304
!\207" [byte-goto-ops byte-compile-depth byte-compile-make-tag TAG byte-compile-out-tag byte-compile-goto byte-return byte-compile-discard t byte-goto byte-compile-out] 8 "\n\n(fn LAP END-DEPTH)"])
#@48 Inline call to byte-code-functions.

(fn FORM)
(defalias 'byte-compile-unfold-bcf #[257 "\211@\211\303H	
\247\205\304\305\"AG\306\307!\210\310\311A\"\210\204x<\2040\312\313\314C\"\210\203n@\211\315=\203CA\262\202j\211\316=\203`
G\317_T\262\211A@)B\262\306\262\202j\211A\262@B\262\210\2020\204x\211G\317_\262
\211\\X\203\237T\317\245Z\303\211W\203\232\211\320\306!\266\211T\262
\202\207\266\202\343\321\322\323\"!\203\271\324\325\306\326#\210\327\317\245Z!\210\202\343
S\317\245Z\211\303V\204\314\330\331$\210\211\332W\203\335\333\334SH\303\"\210\202\342\333\335\"\210\210\310\336\"\210\337\340\323H\317H\341#T\"\210\211\203
\333\342G\"\210	T=\204
\330\343	#\210)\306\207" [byte-compile-bound-variables byte-compile-depth x 0 lsh -7 nil fetch-bytecode mapc byte-compile-form signal cl-assertion-failed (listp fargs) &optional &rest 2 byte-compile-push-constant zerop logand 1 byte-compile-log-warning "Too many arguments for inlined function" :error byte-compile-discard error "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-decompile-bytecode-1 t byte-unbind "Wrong depth start=%s end=%s"] 14 (#$ . 81237)])
#@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!\210
9\203I
\304
\305>\206D\306!\206D\211\205D
>\206D\307!\205D\310\311\312\313\314\315\316!\317\"\320\321%D\322\311\323\310EDC\217\266\202\203j\324\325!\205\246\326
\327=\203Z\330\202[\3319\203d\332\202e\333\334!#\207
\335N\211\205\236	>?\205\236\n>?\205\236\211A@\211\336=\203\217\337=?\202\234\211\340=\203\233\337=\202\234\341\262
\262
\205\246\342!\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 #1=#:err funcall make-byte-code 0 "\300\211JL\210\301\207" vconcat vector [nil] 2 "\n\n(fn)" setting-constant #[257 "\300\207" [t] 2 "\n\n(fn IGNORED)"] 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 set reference get t byte-compile-warn-obsolete] 12 (#$ . 82552)])
(defalias 'byte-compile-dynamic-variable-op #[514 "\211\236\211\204
C\262
\211B\301\"\207" [byte-compile-variables byte-compile-out] 6 "\n\n(fn BASE-OP VAR)"])
(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\204
C\262
\211	B\305\"\207" [byte-compile-bound-variables byte-compile-variables byte-compile-check-variable let-bind byte-varbind byte-compile-out] 7 (#$ . 83913)])
#@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\306
A!\202K\307\310!\2034\311!\2044
	>\2044
\n>\2044\312\313\"\210
\nB\314\211\236\211\204E
C\262
\211B\315\"\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 byte-compile-warn "reference to free variable `%S'" byte-varref byte-compile-out] 8 (#$ . 84268)])
#@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\306
A!\202K\307\310!\2034\311!\2044
	>\2044
\n>\2044\312\313\"\210
\nB\314\211\236\211\204E
C\262
\211B\315\"\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 byte-compile-warn "assignment to free variable `%s'" byte-varset byte-compile-out] 8 (#$ . 84891)])
(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 "\n\n(fn CONST)"]))
(defalias 'byte-compile-constant #[257 "\203\302\211\207\2119\203\303
!\210\304\305;\203:\302	\211\2033\211@\306
@\"\203,\211\262
A\266\202\202\210\211\262
\202=	\236\206GC	B\211@\"\207" [byte-compile--for-effect byte-compile-constants nil byte-compile-set-symbol-position byte-compile-out byte-constant equal-including-properties] 9 "\n\n(fn CONST)"])
(defalias 'byte-compile-push-constant #[257 "\302\211\203\302\211\262
\202Q\2119\203\303
!\210\304\305;\203A\302	\211\203:\211@\306
@\"\2033\211\262
A\266\202\202!\210\211\262
\202D	\236\206NC	B\211@\"\262
)\207" [byte-compile--for-effect byte-compile-constants nil byte-compile-set-symbol-position byte-compile-out byte-constant equal-including-properties] 10 "\n\n(fn CONST)"])
#@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) (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 (#$ . 86704)]))
(defalias 'byte-defop-compiler-1 '(macro . #[513 "\300\301DE\207" [byte-defop-compiler nil] 5 "\n\n(fn FUNCTION &optional COMPILE-HANDLER)"]))
(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\201g#\210\300\201q\324\201r#\210\300\201r\302\201q#\210\300\201s\322\201g#\210\300\201s\324\201t#\210\300\201t\302\201s#\210\300\201u\322\201g#\210\300\201u\324\201v#\210\300\201v\302\201u#\210\300\201w\322\201g#\210\300\201w\324\201x#\210\300\201x\302\201w#\210\300\201y\322\201g#\210\300\201y\324\201z#\210\300\201z\302\201y#\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\322\201\200#\210\300\201\324\201\201#\210\300\201\201\302\201#\210\300\201\202\322\201\200#\210\300\201\202\324\201\203#\210\300\201\203\302\201\202#\210\300\201\204\322\201\200#\210\300\201\204\324\201\203#\210\300\201\203\302\201\204#\210\300\201\205\322\364#\210\300\201\205\324\201\206#\210\300\201\206\302\201\205#\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\201g#\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\216#\210\300\201\216\302\201\221#\210\300\201\222\322\201g#\210\300\201\222\324\201\220#\210\300\201\220\302\201\222#\210\300\201\223\322\201g#\210\300\201\223\324\201\224#\210\300\201\224\302\201\223#\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\236#\210\300\201\236\302\201\241#\210\300\201\242\322\201g#\210\300\201\242\324\201\240#\210\300\201\240\302\201\242#\210\300\201\243\322\201g#\210\300\201\243\324\201\244#\210\300\201\244\302\201\243#\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\201\254#\210\300\201\253\324\201\255#\210\300\201\255\302\201\253#\210\300\201\256\322\201\257#\210\300\201\256\324\201\260#\210\300\201\260\302\201\256#\210\300\201\261\322\201\257#\210\300\201\261\324\201\262#\210\300\201\262\302\201\261#\210\300\201\263\322\201\257#\210\300\201\263\324\201\264#\210\300\201\264\302\201\263#\210\300\201\265\322\201\257#\210\300\201\265\324\201\266#\210\300\201\266\302\201\265#\210\300\201\267\322\201\270#\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-eqlsign < byte-lss > byte-gtr <= byte-leq >= byte-geq get byte-get nth byte-nth substring byte-compile-two-or-three-args byte-substring move-marker 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)
(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 "\n\n(fn FORM N)"])
(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 "\n\n(fn FORM)"])
(defalias 'byte-compile-one-arg #[257 "\211G\300U\204\f\301
\302\"\207\303
A@!\210\304
@\305N\306\"\207" [2 byte-compile-subr-wrong-args 1 byte-compile-form byte-compile-out byte-opcode 0] 4 "\n\n(fn FORM)"])
(defalias 'byte-compile-two-args #[257 "\211G\300U\204\f\301
\302\"\207\303
A@!\210\303\3028!\210\304
@\305N\306\"\207" [3 byte-compile-subr-wrong-args 2 byte-compile-form byte-compile-out byte-opcode 0] 4 "\n\n(fn FORM)"])
(defalias 'byte-compile-three-args #[257 "\211G\300U\204\f\301
\302\"\207\303
A@!\210\303\3048!\210\303\3028!\210\305
@\306N\307\"\207" [4 byte-compile-subr-wrong-args 3 byte-compile-form 2 byte-compile-out byte-opcode 0] 4 "\n\n(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 "\n\n(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 "\n\n(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 "\n\n(fn FORM)"])
(defalias 'byte-compile-noop #[257 "\300\301!\207" [byte-compile-constant nil] 3 "\n\n(fn FORM)"])
#@284 Output byte codes to discard the NUM entries at the top of the stack.
NUM defaults to 1.
If PRESERVE-TOS is non-nil, preserve the top-of-stack value, as if it were
popped before discarding the num values, and then pushed back again after
discarding.

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

(fn STACK-POS)
(defalias 'byte-compile-stack-ref #[257 "
TZ\301
!\203\302\303!\202\302\304\"\207" [byte-compile-depth zerop byte-compile-out byte-dup byte-stack-ref] 5 (#$ . 99050)])
#@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 (#$ . 99311)])
(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\303\233\304\305BB\301G#G\306V\204(\307\310\311C\"\210\312
!\2044\307\310\313C\"\210\314\315\316\306HD\316\317HD\320\321B\316\302HDE\303\322\323\"\233BBBB!\207" [byte-compile--for-effect nil 2 3 byte-compile-lambda lambda 0 signal cl-assertion-failed (> (length env) 0) byte-code-function-p (byte-code-function-p fun) byte-compile-form make-byte-code quote 1 vconcat vector mapcar #[257 "\300
D\207" [quote] 3 "\n\n(fn X)"]] 14 (#$ . 99712)])
#@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 (#$ . 100318)])
(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\"\210
A\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 "\n\n(fn FORM)"])
(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)
(defalias 'byte-compile-char-before #[257 "\211G\300U\203\301\302A@\247\203A@S\202\303A@DD!\207\211G\304U\203*\301\305!\207\306
\307\"\207" [2 byte-compile-form char-after 1- 1 (char-after (1- (point))) byte-compile-subr-wrong-args "0-1"] 5 "\n\n(fn FORM)"])
(defalias 'byte-compile-backward-char #[257 "\211G\300U\203\301\302A@\247\203A@[\202\303A@DD!\207\211G\304U\203*\301\305!\207\306
\307\"\207" [2 byte-compile-form forward-char - 1 (forward-char -1) byte-compile-subr-wrong-args "0-1"] 5 "\n\n(fn FORM)"])
(defalias 'byte-compile-backward-word #[257 "\211G\300U\203\301\302A@\247\203A@[\202\303A@DD!\207\211G\304U\203*\301\305!\207\306
\307\"\207" [2 byte-compile-form forward-word - 1 (forward-word -1) byte-compile-subr-wrong-args "0-1"] 5 "\n\n(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 "\n\n(fn FORM)"])
(defalias 'byte-compile-concat #[257 "\211AG\300
W\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 "\n\n(fn FORM)"])
(defalias 'byte-compile-minus #[257 "\211G\211\301U\203\302\303!\202@\211\304U\203$\305\211A@)!\210\306\307\303\"\202@\211\310U\203=\305A@!\210\305\3048!\210\306\311\303\"\202@\312!\207" [x 1 byte-compile-constant 0 2 byte-compile-form byte-compile-out byte-negate 3 byte-diff byte-compile-normal-call] 6 "\n\n(fn FORM)"])
(defalias 'byte-compile-quo #[257 "\211G\211\300X\203\301\302\"\202\211\303U\203\304!\202\305!\207" [2 byte-compile-subr-wrong-args "2 or more" 3 byte-compile-two-args byte-compile-normal-call] 5 "\n\n(fn FORM)"])
(defalias 'byte-compile-nconc #[257 "\211G\211\300U\203\301\302!\202:\211\303U\203\304A@!\202:\304A\211\262@!\210
A\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 "\n\n(fn FORM)"])
(defalias 'byte-compile-fset #[257 "\300
8\301
\242\302=\203D
A@\211\262\242\303=\203D
AA\262
\211@;\203&\211A\262
\211@\242\304=\2032\211A\262
\211@:\203D\211@@\305=\204D\306\307!\210\266\310
!\207" [2 nil quote lambda interactive byte-code byte-compile-warn "A quoted lambda form is the second argument of `fset'.  This is probably\n     not what you want, as that lambda cannot be compiled.  Consider using\n     the syntax #'(lambda (...) ...) instead." byte-compile-two-args] 5 "\n\n(fn FORM)"])
(defalias 'byte-compile-function-form #[257 "\300
A@\242\301=\203\302A@!\202
A@!\207" [byte-compile-constant lambda byte-compile-lambda] 4 "\n\n(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 "\n\n(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 "\n\n(fn FORM)"])
(byte-code "\300\301\302\303#\210\300\304\302\305#\210\300\306\302\307#\207" [put setq byte-compile byte-compile-setq setq-default byte-compile-setq-default quote byte-compile-quote] 4)
(defalias 'byte-compile-setq #[257 "\211A\211\203,\211\2031\301
A@!\210\204\211AA\204\302\303\304\"\210\305
@!\210\211AA\262
\202\301\306\"\210\306\211\207" [byte-compile--for-effect byte-compile-form byte-compile-out byte-dup 0 byte-compile-variable-set nil] 5 "\n\n(fn FORM)"])
(defalias 'byte-compile-setq-default #[257 "\211A\262
\211\204
\302\303\"\207\211G\304V\2036\303
:\203/\305\211A\262@\211A\262@E
B\262
\202\302\306\237B!\207\211@\2119\203x\211\307
\310>\206s\311!\206s\211\205s
	>\206s\312!\205s\313\314\315\316\317\320\321!\322\"\304\323%D\324\314\325\313EDC\217\266\202\203\217\326\327!\203\217\330\3319\203\211\332\202\212\333\334!#\210\335\336\337DABB!\207" [byte-compile--for-effect byte-compile-const-variables byte-compile-form nil 2 setq-default progn t (nil t) keywordp boundp #1=#:err funcall make-byte-code 0 "\300\211JL\210\301\207" vconcat vector [nil] "\n\n(fn)" setting-constant #[257 "\300\207" [t] 2 "\n\n(fn IGNORED)"] byte-compile-warning-enabled-p constants byte-compile-warn "variable assignment to %s `%s'" "constant" "nonvariable" prin1-to-string byte-compile-normal-call set-default quote] 12 "\n\n(fn FORM)"])
(put 'set-default 'byte-compile 'byte-compile-set-default)
(defalias 'byte-compile-set-default #[257 "\211\243\242\211\242\301=\203\302\303A\242\211AA)BB!\202\304!\207" [x quote byte-compile-setq-default setq-default byte-compile-normal-call] 7 "\n\n(fn FORM)"])
(defalias 'byte-compile-quote #[257 "\300
A@!\207" [byte-compile-constant] 3 "\n\n(fn FORM)"])
(defalias 'byte-compile-body #[513 "
A\203\300@\301\"\210
A\262\202\300@\"\207" [byte-compile-form t] 5 "\n\n(fn BODY &optional FOR-EFFECT)"])
(defalias 'byte-compile-body-do-effect #[257 "\301
\"\210\302\211\207" [byte-compile--for-effect byte-compile-body nil] 4 "\n\n(fn BODY)"])
(put 'byte-compile-body-do-effect 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'byte-compile-form-do-effect #[257 "\301
\"\210\302\211\207" [byte-compile--for-effect byte-compile-form nil] 4 "\n\n(fn FORM)"])
(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\331#\210\300\332\305\331#\207" [put byte-compile-form-do-effect byte-optimizer byte-compile-inline-expand inline byte-compile byte-compile-progn progn prog1 byte-compile-prog1 prog2 byte-compile-prog2 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)
(defalias 'byte-compile-progn #[257 "\211A\301
\"\210\302\211\207" [byte-compile--for-effect byte-compile-body nil] 5 "\n\n(fn FORM)"])
(defalias 'byte-compile-prog1 #[257 "\211A@\301
\"\210\302\211\266\303
AA\304\"\207" [byte-compile--for-effect byte-compile-form nil byte-compile-body t] 5 "\n\n(fn FORM)"])
(defalias 'byte-compile-prog2 #[257 "\301
A@\302\"\210\303
8\301
\"\210\304\211\266\305
AAA\302\"\207" [byte-compile--for-effect byte-compile-form t 2 nil byte-compile-body] 5 "\n\n(fn FORM)"])
(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 "\n\n(fn COND DISCARD TAG)"]))
(defalias 'byte-compile-find-bound-condition #[770 "\300\211\242>\203C\202\242\301=\205A\211\211\203K\211@\211\242>\203D\211A@\211\262\242\302=\203DA@\236\204D\211A@A@B\262
A\266\202\202\210\207" [nil and quote] 10 "\n\n(fn CONDITION-PARAM PRED-LIST &optional ONLY-IF-NOT-PRESENT)"])
#@531 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 ((list 'fboundp) byte-compile-unresolved-functions) bound-list ((list 'boundp 'default-boundp)) ((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 (#$ . 109978)]))
(byte-code "\300\301\302\303#\210\300\301\304\305#\207" [put byte-compile-maybe-guarded lisp-indent-function 1 edebug-form-spec t] 4)
(defalias 'byte-compile-if #[257 "\305
A@!\210\211A@\306 \307\233\204\\\310\203\311\202\312\"\210\313\314C	#\313\315\316D\"\317
\n\"\320\321\322\323\324\325!\326\"\327\330%DC\216\317\"\317\f\"\305\3318\"\210,\266\332
!\210\202\344\306 \310\311\"\210\313\314C	#\313\315\316D\"\317
\n\"\320\321\322\323\324\325!\333\"\327\330%DC\216\317\"\317\f\"\305\3318\"\210,\266\310\334\"\210\332
!\210\313\335D\314C	#\313\335D\315\316D\"\317
\n\"\320\321\322\323\324\325!\336\"\327\330%DC\216\317\"\317\f\"\337AAA\"\210,\266\332!\266\266\340\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 boundp default-boundp append funcall 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 "\n\n(fn)" 2 byte-compile-out-tag [byte-compile-unresolved-functions delq] byte-goto not [byte-compile-unresolved-functions delq] byte-compile-body nil] 13 "\n\n(fn FORM)"])
(defalias 'byte-compile-cond #[257 "\305 \306\211A\211\262\203\234@\262
\211@\307=\204&\211@\242\310=\2031\211@\243\242\2031\307
B\262
\306\262\202A\203\311
@!\210\211A\204P\312\203I\313\202J\314\"\210\202\305 \262\312\315\"\210\316
@\317C	#\316@\320\321D\"\322
\n\"\323\324\325\326\327\330!\331\"\332\333%DC\216\322\"\322\f\"\334A\"\210,\266\312\335\"\210\336!\210\202\211@
A\203\276\211\307=\204\276\311
!\210\312\203\266\315\202\267\337\"\210
A\262\316
\317C	#\316\320\321D\"\322
\n\"\323\324\325\326\327\330!\340\"\332\333%DC\216\322\"\322\f\"\334
\"\210\306\211\266,\266\336!\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-make-tag nil 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 boundp default-boundp append funcall 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 "\n\n(fn)" byte-compile-body byte-goto byte-compile-out-tag byte-goto-if-nil-else-pop [byte-compile-unresolved-functions delq]] 14 "\n\n(fn CLAUSES)"])
(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 "\n\n(fn FORM)"])
(defalias 'byte-compile-and-recursion #[514 "
A\203L\305@!\210\306\203\307\202\310\"\210\311@\312C	#\311@\313\314D\"\315
\n\"\316\317\320\321\322\323!\324\"\325\326%DC\216\315\"\315\f\"\327A\",\207
@\305
\"\210\330\211\266\331
!\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 boundp default-boundp append funcall 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 "\n\n(fn)" byte-compile-and-recursion nil byte-compile-out-tag] 11 "\n\n(fn REST FAILTAG)"])
(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 "\n\n(fn FORM)"])
(defalias 'byte-compile-or-recursion #[514 "
A\203P\305@!\210\306\203\307\202\310\"\210\311\312@D\313C	#\311\312@D\314\315D\"\316
\n\"\317\320\321\322\323\324!\325\"\326\327%DC\216\316\"\316\f\"\330A\",\207
@\305
\"\210\331\211\266\332
!\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 boundp default-boundp append funcall 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 "\n\n(fn)" byte-compile-or-recursion nil byte-compile-out-tag] 11 "\n\n(fn REST WINTAG)"])
(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 "\n\n(fn FORM)"])
(defalias 'byte-compile-funcall #[257 "\300\301A\"\210\302\303AAG\"\207" [mapc byte-compile-form byte-compile-out byte-call] 4 "\n\n(fn FORM)"])
#@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\302\211A@)!\210\202#\303\304!\210\207" [byte-compile-depth x byte-compile-form byte-compile-push-constant nil] 6 (#$ . 116513)])
(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 "\n\n(fn VAR)"])
#@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 "\302!\204

\236B\303\207

\211@@)=\203\304!\210\305\207

\236A\306
!\210\304!\210\307\303!\210\310
!\266\303\207" [byte-compile--lexical-environment x byte-compile-not-lexical-var-p nil byte-compile-dynamic-variable-bind t byte-compile-stack-ref byte-compile-push-constant byte-compile-stack-set] 6 (#$ . 117074)])
#@503 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 &optional PRESERVE-BODY-VALUE)
(defalias 'byte-compile-unbind #[770 "\301\211\203#\211@\211:\203\211@\202\211\236\204T\262
A\266\202\202\210\302
!\204/\303\304\"\210\210
\2059\305G\"\207" [byte-compile--lexical-environment 0 zerop byte-compile-out byte-unbind byte-compile-discard] 8 (#$ . 117714)])
#@51 Generate code for the `let' form FORM.

(fn FORM)
(defalias 'byte-compile-let #[257 "\211\211A@)\306@\307=\203$
\211\203#\211@\310
!B\262
A\266\202\202\210	\n@\307=\2035\311!\2026
\211\203s\211@@\307=\204J\310
!B\262\211:\203T\211@\202U\211\204`\312
!\210\202k\313
\"\203kA\262\210
A\266\202\2026\210\fAA\314

\"\210\306\211\266\203\243\f
=\204\231\f
T=\204\231\315\316\317C\"\210\320\fV#\202\250\321\322G\"\262
*\207" [x byte-compile-bound-variables byte-compile--lexical-environment lexical-binding byte-compile-depth byte-compile--for-effect nil let byte-compile-push-binding-init reverse byte-compile-dynamic-variable-bind byte-compile-bind byte-compile-body signal cl-assertion-failed (or (eq byte-compile-depth init-stack-depth) (eq byte-compile-depth (1+ init-stack-depth))) byte-compile-unbind byte-compile-out byte-unbind] 9 (#$ . 118509)])
(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)
(defalias 'byte-compile-negated #[257 "\301
!\302
\"\210\303\211\207" [byte-compile--for-effect byte-compile-negation-optimizer byte-compile-form nil] 5 "\n\n(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 "\n\n(fn FORM)"])
(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#\210\300\316\302\317#\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 track-mouse byte-compile-track-mouse] 4)
(defalias 'byte-compile-catch #[257 "\301
A@!\210\211\211AA)\302
:\203O
@A
\303=\204#!\210\202J\211:\203F\211@
A\211\204<
\301\304\305E!\266\202A!\210\266\202J!\210\266\202S\211!\210\266\306\307\310\"\207" [x byte-compile-form #[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-compile-out byte-catch 0] 12 "\n\n(fn FORM)"])
(defalias 'byte-compile-unwind-protect #[257 "\211\211AA)\302
:\203K
@A
\303=\204!\210\202F\211:\203B\211@
A\211\2048
\304\305\211\306ED!\266\202=!\210\266\202F!\210\266\202O\211!\210\266\307\310\311\"\210\211A@\304
	\"\210\312\211\266\307\313\314\"\207" [x byte-compile--for-effect #[257 "\300\301\302\"!\207" [byte-compile-push-constant byte-compile-top-level-body t] 5 "\n\n(fn HANDLERS)"] :fun-body byte-compile-form list 'funcall byte-compile-out byte-unwind-protect 0 nil byte-unbind 1] 13 "\n\n(fn FORM)"])
(defalias 'byte-compile-track-mouse #[257 "\300\301:\203UA\211:\203M\211@
A
\302=\204!\202H\211:\203D\211@
A\211\204;
\303\304\305\304\306EED\262
\202?!\266\202\202H!\266\202\202P
!\262
\202X\211!\262
!\207" [byte-compile-form #[257 "\300\301\302\303A!BDD\207" [eval quote track-mouse byte-compile-top-level-body] 6 "\n\n(fn FORM)"] :fun-body eval list 'track-mouse 'funcall] 15 "\n\n(fn FORM)"])
(defalias 'byte-compile-condition-case #[257 "\211A@C\211@\302=
@\203\211\204
@B\202\303\304!\210
@9\204*\305\306@\"\210\211\2034
\307\310!\240\210\311@!\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*\304
\211\203#\211@\2119\204\305\262
A\266\202\202\210\211\262
\204/\306\307\"\210\301\203H\310\311D\310\312\211A@)\311\300@DFE\202O\211\313A\"B\207" vconcat vector [x 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] 10 "\n\n(fn CLAUSE)" byte-compile-out byte-condition-case 0] 11 "\n\n(fn FORM)"])
(defalias 'byte-compile-save-excursion #[257 "\211A\242\242\301=\203\302\303!\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 "\n\n(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 "\n\n(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 "\n\n(fn FORM)"])
(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)
(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 "\n\n(fn FORM)"])
(defconst byte-compile-tmp-var (make-symbol "def-tmp-var"))
(defalias 'byte-compile-defvar #[257 "\211A@9\203\305\306\307A@!\"\204\310\311!\203\312\313A@\"\210\211@
A@\3148\3158\316!\210G\317V\204D\320=\203g\211AA)\204gAG\312\321\211\322U\203V\323\202W\324\314W\203a\325\202b\326\327&\266	B\320=\203u\nB\211\203\205\211;\204\205\312\330$\210\211AA)\203\246\331\332\333C\315\f\233BBBEDE\202\270\320=\203\265\334\332DD\202\270\332D\335
\f\"\210\336\211\262
\207" [x 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] 15 "\n\n(fn FORM)"])
(defalias 'byte-compile-autoload #[257 "\300\301!\210\302
A@!\203/\302\3038!\203/\304\3038!\203/\305\304A@!!\204/\306\307\304A@!\"\210\310
!\207" [byte-compile-set-symbol-position autoload macroexp-const-p 5 eval 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 "\n\n(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 "\n\n(fn FORM)"])
(put 'defalias 'byte-hunk-handler 'byte-compile-file-form-defalias)
(defalias 'byte-compile-file-form-defalias #[257 "\302\211\211:\203\321
\211A\211:\203\311
\211@
A
:\203\301

@A
\303=\204*\304!\202\274
\211:\203\270
\211@
A\211\203>\304!\202\263
:\203\257
@A\211\305:\203\235
@A
\306=\203
\211:\203
\211@
A
:\203


@A
\303=\204\201\n\302
%\202\374\211:\203\360\211@
A
\307=\204\237
\f\302%\202\353\211\203\262
\f\302%\202\353:\203\337@A\211\204\316\n\310%\202\332\n\302%\266\202\202\353
\f\302%\266\202\202\374\n\302
%\266\202\202\f
	\302%\266\202\202\230
\302	%\202\230

\303=\2043
\302	%\202\230
\211:\203\215
\211@
A
:\203}

@A
\307=\204Z
\n\302
%\202x
\204l
\n\310%\202x
\n\302
%\266\202\202\210
	\302%\266\202\202\230
\302	%\266\202\202\246
\211\302%\262
\266\203\266\202\202\263
\304!\266\202\202\274
\304!\266\202\202\304
\304!\266\202\202\314
\304!\262
\202\324
\304
!*\207" [byte-compile-free-assignments byte-compile-free-references nil quote byte-compile-keep-pending #[1285 "\300
:\203Z
@A
\301>\204\302%\202U\211:\203J\211@
A\211\204:\n\n\n\n%\202E\n\n\n\n\302%\266\202\202U\302%\266\202\202e\211\302%\207" [#[1285 "\300
:\203~
@A
\301=\203<\211:\203,\211@
A\n\n\n\n&\266\202\202y\302\211&\202y
\303=\204R\302\211&\202y\211:\203l\211@				\302&\262
\202y\302\211&\266\202\202\213\211\302\211&\207" [#[1542 "\300	%?\205\301!\207" [byte-compile-file-form-defmumble byte-compile-keep-pending] 12 "\n\n(fn FORM REST NAME MACRO BODY ARGLIST)"] lambda t internal-make-closure] 17 "\n\n(fn FORM REST NAME MACRO LAM)"] 'function nil] 16 "\n\n(fn FORM REST NAME MACRO FUN)"] cons macro t] 30 "\n\n(fn FORM)"])
(put 'with-no-warnings 'byte-compile 'byte-compile-no-warnings)
(defalias 'byte-compile-no-warnings #[257 "\301\302\303AB!)\207" [byte-compile-warnings nil byte-compile-form progn] 4 "\n\n(fn FORM)"])
(put 'make-variable-buffer-local 'byte-compile 'byte-compile-make-variable-buffer-local)
(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' should be called at toplevel" byte-compile-normal-call] 3 "\n\n(fn FORM)"])
(put 'make-variable-buffer-local 'byte-hunk-handler 'byte-compile-form-make-variable-buffer-local)
(defalias 'byte-compile-form-make-variable-buffer-local #[257 "\300
\301\"\207" [byte-compile-keep-pending byte-compile-normal-call] 4 "\n\n(fn FORM)"])
(put 'add-to-list 'byte-compile 'byte-compile-add-to-list)
(defalias 'byte-compile-add-to-list #[257 "\211:\203q\211@
A\211:\203o\211@\211:\203n\211@
A
\303=\203l\211:\203l\211@
A\211\204j
\304\305\"\210
\236\203G\306\307\310#\311\312#\210\202h\313\314!\203h\315!\204h
	>\204h
\n>\204h\316\317\"\210
\nB\266\266\266\210\266\320
!\207" [byte-compile--lexical-environment byte-compile-bound-variables byte-compile-free-references quote byte-compile-check-variable assign byte-compile-log-warning format "%s cannot use lexical var `%s'" nil :error byte-compile-warning-enabled-p free-vars boundp byte-compile-warn "assignment to free variable `%S'" byte-compile-normal-call] 15 "\n\n(fn FORM)"])
(defalias 'byte-compile-make-tag #[0 "\301T\211D\207" [byte-compile-tag-number TAG] 3 "\n\n(fn)"])
(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 "\n\n(fn 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 "\n\n(fn OPCODE TAG)"])
#@129 Return the amount by which an operation adjusts the stack.
OP and OPERAND are as passed to `byte-compile-out'.

(fn OP OPERAND)
(defalias 'byte-compile-stack-adjustment #[514 "
\301>\203	\211[\207JH\206\302
Z\207" [byte-stack+-info (byte-call byte-discardN byte-discardN-preserve-tos) 1] 4 (#$ . 130113)])
(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 "\n\n(fn OP &optional OPERAND)"])
(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 "\n\n(fn FORM)"])
#@626 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\224\327CA\330=\203k\331\202\221A\332=\203v\333\202\221A\334=\203\201\335\202\221A\336=\203\214\337\202\221\340\341A\"\"C\306\307!\210Cp\313\211\211\211\203\245
\342@@\"\210@A@\262\343@8\262
\344\345@@\211\262!\204\322\204\316\346\2027
\347\2027
\350K\211\262!\203\340\351\2027
9\203\355\352\353\"\2027
\354!\203\367\355\2027
:\204
\356\2027
@\357=\203
\354A!\204
\360AAA\236\203
\361\2027
\362\2027
\360AA\236\203+
\363\2027
@\364=\2036
\365\2027
\322\352\366GGGG\\$\367\261\210
\203w
\370c\210`\262\371@\203a
\372\373\374#\202b
\375\261\210\371D\376`\"\210)i\377U\204w
\367c\210\211\203\236
\201Fc\210`\262\371\372\373\374#\261\210\371D\376`\"\210)i\377U\204\236
\367c\210A\262\202\237\306\201G!\210C\262\313\211\203!@A@\204\211E@@)\211\262\203\201H\314\"\262
\211\242\357=\203\350
\211\243\242\364=\203\350
\211A\262
\201I
!\204\201H\313\"\262
\211\242\357=\203\f\211\243\242\364=\203\f\211A\262
\201J
!\204B\262A\262\202\261

\203@\201KD\201Lc\210`\262\372\373\237\374#c\210\376`\"\210)\266\306\201M!\201N!\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 callers #[514 "
A@G
A@GW\207" #1=[] 4 "\n\n(fn X Y)"] calls #[514 "\3008G\3008GW\207" [2] 5 "\n\n(fn X Y)"] calls+callers #[514 "
A@G\3008G\\
A@G\3008G\\W\207" [2] 6 "\n\n(fn X Y)"] name #[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 standard-output byte-compile-call-tree-sort byte-compile-current-file byte-compile-call-tree fill-prefix x "  calls:\n" "Generating call tree...(finding uncalled functions...)" byte-compile-fdefinition functionp commandp "  " "Noninteractive functions not known to be called:\n  " "Generating call tree...done." internal-temp-output-buffer-show] 18 (#$ . 130955) nil])
#@163 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.

(fn)
(defalias 'batch-byte-compile-if-not-done #[0 "\300\301!\207" [batch-byte-compile t] 2 (#$ . 134388)])
#@396 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.
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\303\304!\210\305	\203\217\306\307	@!!\203e\305\211\310	@!\211\203`\211@\311\n\"\203Y\312
!\204Y\307
	@\"\211\262\203Y\313!\211\262\203Y\314!\203Y\315\"\203Y\316!\204Y\317\262
A\266\202\202\266\202\210
\203~	@\313
!\314
!?\206y\315\"\266\202\203\210\316	@!\204\210\317\262
	A\211\204
\320
\203\230\321\202\231\322!\207" [noninteractive 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 (#$ . 134660)])
(defalias 'batch-byte-compile-file #[257 "\206	\n\203\303
!\202F\304\305\306\307\310\311\312!\313\"\314\315%D\316\305\306\317\320\311\312	!\321\"\322\323%\304ED\324\305\306\317\325\311\312\n!\326\"\322\323%\304EDD\217)\207" [byte-compile-root-dir default-directory debug-on-error byte-compile-file #1=#:err funcall make-byte-code 0 "\301\300!\207" vconcat vector [byte-compile-file] 2 "\n\n(fn)" file-error 257 "\301
A\203\n\302\202\303\300@\304N\305A!$\210\306\300!\307
!\203#\310
!\210\210\311\207" [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] 7 "\n\n(fn ERR)" error "\301
A\203\n\302\202\303\300@\304N\305A!$\210\306\207" [message ">>Error occurred processing %s: %s (%s)" ">>Error occurred processing %s: %s" error-message prin1-to-string nil]] 12 "\n\n(fn FILE)"])
#@87 Reload any Lisp file that was changed since Emacs was dumped.
Use with caution.

(fn)
(defalias 'byte-compile-refresh-preloaded #[0 "@\302
!\211\203\303
!\204\304\305\"\202x\306	!\211\205v\211@C\211
@@\240\210\307\310@\"\2036\211
@\311\312O\240\210\313
@!\203o\314
@\"\203o\315
@!\316\235\204o\304\317\315@!\"\210\320\321\322\311\323\324\325!\326\"\327\330%D\331\321\332\320EDC\217\210
A\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\\'" 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" #1=#:err funcall make-byte-code "\301\300@\302\303\304$\207" vconcat vector [load noerror nil nosuffix] 5 "\n\n(fn)" error #[257 "\300\207" [nil] 2 "\n\n(fn IGNORED)"]] 12 (#$ . 136709)])
#@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\302\303!\210	\204\304	\203\305	@\"\210	A\211\204\306\307!\207" [noninteractive command-line-args-left error "batch-byte-recompile-directory is to be used only with -batch" (".") byte-recompile-directory kill-emacs 0] 5 (#$ . 137639)])
(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 "\n\n(fn)"])
(run-hooks 'bytecomp-load-hook)