;ELC
;;; Compiled by mockbuild@buildfarm06-new.corp.cloudlinux.com on Fri Oct 11 10:12:50 2024
;;; from file /builddir/build/BUILD/emacs-24.3/lisp/emacs-lisp/lisp-mode.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.

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


(defvar lisp-mode-abbrev-table nil)
(define-abbrev-table 'lisp-mode-abbrev-table nil "Abbrev table for Lisp mode.")
(defvar emacs-lisp-mode-abbrev-table nil)
(byte-code "\301\302\303\304\305C%\207" [lisp-mode-abbrev-table define-abbrev-table emacs-lisp-mode-abbrev-table nil "Abbrev table for Emacs Lisp mode.\nIt has `lisp-mode-abbrev-table' as its parent." :parents] 6)
#@41 Syntax table used in `emacs-lisp-mode'.
(defvar emacs-lisp-mode-syntax-table (byte-code "\302 \303\304W\203\305\306	#\210T\211\202\307\211\310W\203-\305\306	#\210T\211\202\311\211\312W\203B\305\306	#\210T\211\2020\313\211\314W\203W\305\306	#\210T\211\202E\305\315\316	#\210\305\317\316	#\210\305\320\316	#\210\305\321\316	#\210\305\322\323	#\210\305\324\325	#\210\305\326\327	#\210\305\330\327	#\210\305\331\327	#\210\305\332\327	#\210\305\333\306	#\210\305\334\327	#\210\305\335\336	#\210\305\337\340	#\210\305\341\342	#\210\305\343\344	#\210\305\311\345	#\210\305\346\347	#\210	*\207" [i table make-syntax-table 0 48 modify-syntax-entry "_   " 58 65 91 97 123 128 32 "    " 2208 9 12 10 ">   " 59 "<   " 96 "'   " 39 44 64 46 35 34 "\"    " 92 "\\   " 40 "()  " 41 ")(  " "(]  " 93 ")[  "] 5) (#$ . 934))
#@35 Syntax table used in `lisp-mode'.
(defvar lisp-mode-syntax-table (byte-code "\302!\303\304\305	#\210\303\306\305	#\210\303\307\310	#\210\303\311\312	#\210	)\207" [emacs-lisp-mode-syntax-table table copy-syntax-table modify-syntax-entry 91 "_   " 93 35 "' 14" 124 "\" 23bn"] 4) (#$ . 1776))
#@74 Imenu generic expression for Lisp mode.  See `imenu-generic-expression'.
(defvar lisp-imenu-generic-expression (byte-code "\300\301\302!\303E\301\304!\301\305!\303E\301\304!\301\306!\307E\301\310!\301\311!\303EF\207" [nil purecopy "^\\s-*(\\(def\\(?:advice\\|generic\\|ine-\\(?:compiler-macro\\|derived-mode\\|g\\(?:\\(?:eneric\\|lobal\\(?:\\(?:ized\\)?-minor\\)\\)-mode\\)\\|m\\(?:ethod-combination\\|inor-mode\\|odify-macro\\)\\|s\\(?:etf-expander\\|keleton\\)\\)\\|m\\(?:acro\\|ethod\\)\\|s\\(?:etf\\|ubst\\)\\|un\\*?\\)\\)\\s-+\\(\\(\\sw\\|\\s_\\)+\\)" 2 "Variables" "^\\s-*(\\(def\\(?:c\\(?:onst\\(?:ant\\)?\\|ustom\\)\\|ine-symbol-macro\\|parameter\\)\\)\\s-+\\(\\(\\sw\\|\\s_\\)+\\)" "^\\s-*(defvar\\s-+\\(\\(\\sw\\|\\s_\\)+\\)[[:space:]\n]+[^)]" 1 "Types" "^\\s-*(\\(def\\(?:class\\|face\\|group\\|ine-\\(?:condition\\|widget\\)\\|package\\|struct\\|t\\(?:\\(?:hem\\|yp\\)e\\)\\)\\)\\s-+'?\\(\\(\\sw\\|\\s_\\)+\\)"] 6) (#$ . 2074))
(byte-code "\300\301\302\303#\210\300\304\302\303#\210\300\305\302\303#\210\300\306\302\303#\210\300\307\302\303#\210\300\310\302\303#\210\300\311\302\312#\207" [put autoload doc-string-elt 3 defmethod defvar defconst defalias defvaralias define-category 2] 4)
#@61 The symbol property that holds the docstring position info.
(defvar lisp-doc-string-elt-property 'doc-string-elt (#$ . 3281))
(defalias 'lisp-font-lock-syntactic-face-function #[(state) "\3068\203t\3078\211f\310=?\205rA@\211\205(\212\nb\210\311\312!\205'\313\314!)\211\2053\315\316!\f\"\211\203o\212\317
!\203F\314\225b\210
 \nb\210\314u\210\320\321\322\217\210\323
!\205f`	X\205f\324d!\210`\3078U)\203o\202q+)\207\207" [state startpos listbeg firstsym lisp-doc-string-elt-property docelt 3 8 124 looking-at "([ 	\n]*\\(\\(\\sw\\|\\s_\\)+\\)" match-string 1 function-get intern-soft functionp nil (byte-code "\302V\203`	W\203\303\304!\210S\211\202
\302\207" [docelt startpos 0 forward-sexp 1] 3) ((error)) zerop forward-comment font-lock-doc-face font-lock-string-face font-lock-comment-face] 4])
#@283 Common initialization routine for lisp modes.
The LISP-SYNTAX argument is used by code in inf-lisp.el and is
(uselessly) passed from pp.el, chistory.el, gnus-kill.el and
score-mode.el.  KEYWORDS-CASE-INSENSITIVE non-nil means that for
font-lock keywords will not be case sensitive.
(defalias 'lisp-mode-variables #[(&optional lisp-syntax keywords-case-insensitive) "\203\306	!\210\307\302!\210\310\307\303!\210\311\307\304!\210\312\307\305!\210\313\307\314!\210\315\f\307\316!\210\317\307\320!\210\321\307\322!\210\323\307\324!\210\325\307\326!\210\327\307\330!\210\331\307\332!\210\310\307\333!\210\"\307\334!\210\310\307\335!\210\336\337\340#\341BBB\211$\207" [lisp-syntax lisp-mode-syntax-table paragraph-ignore-fill-prefix fill-paragraph-function adaptive-fill-function indent-line-function set-syntax-table make-local-variable t lisp-fill-paragraph #[nil "\300\301!\205\302\207" [looking-at "\\s-+\"[^\n\"]+\"\\s-*$" ""] 2] lisp-indent-line outline-regexp ";;;\\(;* [^ 	\n]\\|###autoload\\)\\|(" outline-level lisp-outline-level comment-start ";" comment-start-skip "\\(\\(^\\|[^\\\\\n]\\)\\(\\\\\\\\\\)*\\);+ *" font-lock-comment-start-skip ";+ *" comment-add 1 comment-column 40 comment-use-global-state imenu-generic-expression multibyte-syntax-as-symbol syntax-begin-function beginning-of-defun (lisp-font-lock-keywords lisp-font-lock-keywords-1 lisp-font-lock-keywords-2) nil ((("+-*/.<>=!?$%_&~^:@" . "w")) nil (font-lock-mark-block-function . mark-defun) (font-lock-syntactic-face-function . lisp-font-lock-syntactic-face-function)) lisp-imenu-generic-expression keywords-case-insensitive font-lock-defaults] 4 (#$ . 4120)])
#@37 Lisp mode `outline-level' function.
(defalias 'lisp-outline-level #[nil "\301\225\301\224Z\302\303!\203\304\202)\207" [len 0 looking-at "(\\|;;;###autoload" 1000] 2 (#$ . 5796)])
#@56 Keymap for commands shared by all sorts of Lisp modes.
(defvar lisp-mode-shared-map (byte-code "\301 \302\303\304#\210\302\305\306#\210)\207" [map make-sparse-keymap define-key "" indent-sexp "" backward-delete-char-untabify] 4) (#$ . 5987))
#@95 Keymap for Emacs Lisp mode.
All commands in `lisp-mode-shared-map' are inherited by this map.
(defvar emacs-lisp-mode-map (byte-code "\306\307!\306\307!\306 \306 \306 \310\f
\"\210\311\f\312\313#\210\311\f\314\315#\210\311\f\316\317#\210\320\f\321\307B#\210\320\322\323#\210\320\324\325#\210\320\326\327#\210\320\330\331B#\210\320\332\333#\210\320\334\335#\210\320\336@#\210\320\337\340#\210\320\341\342#\210\320\343\344	B#\210\320	\345\346#\210\320	\347\350#\210\320	\351@#\210\320	\352\353#\210\320	\354\355#\210\320	\356\357#\210\320	\360\361#\210\320	\362\363#\210\320\364\365\nB#\210\320\n\366\367#\210\320\n\370\371#\210\320\n\372\373#\210\320\n\374\375#\210\320\376\377#\210\320\201A@#\210\320\201B\201C#\210\320\201D\201E#\210\320\201F\201G#\210\320\201H\201I#\210\320\201J@#\210\320\201K\201L#\210\320\201M\201N#\210\320\201O\201P#\210\320\201Q\201R#\210\320\201S@#\210\320\201T\201U#\210\320\201V\201W#\210\320\201X\201Y#\210\f-\207" [tracing-map prof-map lint-map menu-map map lisp-mode-shared-map make-sparse-keymap "Emacs-Lisp" set-keymap-parent define-key "	" completion-at-point "" eval-defun "" indent-pp-sexp bindings--define-key [menu-bar emacs-lisp] [eldoc] (menu-item "Auto-Display Documentation Strings" eldoc-mode :button (:toggle bound-and-true-p eldoc-mode) :help "Display the documentation string for the item under cursor") [checkdoc] (menu-item "Check Documentation Strings" checkdoc :help "Check documentation strings for style requirements") [re-builder] (menu-item "Construct Regexp" re-builder :help "Construct a regexp interactively") [tracing] "Tracing" [tr-a] (menu-item "Untrace All" untrace-all :help "Untrace all currently traced functions") [tr-uf] (menu-item "Untrace Function..." untrace-function :help "Untrace function, and possibly activate all remaining advice") [tr-sep] [tr-q] (menu-item "Trace Function Quietly..." trace-function-background :help "Trace the function with trace output going quietly to a buffer") [tr-f] (menu-item "Trace Function..." trace-function :help "Trace the function given as an argument") [profiling] "Profiling" [prof-restall] (menu-item "Remove Instrumentation for All Functions" elp-restore-all :help "Restore the original definitions of all functions being profiled") [prof-restfunc] (menu-item "Remove Instrumentation for Function..." elp-restore-function :help "Restore an instrumented function to its original definition") [sep-rem] [prof-resall] (menu-item "Reset Counters for All Functions" elp-reset-all :help "Reset the profiling information for all functions being profiled") [prof-resfunc] (menu-item "Reset Counters for Function..." elp-reset-function :help "Reset the profiling information for a function") [prof-res] (menu-item "Show Profiling Results" elp-results :help "Display current profiling results") [prof-pack] (menu-item "Instrument Package..." elp-instrument-package :help "Instrument for profiling all function that start with a prefix") [prof-func] (menu-item "Instrument Function..." elp-instrument-function :help "Instrument a function for profiling") [lint] "Linting" [lint-di] (menu-item "Lint Directory..." elint-directory :help "Lint a directory") [lint-f] (menu-item "Lint File..." elint-file :help "Lint a file") [lint-b] (menu-item "Lint Buffer" elint-current-buffer :help "Lint the current buffer") [lint-d] (menu-item "Lint Defun" elint-defun :help "Lint the function at point") [edebug-defun] (menu-item "Instrument Function for Debugging" edebug-defun :help "Evaluate the top level form point is in, stepping through with Edebug" :keys "C-u C-M-x") menu-bar-separator [separator-byte] [disas] (menu-item "Disassemble Byte Compiled Object..." disassemble :help "Print disassembled code for OBJECT in a buffer") [byte-recompile] (menu-item "Byte-recompile Directory..." byte-recompile-directory :help "Recompile every `.el' file in DIRECTORY that needs recompilation") [emacs-byte-compile-and-load] (menu-item "Byte-compile and Load" emacs-lisp-byte-compile-and-load :help "Byte-compile the current file (if it has changed), then load compiled code") [byte-compile] (menu-item "Byte-compile This File" emacs-lisp-byte-compile :help "Byte compile the file containing the current buffer") [separator-eval] [ielm] (menu-item "Interactive Expression Evaluation" ielm :help "Interactively evaluate Emacs Lisp expressions") [eval-buffer] (menu-item "Evaluate Buffer" eval-buffer :help "Execute the current buffer as Lisp code") [eval-region] (menu-item "Evaluate Region" eval-region :help "Execute the region as Lisp code" :enable mark-active) [eval-sexp] (menu-item "Evaluate Last S-expression" eval-last-sexp :help "Evaluate sexp before point; print value in minibuffer") [separator-format] [comment-region] (menu-item "Comment Out Region" comment-region :help "Comment or uncomment each line in the region" :enable mark-active) [indent-region] (menu-item "Indent Region" indent-region :help "Indent each nonblank line in the region" :enable mark-active) [indent-line] (menu-item "Indent Line" lisp-indent-line)] 5) (#$ . 6242))
#@54 Byte compile the file containing the current buffer.
(defalias 'emacs-lisp-byte-compile #[nil "\203\301!\207\302\303!\207" [buffer-file-name byte-compile-file error "The buffer must be saved in a file first"] 2 (#$ . 11354) nil])
#@77 Byte-compile the current file (if it has changed), then load compiled code.
(defalias 'emacs-lisp-byte-compile-and-load #[nil "\204\301\302!\210\303\304!\210\305 \203\306\307\310\311 \"!\203\312 \210\313\314\315\316$\207" [buffer-file-name error "The buffer must be saved in a file first" require bytecomp buffer-modified-p y-or-n-p format "Save buffer %s first? " buffer-name save-buffer byte-recompile-file nil 0 t] 5 (#$ . 11594) nil])
(byte-code "\300\301\302\303\304\305\306\307\310\311&	\210\300\312\302\313\304\314\306\307\310\311&	\210\300\315\302\316\304\317\306\307\310\311&	\210\301\320N\2045\321\301\320\322\323!#\210\324\325!\204A\321\325\326\327#\210\302\207" [custom-declare-variable emacs-lisp-mode-hook nil "Hook run when entering Emacs Lisp mode." :options (turn-on-eldoc-mode imenu-add-menubar-index checkdoc-minor-mode) :type hook :group lisp lisp-mode-hook "Hook run when entering Lisp mode." (imenu-add-menubar-index) lisp-interaction-mode-hook "Hook run when entering Lisp Interaction mode." (turn-on-eldoc-mode) variable-documentation put purecopy "Hook run when entering Emacs-Lisp mode.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it.  (This is true for all hook variables.)" boundp emacs-lisp-mode-map definition-name emacs-lisp-mode] 10)
(defvar emacs-lisp-mode-map (make-sparse-keymap))
(byte-code "\300\301N\204\302\300\301\303\304!#\210\305\306!\204\302\306\307\310#\210\300\207" [emacs-lisp-mode-map variable-documentation put purecopy "Keymap for `emacs-lisp-mode'." boundp emacs-lisp-mode-syntax-table definition-name emacs-lisp-mode] 5)
(defvar emacs-lisp-mode-syntax-table (make-syntax-table))
(byte-code "\300\301N\204\302\300\301\303\304!#\210\302\305\306\307#\207" [emacs-lisp-mode-syntax-table variable-documentation put purecopy "Syntax table for `emacs-lisp-mode'." emacs-lisp-mode-abbrev-table definition-name emacs-lisp-mode] 5)
(defvar emacs-lisp-mode-abbrev-table (progn (define-abbrev-table 'emacs-lisp-mode-abbrev-table nil) emacs-lisp-mode-abbrev-table))
(byte-code "\300\301N\204\302\300\301\303\304!#\210\302\305\306\307#\210\302\305\310\311#\207" [emacs-lisp-mode-abbrev-table variable-documentation put purecopy "Abbrev table for `emacs-lisp-mode'." emacs-lisp-mode derived-mode-parent prog-mode custom-mode-group lisp] 5)
#@282 Major mode for editing Lisp code to run in Emacs.
Commands:
Delete converts tabs to spaces as it moves back.
Blank lines separate paragraphs.  Semicolons start comments.

\{emacs-lisp-mode-map}
Entry to this mode calls the value of `emacs-lisp-mode-hook'
if that value is non-nil.
(defalias 'emacs-lisp-mode #[nil "\306\300!\210\307\310 \210\311\312\310\313N\203\314\311\313\310\313N#\210\315!\204'\316\317 \"\210\320\f!\211\2036
\321 =\203<\322\f\323 \"\210)\324!\325\"\204V!\"=\204V\326!\325\"C#\210\327!\210\330\f!\210!\"\331 \210\332#\333\334\335\332\336$\210)\337\340!\207" [delay-mode-hooks major-mode mode-name emacs-lisp-mode-map emacs-lisp-mode-syntax-table parent make-local-variable t prog-mode emacs-lisp-mode "Emacs-Lisp" mode-class put keymap-parent set-keymap-parent current-local-map char-table-parent standard-syntax-table set-char-table-parent syntax-table abbrev-table-get :parents abbrev-table-put use-local-map set-syntax-table lisp-mode-variables nil add-hook completion-at-point-functions lisp-completion-at-point local run-mode-hooks emacs-lisp-mode-hook emacs-lisp-mode-abbrev-table local-abbrev-table imenu-case-fold-search] 6 (#$ . 13934) nil])
(defconst emacs-list-byte-code-comment-re "\\(#\\)@\\([0-9]+\\) \\(?:[^(]\\|([^\"]\\)")
#@75 Try to syntactically mark the #@NNN ....^_ docstrings in byte-code files.
(defalias 'emacs-lisp-byte-code-comment #[(end &optional _point) "\306 \3078\205\203\3108f\311=\205\203\212\3108b\210\312	!\205#\313\314\315!!)\211\n\205\202\315\225\316\f!\211\n\\b\210\317\316`!
\n#\320!?\205iV\203R[u\210\321V\203c\202gS\322]\323)\2047*`X\203\324`S`\325\326$\202\202b*)\207" [ppss emacs-list-byte-code-comment-re n maxdiff bchar b syntax-ppss 4 8 35 looking-at string-to-number match-string 2 position-bytes - zerop 0 1 t put-text-property syntax-table (2097164) diff end] 6 (#$ . 15222)])
(defalias 'emacs-lisp-byte-code-syntax-propertize #[(start end) "\302`\"\210	\211b\210`W\2050\303\304\305#\2050\306\224\203\f\307\306\224\306\225\310\311$\210\302`\"\210\202\f*\207" [end start emacs-lisp-byte-code-comment re-search-forward "\\(#\\)@\\([0-9]+\\) \\(?:[^(]\\|([^\"]\\)" t 1 put-text-property syntax-table (2097163)] 6])
(byte-code "\300\301\302\"\210\303\304N\204\305\303\304\306\307!#\210\310\311!\204\305\311\312\313#\210\300\207" [add-to-list auto-mode-alist ("\\.elc\\'" . emacs-lisp-byte-code-mode) emacs-lisp-byte-code-mode-hook variable-documentation put purecopy "Hook run when entering Elisp-Byte-Code mode.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it.  (This is true for all hook variables.)" boundp emacs-lisp-byte-code-mode-map definition-name emacs-lisp-byte-code-mode] 5)
(defvar emacs-lisp-byte-code-mode-map (make-sparse-keymap))
(byte-code "\300\301N\204\302\300\301\303\304!#\210\305\306!\204\302\306\307\310#\210\300\207" [emacs-lisp-byte-code-mode-map variable-documentation put purecopy "Keymap for `emacs-lisp-byte-code-mode'." boundp emacs-lisp-byte-code-mode-syntax-table definition-name emacs-lisp-byte-code-mode] 5)
(defvar emacs-lisp-byte-code-mode-syntax-table (make-syntax-table))
(byte-code "\300\301N\204\302\300\301\303\304!#\210\302\305\306\307#\207" [emacs-lisp-byte-code-mode-syntax-table variable-documentation put purecopy "Syntax table for `emacs-lisp-byte-code-mode'." emacs-lisp-byte-code-mode-abbrev-table definition-name emacs-lisp-byte-code-mode] 5)
(defvar emacs-lisp-byte-code-mode-abbrev-table (progn (define-abbrev-table 'emacs-lisp-byte-code-mode-abbrev-table nil) emacs-lisp-byte-code-mode-abbrev-table))
(byte-code "\300\301N\204\302\300\301\303\304!#\210\302\305\306\307#\207" [emacs-lisp-byte-code-mode-abbrev-table variable-documentation put purecopy "Abbrev table for `emacs-lisp-byte-code-mode'." emacs-lisp-byte-code-mode derived-mode-parent emacs-lisp-mode] 5)
#@238 Major mode for *.elc files.

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

\{emacs-lisp-byte-code-mode-map}
(defalias 'emacs-lisp-byte-code-mode #[nil "\306\300!\210\307\310 \210\311\312\310\313N\203\314\311\313\310\313N#\210\315!\204'\316\317 \"\210\320\f!\211\2036
\321 =\203<\322\f\323 \"\210)\324\325\"\204V =\204V\326\325 C#\210\327!\210\330\f!\210 \306\331!\210\332\306\333!\210\334)\335\336!\207" [delay-mode-hooks major-mode mode-name emacs-lisp-byte-code-mode-map emacs-lisp-byte-code-mode-syntax-table parent make-local-variable t emacs-lisp-mode emacs-lisp-byte-code-mode "Elisp-Byte-Code" mode-class put keymap-parent set-keymap-parent current-local-map char-table-parent standard-syntax-table set-char-table-parent syntax-table abbrev-table-get :parents abbrev-table-put use-local-map set-syntax-table open-paren-in-column-0-is-defun-start nil syntax-propertize-function emacs-lisp-byte-code-syntax-propertize run-mode-hooks emacs-lisp-byte-code-mode-hook emacs-lisp-byte-code-mode-abbrev-table local-abbrev-table] 6 (#$ . 17851) nil])
#@98 Keymap for ordinary Lisp mode.
All commands in `lisp-mode-shared-map' are inherited by this map.
(defvar lisp-mode-map (byte-code "\303 \303\304!\305	\n\"\210\306	\307\310#\210\306	\311\312#\210\313	\314\304B#\210\313\315\316#\210\313\317\320#\210\313\321\322#\210	*\207" [menu-map map lisp-mode-shared-map make-sparse-keymap "Lisp" set-keymap-parent define-key "" lisp-eval-defun "" run-lisp bindings--define-key [menu-bar lisp] [run-lisp] (menu-item "Run inferior Lisp" run-lisp :help "Run an inferior Lisp process, input and output via buffer `*inferior-lisp*'") [ev-def] (menu-item "Eval defun" lisp-eval-defun :help "Send the current defun to the Lisp process made by M-x run-lisp") [ind-sexp] (menu-item "Indent sexp" indent-sexp :help "Indent each line of the list starting just after point")] 5) (#$ . 19064))
(byte-code "\300\301N\204\302\300\301\303\304!#\210\305\306!\204\302\306\307\310#\210\300\207" [lisp-mode-hook variable-documentation put purecopy "Hook run when entering Lisp mode.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it.  (This is true for all hook variables.)" boundp lisp-mode-map definition-name lisp-mode] 5)
(defvar lisp-mode-map (make-sparse-keymap))
(byte-code "\300\301N\204\302\300\301\303\304!#\210\305\306!\204\302\306\307\310#\210\300\207" [lisp-mode-map variable-documentation put purecopy "Keymap for `lisp-mode'." boundp lisp-mode-syntax-table definition-name lisp-mode] 5)
(defvar lisp-mode-syntax-table (make-syntax-table))
(byte-code "\300\301N\204\302\300\301\303\304!#\210\302\305\306\307#\207" [lisp-mode-syntax-table variable-documentation put purecopy "Syntax table for `lisp-mode'." lisp-mode-abbrev-table definition-name lisp-mode] 5)
(defvar lisp-mode-abbrev-table (progn (define-abbrev-table 'lisp-mode-abbrev-table nil) lisp-mode-abbrev-table))
(byte-code "\300\301N\204\302\300\301\303\304!#\210\302\305\306\307#\207" [lisp-mode-abbrev-table variable-documentation put purecopy "Abbrev table for `lisp-mode'." lisp-mode derived-mode-parent prog-mode] 5)
#@399 Major mode for editing Lisp code for Lisps other than GNU Emacs Lisp.
Commands:
Delete converts tabs to spaces as it moves back.
Blank lines separate paragraphs.  Semicolons start comments.

\{lisp-mode-map}
Note that `run-lisp' may be used either to start an inferior Lisp job
or to switch back to an existing one.

Entry to this mode calls the value of `lisp-mode-hook'
if that value is non-nil.
(defalias 'lisp-mode #[nil "\306\300!\210\307\310 \210\311\312\310\313N\203\314\311\313\310\313N#\210\315!\204'\316\317 \"\210\320\f!\211\2036
\321 =\203<\322\f\323 \"\210)\324!\325\"\204V!\"=\204V\326!\325\"C#\210\327!\210\330\f!\210!\"\331\332\307\"\210\306\333!\210\334\306\335!\210\336\307#)\337\340!\207" [delay-mode-hooks major-mode mode-name lisp-mode-map lisp-mode-syntax-table parent make-local-variable t prog-mode lisp-mode "Lisp" mode-class put keymap-parent set-keymap-parent current-local-map char-table-parent standard-syntax-table set-char-table-parent syntax-table abbrev-table-get :parents abbrev-table-put use-local-map set-syntax-table lisp-mode-variables nil find-tag-default-function lisp-find-tag-default comment-start-skip "\\(\\(^\\|[^\\\\\n]\\)\\(\\\\\\\\\\)*\\)\\(;+\\|#|\\) *" run-mode-hooks lisp-mode-hook lisp-mode-abbrev-table local-abbrev-table imenu-case-fold-search] 6 (#$ . 21142) nil])
(defalias 'lisp-find-tag-default #[nil "\301 \211;\205\302\303\"\203\304\225\305O\202)\207" [default find-tag-default string-match ":+" 0 nil] 4])
(defalias 'common-lisp-mode 'lisp-mode)
#@65 Send the current defun to the Lisp process made by \[run-lisp].
(defalias 'lisp-eval-defun #[(&optional and-go) "\300\301!\207" [error "Process lisp does not exist"] 2 (#$ . 22691) nil])
#@101 Keymap for Lisp Interaction mode.
All commands in `lisp-mode-shared-map' are inherited by this map.
(defvar lisp-interaction-mode-map (byte-code "\303 \303\304!\305	\n\"\210\306	\307\310#\210\306	\311\312#\210\306	\313\314#\210\306	\315\316#\210\317	\320\304B#\210\317\321\322#\210\317\323\324#\210\317\325\326#\210\317\327\330#\210\317\331\332#\210	*\207" [menu-map map lisp-mode-shared-map make-sparse-keymap "Lisp-Interaction" set-keymap-parent define-key "" eval-defun "" indent-pp-sexp "	" completion-at-point "\n" eval-print-last-sexp bindings--define-key [menu-bar lisp-interaction] [eval-defun] (menu-item "Evaluate Defun" eval-defun :help "Evaluate the top-level form containing point, or after point") [eval-print-last-sexp] (menu-item "Evaluate and Print" eval-print-last-sexp :help "Evaluate sexp before point; print value into current buffer") [edebug-defun-lisp-interaction] (menu-item "Instrument Function for Debugging" edebug-defun :help "Evaluate the top level form point is in, stepping through with Edebug" :keys "C-u C-M-x") [indent-pp-sexp] (menu-item "Indent or Pretty-Print" indent-pp-sexp :help "Indent each line of the list starting just after point, or prettyprint it") [complete-symbol] (menu-item "Complete Lisp Symbol" completion-at-point :help "Perform completion on Lisp symbol preceding point")] 5) (#$ . 22885))
(byte-code "\300\301N\204\302\300\301\303\304!#\210\305\306!\204\302\306\307\310#\210\300\207" [lisp-interaction-mode-hook variable-documentation put purecopy "Hook run when entering Lisp Interaction mode.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it.  (This is true for all hook variables.)" boundp lisp-interaction-mode-map definition-name lisp-interaction-mode] 5)
(defvar lisp-interaction-mode-map (make-sparse-keymap))
(byte-code "\300\301N\204\302\300\301\303\304!#\210\305\306!\204\302\306\307\310#\210\300\207" [lisp-interaction-mode-map variable-documentation put purecopy "Keymap for `lisp-interaction-mode'." boundp lisp-interaction-mode-syntax-table definition-name lisp-interaction-mode] 5)
(defvar lisp-interaction-mode-syntax-table (make-syntax-table))
(byte-code "\300\301N\204\302\300\301\303\304!#\210\302\305\306\307#\207" [lisp-interaction-mode-syntax-table variable-documentation put purecopy "Syntax table for `lisp-interaction-mode'." lisp-interaction-mode derived-mode-parent emacs-lisp-mode] 5)
#@554 Major mode for typing and evaluating Lisp forms.
Like Lisp mode except that \[eval-print-last-sexp] evals the Lisp expression
before point, and prints its value into the buffer, advancing point.
Note that printing is controlled by `eval-expression-print-length'
and `eval-expression-print-level'.

Commands:
Delete converts tabs to spaces as it moves back.
Paragraphs are separated only by blank lines.
Semicolons start comments.

\{lisp-interaction-mode-map}
Entry to this mode calls the value of `lisp-interaction-mode-hook'
if that value is non-nil.
(defalias 'lisp-interaction-mode #[nil "\306\300!\210\307\310 \210\311\312\310\313N\203\314\311\313\310\313N#\210\315!\204'\316\317 \"\210\320\f!\211\2036
\321 =\203<\322\f\323 \"\210)\324!\210\325\f!\210)\326\327!\207" [delay-mode-hooks major-mode mode-name lisp-interaction-mode-map lisp-interaction-mode-syntax-table parent make-local-variable t emacs-lisp-mode lisp-interaction-mode "Lisp Interaction" mode-class put keymap-parent set-keymap-parent current-local-map char-table-parent standard-syntax-table set-char-table-parent syntax-table use-local-map set-syntax-table run-mode-hooks lisp-interaction-mode-hook] 6 (#$ . 25322) nil])
#@332 Evaluate sexp before point; print value into current buffer.

If `eval-expression-debug-on-error' is non-nil, which is the default,
this command arranges for all errors to enter the debugger.

Note that printing the result is controlled by the variables
`eval-expression-print-length' and `eval-expression-print-level',
which see.
(defalias 'eval-print-last-sexp #[nil "p\301 \210\302\303!\210\301 )\207" [standard-output terpri eval-last-sexp t] 2 (#$ . 26535) nil])
#@255 Set up text properties for the output of `eval-last-sexp-1'.
BEG and END are the start and end of the output in current-buffer.
VALUE is the Lisp value printed, ALT1 and ALT2 are strings for the
alternative printed representations that can be displayed.
(defalias 'last-sexp-setup-props #[(beg end value alt1 alt2) "\306 \307\310\311#\210\307\312\313#\210\307\314\311#\210\315	\n\316\f
E\317\320\321\322BBBBBB#)\207" [map beg end value alt1 alt2 make-sparse-keymap define-key "
" last-sexp-toggle-display [down-mouse-2] mouse-set-point [mouse-2] add-text-properties printed-value mouse-face highlight keymap (help-echo "RET, mouse-2: toggle abbreviated display" rear-nonsticky (mouse-face keymap help-echo printed-value))] 10 (#$ . 27011)])
#@71 Toggle between abbreviated and unabbreviated printed representations.
(defalias 'last-sexp-toggle-display #[(&optional arg) "\214~\210\305`\306\"\211\205I\307d`T^\306\"\206`\310`\306\"\206`p`\211|\210A@c\210\f	U\2047`S\311\f`@\3128A@%\210d	^b,*\207" [value point standard-output end beg get-text-property printed-value previous-single-property-change next-single-char-property-change last-sexp-setup-props 2] 7 (#$ . 27764) "P"])
#@117 Return a string representing CHAR as a character rather than as an integer.
If CHAR is not a character, return nil.
(defalias 'prin1-char #[(char) "\250\205H\305!\205H\306!\307!\310\311\n>\2034\312\313\314\"!\2034\310\315\211\226\")\2044\226\310\310\316\317\217\210	\205G\320	!@U\205G	+\207" [char string mods c case-fold-search eventp event-basic-type event-modifiers nil shift zerop logand 33554432 char-equal (byte-code "\303\304\305\306#	\307>\203\302\310	\"\202 	\311=\203\312\202 \302	!Q\304\207" [mods c string "?" mapconcat #[(modif) "\301=\203\302\207\303\304\305!\306H\226\307#\207" [modif super "\\s-" string 92 symbol-name 0 45] 4] "" (59 40 41 123 125 91 93 34 39 92) 92 127 "\\C-?"] 5) ((error)) read-from-string] 4 (#$ . 28218)])
#@31 Return sexp before the point.
(defalias 'preceding-sexp #[nil "`\306\211\212\307 p\310\216\311
!\210g\312=\206h\312=\313\314!\210h\315=\2032\314u\210h\316=\2032\314u\210`eTV\203E\317\320`\321Z\"\203E\322u\210h\323=\203c\306\212\324\306x\210\325\326!)\203b\313\314!\210)\214	\203qg\327=\203q\306u\210e\n}\210\330p!\211:\203\217@\331=\203\217\332\333\334\335\336FDD.\207" [expr ignore-quotes opoint #1=#:buffer #2=#:table emacs-lisp-mode-syntax-table nil syntax-table ((byte-code "rq\210\302	!\210)\302\207" [#1# #2# set-syntax-table] 2)) set-syntax-table 39 forward-sexp -1 92 63 looking-back "#s" 2 -2 61 "0-9#=" looking-at "\\(#[0-9]+=\\)+" 96 read interactive call-interactively quote lambda (&rest args) args labeled-p] 7 (#$ . 29002)])
#@105 Evaluate sexp before point; print value in minibuffer.
With argument, print output into current buffer.
(defalias 'eval-last-sexp-1 #[(eval-last-sexp-arg-internal) "\203p\202	\303\304\305\306\307 !\n\"!)\207" [eval-last-sexp-arg-internal standard-output lexical-binding t eval-last-sexp-print-value eval eval-sexp-add-defvars preceding-sexp] 4 (#$ . 29780)])
(defalias 'eval-last-sexp-print-value #[(value) "\306\211\307\n!*\f`\306\310\n!\311\n!\211\203$\312!\210)`\313!\203O	\2046\203O\314
\"\230\204O\315
\n\314
\"%\210-\207" [print-level print-length value eval-expression-print-length eval-expression-print-level end nil prin1-to-string prin1 eval-expression-print-format princ bufferp buffer-substring-no-properties last-sexp-setup-props beg unabbreviated str standard-output] 10])
(defvar eval-last-sexp-fake-value (make-symbol "t"))
#@146 Prepend EXP with all the `defvar's that precede it in the buffer.
POS specifies the starting position where EXP was found and defaults to point.
(defalias 'eval-sexp-add-defvars #[(exp &optional pos) "\204	\207\212\n\204
`\305eb\210\306\307\n\310#\203:\311\312\313!!\314\f!\2046\212\315\316\317\224!@!)\2036\fB)\202\320\321\322\323\"	C\"*B\207" [lexical-binding exp pos vars var nil re-search-forward "(def\\(?:var\\|const\\|custom\\)[ 	\n]+\\([^; '()\n	]+\\)" t intern match-string 1 special-variable-p zerop syntax-ppss 0 progn append mapcar #[(v) "\301D\207" [v defvar] 2]] 5 (#$ . 30665)])
#@386 Evaluate sexp before point; print value in minibuffer.
Interactively, with prefix argument, print output into current buffer.
Truncates long output according to the value of the variables
`eval-expression-print-length' and `eval-expression-print-level'.

If `eval-expression-debug-on-error' is non-nil, which is the default,
this command arranges for all errors to enter the debugger.
(defalias 'eval-last-sexp #[(eval-last-sexp-arg-internal) "\204\305	!\207\n\305	!)B\211A\n=\204\fA\f@)\207" [eval-expression-debug-on-error eval-last-sexp-arg-internal eval-last-sexp-fake-value debug-on-error value eval-last-sexp-1] 3 (#$ . 31282) "P"])
#@166 Treat some expressions specially.
Reset the `defvar' and `defcustom' variables to the initial value.
Reinitialize the face according to the `defface' specification.
(defalias 'eval-defun-1 #[(form) "<\204\207@\305=\2035\243\243\2035\306\211A@)!\2035\307\305A@\310\311\233BBB\312A@\3138EE\207@\314=\203Z\315\316A@\n\"!\203Z\317\316A@\n\"\316\211\3138\n\"!\"\210\207@\320=\203\232\316A@\n\"\321\f\"\322\323\310#\210\322\324\3118#\210\325\322A@\326\327\330NDF\322A@\331\3138FF\322\330\310#\210)\207@\307=\203\251\307\332\333A\"B\207\207" [form x lexical-binding face-symbol face-new-frame-defaults defvar boundp progn nil 3 setq-default 2 custom-declare-variable default-boundp eval set-default custom-declare-face assq-delete-all put face-defface-spec face-documentation prog1 'saved-face quote saved-face 'customized-face mapcar eval-defun-1] 9 (#$ . 31937)])
#@430 Evaluate defun that point is in or before.
The value is displayed in the minibuffer.
If the current defun is actually a call to `defvar',
then reset the variable using the initial value expression
even if the variable already has some other value.
(Normally `defvar' does not change the variable's value
if it already has a value.)

With argument, insert value in current buffer after the defun.
Return the result of evaluation.
(defalias 'eval-defun-2 #[nil "	\n\212\306\307\310\311\211\211\212\312 \210\313 \210`\314p!`)\315\316\317!!!\320\321\322D\323DFF,\"\210,@\207" [eval-expression-debug-on-error eval-expression-print-length eval-expression-print-level print-level print-length debug-on-error apply eval-region t nil end-of-defun beginning-of-defun read eval-sexp-add-defvars eval-defun-1 macroexpand lambda (ignore) goto-char quote form end beg standard-output values] 10 (#$ . 32844)])
#@1067 Evaluate the top-level form containing point, or after point.

If the current defun is actually a call to `defvar' or `defcustom',
evaluating it this way resets the variable using its initial value
expression even if the variable already has some other value.
(Normally `defvar' and `defcustom' do not alter the value if there
already is one.)  In an analogous way, evaluating a `defface'
overrides any customizations of the face, so that it becomes
defined exactly as the `defface' expression says.

If `eval-expression-debug-on-error' is non-nil, which is the default,
this command arranges for all errors to enter the debugger.

With a prefix argument, instrument the code for Edebug.

If acting on a `defun' for FUNCTION, and the function was
instrumented, `Edebug: FUNCTION' is printed in the minibuffer.  If not
instrumented, just FUNCTION is printed.

If not acting on a `defun', the result of evaluation is displayed in
the minibuffer.  This display is controlled by the variables
`eval-expression-print-length' and `eval-expression-print-level',
which see.
(defalias 'eval-defun #[(edebug-it) "\203
\306\307!\210\310	?!\207\n\204\311 \207\312\313!\314\211\211
\311 
)
\f=\204/\f
+\207" [edebug-it edebug-all-defs eval-expression-debug-on-error value new-value old-value require edebug eval-defun eval-defun-2 make-symbol "t" nil debug-on-error] 4 (#$ . 33782) "P"])
(byte-code "\300\301\302\303#\210\304\301\302\305#\210\300\306\307\303#\210\304\306\307\310#\210\311\312\303\313\314\315\316\317&\210\320\312\321\322#\210\311\323\324\325\316\326\314\315&\207" [defalias lisp-comment-indent comment-indent-default nil make-obsolete "22.1" lisp-mode-auto-fill do-auto-fill "23.1" custom-declare-variable lisp-indent-offset "If non-nil, indent second line of expressions that many more columns." :group lisp :type (choice (const nil) integer) put safe-local-variable #[(x) "?\206\250\207" [x] 1] lisp-indent-function 'lisp-indent-function "A function to be called by `calculate-lisp-indent'.\nIt indents the arguments of a Lisp function call.  This function\nshould accept two arguments: the indent-point, and the\n`parse-partial-sexp' state at that position.  One option for this\nfunction is `common-lisp-indent-function'." function] 8)
#@130 Indent current line as Lisp code.
With argument, indent any additional lines of the same expression
rigidly along with this one.
(defalias 'lisp-indent-line #[(&optional whole-exp) "\305 \306\211d`Z\307 \210`\310\306w\210\f\203\311\312!\203%d	Zb\202_\311\313!\203:\311\314!\204:\315 \210\316u\210\202S\f<\203B\f@\fiZ\317!\204S`|\210\fj\210d	Z`V\205_d	Zb-\207" [beg pos end shift-amt indent calculate-lisp-indent nil beginning-of-line " 	" looking-at "\\s<\\s<\\s<" "\\s<" "\\s<\\s<" indent-for-comment -1 zerop] 5 (#$ . 36053) "P"])
#@553 Return appropriate indentation for current line as Lisp code.
In usual case returns an integer: the column to indent to.
If the value is nil, that means don't change the indentation
because the line starts inside a string.

The value can also be a list of the form (COLUMN CONTAINING-SEXP-START).
This means that following lines at the same level of indentation
should not necessarily be indented the same as this line.
Then COLUMN is the column to indent to, and CONTAINING-SEXP-START
is the buffer position of the start of the containing expression.
(defalias 'calculate-lisp-indent #[(&optional parse-start) "\212\306 \210`\307\211\211\310\307\211\203b\210\202\"\311 \210`W\2033\312`\313#\202\"\n\203t
\203t
\313\234\211\313V\203t\307
\314\234
\315\234\211Tb\210	\2033	`V\2033\312	\313#\211A@\211\203p)\2023\n\204\304Tb\210	\204\205i\202\304\312`	\313\310$\210\316\317!\204\304\212\315y\210`)	V\203\264`	U\204\256\320\315!\210\312`	\313\310$\210\321 \210\202\304	b\210\306 \210\312`	\313\310$\210\321 \210i
\322\234\203\321\307\202\201
\250\203\345\203\345b\210i\\\202\201
	\203{
\203\373\n\204\373
\"\206\201
\212b\210\323\307w\210\316\324!)\203v
\212	b\210\321 \210\325\326!\204-
\203#
T`W\203-
\320\327!\210\321 \210\202
`\211)\203v
	\212Tb\210\312`	\313\310$\210`)V\203v
\310\307 !	b\210\316\324!\203]
i\211 \204p
\330 \331 \210`W\203p
\316\324!\203p
i  *\206\201
\202\201
\206\201
.	\207" [containing-sexp calculate-lisp-indent-last-sexp retry desired-indent paren-depth state beginning-of-line nil t beginning-of-defun parse-partial-sexp 0 2 1 looking-at "\\s(" forward-sexp backward-prefix-chars 3 " 	" ":" looking-back "^[ 	]*\\|([ 	]+" -1 line-beginning-position backward-sexp indent-point parse-start peek normal-indent lisp-indent-offset lisp-indent-function indent parse-sexp-ignore-comments] 8 (#$ . 36612)])
#@1222 This function is the normal value of the variable `lisp-indent-function'.
The function `calculate-lisp-indent' calls this to determine
if the arguments of a Lisp function call should be indented specially.

INDENT-POINT is the position at which the line being indented begins.
Point is located at the point to indent under (for default indentation);
STATE is the `parse-partial-sexp' state for that position.

If the current line is in a call to a Lisp function that has a non-nil
property `lisp-indent-function' (or the deprecated `lisp-indent-hook'),
it specifies how to indent.  The property value can be:

* `defun', meaning indent `defun'-style
  (this is also the case if there is no property and the function
  has a name that begins with "def", and three or more arguments);

* an integer N, meaning indent the first N arguments specially
  (like ordinary function arguments), and then indent any further
  arguments like a body;

* a function to call that returns the indentation (or nil).
  `lisp-indent-function' calls this function with the same two arguments
  that it itself received.

This function returns either the indentation to use, or nil if the
Lisp function does not specify a special indentation.
(defalias 'lisp-indent-function #[(indent-point state) "i	\306\234Tb\210\307`\n\310\311$\210	\312\234\203:\313\314!\204:\212\306y\210`)\nV\2043\nb\210\315 \210\307`\n\310\311$\210\316 \210i\202\211`\317\306!\210`{\320\321\322\f!\323\"\206R\322\f!\324N\211\325=\204k\204r\fG\326V\203r\327\330\f\"\203r\331	
\"\202\210\250\203\200\332	
$\202\210\205\210
	\"*)\207" [normal-indent state calculate-lisp-indent-last-sexp method function indent-point 1 parse-partial-sexp 0 t 2 looking-at "\\sw\\|\\s_" beginning-of-line backward-prefix-chars forward-sexp nil function-get intern-soft lisp-indent-function lisp-indent-hook defun 3 string-match "\\`def" lisp-indent-defform lisp-indent-specform] 6 (#$ . 38531)])
(byte-code "\300\301\302\303\304\305\306\307&\210\310\301\311\312#\207" [custom-declare-variable lisp-body-indent 2 "Number of columns to indent the second line of a `(def...)' form." :group lisp :type integer put safe-local-variable integerp] 8)
(defalias 'lisp-indent-specform #[(count state indent-point normal-indent) "\306\234	\307\211\211b\210i\n\\\306u\210\310\306!\210\311`\306\312$\210`W\2031\307\313\314\217\204#	\315V\203Q\f	Z\306X\203J\n\316_\\
D\202p
D\202p\f\315U\203]	\315U\204j	\315U\203nX\203n\202p,\207" [state count containing-form-column body-indent i containing-form-start 1 nil forward-sexp parse-partial-sexp t (byte-code "S\302\303!\210\304`	\303\305$\207" [count indent-point forward-sexp 1 parse-partial-sexp t] 5) ((error)) 0 2 lisp-body-indent indent-point normal-indent] 6])
(defalias 'lisp-indent-defform #[(state indent-point) "A@b\210\302y\210`AA@V\205A@b\210	i\\\207" [state lisp-body-indent 1] 2])
(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\305#\210\300\313\302\305#\210\300\314\302\305#\210\300\315\302\307#\210\300\316\302\307#\210\300\317\302\307#\210\300\320\302\311#\210\300\321\302\307#\210\300\322\302\311#\210\300\323\302\307#\210\300\324\302\307#\207" [put autoload lisp-indent-function defun progn 0 prog1 1 prog2 2 save-excursion save-restriction save-current-buffer let let* while if catch condition-case unwind-protect with-output-to-temp-buffer] 4)
#@145 Indent each line of the list starting just after point.
If optional arg ENDPOS is given, indent each line, stopping when
ENDPOS is encountered.
(defalias 'indent-sexp #[(&optional endpos) "\306C\307?\205	``\306\211\211\211\211\211\204)\212\310\311!\210)\212\306\2036`W\2028\f?\205w
\306\204\206m\211\204\206\312`\306\210`\306\211\n%\211@\313\n\233@\203m\314 \210\306\210\313\n\233\306\240\210\315\n\233@\203\200\311y\210\316\n\233\306\240\210\202A\317\211\203E\203\246\307X\203\246\320[\306\"\244Z\307\311y\210\203\270`X\203\301\317\202\301\307X\203\301\317\f\204d
V\203\333AS\211\202\307W\203\362\306BT\211\202\335`\321\306w\210m\204d
\322\323!\204d
@\203
@\307Y\203
@\202S
\324@\203%
@[\202'
!\211\2044
\202R
\250\203E
\211\240\210\202R
A@[\240\210@)	\203d
i	U\204d

`|\210	j\210\f\204,`U\211\204,`\202,.\207" [endpos this-indent state inner-loop-done outer-loop-done bol nil 0 forward-sexp 1 parse-partial-sexp 4 indent-for-comment 3 5 t make-list " 	" looking-at "\\s<\\|\n" calculate-lisp-indent last-depth last-point starting-point next-depth indent-stack val] 11 (#$ . 41993) nil])
#@121 Indent each line of the list starting just after point, or prettyprint it.
A prefix argument specifies pretty-printing.
(defalias 'indent-pp-sexp #[(&optional arg) "\203!\212\214`\301\302!\210`}\210\303 \210db\210`Sf\304=\203 \305\306!\210*\307 \207" [arg forward-sexp 1 pp-buffer 10 delete-char -1 indent-sexp] 3 (#$ . 43233) "P"])
#@156 Value of `fill-column' to use when filling a docstring.
Any non-integer value means do not use a different value of
`fill-column' when filling docstrings.
(custom-declare-variable 'emacs-lisp-docstring-fill-column 65 '(#$ . 43576) :type '(choice (integer) (const :tag "Use the current `fill-column'" t)) :group 'lisp)
#@232 Like \[fill-paragraph], but handle Emacs Lisp comments and docstrings.
If any of the current line is a comment, fill the comment or the
paragraph of it that point is in, preserving the comment's indentation
and initial semicolons.
(defalias 'lisp-fill-paragraph #[(&optional justify) "\305!\206'	\306P\n\307P\250\203\310\311!\203\202\f\312!+\206'\313\207" [justify paragraph-start paragraph-separate emacs-lisp-docstring-fill-column fill-column fill-comment-paragraph "\\|\\s-*\\([(;:\"]\\|`(\\|#'(\\)" "\\|\\s-*\".*[,\\.]$" derived-mode-p emacs-lisp-mode fill-paragraph t] 4 (#$ . 43901) "P"])
#@366 Indent all lines of code, starting in the region, sideways by ARG columns.
Does not affect lines starting inside comments or strings, assuming that
the start of the region is not inside them.

Called from a program, takes args START, END, COLUMNS and NOCHANGE-REGEXP.
The last is a regexp which, if matched at the beginning of a line,
means don't indent that line.
(defalias 'indent-code-rigidly #[(start end arg &optional nochange-regexp) "\306\212	b\210\307 \nb\210n\204\310`\311y\210`\306\211%`	W\205Y\312\233@\204K\2032\313!\204K\314 `\315\306w\210`|\210l\204J\316\317\f
\\]\317\"\210)\310`\311y\210`\306\211%\202*\207" [state end start nochange-regexp indent arg nil point-marker parse-partial-sexp 1 3 looking-at current-indentation " 	" indent-to 0] 6 (#$ . 44518) "r\np"])
(provide 'lisp-mode)