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



(byte-code "\300\301!\210\300\302!\210\300\303!\207" [require cc-defs cc-vars cc-engine] 2)
(defvar c-fix-backslashes t)
#@607 Indent the current line according to the syntactic context,
if `c-syntactic-indentation' is non-nil.  Optional SYNTAX is the
syntactic information for the current line.  Be silent about syntactic
errors if the optional argument QUIET is non-nil, even if
`c-report-syntactic-errors' is non-nil.  Normally the position of
point is used to decide where the old indentation is on a lines that
is otherwise empty (ignoring any line continuation backslash), but
that's not done if IGNORE-POINT-POS is non-nil.  Returns the amount of
indentation change (in columns).

(fn &optional SYNTAX QUIET IGNORE-POINT-POS)
(defalias 'c-indent-line #[768 "\212\306\210`Sf)\307=\306\211\204B\212\310 \210\311\203 \312\202!\313!)\203B`\314\225X\203B	\204;\212\315\225b\210iS\262)`\315\225|\210\316\n\203\236\306\206S\317\303!\205S\320 \316\211\316 \321\322\"\216\306\204l\323 \324!\262
\325!\204\203!\203\203\326\327#\210\211\330 Z\262\210,\210\331
!\210\332\333!\210\f*\206\232\f\202\275\315\212\334y\315U\203\261\311\335!\204\240\330 \262
)\211\330 Z\262\331!\266\203\337\203\337
\203\324\212
j\210\307c\210)\202\337	\203\337\336``\306\316$\210)\207" [c-fix-backslashes c-auto-align-backslashes c-syntactic-indentation c-syntactic-context c-parsing-error buffer-undo-list nil 92 beginning-of-line looking-at "\\([ 	]*\\)\\\\$" "\\([ 	]*\\)$" 1 0 t boundp buffer-modified-p make-closure #[0 "\300?\205\301\302!\207" [V0 restore-buffer-modified-p nil] 2] c-guess-basic-syntax c-get-syntactic-indentation c-echo-parsing-error message "syntax: %s, indent: %d" current-indentation c-shift-line-indentation run-hooks c-special-indent-hook -1 "\\s *\\\\?$" c-backslash-region inhibit-read-only inhibit-modification-hooks c-echo-syntactic-information-p] 14 (#$ . 206)])
#@288 Insert a newline and indent the new line.
This function fixes line continuation backslashes if inside a macro,
and takes care to set the indentation before calling
`indent-according-to-mode', so that lineup functions like
`c-lineup-dont-change' works better.

(fn &optional NEWLINE-ARG)
(defalias 'c-newline-and-indent #[256 "9\203 \212\306 \307\211\307\310\311\"\216\312 \205`,\262
)\202!\313\211\211\211C\313\212\314 \210
`\240\210\315\316!\203@\317y\320U\2043\321 \262
)\203jl\203^`Sf\322=\203^\307\262\307\262\202j\323 \206d`Sf\322=\262\324!\210\211j\210\203\233\203\212\322c\210\317u\210\325``\313\307$\210\202\233\325\242\203\225`\202\227\242\313\307$\210
\205\325\306 \307\211\307\310\326\"\216\327 ,\262
\330c\210\331 \210
d`Z\240\210\310\332\"\216\317u\210\333 \210*\205\325\325``\313\307$*\207" [c-macro-start buffer-undo-list inhibit-read-only inhibit-modification-hooks c-fix-backslashes c-syntactic-indentation buffer-modified-p t make-closure #[0 "\300?\205\301\302!\207" [V0 restore-buffer-modified-p nil] 2] c-beginning-of-macro nil beginning-of-line looking-at "[ 	]*\\\\?$" -1 0 current-indentation 92 line-end-position newline c-backslash-region #[0 "\300?\205\301\302!\207" [V0 restore-buffer-modified-p nil] 2] c-guess-basic-syntax 10 delete-horizontal-space #[0 "d\300\242Zb\210\301\302!\207" [V0 delete-char -1] 2] indent-according-to-mode c-syntactic-context] 13 (#$ . 2013)])
#@129 Show syntactic information for current line.
With universal argument, inserts the analysis as a comment on that line.

(fn ARG)
(defalias 'c-show-syntactic-information #[257 "\306\307\301!\203\f	\202\310 \311\211\311\312\313\"\216\314 ,\262

:\204\230\306\211\211C\315\316\"\210\312\317\"\216\203\216\211A\262\242\262\211A:\203L\211A\242\262
\202P\211A\262
\211\262\203j\211\320\211T\"\321
\322\323#\210\211\262
\242B\240\210\211\243\243\242\262
\211\262\2031\211\320\211T\"\321
\322\324#\210\211\262
\242B\240\210\2021\325\326!\210)\266\202\242\327 \210\330\331\332\"!\210)\210\307\305!\205\255\311\211\207" [c-parsing-error c-syntactic-context buffer-undo-list inhibit-read-only inhibit-modification-hooks zmacs-region-stays nil boundp buffer-modified-p t make-closure #[0 "\300?\205\301\302!\207" [V0 restore-buffer-modified-p nil] 2] c-guess-basic-syntax message "Syntactic analysis: %s" #[0 "\300\242\205\301\300\242\300\211\242A\240\210\242!\210\202\207" [V0 delete-overlay] 4] make-overlay overlay-put face highlight secondary-selection sit-for 10 indent-for-comment insert-and-inherit format "%s"] 12 (#$ . 3472) "P"])
#@89 Insert a comment with the syntactic analysis on every line in the region.

(fn FROM TO)
(defalias 'c-syntactic-information-on-region #[514 "\212\214

}\210eb\210m?\205\300\301!\210\302y\210\202	*\207" [c-show-syntactic-information (0) nil] 4 (#$ . 4645) "*r"])
(defvar c-block-comment-flag nil)
(make-variable-buffer-local 'c-block-comment-flag)
(defalias 'c-update-modeline #[0 "\305\306\203\n\307\202\310	\203\311\202\312	\203 \n\203 \313\202!\312\203)\314\202*\312\315\316!\2039\316J\2039\317\202:\312&\320\321\f\"\203J\322\323\f\"\202K\f
G\323V\203X\211P\202Y\211\324 \207" [c-block-comment-flag c-electric-flag c-auto-newline c-hungry-delete-key mode-name format "/%s%s%s%s%s" "*" "/" "l" "" "a" "h" boundp c-subword-mode "w" string-match "\\(^[^/]*\\)/" match-string 1 force-mode-line-update] 8])
#@804 Toggle syntactic indentation.
Optional numeric ARG, if supplied, turns on syntactic indentation when
positive, turns it off when negative, and just toggles it when zero or
left out.

When syntactic indentation is turned on (the default), the indentation
functions and the electric keys indent according to the syntactic
context keys, when applicable.

When it's turned off, the electric keys don't reindent, the indentation
functions indents every new line to the same level as the previous
nonempty line, and \[c-indent-command] adjusts the indentation in steps
specified by `c-basic-offset'.  The indentation style has no effect in
this mode, nor any of the indentation associated variables,
e.g. `c-special-indent-hook'.

This command sets the variable `c-syntactic-indentation'.

(fn &optional ARG)
(defalias 'c-toggle-syntactic-indentation #[256 "\302
\"\303\301!\205\304\211\207" [c-syntactic-indentation zmacs-region-stays c-calculate-state boundp t] 4 (#$ . 5482) "P"])
#@468 Toggle auto-newline feature.
Optional numeric ARG, if supplied, turns on auto-newline when
positive, turns it off when negative, and just toggles it when zero or
left out.

Turning on auto-newline automatically enables electric indentation.

When the auto-newline feature is enabled (indicated by "/la" on the
mode line after the mode name) newlines are automatically inserted
after special characters such as brace, comma, semi-colon, and colon.

(fn &optional ARG)
(defalias 'c-toggle-auto-newline #[256 "\303
\205	\"\211\203\304\305 \210\306\302!\205\304\211\207" [c-auto-newline c-electric-flag zmacs-region-stays c-calculate-state t c-update-modeline boundp] 5 (#$ . 6472) "P"])
(byte-code "\300\301\302\"\210\303\301\302\304#\207" [defalias c-toggle-auto-state c-toggle-auto-newline make-obsolete "22.1"] 4)
#@370 Toggle hungry-delete-key feature.
Optional numeric ARG, if supplied, turns on hungry-delete when
positive, turns it off when negative, and just toggles it when zero or
left out.

When the hungry-delete-key feature is enabled (indicated by "/h" on
the mode line after the mode name) the delete key gobbles all preceding
whitespace in one fell swoop.

(fn &optional ARG)
(defalias 'c-toggle-hungry-state #[256 "\302
\"\303 \210\304\301!\205\305\211\207" [c-hungry-delete-key zmacs-region-stays c-calculate-state c-update-modeline boundp t] 4 (#$ . 7303) "P"])
#@308 Toggle auto-newline and hungry-delete-key features.
Optional numeric ARG, if supplied, turns on auto-newline and
hungry-delete when positive, turns them off when negative, and just
toggles them when zero or left out.

See `c-toggle-auto-newline' and `c-toggle-hungry-state' for details.

(fn &optional ARG)
(defalias 'c-toggle-auto-hungry-state #[256 "\303
\"\303
	\"\304 \210\305\302!\205\306\211\207" [c-auto-newline c-hungry-delete-key zmacs-region-stays c-calculate-state c-update-modeline boundp t] 4 (#$ . 7873) "P"])
#@213 Toggle the electric indentation feature.
Optional numeric ARG, if supplied, turns on electric indentation when
positive, turns it off when negative, and just toggles it when zero or
left out.

(fn &optional ARG)
(defalias 'c-toggle-electric-state #[256 "\302
\"\303 \210\304\305!\203\305\203\306\202\307!\210\310\301!\205#\311\211\207" [c-electric-flag zmacs-region-stays c-calculate-state c-update-modeline fboundp electric-indent-local-mode 1 0 boundp t] 4 (#$ . 8410) "P"])
#@309 Toggle the comment style between block and line comments.
Optional numeric ARG, if supplied, switches to block comment
style when positive, to line comment style when negative, and
just toggles it when zero or left out.

This action does nothing when the mode only has one comment style.

(fn &optional ARG)
(defalias 'c-toggle-comment-style #[256 "\203	\203\306
\n\"\202\203\307\202\310\211\203!	\202\"\311P\n\203/\311\fP\2020\312\203P\203P	\203P\f\203P\212\214~\210eb\210\313ed\"\210*\314 \210\315\316!\205]\310\211\207" [c-line-comment-starter c-block-comment-starter c-block-comment-flag comment-start c-block-comment-ender comment-end c-calculate-state nil t " " "" font-lock-flush c-update-modeline boundp zmacs-region-stays c-mark-wrong-style-of-comment font-lock-mode] 5 (#$ . 8905) "P"])
#@346 Delete the preceding character or whitespace.
If `c-hungry-delete-key' is non-nil (indicated by "/h" on the mode
line) then all preceding whitespace is consumed.  If however a prefix
argument is supplied, or `c-hungry-delete-key' is nil, or point is
inside a literal then the function in the variable
`c-backspace-function' is called.

(fn ARG)
(defalias 'c-electric-backspace #[257 "\305 \306\211\306\307\310\"\216?\206
\206\311 ,\262
\203$\f\312!!\207\313 \207" [buffer-undo-list inhibit-read-only inhibit-modification-hooks c-hungry-delete-key c-backspace-function buffer-modified-p t make-closure #[0 "\300?\205\301\302!\207" [V0 restore-buffer-modified-p nil] 2] c-in-literal prefix-numeric-value c-hungry-delete-backwards] 6 (#$ . 9740) "*P"])
#@144 Delete the preceding character or all preceding whitespace
back to the previous non-whitespace character.
See also \[c-hungry-delete-forward].
(defalias 'c-hungry-delete-backwards #[0 "`\301\302x\210l\203`Sf\303=\203\304u\210\202
`
U\204!`
|\207\305!\207" [c-backspace-function " 	\n
\f" nil 92 -1 1] 3 (#$ . 10510) nil])
(defalias 'c-hungry-backspace 'c-hungry-delete-backwards)
#@343 Delete the following character or whitespace.
If `c-hungry-delete-key' is non-nil (indicated by "/h" on the mode
line) then all following whitespace is consumed.  If however a prefix
argument is supplied, or `c-hungry-delete-key' is nil, or point is
inside a literal then the function in the variable `c-delete-function'
is called.

(fn ARG)
(defalias 'c-electric-delete-forward #[257 "\305 \306\211\306\307\310\"\216?\206
\206\311 ,\262
\203$\f\312!!\207\313 \207" [buffer-undo-list inhibit-read-only inhibit-modification-hooks c-hungry-delete-key c-delete-function buffer-modified-p t make-closure #[0 "\300?\205\301\302!\207" [V0 restore-buffer-modified-p nil] 2] c-in-literal prefix-numeric-value c-hungry-delete-forward] 6 (#$ . 10905) "*P"])
#@140 Delete the following character or all following whitespace
up to the next non-whitespace character.
See also \[c-hungry-delete-backwards].
(defalias 'c-hungry-delete-forward #[0 "`\301\302w\210\302f\303=\203\302u\210l\204
\304u\210`
U\204 `
|\207\305!\207" [c-delete-function " 	\n
\f" nil 92 -1 1] 3 (#$ . 11673) nil])
#@491 Deletes preceding or following character or whitespace.
This function either deletes forward as `c-electric-delete-forward' or
backward as `c-electric-backspace', depending on the configuration: If
the function `delete-forward-p' is defined and returns non-nil, it
deletes forward.  Otherwise it deletes backward.

Note: This is the way in XEmacs to choose the correct action for the
[delete] key, whichever key that means.  Other flavors don't use this
function to control that.

(fn ARG)
(defalias 'c-electric-delete #[257 "\300\301!\203\301 \203\302
!\207\303
!\207" [fboundp delete-forward-p c-electric-delete-forward c-electric-backspace] 3 (#$ . 12006) "*P"])
#@479 Delete non-whitespace char, or all whitespace up to next non-whitespace char.
The direction of deletion depends on the configuration: If the
function `delete-forward-p' is defined and returns non-nil, it deletes
forward using `c-hungry-delete-forward'.  Otherwise it deletes
backward using `c-hungry-backspace'.

Note: This is the way in XEmacs to choose the correct action for the
[delete] key, whichever key that means.  Other flavors don't use this
function to control that.
(defalias 'c-hungry-delete #[0 "\300\301!\203\301 \203\302 \207\303 \207" [fboundp delete-forward-p c-hungry-delete-forward c-hungry-delete-backwards] 2 (#$ . 12683) nil])
#@76 Known unsafe functions when members of `post-self-insert-hook' in CC Mode.
(defvar c--unsafe-post-self-insert-hook-functions '(electric-pair-post-self-insert-function) (#$ . 13343))
(defalias 'c--call-post-self-insert-hook-more-safely-1 #[0 "\302
\203@
@	>\2049
@\303=\2033\304\300!\211\203/\211@	>\204(\211@B\262\211A\262
\202\210\2029
@
B\262

A\262\202\305\306\237\"\207" [post-self-insert-hook c--unsafe-post-self-insert-hook-functions nil t default-value mapc funcall] 5])
(defalias 'c--call-post-self-insert-hook-more-safely '(macro . #[0 "\300\301!\203\302\207\303\207" [boundp post-self-insert-hook (c--call-post-self-insert-hook-more-safely-1) (progn)] 2]))
#@229 Insert a "#".
If `c-electric-flag' is set, handle it specially according to the variable
`c-electric-pound-behavior'.  If a numeric ARG is supplied, or if point is
inside a literal or a macro, nothing special happens.

(fn ARG)
(defalias 'c-electric-pound #[257 "\306 \307\211\307\310\311\"\216
\206>?\206>\312\f>?\206>\212\313\314x\210n)?\206>\212\315y\316U\2058\314\210`Sf\317=)\206>\320 ,\262
\203P\314\321\322!!\210)\202id`Zn\323 \210\324 \210c\210\211\204gdZb\210\266\325 \207" [buffer-undo-list inhibit-read-only inhibit-modification-hooks c-electric-flag c-electric-pound-behavior post-self-insert-hook buffer-modified-p t make-closure #[0 "\300?\205\301\302!\207" [V0 restore-buffer-modified-p nil] 2] alignleft " 	" nil -1 0 92 c-in-literal self-insert-command prefix-numeric-value beginning-of-line delete-horizontal-space c--call-post-self-insert-hook-more-safely-1 last-command-event] 6 (#$ . 14034) "*P"])
(defalias 'c-point-syntax #[0 "\306 \307\211\307\310\311\"\216\312\211\312C\312C\310\313#\216\211\307=?\205%\312B\211\307=\2030\307\2021\262

\314!\240\210\315\316\317\"\210\212\320\321!\206Ge\322
x\210l\203c`Sf\323=\203c`
V\203c\324u\210\202G\210\f\205j\f )\204\204`\212\324u\210\325 \205~\326 \210`
W)\262
\203\217\324u\210\315\323\317\"\210\312u\210\307\211\327 \262*\312\240\210)\266)\211\262
,\207" [buffer-undo-list inhibit-read-only inhibit-modification-hooks c-echo-syntactic-information-p c-at-vsemi-p-fn c-auto-newline-analysis buffer-modified-p t make-closure #[0 "\300?\205\301\302!\207" [V0 restore-buffer-modified-p nil] 2] nil #[0 "\302\300\242\301\242\"\207" [V0 V1 c-tnt-chng-cleanup] 3] c-tnt-chng-record-state insert-char 10 1 line-beginning-position 0 " 	\n
\f" 92 -1 c-beginning-of-macro c-end-of-macro c-guess-basic-syntax c-syntactic-indentation-in-macros] 10])
#@15 

(fn SYNTAX)
(defalias 'c-brace-newlines #[257 "\306 \307\211\307\310\311\"\216\312\313\211\f\2057\212\31414`Sf\315U\203(\316u\210\202.\317`\316\"b\210\320 0\2026\210\313)?\205
\321\236\203Z\322\236\203L\323\202[\324\236\203V\325\202[\202[
\313\203t@\236\211\262\204tA\262\202_\266\202@
\236\266\203\206\326\262
\211A:\204\233\327
A!\203\233\211A
@`\")\202\235\211A)\266\202,\207" [buffer-undo-list inhibit-read-only inhibit-modification-hooks c-echo-syntactic-information-p c-special-brace-lists c-hanging-braces-alist buffer-modified-p t make-closure #[0 "\300?\205\301\302!\207" [V0 restore-buffer-modified-p nil] 2] (arglist-cont-nonempty class-open class-close defun-open defun-close inline-open inline-close brace-list-open brace-list-close brace-list-intro brace-entry-open block-open block-close substatement-open statement-case-open extern-lang-open extern-lang-close namespace-open namespace-close module-open module-close composition-open composition-close inexpr-class-open inexpr-class-close statement-cont) nil (error) 123 -1 scan-sexps c-looking-at-special-brace-list inexpr-class class-open ((inexpr-class-open)) class-close ((inexpr-class-close)) (ignore before after) functionp c-syntactic-context] 13 (#$ . 15900)])
(defalias 'c-try-one-liner #[0 "`d`Z\302\211\211\211\211\211\211\211\212\214\212\303y\210`)`}\210\3041$\305`\306\"b0\202)\210\302\2028\2058\302u\210`\nS}\210\307\310!*\205
\302C\302C\311\312#\216\211\313=?\205Q\302B\211\313=\203\\\313\202]\262

\314!\240\210\315\224\262\f\315\225\262\316\224\262\n\316\225\262	\306u\210\212\317 \205\206`
ZZ\262)		|\210|\210\212\302\210i)\262\203\341\320\315!\210b\210iT\262T\262\321\302x\210l\203\311`Sf\322=\203\311\306u\210\202\263\323\324\315\"\210iZ\262\325U\203\341\323\326\315\"\210\315\262	?\206\f
	\325U\206\f
	X\206\f
\205\f
Z	W\205\f
b\210\327	Z!\210\313\240)\266\203\205
d	Zb\207" [buffer-undo-list c-max-one-liner-length nil -2 (error) scan-sexps -1 looking-at "\\([ 	]*\\([
\n][ 	]*\\)?\\)[^ 	
\n]+\\([ 	]+[^ 	
\n]+\\)*\\([ 	]*\\([
\n][ 	]*\\)?\\)\\'" make-closure #[0 "\302\300\242\301\242\"\207" [V0 V1 c-tnt-chng-cleanup] 3] t c-tnt-chng-record-state 1 4 c-backward-single-comment delete-char " 	\n
\f" 92 insert-char 125 0 32 backward-delete-char-untabify] 17])
#@21 

(fn BEFORE AFTER)
(defalias 'c-do-brace-electrics #[514 "\306\211\211\211\211\307 \310\211\310\311\312\"\216\310\211\313 \262.\2101\203(\314!\2102\205\312
\315u\210\316 \262\317!\262\204K\320>\203Ki\321 V\204R\322=\203`1\203]\323 \210\202`\324 \210\306u\210\320>\203m
\202n\262
`d`Z\306\211\307 \310\211\310\311\325\"\216\3263>\205\3234\327=\205\323\330\306\203\252@\236\211\262\204\252A\262\202\225\266\202\205\323\315u\210\331\306x\210l\203\310`Sf\332=\203\310\315u\210\202\262`Sf\333=\205\323\334 ?,\262
\203\343`S|\210dZ\262b\210\335 \311\336\"\2164\327=\203#
\3373>\203#
\340\306\203
@\236\211\262\204
A\262\202\377\266\202\203#
\341 \203#
dZ\262)\2104\333=\203\251
\3423>\203H
\343\344\306\310#\203H
\345\224\345\225|\210\346\347!\210\202\251
\3503>\203\251
Sb\210`\262
\331\306x\210l\203l
`Sf\332=\203l
\315u\210\202V
`\262`Sf\351=\203\251
\307 \310\211\310\311\352\"\216\353\354\310\",\262
\345U\203\251
\306f\355=\203\251
\343\356\306\310#\203\251


|\210
b\210\357c\210dZb\2101\203\266
\314 \210\266\204\302
\360>\204\310
\322=\205\312
\324 )\207" [c-echo-syntactic-information-p buffer-undo-list inhibit-read-only inhibit-modification-hooks c-syntactic-indentation-in-macros c-auto-newline-analysis nil buffer-modified-p t make-closure #[0 "\300?\205\301\302!\207" [V0 restore-buffer-modified-p nil] 2] c-guess-basic-syntax c-indent-line -1 c-point-syntax c-brace-newlines before current-indentation assume newline c-newline-and-indent #[0 "\300?\205\301\302!\207" [V0 restore-buffer-modified-p nil] 2] empty-defun-braces 125 (defun-close class-close inline-close) " 	\n
\f" 92 123 c-in-literal match-data #[0 "\301\300\302\"\207" [V0 set-match-data evaporate] 3] one-liner-defun (defun-close) c-try-one-liner brace-else-brace re-search-backward "}\\([ 	\n]\\|\\\\\n\\)*else\\([ 	\n]\\|\\\\\n\\)*{\\=" 0 insert-and-inherit "} else {" brace-elseif-brace 41 #[0 "\300?\205\301\302!\207" [V0 restore-buffer-modified-p nil] 2] c-backward-token-2 1 40 "}\\([ 	\n]\\|\\\\\n\\)*else\\([ 	\n]\\|\\\\\n\\)+if\\([ 	\n]\\|\\\\\n\\)*\\=" 32 after c-syntactic-indentation c-auto-newline c-cleanup-list last-command-event] 18 (#$ . 18261)])
#@600 Insert a brace.

If `c-electric-flag' is non-nil, the brace is not inside a literal and a
numeric ARG hasn't been supplied, the command performs several electric
actions:

(a) If the auto-newline feature is turned on (indicated by "/la" on
the mode line) newlines are inserted before and after the brace as
directed by the settings in `c-hanging-braces-alist'.

(b) Any auto-newlines are indented.  The original line is also
reindented unless `c-syntactic-indentation' is nil.

(c) If auto-newline is turned on, various newline cleanups based on the
settings of `c-cleanup-list' are done.

(fn ARG)
(defalias 'c-electric-brace #[257 "\306\211\306\211\307\310!\311\312!\205\312 \306\211\313 \314\211\314\315\316\"\216\317`\320 \"\262\n\321\n!\262	,\210\306\322\323!!\210)\324\325!\203g\203g\326 \306\327 \210\205]!\330=\205]\306f\331=\262\326 
W\262)\210\204\251	\204\251\"\203\251\204\251\204\204\332 \210\202\251\211\203\223\332 \210\333\334\306\"\210\202\251\333\306\211\"\210
\203\251\212\306u\210\333\335\334\"\210)\332 \210!\331=\203\350#\204\350\203\350\212\313 \314\211\314\315\336\"\216`\n\206\317eV\203\341\214	\206\332ed}\210\337 \210),\210 \210)\340 *\207" [blink-paren-function case-fold-search buffer-undo-list inhibit-read-only inhibit-modification-hooks post-self-insert-hook nil looking-at "[ 	]*\\\\?$" fboundp use-region-p buffer-modified-p t make-closure #[0 "\300?\205\301\302!\207" [V0 restore-buffer-modified-p nil] 2] c-safe-position c-parse-state c-in-literal self-insert-command prefix-numeric-value boundp electric-pair-mode buffer-size electric-pair-post-self-insert-function 123 125 c-indent-line c-do-brace-electrics ignore assume #[0 "\300?\205\301\302!\207" [V0 restore-buffer-modified-p nil] 2] c-backward-sws c--call-post-self-insert-hook-more-safely-1 last-command-event c-electric-flag executing-kbd-macro] 15 (#$ . 20508) "*P"])
#@626 Insert a slash character.

If the slash is inserted immediately after the comment prefix in a c-style
comment, the comment might get closed by removing whitespace and possibly
inserting a "*".  See the variable `c-cleanup-list'.

Indent the line as a comment, if:

  1. The slash is second of a "//" line oriented comment introducing
     token and we are on a comment-only-line, or

  2. The slash is part of a "*/" token that closes a block oriented
     comment.

If a numeric ARG is supplied, point is inside a literal, or
`c-syntactic-indentation' is nil or `c-electric-flag' is nil, indentation
is inhibited.

(fn ARG)
(defalias 'c-electric-slash #[257 "\306 \307\211\307\310\311\"\216\312 ,\262
\313\211\204Y
\314=\203Y\315\f>\203Y
\316=\203Y\317\320\321!\322Q!\203Y\212\214e`}\210\323 \210\317\324P!*\203Y\325y\210`\313\210`|\210\326\327\330\"\210?\205{\205{ \205{
\316=\205{`Sf\203y\327\202z\316=\262
\313!\331\332!!\210)\211\203\216\333 \210\334 )\207" [buffer-undo-list inhibit-read-only inhibit-modification-hooks c-echo-syntactic-information-p c-cleanup-list last-command-event buffer-modified-p t make-closure #[0 "\300?\205\301\302!\207" [V0 restore-buffer-modified-p nil] 2] c-in-literal nil c comment-close-slash 47 looking-at "[ 	]*\\(" regexp-quote "\\)?$" back-to-indentation "[ 	]*$" 0 insert-char 42 1 self-insert-command prefix-numeric-value indent-according-to-mode c--call-post-self-insert-hook-more-safely-1 comment-end c-current-comment-prefix c-syntactic-indentation c-electric-flag post-self-insert-hook] 8 (#$ . 22443) "*P"])
#@351 Insert a star character.
If `c-electric-flag' and `c-syntactic-indentation' are both non-nil, and
the star is the second character of a C style comment starter on a
comment-only-line, indent the line as a comment.  If a numeric ARG is
supplied, point is inside a literal, or `c-syntactic-indentation' is nil,
this indentation is inhibited.

(fn ARG)
(defalias 'c-electric-star #[257 "\306\307\310!!\210)\311 \312\211\312\313\314\"\216\f\205K
\205K
?\205K\315 \316=\205K`Sf\317=\205K\212\320u\210\321\306x\210`Sf\322=\203E\320u\210\323\306x\210n),\262
\203X\306\324 \210)\325 \207" [post-self-insert-hook buffer-undo-list inhibit-read-only inhibit-modification-hooks c-syntactic-indentation c-electric-flag nil self-insert-command prefix-numeric-value buffer-modified-p t make-closure #[0 "\300?\205\301\302!\207" [V0 restore-buffer-modified-p nil] 2] c-in-literal c 42 -1 "*" 47 " 	" indent-according-to-mode c--call-post-self-insert-hook-more-safely-1 c-echo-syntactic-information-p] 6 (#$ . 24039) "*P"])
#@679 Insert a comma or semicolon.

If `c-electric-flag' is non-nil, point isn't inside a literal and a
numeric ARG hasn't been supplied, the command performs several electric
actions:

(a) When the auto-newline feature is turned on (indicated by "/la" on
the mode line) a newline might be inserted.  See the variable
`c-hanging-semi&comma-criteria' for how newline insertion is determined.

(b) Any auto-newlines are indented.  The original line is also
reindented unless `c-syntactic-indentation' is nil.

(c) If auto-newline is turned on, a comma following a brace list or a
semicolon following a defun might be cleaned up, depending on the
settings of `c-cleanup-list'.

(fn ARG)
(defalias 'c-electric-semi&comma #[257 "\306\211\211`\306\307 \310\211\310\311\312\"\216\313\314 !\262\315!\262,\210\306\316\317!!\210) \203\347
\204\347\204\347!\203B\320\321!\204M\"\203\347\322 \210\202\347d`Z\307 \310\211\310\311\323\"\216#\324=\203k\325$>\204y#\326=\205\236\327$>\205\236\330u\210\331\306x\210l\203\222`Sf\332=\203\222\330u\210\202|`Sf\333=\205\236\315!?,\262
\203\250`|\210d
Zb\266\"\203\272\334 \322!\210%\306\211\203\336@ \262
\204\322A\262\202\276\306\262
\335=?\262
\202\276\211\203\345\336 \210\266\337 *\207" [c-syntactic-context c-echo-syntactic-information-p buffer-undo-list inhibit-read-only inhibit-modification-hooks post-self-insert-hook nil buffer-modified-p t make-closure #[0 "\300?\205\301\302!\207" [V0 restore-buffer-modified-p nil] 2] c-most-enclosing-brace c-parse-state c-in-literal self-insert-command prefix-numeric-value looking-at "[ 	]*\\\\?$" c-indent-line #[0 "\300?\205\301\302!\207" [V0 restore-buffer-modified-p nil] 2] 44 list-close-comma 59 defun-close-semi -1 " 	\n
\f" 92 125 c-guess-basic-syntax stop c-newline-and-indent c--call-post-self-insert-hook-more-safely-1 c-electric-flag c-auto-newline c-syntactic-indentation last-command-event c-cleanup-list c-hanging-semi&comma-criteria] 10 (#$ . 25070) "*P"])
#@637 Insert a colon.

If `c-electric-flag' is non-nil, the colon is not inside a literal and a
numeric ARG hasn't been supplied, the command performs several electric
actions:

(a) If the auto-newline feature is turned on (indicated by "/la" on
the mode line) newlines are inserted before and after the colon based on
the settings in `c-hanging-colons-alist'.

(b) Any auto-newlines are indented.  The original line is also
reindented unless `c-syntactic-indentation' is nil.

(c) If auto-newline is turned on, whitespace between two colons will be
"cleaned up" leaving a scope operator, if this action is set in
`c-cleanup-list'.

(fn ARG)
(defalias 'c-electric-colon #[257 "\212\306\211\307 \210*\n\203\310\n!\203\311\225b\210`)\312 \313\211\313\314\315\"\216\316!,\262
\306\211\211'\306(\317\320!!\210))\203\204
\204\204
\204\204
\310\321!\204Z*\203\204
\322 \210\202\204
d`Z`\312 \313\211\313\314\323\"\216+\205\255\324,>\205\255`Sf\325=\205\255\326u\210\327\306x\210l\203\230`Sf\330=\203\230\326u\210\202\202`Sf\325=\205\255\316 ?\205\255`\331Zf\325=?,\262
\203\273`
S|\210\313\262dZb\266*\203\311\322 \210\312 \313\211\313\314\332\"\216\313\211-.\333 \211\211\203\367\211@@\334=\203\360\211@\335\240\210\211A\262
\202\337+\205L
\336/\306\203
@\236\211\262\204
A\262\202
\266\202@
\236\266\203\206L
\337\340c\210\341\216\333 )/\306\203E
@\236\211\262\204E
A\262\2020
\266\202@
\236\266\203\262*\266,\210\342>\203v
\211\204v
\212\343\306x\210n)\204v
d`Z\326u\210\344 \210d
Zb\266\345\243>\203\204
\211\204\204
\344 \210\346 )\207" [end-of-defun-function beginning-of-defun-function defun-prompt-regexp buffer-undo-list inhibit-read-only inhibit-modification-hooks nil beginning-of-defun looking-at 0 buffer-modified-p t make-closure #[0 "\300?\205\301\302!\207" [V0 restore-buffer-modified-p nil] 2] c-in-literal self-insert-command prefix-numeric-value "[ 	]*\\\\?$" indent-according-to-mode #[0 "\300?\205\301\302!\207" [V0 restore-buffer-modified-p nil] 2] scope-operator 58 -1 " 	\n
\f" 92 2 #[0 "\300?\205\301\302!\207" [V0 restore-buffer-modified-p nil] 2] c-guess-basic-syntax substatement-label label (case-label label access-label) (member-init-intro inher-intro) 10 #[0 "\300\301!\207" [delete-char -1] 2] before ": 	" c-newline-and-indent after c--call-post-self-insert-hook-more-safely-1 c-echo-syntactic-information-p post-self-insert-hook c-electric-flag c-syntactic-indentation c-auto-newline c-cleanup-list c-syntactic-indentation-in-macros c-auto-newline-analysis c-hanging-colons-alist] 17 (#$ . 27087) "*P"])
#@501 Insert a "<" or ">" character.
If the current language uses angle bracket parens (e.g. template
arguments in C++), try to find out if the inserted character is a
paren and give it paren syntax if appropriate.

If `c-electric-flag' and `c-syntactic-indentation' are both non-nil, the
line will be reindented if the inserted character is a paren or if it
finishes a C++ style stream operator in C++ mode.  Exceptions are when a
numeric argument is supplied, or the point is inside a literal.

(fn ARG)
(defalias 'c-electric-lt-gt #[257 "\306 \307\211\307\310\311\"\216\312 ,\262
\313\211\211\211\211\211\313\314\315!!\210)`\262\204\367\204\367\316 \210\317\"!\205X#\320=\203J\321\225S=\202X
Sb\210\322\323 x\210`Sf\320=\262
b\210$\203\336%\203\336&\203\336#\320=\203\253\324u\210`\325 \210`U\203\220\326 \210\317'!\203\220\307\211\262\206\322(\327=\205\322
Sb\210\325 \210\317\330!\205\322\321\225Y\202\322\331S\332\"\203\272\307\211\262\206\322(\327=\205\322
Sb\210\325 \210\317\333!\205\322\321\225Y\262

b\210\211\203\336\334 \210\335\336!\203\367\203\367\204\361\203\367\313\337 \210)\211\203
`Sf\340=\203
)\204
*\203
* \210*\266\341 \207" [buffer-undo-list inhibit-read-only inhibit-modification-hooks case-fold-search c-echo-syntactic-information-p post-self-insert-hook buffer-modified-p t make-closure #[0 "\300?\205\301\302!\207" [V0 restore-buffer-modified-p nil] 2] c-in-literal nil self-insert-command prefix-numeric-value beginning-of-line looking-at 60 0 "^<>" line-beginning-position -1 c-beginning-of-current-token c-backward-token-2 c++-mode "<<" get-text-property syntax-table ">>" indent-according-to-mode boundp electric-pair-mode electric-pair-post-self-insert-function 62 c--call-post-self-insert-hook-more-safely-1 c-cpp-include-key last-command-event c-electric-flag c-syntactic-indentation c-recognize-<>-arglists c-opt-<>-sexp-key c-buffer-is-cc-mode executing-kbd-macro blink-paren-function] 11 (#$ . 29705) "*P"])
#@475 Insert a parenthesis.

If `c-syntactic-indentation' and `c-electric-flag' are both non-nil, the
line is reindented unless a numeric ARG is supplied, or the parenthesis
is inserted inside a literal.

Whitespace between a function name and the parenthesis may get added or
removed; see the variable `c-cleanup-list'.

Also, if `c-electric-flag' and `c-auto-newline' are both non-nil, some
newline cleanups are done if appropriate; see the variable `c-cleanup-list'.

(fn ARG)
(defalias 'c-electric-paren #[257 "\306 \307\211\307\310\311\"\216\312 ,\262
\313\211\313\314\315!!\210)
\204w
\211\204w
/\313/0\20391\2039\316 \2101\203\2632\203\263\317\320!\203\263\3213>\203~4\322=\203~\323\324\313\307#\203~\306 \307\211\307\310\325\"\216\312 ,\262
\204~\326\224\326\225|\210\327\330!\210\3313>\203\2634\322=\203\263\323\332\313\307#\203\263\306 \307\211\307\310\333\"\216\312 ,\262
\204\263\326\224\326\225|\210\327\334!\210\335\336!\203\304\203\304\313\337 \210)\313`S\3403>\203
4\322=\203
\212\341u\210\342\313x\210`\262\306 \307\211\307\310\343\"\216\344 ,\262
\205
\345 \205
\346 \205
`=?)\203
\212

|\210
b\210\347c\210)\266\202_
\306 \307\211\307\310\350\"\216\3513>\205S
4\352=\205S
\212\3531?
\354u0\210\202@
\210\317\355!\205R
`\262\342\313x\210`\262\344 ),\262
\203]


|\210\2665\352=\203r
6\204r
\211\203r
\211 \210)\210\202\210
\335\336!\203\210
\203\210
\313\337 \210)\356 *\207" [buffer-undo-list inhibit-read-only inhibit-modification-hooks case-fold-search c-echo-syntactic-information-p post-self-insert-hook buffer-modified-p t make-closure #[0 "\300?\205\301\302!\207" [V0 restore-buffer-modified-p nil] 2] c-in-literal nil self-insert-command prefix-numeric-value indent-according-to-mode looking-at "[ 	]*\\\\?$" brace-elseif-brace 40 re-search-backward "}\\([ 	\n]\\|\\\\\n\\)*else\\([ 	\n]\\|\\\\\n\\)+if\\([ 	\n]\\|\\\\\n\\)*(\\=" #[0 "\300?\205\301\302!\207" [V0 restore-buffer-modified-p nil] 2] 0 insert-and-inherit "} else if (" brace-catch-brace "}\\([ 	\n]\\|\\\\\n\\)*catch\\([ 	\n]\\|\\\\\n\\)*(\\=" #[0 "\300?\205\301\302!\207" [V0 restore-buffer-modified-p nil] 2] "} catch (" boundp electric-pair-mode electric-pair-post-self-insert-function space-before-funcall -1 " 	" #[0 "\300?\205\301\302!\207" [V0 restore-buffer-modified-p nil] 2] c-on-identifier c-beginning-of-macro c-forward-over-cpp-define-id 32 #[0 "\300?\205\301\302!\207" [V0 restore-buffer-modified-p nil] 2] compact-empty-funcall 41 (error) -2 "()" c--call-post-self-insert-hook-more-safely-1 blink-paren-function c-syntactic-indentation c-electric-flag c-auto-newline c-cleanup-list last-command-event last-input-event executing-kbd-macro] 10 (#$ . 31721) "*P"])
#@408 Reindent the current line if appropriate.

This function is used to reindent the line after a keyword which
continues an earlier statement is typed, e.g. an "else" or the
"while" in a do-while block.

The line is reindented if there is nothing but whitespace before the
keyword on the line, the keyword is not inserted inside a literal, and
`c-electric-flag' and `c-syntactic-indentation' are both non-nil.
(defalias 'c-electric-continued-statement #[0 "\306\307 \310\211\310\311\312\"\216\f\205P
\205P\313=?\205P\212\314\315!\210`)\212\316 \210`)U\205P\317\212\306\211\320 \210*\203L\321!\203L\322\225b\210`)!?,\262
\205_\323\324!\210\325\216\326 ))\207" [c-echo-syntactic-information-p buffer-undo-list inhibit-read-only inhibit-modification-hooks c-electric-flag c-syntactic-indentation nil buffer-modified-p t make-closure #[0 "\300?\205\301\302!\207" [V0 restore-buffer-modified-p nil] 2] 95 skip-syntax-backward "w" back-to-indentation c-in-literal beginning-of-defun looking-at 0 insert-and-inherit " x" #[0 "\300\301!\207" [delete-char -2] 2] indent-according-to-mode last-command-event end-of-defun-function beginning-of-defun-function defun-prompt-regexp] 5 (#$ . 34471)])
#@123 Align a "#pragma" line under the previous line.
This function is intented for use as a member of `c-special-indent-hook'.
(defalias 'c-align-cpp-indent-to-body #[0 "\303\236\205+\212\304 \305\306\"\216\307 \210\310	\311P!\205\312\313!\n\235)\262
)\205+\314\315\316\"!\207" [c-syntactic-context c-opt-cpp-symbol c-cpp-indent-to-body-directives cpp-macro match-data make-closure #[0 "\301\300\302\"\207" [V0 set-match-data evaporate] 3] back-to-indentation looking-at "[ 	]*\\([a-zA-Z0-9_]+\\)" match-string-no-properties 1 c-indent-line delete (cpp-macro)] 4 (#$ . 35685)])
(defvar c-cpp-indent-to-body-flag nil)
(make-variable-buffer-local 'c-cpp-indent-to-body-flag)
#@558 Reindent the current line if appropriate.

This function is used to reindent a preprocessor line when the
symbol for the directive, typically "pragma", triggers this
function as a hook function of an abbreviation.

The "#" of the preprocessor construct is aligned under the
first anchor point of the line's syntactic context.

The line is reindented if the construct is not in a string or
comment, there is exactly one "#" contained in optional
whitespace before it on the current line, and `c-electric-flag'
and `c-syntactic-indentation' are both non-nil.
(defalias 'c-electric-pragma #[0 "\212\305 \306\307\"\216\205;	\205;\n\205;\205;\f\205;\310 \210\311\f\312P!\205;\313\225Y\205;\314 ?\205;\315\316\317\320 \"!)\262
)\207" [c-cpp-indent-to-body-flag c-electric-flag c-syntactic-indentation last-abbrev-location c-opt-cpp-symbol match-data make-closure #[0 "\301\300\302\"\207" [V0 set-match-data evaporate] 3] back-to-indentation looking-at "[ 	]*" 0 c-literal-limits c-indent-line delete (cpp-macro) c-guess-basic-syntax] 5 (#$ . 36367)])
#@10 

(fn D)
(defalias 'c-add-indent-to-body-to-abbrev-table #[257 "\205&	\205&\302
	\"?\205&\3031\304	\211\305\306\307&0\207\210\304	\211\305$\207" [c-buffer-is-cc-mode local-abbrev-table abbrev-symbol (wrong-number-of-arguments) define-abbrev c-electric-pragma 0 t] 8 (#$ . 37430)])
(defalias 'c-clear-stale-indent-to-body-abbrevs #[0 "\301\302!\205\n\303\304\"\207" [local-abbrev-table fboundp abbrev-get mapatoms #[257 "\303
\304\"\205\305
!\235?\205\305
!	\235?\205\306
\n\"\207" [c-std-abbrev-keywords c-cpp-indent-to-body-directives local-abbrev-table abbrev-get :system symbol-name unintern] 4 "\n\n(fn A)"]] 3])
#@342 Toggle the C preprocessor indent-to-body feature.
When enabled, preprocessor directives which are words in
`c-indent-to-body-directives' are indented as if they were statements.

Optional numeric ARG, if supplied, turns on the feature when positive,
turns it off when negative, and just toggles it when zero or
left out.

(fn &optional ARG)
(defalias 'c-toggle-cpp-indent-to-body #[256 "\302
\"\211\203\303 \210\304\305	\"\210\306\307\310\311\312$\210\202!\313\307\310\312#\210\314\315\203+\316\202,\317\"\207" [c-cpp-indent-to-body-flag c-cpp-indent-to-body-directives c-calculate-state c-clear-stale-indent-to-body-abbrevs mapc c-add-indent-to-body-to-abbrev-table add-hook c-special-indent-hook c-align-cpp-indent-to-body nil t remove-hook message "c-cpp-indent-to-body %sabled" "en" "dis"] 7 (#$ . 38072) "P"])
(byte-code "\300\301!\203J\300\302!\204J\303\302\301\304#\210\305\302\301\306#\210\307\302\301\304#\210\310\211\203@\211@\302
N\2039\301
N\2049\311\301\302N#\210
A\266\202\202\210\312\302\301\306#\210\202Q\313\302\314\315\316$\210\304\207" [fboundp subword-mode c-subword-mode defalias nil make-obsolete "24.3" defvaralias (saved-value saved-variable-comment) put make-obsolete-variable autoload "cc-subword" "Mode enabling subword movement and editing keys." t] 7)
#@67 Compatibility alias for `c-backward-subword'.

(fn &optional ARG)
(defalias 'c-backward-into-nomenclature #[256 "\300\301!\203\302\303!\210\304
!\207\302\305!\210\306
!\207" [fboundp subword-mode require subword subword-backward cc-subword c-backward-subword] 3 (#$ . 39377) "p"])
(byte-code "\300\301\302\303!\203\f\304\202
\305\306#\207" [make-obsolete c-backward-into-nomenclature fboundp subword-mode subword-backward c-backward-subword "23.2"] 4)
#@106 Insert a double colon scope operator at point.
No indentation or other "electric" behavior is performed.
(defalias 'c-scope-operator #[0 "\300\301!\207" [insert-and-inherit "::"] 2 (#$ . 39840) "*"])
#@22 

(fn &optional LIM)
(defalias 'c-in-function-trailer-p #[256 "\205\217\212\301\302\"\210`\303`Sf\304=\205\214\305!@\306>\205\214`\211\262\205\214\307\310\311Q\312\211\211%\205\214\313\224\205\214`Sf\314=?\205\214\307\315\312\211\211%\205\214`Sf\316=\205\214\3171^\320`\313\211#0\202`\210\303\211\205h\211b\210\312\262
\205\207`Sf\304=\205\207\321 \210\307\315\303\312\211\211%\205\207`Sf\322=?\205\214\211\266\202)\207" [c-opt-block-decls-with-vars-key c-syntactic-skip-backward "^;}" nil 125 c-beginning-of-decl-1 (same previous) c-syntactic-re-search-forward "[;=([{]\\|\\(" "\\)" t 1 95 "[;=([{]" 123 (error) scan-lists c-forward-sws 40] 9 (#$ . 40046)])
(defalias 'c-where-wrt-brace-construct #[0 "\212\304\211\211`\305 \306
!\211\203\211f\307=\203\266\310\202P
\311 \203&\266\312\202P
`Sf\313=\2038\212\314u\210\311 )\204q\211\204w
:\203w
@:\203w@A=\203w\212\315 \210\316!?\206]\316	!)\204q\212
@@b\210\317 \210\316\n!)\204w\266\320\202P
l\203m\203\205\316\321!\204\210\304u\210\211\203\252\211f\322=\203\252\3231\240\324
\325\326#0\202\242\210\304\211\203\251\211b\210\210\315 \210`\262\327\330\304\331\211$\203M
`Sf\307=\203M
\314u\210\332 \210`X\204\340\203\346\333 \211\262\203\346X\203\346\266\334\202P
\203\364b\203\364\332 \206N
`Sf\335=\203
\3361	
\324`\314\326#0\202
\210\304\211\203
\211b\210\210\317
\205
\337\"!@\262`V\203,
\266\340\202P
\341=\203D
`=\203>
\266\342\202P
\266\334\202P
\343\344\"\266\206\202P
\340\266\206)\207" [c-symbol-start c-keywords-regexp c-defun-type-name-decl-key c-recognize-knr-p nil c-parse-state c-least-enclosing-brace 123 in-block c-in-function-trailer-p in-trailer 59 -1 c-forward-sws looking-at c-beginning-of-decl-1 at-function-end "\\([;#]\\|\\'\\|\\s(\\|\\s)\\|\\s\"\\|\\s\\\\|\\s$\\|\\s<\\|\\s>\\|\\s!\\)" 40 (error) scan-lists 1 0 c-syntactic-re-search-forward "[;{]" t c-backward-sws c-in-knr-argdecl in-header 41 (error) c-safe-position outwith-function same at-header error "c-where-wrt-brace-construct: c-beginning-of-decl-1 returned %s"] 11])
#@16 

(fn N WHERE)
(defalias 'c-backward-to-nth-BOF-{ #[514 "o\204O\211\300\267\202J\301\302 !b\210
S\262\202O\301\302 !\211\203\"\211b\210\303\304\305\306\211$\210\307u\210S\262\210\202O\310\311!\210`Sf\312=\203O\313 \210
S\262\202O\314\315\"\210
\316V\203ro\204r\302 \210\310\311!\210`Sf\312=\203O\313 \210
S\262\202O
\207" [#s(hash-table size 6 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (in-block 10 in-header 23 at-header 52 outwith-function 52 at-function-end 52 in-trailer 52)) c-least-enclosing-brace c-parse-state c-syntactic-re-search-forward "{" nil t -1 c-syntactic-skip-backward "^}" 125 backward-sexp error "Unknown `where' %s in c-backward-to-nth-EOF-{" 0] 8 (#$ . 42138)])
#@34 

(fn &optional INCLUSIVE LEVEL)
(defalias 'c-narrow-to-most-enclosing-decl-block #[512 "\300 \301\206\302\262\303V\203>\304!\262
\211\2038
@:\203&
A\262\202
@A\262
V\204S\262\202\n\303\262\202\n\211\205u\212\203Q\211b\210\305 \210`\202S\211T
b\210\3061k\307 \210\203e`\202g`S0\202o\210\202r\206sd})\207" [c-parse-state nil 1 0 c-most-enclosing-decl-block c-beginning-of-decl-1 (error) forward-list] 6 (#$ . 42867)])
#@50 

(fn PAREN-STATE ORIG-POINT-MIN ORIG-POINT-MAX)
(defalias 'c-widen-to-enclosing-decl-scope #[771 "\300\214}\210\205
\301!\262
)\211\2035~\210\211T\212
b\210\3021)\303 \210`S0\202-\210\2020\2061)}\210\207}\210\300\207" [nil c-most-enclosing-decl-block (error) forward-list] 6 (#$ . 43322)])
#@37 

(fn CONDITION &optional NO-WHERE)
(defalias 'c-while-widening-to-decl-block '(macro . #[513 "\300\301\302BB\303\304?\205\305BBBB\207" [while and ((eq c-defun-tactic 'go-outward) lim) (setq paren-state (c-whack-state-after lim paren-state)) (setq lim (c-widen-to-enclosing-decl-scope paren-state orig-point-min orig-point-max)) ((setq where 'in-block))] 7 (#$ . 43632)]))
(byte-code "\300\301\302\303#\210\300\301\302\303#\207" [put c-while-widening-to-decl-block edebug-form-spec t] 4)
#@496 Move backward to the beginning of a defun.
Every top level declaration that contains a brace paren block is
considered to be a defun.

With a positive argument, move backward that many defuns.  A negative
argument -N means move forward to the Nth following beginning.  Return
t unless search stops due to beginning or end of buffer.

Unlike the built-in `beginning-of-defun' this tries to be smarter
about finding the char with open-parenthesis syntax that starts the
defun.

(fn &optional ARG)
(defalias 'c-beginning-of-defun #[256 "\211\204\306\262
\307=\203	\307=\204\310 \204\311 \210\312 \313\211\313\314\315\"\216\316\211%\317 ed\316\211\211\211&\214'\320=\203I\321#\262\322 \210\323 \262
\211\203W\211b\210\324 \262\325W\203\350
\326>\203mT\262\325W\203\245\327[\"[\211\262	\325W\203\245'\320=\203\245\203\245\330\"\262\321#\262\331\262\202t\325U\205V
\332\333\316\334#\204\326'\320=\203\326\203\326\330\"\262\321#\262\331\262\202\254`Sf\335=\205V
\336u\210\337 \210\313\202V
\325V\203
\340\"\211\262	\325V\203
'\320=\203
\203
\330\"\262\321#\262\331\262\202\357\325=\203I
\337 \210`\262
`\212\341 \210`)U\204;
\342 \204+
`\212\341 \210`)U\204I
\211b\210\343\344!\203R
\313$\325U,\266\206,\207" [this-command last-command buffer-undo-list inhibit-read-only inhibit-modification-hooks beginning-of-defun-function 1 c-beginning-of-defun region-active-p push-mark buffer-modified-p t make-closure #[0 "\300?\205\301\302!\207" [V0 restore-buffer-modified-p nil] 2] nil c-parse-state go-outward c-widen-to-enclosing-decl-scope c-beginning-of-macro c-literal-start c-where-wrt-brace-construct 0 (at-function-end outwith-function) c-forward-to-nth-EOF-\;-or-} c-whack-state-after in-block c-syntactic-re-search-forward "{" eob 123 -1 c-beginning-of-decl-1 c-backward-to-nth-BOF-{ back-to-indentation c-backward-single-comment boundp zmacs-region-stays end-of-defun-function case-fold-search c-defun-tactic] 13 (#$ . 44131) "p"])
#@16 

(fn N WHERE)
(defalias 'c-forward-to-nth-EOF-\;-or-} #[514 "m\204b\211\300\267\202]\301\302 !b\210\303 \210
S\262\202b
S\262\202b\211\304=\203G\301\302 !\211\203F\3051<\306
\307\310#0\202>\210\311\211\203E\211b\210\210\210\312\313\311\314\315$\203b\316u\210\303 \210
S\262\202b\317\320\"\210
\310V\203\201m\204\201\312\313\311\314#\203b\316u\210\303 \210
S\262\202b\321 \203\215\312\322\311\314\315$\210
\207" [#s(hash-table size 6 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (in-block 10 in-trailer 26 at-function-end 33 outwith-function 33 at-header 33 in-header 33)) c-least-enclosing-brace c-parse-state forward-sexp in-header (error) scan-lists 1 0 nil c-syntactic-re-search-forward "{" eob t -1 error "c-forward-to-nth-EOF-\\;-or-}: `where' is %s" c-in-function-trailer-p ";"] 7 (#$ . 46175)])
#@378 Move forward to the end of a top level declaration.
With argument, do it that many times.  Negative argument -N means move
back to Nth preceding end.  Returns t unless search stops due to
beginning or end of buffer.

An end of a defun occurs right after the close-parenthesis that matches
the open-parenthesis that starts a defun; see `beginning-of-defun'.

(fn &optional ARG)
(defalias 'c-end-of-defun #[256 "\211\204\306\262
\307=\203	\307=\204\310 \204\311 \210\312 \313\211\313\314\315\"\216\316\211&\317 ed\316\211\211\211'\214(\320=\203I\321#\262\322 \210\323 \262
\211\203W\211b\210\324 \262\325W\203\332
\326>\203mT\262\325W\203\245\327[\"[\211\262	\325W\203\245(\320=\203\245\203\245\330\"\262\321#\262\331\262\202t\325U\203
\332\333!\210`Sf\334=\204
(\320=\203
\203
\330\"\262\321#\262\331\262\202\254\325V\203
\335\"\211\262	\325V\203
(\320=\203
\203
\330\"\262\321#\262\331\262\202\341\325=\203E
\336 \203 
\337\340!\210`\262
n\2042
\341\342!\2042
\343 \204#
n\204E
\341\342!\203B
\306y\210\202E
\211b\210\344\345!\203N
\313%\325U,\266\206,\207" [this-command last-command buffer-undo-list inhibit-read-only inhibit-modification-hooks beginning-of-defun-function 1 c-end-of-defun region-active-p push-mark buffer-modified-p t make-closure #[0 "\300?\205\301\302!\207" [V0 restore-buffer-modified-p nil] 2] nil c-parse-state go-outward c-widen-to-enclosing-decl-scope c-beginning-of-macro c-literal-start c-where-wrt-brace-construct 0 (at-header outwith-function) c-backward-to-nth-BOF-{ c-whack-state-after in-block c-syntactic-skip-backward "^}" 125 c-forward-to-nth-EOF-\;-or-} c-in-function-trailer-p c-syntactic-re-search-forward ";" looking-at "\\s *$" c-forward-single-comment boundp zmacs-region-stays end-of-defun-function case-fold-search c-defun-tactic] 13 (#$ . 47025) "p"])
#@160 Return name of current defun, at current narrowing, or nil if there isn't one.
"Defun" here means a function, or other top level construct
with a brace block.
(defalias 'c-defun-name-1 #[0 "\306 \307\211\307\310\311\"\216\312\211\312\211\211\211\211\211\211\212\313 \210\314 \262\203(b\210\315 \262\316>?\205 
\317=\204B\320\321\"\210\322 \210\323-!\203P\324\225b\210\325 \210`\262\323\326!\203{\327\321!\210\325 \210\312f\330=\203n\331\321!\210\332 \210\333`\332 \210\334 \210`\"\202 
.\335=\203\322\323\336!\203\322\332\337\307\"\210\212\340\341\312\307#\205\231\342\337!)\212\343\344\312\307#)\343\345\307#\205\254\342\321!\205\315\211\205\315\343\346\321#\203\306\211\342\321!P\262
\202\264\347\350\351\260\266\203\202 
\323/!\203\346\324\225b\210\325 \210`\262

b\210\352\212\334 \210`)\353\312#\262:\203\377@b\210\354 \262\205 
@\205 
A@\205 
\333@=\203
\202
@A@\",\266\206,\207" [buffer-undo-list inhibit-read-only inhibit-modification-hooks beginning-of-defun-function end-of-defun-function case-fold-search buffer-modified-p t make-closure #[0 "\300?\205\301\302!\207" [V0 restore-buffer-modified-p nil] 2] nil c-beginning-of-macro c-literal-start c-where-wrt-brace-construct (outwith-function at-function-end) at-header c-backward-to-nth-BOF-{ 1 c-beginning-of-decl-1 looking-at 0 c-forward-sws "DEFUN\\s-*(" down-list 34 forward-sexp c-forward-token-2 buffer-substring-no-properties c-backward-sws objc-mode "[-+]\\s-*(" 2 re-search-backward "^\\s-*@\\(implementation\\|class\\|interface\\)\\s-+\\(\\sw+\\)" match-string-no-properties re-search-forward "[;{]" "\\(\\sw+:?\\)" "\\(\\sw+:\\)" "[" " " "]" c-forward-decl-or-cast-1 top c-forward-declarator c-typedef-key c-buffer-is-cc-mode c-defun-type-name-decl-key] 16 (#$ . 48940)])
#@181 Return the name of the current defun, or NIL if there isn't one.
"Defun" here means a function, or other top level construct
with a brace block, at the outermost level of nesting.
(defalias 'c-defun-name #[0 "\303 \304\211\304\305\306\"\216\214~\210\307 -\207" [buffer-undo-list inhibit-read-only inhibit-modification-hooks buffer-modified-p t make-closure #[0 "\300?\205\301\302!\207" [V0 restore-buffer-modified-p nil] 2] c-defun-name-1] 5 (#$ . 50747)])
#@13 

(fn NEAR)
(defalias 'c-declaration-limits-1 #[257 "\212`\301 \302\211\211\211\3032\225
\3041Y\305!b\210\306`\"\262\206!`Sf\307=\203T\212\31016\311\312\313#0\2028\210\302\211\205@\211b\210\211\262
\205M\301 \306`\"\262
)\206Re\262\3140\202[\210\302\204n\315\306`\"!\262\203nb\210\316 \203\202\317\303`\212\320 \210\321y\210`)B\"\210`\262\212\316 )?\205\217\322 \262
\211\323=\204\356\203\255\211\324>\203\255\212\325!@\326>)\204\274\325!@\327=\204\274`U\203\356b\210\330\331!\203\311m\203\277\332\333!\203\325\334u\210\202\277\203\356\316 \203\356\317\303`\212\320 \210\321y\210`)B\"\210m\203\367\317\303\302\"\210`\262\203#
\335 \210`Sf\307=\203#
\325 @\327=\203#
\212\336 \210`V\205
`\211\262)\204&
b\210\2042
`V\2067
\322 \323=??\205\224
`\262`\212\337 \210`)U\204N
\340 \204>
`\212\337 \210`)U\204]
\202^
`\203h
b\210\202k
\336 \210`\262n\204}
\332\341!\204}
\342 \204n
n\203\205
`\202\223
\332\341!\203\222
\321y\210`\202\223
B0\206\265
?\205\265
eb\205\265
\343\312\302\211#\205\265
\302f\344=\205\265
edB\266\206)\207" [c-opt-block-decls-with-vars-key c-parse-state nil exit (error) c-least-enclosing-brace c-safe-position 125 (error) scan-lists -1 0 t c-literal-start c-beginning-of-macro throw c-end-of-macro 1 c-where-wrt-brace-construct at-header (at-function-end outwith-function) c-beginning-of-decl-1 (previous label) previous forward-comment 5 looking-at "\\\\[\n
]" 2 c-backward-sws c-end-of-decl-1 back-to-indentation c-backward-single-comment "\\s *$" c-forward-single-comment c-forward-decl-or-cast-1 123] 11 (#$ . 51216)])
#@13 

(fn NEAR)
(defalias 'c-declaration-limits #[257 "\214\301=\2035\214\212\302 )\204'\214\303 \210\304 \305>)\203'\211\204'\303\306\307\"\210\202*\303 \210ed)B\211@
A}\266\310
!)\207" [c-defun-tactic go-outward c-beginning-of-macro c-narrow-to-most-enclosing-decl-block c-where-wrt-brace-construct (at-function-end outwith-function) nil 2 c-declaration-limits-1] 4 (#$ . 52832)])
#@13 

(fn NEAR)
(defalias 'c-defun-name-and-limits #[257 "\214~\210\304=\203j\305 \306\211\306\307\310\"\216\311 ed\312\211\211\313#\262\203/S\262\314 \211\262\204U\304=\203U\203U\315\"\262\313#\262\202/
\205b\316!\262


B\266\206,\262
\202\214\305 \306\211\306\307\317\"\216\320 \321!
\205\207\211\205\207

B\266\202,\262
)\207" [c-defun-tactic buffer-undo-list inhibit-read-only inhibit-modification-hooks go-outward buffer-modified-p t make-closure #[0 "\300?\205\301\302!\207" [V0 restore-buffer-modified-p nil] 2] c-parse-state nil c-widen-to-enclosing-decl-scope c-defun-name-1 c-whack-state-after c-declaration-limits-1 #[0 "\300?\205\301\302!\207" [V0 restore-buffer-modified-p nil] 2] c-defun-name c-declaration-limits] 13 (#$ . 53224)])
#@148 Display the name of the current CC mode defun and the position in it.
With a prefix arg, push the name onto the kill ring too.

(fn &optional ARG)
(defalias 'c-display-defun-name #[256 "\214~\210\303 \304\211\304\305\306\"\216\307\310!\211@
A\311 \205@\312\313\314@@]\"T\314@A\"$\210\203<\315!\210\316\317\304\"\266\204,\262
)\207" [buffer-undo-list inhibit-read-only inhibit-modification-hooks buffer-modified-p t make-closure #[0 "\300?\205\301\302!\207" [V0 restore-buffer-modified-p nil] 2] c-defun-name-and-limits nil line-beginning-position message "%s.  Line %s/%s." count-lines kill-new sit-for 3] 14 (#$ . 54024) "P"])
(put 'c-display-defun-name 'isearch-scroll t)
#@470 Put mark at end of current top-level declaration or macro, point at beginning.
If point is not inside any then the closest following one is
chosen.  Each successive call of this command extends the marked
region by one function.

A mark is left where the command started, unless the region is already active
(in Transient Mark mode).

As opposed to \[c-beginning-of-defun] and \[c-end-of-defun], this
function does not require the declaration to contain a brace block.
(defalias 'c-mark-function #[0 "\306\211\307 \310\211\310\311\312\"\216\313\f!\203\314\315\306\316 #\210\317\310!\262,\210\211\204.\320\321!\202{
\322=\2058\322=
\322=\205F\211?\205F\323 ?\211\203M\324 \210
\203o\325 \210\317\310!\262\204d\325 \210\320\321!\210Ab\210\325 \266\202\202{@b\210\324A\306\310#\266\202)\207" [case-fold-search buffer-undo-list inhibit-read-only inhibit-modification-hooks c-syntactic-eol this-command nil buffer-modified-p t make-closure #[0 "\300?\205\301\302!\207" [V0 restore-buffer-modified-p nil] 2] looking-at c-backward-token-2 1 line-beginning-position c-declaration-limits error "Cannot find any declaration" c-mark-function region-active-p push-mark exchange-point-and-mark last-command] 8 (#$ . 54725) nil])
#@71 Return the name of the current CPP macro, or NIL if we're not in one.
(defalias 'c-cpp-define-name #[0 "\302\212	\205\303 \205\304	!\205\305\306!*\207" [case-fold-search c-opt-cpp-macro-define-start nil c-beginning-of-macro looking-at match-string-no-properties 1] 2 (#$ . 55973)])
(defalias 'c-in-comment-line-prefix-p #[0 "`\212\301 \210\302\303w\210\304!\205\305\224\305\225U?\205\211\305\225W)\207" [c-current-comment-prefix beginning-of-line " 	" nil looking-at 0] 3])
#@14 

(fn RANGE)
(defalias 'c-narrow-to-comment-innards #[257 "\300
!\211\301=\203
@\302\\\202
@
\301=\203>A\206`Sf\303=\203:AS\206,`Sf\304=\203:A\302Z\202Ld\202LAd=\203Id\202LAS`
V\203U\211b\210`W\203^
b\210

}\207" [c-literal-type c 2 47 42] 6 (#$ . 56465)])
#@14 

(fn RANGE)
(defalias 'c-beginning-of-sentence-in-comment #[257 "\301 \302\303\"\216`\214\304!\210`\305\306\307Q\310\311Q\212\312\313!\210\314\305\315#V\203)b\210`Y\203@\312\316!\210\314\305\315#V\203@b\210`)\317\320 \321#\203\215`\211\262\203\215\322\225b\203\215`Y\204\207n\204u\212\317\305\315#\205q\323\224\323\225U?)\204\207\324 \203}\325 \210\314!\210`Y\203\215b\210\202B\314!\266)`
W?\205\237@b\210\315\262
)\207" [c-current-comment-prefix match-data make-closure #[0 "\301\300\302\"\207" [V0 set-match-data evaporate] 3] c-narrow-to-comment-innards nil "\\=\\(^[ 	]*\\(" "\\)\\|[ 	\n
\f]\\)*" "^[ 	]*\\(" "\\)[ 	\n
\f]*\\=" forward-paragraph -1 re-search-forward t -2 re-search-backward sentence-end limit 0 1 c-in-comment-line-prefix-p beginning-of-line] 12 (#$ . 56750)])
#@14 

(fn RANGE)
(defalias 'c-end-of-sentence-in-comment #[257 "\301 \302\303\"\216`\214\304!\210`\212\305\306!\210h\307=\203\310u\210`
X\2032\211b\210\305\311!\210h\307=\2032\310u\210`)\312\313\314Q\315\316 \317#\203i`\262\320\312x\210n\204]\321
\312\322#\203]\306\224\306\225U\203c`X\203i
b\210\2029`d=\203\207\320\312x\323U\203o\321
\312\322#\203\207\306\224\306\225U\203o\266)`
V?\205\226Ab\210\322\262
)\207" [c-current-comment-prefix match-data make-closure #[0 "\301\300\302\"\207" [V0 set-match-data evaporate] 3] c-narrow-to-comment-innards forward-paragraph 1 10 -1 2 nil "^[ 	]*\\(" "\\)\\=" re-search-forward sentence-end limit " 	\n" re-search-backward t 0] 11 (#$ . 57574)])
#@14 

(fn RANGE)
(defalias 'c-beginning-of-sentence-in-string #[257 "\305 \306\307\"\216`\310AS\n\212\214@T
}\210\311\312!\210\313\314\310\315#V\203)b\210`Y\203@\311\316!\210\313\314\310\315#V\203@b\210`*\317\f\320#\203o`\211\262\203o\321\225b\203o`V\204i\313\314\315#\210`Y\203ob\210\202B\313\314\315#\210`W?\205\201@b\210\315*\266\204)\207" [c-string-par-start paragraph-start c-string-par-separate paragraph-separate c-sentence-end-with-esc-eol match-data make-closure #[0 "\301\300\302\"\207" [V0 set-match-data evaporate] 3] nil forward-paragraph -1 re-search-forward "\\=\\([ 	\n
\f]\\|\\\\[\n
]\\)*" t -2 re-search-backward limit 0] 10 (#$ . 58288)])
#@14 

(fn RANGE)
(defalias 'c-end-of-sentence-in-string #[257 "\305 \306\307\"\216`\310\n\212\214@AS}\210\311\312!\210`\262
\313\310x\314U\203\315\316\310\317#\204`V\204J\211b\210\311\312!\210\313\310x\314U\203:\315\316\310\317#\204:`*\320\f\321#\203g`\262\322\310x\314U\203W\315\316\310\317#\204W`V?\205sAb\210\317*\266\203)\207" [c-string-par-start paragraph-start c-string-par-separate paragraph-separate c-sentence-end-with-esc-eol match-data make-closure #[0 "\301\300\302\"\207" [V0 set-match-data evaporate] 3] nil forward-paragraph 1 " 	\n
\f" 0 re-search-backward "\\\\\\($\\)\\=" t re-search-forward limit " 	\n"] 9 (#$ . 58978)])
(defalias 'c-ascertain-preceding-literal #[0 "\212\302`\303\304 \203`\305 \210`B\266\202\202J\214e}\210\306!\204-o?\205G\307u\210\306	!\205G\310\225b\210`\262
\3111E\312`\307\"b\210`
B0\202G\210\303)\266\202!)\207" [c-ws*-string-limit-regexp c-string-limit-regexp c-collect-line-comments nil c-backward-single-comment c-forward-single-comment looking-at -1 0 (error) scan-sexps] 6])
(defalias 'c-ascertain-following-literal #[0 "\212\301\302\303\302w\210\302f\304=\203\302u\210l\204\305u\210\306!\203:`\3071.\310`\311\"b\210`0\2022\210\2025\2066dB\202E`\262
\312 \205E\211`B\262
!)\207" [c-string-limit-regexp c-collect-line-comments nil " 	\n
\f" 92 -1 looking-at (error) scan-sexps 1 c-forward-single-comment] 6])
(defalias 'c-after-statement-terminator-p #[0 "\212\302u\210\303\304!\205\205\305f\306=\205\307 ?)\206T	\203%	 \206T\305\212\310 \2032\311 \210`\262
)\211\205R\212\312\313!\203Bm\2038\303\314!\203N\315u\210\2028`
Y)\262
\207" [c-special-brace-lists c-at-vsemi-p-fn -1 looking-at "[;{}]" nil 123 c-looking-at-special-brace-list c-beginning-of-macro c-end-of-macro forward-comment 5 "\\\\[\n
]" 2] 3])
#@20 

(fn MACRO-START)
(defalias 'c-back-over-illiterals #[257 "\303 \304\305\"\216`\306\3072
`\262
\310 \203 \211b\210\311\307\312\"\210\202
\212\313 \210\314\315\316#)\203P\2037`W\2029\317 \203P\211b\210\311\307`=\206I?\320B\"\210\202
\203q \203q\211W\203q\211f\321>\204q\211b\210\311\307\322\"\210\202
o\203\206

U\204~\211b\210\311\307\323\"\210\202
\324u\210\306f\325=\203\261	\203\240\326 \203\240\327\330!\210\202


U\204\251\211b\210\311\307\331\"\210\202
\203\307`=\203\307\311\307`=\320B\"\210\202
\332\333!\203\372

U\204\332\211f\334>\203\357`Sf\335=\203
\306f\336=\203
\324u\210\202
\211b\210\311\307\337\"\210\202
\332\n!\203
\211b\210\311\307\340\"\210\202
\327\330!\210\202
\266\202)\207" [c-at-vsemi-p-fn c-special-brace-lists c-string-limit-regexp match-data make-closure #[0 "\301\300\302\"\207" [V0 set-match-data evaporate] 3] nil done c-backward-single-comment throw (t . literal) beginning-of-line re-search-forward "\\(^\\|[^\\]\\)[\n
]" t c-beginning-of-macro macro-boundary (41 125) (nil) (nil) -1 123 c-looking-at-special-brace-list skip-syntax-backward "w_" (nil) looking-at "[;}]" (41 125) 125 59 (nil) (t . literal)] 8 (#$ . 60798)])
#@35 

(fn MACRO-END ALLOW-EARLY-STOP)
(defalias 'c-forward-over-illiterals #[514 "`\304\3052m
`\262
\211V\203\203 \203\306\305\307\"\210\310\304w\210\304f\311=\2032\304u\210l\204\312u\210\203K`V\203K\211b\210\306\305`=\313B\"\210\202\212\314 )\203]\211b\210\306\305\315\"\210\202m\203r

U\204j\211b\210\306\305\316\"\210\202\304f\317=\203\263	\203\202\320 \204\263\204\214

U\204\263\212\3211\232\322\312!\210\3230\202\234\210\304?\206\244\304f\317U)\203\263\211b\210\306\305\324\"\210\202	\203\344\304f\325=\203\344\212\3261\314\322\312!\210\3230\202\321\210\304\202\326\205\326\320 )\203\344\304u\210\327\330!\210\202\304f\325=\203\374

U\204\374\211b\210\306\305\331\"\210\202\n\203*
\204*
\304f\332=\203*
`\212\333 \210`)U\203*
`U\203\"
\304u\210\202\306\305\334\"\210\202\335\336!\203<
\337\225b\210\306\305\340\"\210\202\335!\203M
\211b\210\306\305\341\"\210\202\304u\210\327\330!\210\203`V\203\211b\210\306\305`=\313B\"\210\202\207" [c-at-vsemi-p-fn c-special-brace-lists c-opt-cpp-prefix c-string-limit-regexp nil done throw (nil) " 	\n
\f" 92 -1 macro-boundary c-forward-single-comment (t . literal) (nil) 123 c-looking-at-special-brace-list (error) up-list t (nil) 125 (error) skip-syntax-forward "w_" (nil) 35 back-to-indentation (t . macro-boundary) looking-at ";\\|};?" 0 (nil) (t . literal)] 8 (#$ . 62012)])
#@14 

(fn RANGE)
(defalias 'c-one-line-string-p #[257 "\212\211@b\210\301!\205\302
Aw\210`
A=)\207" [c-string-limit-regexp looking-at "^\n"] 3 (#$ . 63409)])
#@899 Go to the beginning of the innermost C statement.
With prefix arg, go back N - 1 statements.  If already at the
beginning of a statement then go to the beginning of the closest
preceding one, moving into nested blocks if necessary (use
\[backward-sexp] to skip over a block).  If within or next to a
comment or multiline string, move by sentences instead of statements.

When called from a program, this function takes 3 optional args: the
repetition count, a buffer position limit which is the farthest back
to search for the syntactic context, and a flag saying whether to do
sentence motion in or near comments and multiline strings.

Note that for use in programs, `c-beginning-of-statement-1' is
usually better.  It has much better defined semantics than this one,
which is intended for interactive use, and might therefore change to
be more "DWIM:ey".

(fn &optional COUNT LIM SENTENCE-FLAG)
(defalias 'c-beginning-of-statement #[768 "\305W\203
\306[#\207\307 \310\211\310\311\312\"\216\206\313\314\212o?\205,\315 \205,`)\314\211\316\317	!!\305U\204u\203G`	V\203u`\262o\203T\305\262\202h\211\203L
\203c\320
!\203-
\211@b\210\321 \262
\212\203
`o?\205
\314\204\201\322\323!\202\274\324\325!\211\305W\203\234\326\327`ZS\"\210\314f\330=\203\234\314u\210\210`Sf\330=\203\271`S\206\253`Sf\331=\203\271\323u\210\314\202\274\322\323!\211\262\204\353`Sf\332=\203\320\323u\210\202w`Sf\330=\203\353`S\206\336`Sf\332=\203\353\333u\210\202w\211\262
\203
\334\335!\203q\336u\210\314\266\202\"
\334\337!\205
`Sf\331=\205
`
W\205
\323u\210\202q\266\202\"
\340 \210o\206(
\341 )?\202_\342
!\343=\203;
\344
!\202>
\345
!\211\262\203H
\321 \262
\202_\346!\262`U\206\"\314f\347>\206\"@\205\"\212\203`o?\205\314\204y
\322\323!\202\264
\324\325!\211\305W\203\224
\326\327`ZS\"\210\314f\330=\203\224
\314u\210\210`Sf\330=\203\261
`S\206\243
`Sf\331=\203\261
\323u\210\314\202\264
\322\323!\211\262\204\343
`Sf\332=\203\310
\323u\210\202o
`Sf\330=\203\343
`S\206\326
`Sf\332=\203\343
\333u\210\202o
\211\262
\203\370
\334\335!\203i
\336u\210\314\266\202\334\337!\205`Sf\331=\205`
W\205\323u\210\202i
\266\202\340 \210o\206 \341 )?\262A\350=\203S\212\351 \210o?\205P\352\314x\210l\203J`Sf\331=\203J\323u\210\2024\315 \205P`\262)A\353>\203^\321 \262

\203h`\262\202J\305U\2045S\262\2025\354\304!\205~\310\211\266\206,\207" [buffer-undo-list inhibit-read-only inhibit-modification-hooks comment-end-can-be-escaped zmacs-region-stays 0 c-end-of-statement buffer-modified-p t make-closure #[0 "\300?\205\301\302!\207" [V0 restore-buffer-modified-p nil] 2] 1 nil c-beginning-of-macro c-collect-line-comments c-literal-limits c-one-line-string-p c-ascertain-preceding-literal forward-comment -1 skip-syntax-backward " >" skip-syntax-forward " " 10 92 13 -2 looking-at "\\*/" 2 "[\n
]" c-backward-sws c-after-statement-terminator-p c-literal-type string c-beginning-of-sentence-in-string c-beginning-of-sentence-in-comment c-back-over-illiterals (41 125) macro-boundary beginning-of-line " 	\n
\f" (macro-boundary literal) boundp] 18 (#$ . 63573) (byte-code "\301!\302\303E\207" [current-prefix-arg prefix-numeric-value nil t] 3)])
#@630 Go to the end of the innermost C statement.
With prefix arg, go forward N - 1 statements.  Move forward to the end
of the next statement if already at end, and move into nested blocks
(use \[forward-sexp] to skip over a block).  If within or next to a
comment or multiline string, move by sentences instead of statements.

When called from a program, this function takes 3 optional args: the
repetition count, a buffer position limit which is the farthest back
to search for the syntactic context, and a flag saying whether to do
sentence motion in or near comments and multiline strings.

(fn &optional COUNT LIM SENTENCE-FLAG)
(defalias 'c-end-of-statement #[768 "\206\305\262\306W\203\307[#\207\310 \311\211\311\312\313\"\216\314\212m?\2051\315 \2051\316 \210`)\314\317\320!!\306U\204
\203L`W\203
`\262m\203Y\306\262\202

\211\203\242\203g\321
!\203y\211Ab\210\322 \262
\205u ?\202\376\323
!\324=\203\207\325
!\202\212\326
!\211\262\203\224\322 \262

\203

\205\236 ?\202\376\327`V\"\262
A\330=\203\361\212\203\340\314\210m?\205\356\331\314w\210\314f\332=\203\324\314u\210l\204\277\333u\210\315 \205\356\316 \210`\202\356m?\205\356\315 \205\356\316 \210`)\262
A\334>\203\374\322 \262

@\204O\306U\2049S\262\2029\335\304!\205
\311\211\266\204,\207" [buffer-undo-list inhibit-read-only inhibit-modification-hooks c-at-vsemi-p-fn zmacs-region-stays 1 0 c-beginning-of-statement buffer-modified-p t make-closure #[0 "\300?\205\301\302!\207" [V0 restore-buffer-modified-p nil] 2] nil c-beginning-of-macro c-end-of-macro c-collect-line-comments c-literal-limits c-one-line-string-p c-ascertain-following-literal c-literal-type string c-end-of-sentence-in-string c-end-of-sentence-in-comment c-forward-over-illiterals macro-boundary " 	\n
\f" 92 -1 (macro-boundary literal) boundp] 13 (#$ . 66802) (byte-code "\301!\302\303E\207" [current-prefix-arg prefix-numeric-value nil t] 3)])
(byte-code "\300\301\302\"\210\300\303\304\"\210\305\306\307\310#\210\305\306\311\310#\210\305\312\307\310#\210\305\312\311\310#\210\305\313\307\310#\210\305\313\311\310#\207" [mapc #[257 "\300
\301\302#\210\300
\303\302#\207" [put delete-selection t pending-delete] 5 "\n\n(fn SYM)"] (c-electric-pound c-electric-slash c-electric-star c-electric-semi&comma c-electric-lt-gt c-electric-colon) #[257 "\300
\301\302\303!\203
\303\202\304#\210\300
\305\304#\207" [put delete-selection fboundp delete-selection-uses-region-p t pending-delete] 6 "\n\n(fn SYM)"] (c-electric-brace c-electric-paren) put c-electric-delete delete-selection supersede pending-delete c-electric-backspace c-electric-delete-forward] 4)
#@14 

(fn ENTRY)
(defalias 'c-calc-comment-indent #[257 "\2119\203\211\236\206\302\236\206\303\262
\211A@
AAi\304\267\202n\211\\\207
\204,	\262n\2032
\207\211T]\207\212\305 \210o?\205e\306u\210\307\310 \311\"\211:\205c\211@b\210\312\313!\205cn\203_\314\202c
Ti]\262
)\206o\315A!\207\316\207" [c-indent-comment-alist comment-column other (default column) #s(hash-table size 3 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (space 33 column 37 align 55)) beginning-of-line -1 c-literal-limits line-beginning-position t looking-at "/[/*]" 0 c-calc-comment-indent nil] 7 (#$ . 69475)])
#@109 Used by `indent-for-comment' to create and indent comments.
See `c-indent-comment-alist' for a description.
(defalias 'c-comment-indent #[0 "\212\306\210\307 \310\211\310\311\312\"\216\313\314 \310\"\211:\203-\211@b\210\315\316!\203-\317\306x\210`\2062\317\306x\210`\262
\315\320!\203>\321\202r\322 \210`
=\203K\323\202r\324 \210\306f\325=\203``
S=\203`\326\202r\315\327!\203q\330\225
=\203q\331\202r\332\306\211\333>\203\250\f\203\250\334 l\203\220\335\306

B
B\211\266 :\203\233 \202\237 \211B \336
!*\202\256
b\210\337
!)\266\202,\262
)\207" [buffer-undo-list inhibit-read-only inhibit-modification-hooks case-fold-search c-indent-comments-syntactically-p c-syntactic-context nil buffer-modified-p t make-closure #[0 "\300?\205\301\302!\207" [V0 restore-buffer-modified-p nil] 2] c-literal-limits line-beginning-position looking-at "/[/*]" " 	" "^/[/*]" anchored-comment beginning-of-line empty-line back-to-indentation 125 end-block "#[ 	]*\\(endif\\|else\\)" 0 cpp-end-block other (anchored-comment empty-line) c-guess-basic-syntax comment-intro c-get-syntactic-indentation c-calc-comment-indent c-comment-only-line-offset] 8 (#$ . 70099)])
(defalias 'c-outline-level #[0 "\301\212\302\301w\210i*\207" [buffer-invisibility-spec nil "	 "] 2])
#@356 Move back to the containing preprocessor conditional, leaving mark behind.
A prefix argument acts as a repeat count.  With a negative argument,
move forward to the end of the containing preprocessor conditional.

"#elif" is treated like "#else" followed by "#if", so the
function stops at them when going backward, but not when going
forward.

(fn COUNT)
(defalias 'c-up-conditional #[257 "\301
[\302\"\303 \210\211b\266\304\300!\205\305\211\207" [zmacs-region-stays c-scan-conditionals -1 push-mark boundp t] 4 (#$ . 71388) "p"])
#@160 Move back to the containing preprocessor conditional, including "#else".
Just like `c-up-conditional', except it also stops at "#else"
directives.

(fn COUNT)
(defalias 'c-up-conditional-with-else #[257 "\301
[\302\303#\304 \210\211b\266\305\300!\205\303\211\207" [zmacs-region-stays c-scan-conditionals -1 t push-mark boundp] 5 (#$ . 71930) "p"])
#@345 Move forward into the next preprocessor conditional, leaving mark behind.
A prefix argument acts as a repeat count.  With a negative argument,
move backward into the previous preprocessor conditional.

"#elif" is treated like "#else" followed by "#if", so the
function stops at them when going forward, but not when going
backward.

(fn COUNT)
(defalias 'c-down-conditional #[257 "\301
\302\"\303 \210\211b\266\304\300!\205\305\211\207" [zmacs-region-stays c-scan-conditionals 1 push-mark boundp t] 4 (#$ . 72289) "p"])
#@161 Move forward into the next preprocessor conditional, including "#else".
Just like `c-down-conditional', except it also stops at "#else"
directives.

(fn COUNT)
(defalias 'c-down-conditional-with-else #[257 "\301
\302\303#\304 \210\211b\266\305\300!\205\303\211\207" [zmacs-region-stays c-scan-conditionals 1 t push-mark boundp] 5 (#$ . 72820) "p"])
#@475 Move back across a preprocessor conditional, leaving mark behind.
A prefix argument acts as a repeat COUNT.  With a negative argument,
move forward across a preprocessor conditional.

The optional arguments TARGET-DEPTH and WITH-ELSE are historical,
and have the same meanings as in `c-scan-conditionals'.  If you
are calling `c-forward-conditional' from a program, you might want
to call `c-scan-conditionals' directly instead.

(fn COUNT &optional TARGET-DEPTH WITH-ELSE)
(defalias 'c-backward-conditional #[769 "\301[#\302 \210\211b\266\303\300!\205\304\211\207" [zmacs-region-stays c-scan-conditionals push-mark boundp t] 7 (#$ . 73180) "p"])
#@688 Move forward across a preprocessor conditional, leaving mark behind.
A prefix argument acts as a repeat count.  With a negative argument,
move backward across a preprocessor conditional.

If there aren't enough conditionals after (or before) point, an
error is signaled.

"#elif" is treated like "#else" followed by "#if", except that
the nesting level isn't changed when tracking subconditionals.

The optional arguments TARGET-DEPTH and WITH-ELSE are historical,
and have the same meanings as in `c-scan-conditionals'.  If you
are calling c-forward-conditional from a program, you might want
to call `c-scan-conditionals' directly instead.

(fn COUNT &optional TARGET-DEPTH WITH-ELSE)
(defalias 'c-forward-conditional #[769 "\300#\301 \210\211b\207" [c-scan-conditionals push-mark] 7 (#$ . 73841) "p"])
#@778 Scan forward across COUNT preprocessor conditionals.
With a negative argument, scan backward across preprocessor
conditionals.  Return the end position.  Point is not moved.

If there aren't enough preprocessor conditionals, throw an error.

"#elif" is treated like "#else" followed by "#if", except that
the nesting level isn't changed when tracking subconditionals.

The optional argument TARGET-DEPTH specifies the wanted nesting depth
after each scan.  E.g. if TARGET-DEPTH is -1, the end position will be
outside the enclosing conditional.  A non-integer non-nil TARGET-DEPTH
counts as -1.

If the optional argument WITH-ELSE is non-nil, "#else" directives
are treated as conditional clause limits.  Normally they are ignored.

(fn COUNT &optional TARGET-DEPTH WITH-ELSE)
(defalias 'c-scan-conditionals #[769 "\302V\211\203\303\202\f\304
\203\305\202\306\307\211\250\204(\203%\303\202&\302\262\212\302U\204
\302\211\307\212\211\204

\310\307\311#\203

\312 \210\313\314!\203\366\307\315\304!\211\316\230\203[[\262\202\242\211\317\230\203h\262\202\242\302U\203\242	\203\205\n\302V\203~\304\202\303\211\262\202\221\211\320\230\203\242[\211\262\203\242
\302V\302X=\203\242\307\262
\203\333\302U\203\267
\302V\302X=\203\274\\\262\\\262W\203\333
\302W\203\333\321	\203\330\322\202\331\323!\210\203\343\304y\210
\203\361U\203\361`\262\266\2024\2034\304y\210\2024)\211\204\n
\321\324!\210\211\211\262b\266\\\262\202))\325\301!\203#
\311)\207" [case-fold-search zmacs-region-stays 0 -1 1 re-search-forward re-search-backward nil "#[ 	]*\\(if\\|elif\\|endif\\|else\\)" t beginning-of-line looking-at "^[ 	]*#[ 	]*\\(if\\|elif\\|endif\\|else\\)" match-string "if" "endif" "elif" error "No following conditional at this level" "No previous conditional at this level" "No containing preprocessor conditional" boundp] 15 (#$ . 74656)])
#@1324 Indent current line as C code, and/or insert some whitespace.

If `c-tab-always-indent' is t, always just indent the current line.
If nil, indent the current line only if point is at the left margin or
in the line's indentation; otherwise insert some whitespace[*].  If
other than nil or t, then some whitespace[*] is inserted only within
literals (comments and strings), but the line is always reindented.

If `c-syntactic-indentation' is t, indentation is done according to
the syntactic context.  A numeric argument, regardless of its value,
means indent rigidly all the lines of the expression starting after
point so that this line becomes properly indented.  The relative
indentation among the lines of the expression is preserved.

If `c-syntactic-indentation' is nil, the line is just indented one
step according to `c-basic-offset'.  In this mode, a numeric argument
indents a number of such steps, positive or negative, and an empty
prefix argument is equivalent to -1.

  [*] The amount and kind of whitespace inserted is controlled by the
  variable `c-insert-tab-function', which is called to do the actual
  insertion of whitespace.  Normally the function in this variable
  just inserts a tab character, or the equivalent number of spaces,
  depending on the variable `indent-tabs-mode'.

(fn &optional ARG)
(defalias 'c-indent-command #[256 "\203	\306K\202
\307\310\"\203W
\203W\212\311 \210i)\312\211\313 \210\212\311 \210i)Z\262\212	\314=\2034\315 \210`\262\316`\317\"b\210`\262

b\210\317y\210`\262)\211V\205V\320\321$\207	\322\267\202p\212\323\312x\210n)\204j\n \207\211 \207\211 \207\324 \314\211\314\307\325\"\216\326 ,\262
\203\210\n \210\211 \207" [c-syntactic-indentation c-tab-always-indent c-insert-tab-function buffer-undo-list inhibit-read-only inhibit-modification-hooks indent-according-to-mode make-closure #[0 "	\300\306\232\203\307\202\310\300!
\311
\n_!\210\205T\212\312\210`Sf)\313=\205T	9\203J\212\314 \315\211\315\316\317\"\216\320 \205A`,\262
)\211\202K	\205T\321``\312\315$)\207" [V0 c-macro-start c-basic-offset c-auto-align-backslashes buffer-undo-list inhibit-read-only (4) -1 prefix-numeric-value c-shift-line-indentation nil 92 buffer-modified-p t make-closure #[0 "\300?\205\301\302!\207" [V0 restore-buffer-modified-p nil] 2] c-beginning-of-macro c-backslash-region inhibit-modification-hooks] 7] back-to-indentation nil c-indent-line t beginning-of-line scan-sexps 1 indent-code-rigidly "#" #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (nil 93 t 109)) " 	" buffer-modified-p #[0 "\300?\205\301\302!\207" [V0 restore-buffer-modified-p nil] 2] c-in-literal] 11 (#$ . 76584) "P"])
#@193 Indent each line in the balanced expression following point syntactically.
If optional SHUTUP-P is non-nil, no errors are signaled if no
balanced expression is found.

(fn &optional SHUTUP-P)
(defalias 'c-indent-exp #[256 "\300 \301\302\303\"\210\304\305\"\216\214e\306 }\210\301`\3071\"\310
\311\312#0\202$\210\301\211\262\203?\31317\310\311\211#0\2029\210\301\211\262\204
\205R
\206H`Sfz\314=\205R
S\266\202)\211\204d?\205\223\315\316!\202\223\211b\210\3171s\320`\311\"0\202u\210\301\262
\204\206?\205\223\315\321!\202\223\301y\210`W\205\223\322`\"\262
)\207" [point-marker nil set-marker-insertion-type t make-closure #[0 "\300b\210\300\301\211\223\207" [V0 nil] 3] line-end-position (error) scan-lists 1 -1 (error) 40 error "Cannot find start of balanced expression to indent" (error) scan-sexps "Cannot find end of balanced expression to indent" c-indent-region] 9 (#$ . 79304) "*P"])
#@200 Indent the current top-level declaration or macro syntactically.
In the macro case this also has the effect of realigning any line
continuation backslashes, unless `c-auto-align-backslashes' is nil.
(defalias 'c-indent-defun #[0 "\305 \306\211\307\310\"\216\311 \312\211\312\307\313\"\216\314\f!\203'\315\316\306\317 #\210\202.\320\321\306\322 #\210\323\306!\262,\210\211\205?\324
@A\"*\207" [case-fold-search buffer-undo-list inhibit-read-only inhibit-modification-hooks c-syntactic-eol point-marker nil make-closure #[0 "\300b\210\300\301\211\223\207" [V0 nil] 3] buffer-modified-p t #[0 "\300?\205\301\302!\207" [V0 restore-buffer-modified-p nil] 2] looking-at c-backward-token-2 1 line-beginning-position c-forward-token-2 0 line-end-position c-declaration-limits c-indent-region] 8 (#$ . 80230) "*"])
#@242 Indent syntactically lines whose first char is between START and END inclusive.
If the optional argument QUIET is non-nil then no syntactic
errors are reported, even if `c-report-syntactic-errors' is
non-nil.

(fn START END &optional QUIET)
(defalias 'c-indent-region #[770 "\212
b\210\306\307x\210`\262b\210\310 \210\306\307w\210`\262\310 \210\311!\307\211\312 \313\211\313\314\315\"\216\212\316 -\262
\205D\317 \206<`Sf\320=\205D\307\211
\314\321\"\216\322		\323#\210n\203\325m\204\325`W\203\325\324 \210\325\326!\204\225\203|\325\327!\204\225\312 \313\211\313\314\330\"\216\331 \262,\210\332
\313\211#\210\203\271!\203\317\317 \206\244`Sf\320=\204\317\333\334\335!\307#\210\307\262\202\317\336
\236\203\317\317 \206\305`Sf\320=\203\317`\262\307y\210\202Z\203\347!\203\347\333\334\337!\307\313$\210)\340!+\266\206\206\363
\211)\207" [buffer-undo-list inhibit-read-only inhibit-modification-hooks c-fix-backslashes c-echo-syntactic-information-p c-parsing-error " 	\n
\f" nil beginning-of-line copy-marker buffer-modified-p t make-closure #[0 "\300?\205\301\302!\207" [V0 restore-buffer-modified-p nil] 2] c-beginning-of-macro line-end-position 92 #[0 "\300\301\211\223\210\302\303!\207" [V0 nil c-progress-fini c-indent-region] 3] c-progress-init c-indent-region c-progress-update looking-at "\\s *$" "\\s *\\\\$" #[0 "\300?\205\301\302!\207" [V0 restore-buffer-modified-p nil] 2] c-guess-basic-syntax c-indent-line c-backslash-region line-beginning-position 2 cpp-macro 0 c-echo-parsing-error c-auto-align-backslashes] 15 (#$ . 81056)])
(defalias 'c-fn-region-is-active-p #[0 "\300 \207" [region-active-p] 1])
#@307 Indent active region, current line, or block starting on this line.
In Transient Mark mode, when the region is active, reindent the region.
Otherwise, with a prefix argument, rigidly reindent the expression
starting on the current line.
Otherwise reindent just the current line.

(fn &optional ARG REGION)
(defalias 'c-indent-line-or-region #[512 "\211\203\300\301 \302 \"\207\303!\207" [c-indent-region region-beginning region-end c-indent-command] 5 (#$ . 82739) (byte-code "\301 D\207" [current-prefix-arg region-active-p] 2)])
(defvar c-progress-info nil)
#@26 

(fn START END CONTEXT)
(defalias 'c-progress-init #[771 "?\206&\302\303!\204\304\305!\207	\206&\306\212b\210\307 )\310\311\312\"$\304\313!\207" [c-progress-interval c-progress-info fboundp current-time message "Indenting region... (this may take a while)" vector point-marker time-convert nil integer "Indenting region..."] 9 (#$ . 83309)])
(defalias 'c-progress-update #[0 "\2053	\2053\302\303\304\"\305H\306H\307H	ZW\2051\310\311\312\313`Z_Z\"\"\210\307I\266\204\207" [c-progress-info c-progress-interval time-convert nil integer 0 1 2 message "Indenting region... (%d%% complete)" floor 100.0] 10])
#@16 

(fn CONTEXT)
(defalias 'c-progress-fini #[257 "\205\211	\302H=\204\211\303=\205	\304H\305\211\223\210\305\306\307!\207" [c-progress-interval c-progress-info 3 t 1 nil message "Indenting region... done"] 4 (#$ . 83944)])
#@739 Insert, align, or delete end-of-line backslashes on the lines in the region.
With no argument, inserts backslashes and aligns existing backslashes.
With an argument, deletes the backslashes.  The backslash alignment is
done according to the settings in `c-backslash-column',
`c-backslash-max-column' and `c-auto-align-backslashes'.

This function does not modify blank lines at the start of the region.
If the region ends at the start of a line and the macro doesn't
continue below it, the backslash (if any) at the end of the previous
line is deleted.

You can put the region around an entire macro definition and use this
command to conveniently insert and align the necessary backslashes.

(fn FROM TO DELETE-FLAG &optional LINE-MODE)
(defalias 'c-backslash-region #[1027 "\304 \212\305\306x\210n\205\307\310!)\203\311 \202e\306\211\211\212b\210\204(o\204\227
\2046n\2036\312u\210`\262\203L`\306\223\210b\210\313\"\210\202\227
\306\210`Sf\314=\205k\315y\316U\205k\306\210`Sf\314=\205kiS\262
\203\221\3171~\320\316!0\202\202\210\202\205\206\207	]\262\211\204\221\321\262
\203\240\204\240b\210\202S
\316\262b\210\211\203\256\315y\210\306\210`	Y\203\332`Sf\314=\203\303\312u\210\305\306x\210
iT]\262\322 \210o\204\332\312u\210\202\261b\210\322 \210o\204
\312u\210`Sf\314=\203
iS\262\211\247\203\376
]\262b\210\202&
\211\247\203

\211\262b\210`W\203&
n\203&
l\203&
\315y\210\202
\2033
W\2033
\306\262\204N

	\246\316V\203I

	\\S	\245	_\262\n]\262^\262\211\203g
\306\223\210\323#\210\202\227
\212b\210\322 \210o?\205y
`S\306\223)\203\214
\323#\210`\306\223\210\202\222
\306\223\210\313\"\210)\306\211\223\210\324!\205\247
\306\211\223\207" [c-auto-align-backslashes tab-width c-backslash-column c-backslash-max-column make-marker " 	" nil looking-at "[ 	]*\\\\?$" point-marker -1 c-delete-backslashes-forward 92 1 0 (error) line-end-position t beginning-of-line c-append-backslashes-forward markerp] 13 (#$ . 84181) "*r\nP"])
#@33 

(fn TO-MARK COLUMN POINT-POS)
(defalias 'c-append-backslashes-forward #[771 "\300\301 `\"\203\237`X\205

`\302\211\211\211\210`Sf\303=\204$\303c\210\304\262\300`\302\211	%\262\305u\210i\262
\204>\3068\204\217\211W\203\\`\307`Y\205Px\210`|\210j\210\202\217\211U\203k`Sf\310>\204\217`\262\307`Y\205xx\305U\203\205\302f\311U\204\217`|\210\312\313\"\210\313y\314U\266\204\205

n\205

\202	`X\205

`\302\210\300
`\302\211%\262`Sf\303=\203\330\3068\204\361\305u\210`Sf\315>\203\322`U\203\361\311c\210\202\361`Sf\316>\203\354`U\204\354\303c\210\202\361\311\303\261\210\313y\314U\262
\205

n\205

\202\237\207" [parse-partial-sexp line-beginning-position nil 92 t -1 3 " 	" (32 9) 32 indent-to 1 0 (32 9) (32 9)] 14 (#$ . 86216)])
#@26 

(fn TO-MARK POINT-POS)
(defalias 'c-delete-backslashes-forward #[514 "`X\2050\300\210`Sf\301=\203\"`\302u\210\303`Y\205x\210`|\210\304y\305U\2050n\2050\202\207" [nil 92 -1 " 	" 1 0] 6 (#$ . 87005)])
(defvar c-auto-fill-prefix t)
(defvar c-lit-limits nil)
(defvar c-lit-type nil)
#@28 

(fn LIT-LIMITS LIT-TYPE)
(defalias 'c-guess-fill-prefix #[514 "`\305\306Q\307=\203\211\202	\310\211\211\211C\n\203/\n`\311\312\"\216\313\314\n\"\210i)\262
B\262\202:\307=\203\355\212\315\262\211	A\240\210\316 \210`	@V\203Q`\262\202\351@b\210\317y\320U\203k`	AW\203k`\262\202\351@b\210\321!\203~\320\225b\210\202\205\322u\210\323\310w\210\310\211\212\324 \210`)@=\203\241\325\326 `\"\262i\262
\202\316`@Z\310C\311\327#\216\f@b\210i\330c\210j\210\211`\240\210
u\210\325\326 `\"\262i\262)\266\331\332\"\204\331l\204\337

B\202\345
\333P
TB\262\266)\202:\211\212	A\322Zb\210\321\334!\203
`\202
	A)\240\210\212\316 \210`	@V\203'
\321\335!\203!
A\320\225=\204'
`\262\2029@b\210\317y\320U\203[
`	AY\204[
\321\335!\203J
A\320\225=\204[
\321!\203e
AS\320\225X\203e
\206`
\336\262\202\264
`W\203\261
\317\224\203\217
\317\224\317\225U\204\217
\320\225\337 U\203\211
\340\317!\262\202\264
`\262\202\264
\212\324 \210i)\212	@b\210i)X\203\253
\206\246
\336\262\202\264
`\262\202\264
`\262\2039\310C\310C\310\311\341#\216@b\210\321!\203\336
\320\225\242^b\210\321\f!\262
\202\345
\322u\210\323\310w\210`Sfz\342=\203\320\331\343	\"O\325\212\323\310x\210`)`\"P\262\211\203\331\344\"\204\333P\262\345 \240\210\313\346\347#\210
\345 \240\210\350 \210
\242Sb\210\325\326 `\"i)B\266\203\262)
\206}\212\310C\310C\351\3522\331b\210\211	$\203z\317\225\320\225U\203n\317\224\317\225U\203z\320\224\320\225U\204z\353\352\242\242b\210iB\"\210\n\307=\203\233\354y\320U\203\265`\f@Y\203\265\211	$\210\202\201\354y\320U\203\265`\f@V\203\265\211	$\210\202\233b\210\317y\320U\203\323`\fAW\203\323\211	$\210\202\271b\210\3100\206z\242\203Z\331\332\242\"\204\361
\242b\210l\204\370\242iB\202W@b\210\321!\203\320\225b\210\202\322u\210\323\310w\210l\203`Sfz\342=\203L\325\212\323\310x\210`)`\"\240\210
\242b\210\323\310x\210`\311\355\"\216\313\242!\210\325\326 `\"i)B\262
\202W\242\333P\242b\210iTB\206z\203y\325\212\324 \210`)\"P\324 \210iG\\B\266\203\202|\356\266\203)\207" [c-current-comment-prefix comment-start-skip fill-prefix c-block-comment-prefix c-block-comment-ender-regexp "[ 	]*\\(" "\\)[ 	]*" c++ nil make-closure #[0 "\300`|\207" [V0] 2] insert-and-inherit "\n" "// " beginning-of-line 1 0 looking-at 2 " 	" back-to-indentation buffer-substring-no-properties line-beginning-position #[0 "\300@\301\242|\207" [V0 V1] 2] 10 string-match "\\s \\'" " " "\\*/" "[ 	]*\\*/" #1="" line-end-position match-string #[0 "\301\242\205\300\242\301\242|\210\300\242\302\211\223\210\301\242\302\211\223\207" [V0 V1 nil] 3] 32 "\\s *\\'" "\\s \\s +\\'" point-marker "x\n" "x" indent-according-to-mode #[1028 "\300!\205:\301\225\242X\205:\301\225\302 =\204&\303\304\305\301\224\301\225\"\301\225b\210iB\"\210
\242\2049
\305\301\224\301\225\"\240\210\211\301\225\240\210\306\207" [looking-at 0 line-end-position throw found buffer-substring-no-properties t] 9 "\n\n(fn PREFIX-REGEXP COMMENT-TEXT-END FB-STRING FB-ENDPOS)"] found throw -1 #[0 "\300`|\207" [V0] 2] (#1# . 0)] 17 (#$ . 87304)])
#@60 

(fn FILL-PARAGRAPH APPLY-OUTSIDE-LITERAL FUN &rest ARGS)
(defalias 'c-mask-paragraph #[899 "\306\211\211C\306C\306C\306C\306C`C	\n\203 \n\307=\204 `\nB\310 \307\211\307\311\312\"\216\214~\210\204:\313\306\"\314!	\204F\315!)\212\3161Z\317u\210\320 \210`\242Y0\202\\\210\306\204f
\242b\210\320 \210\321 \240\210)\212\3221\200\306u\210\323 \210`\242X0\202\202\210\306\204\214
\242b\210\323 \210`\262-\210\311\324
&\216	\325\267\202\262\212\242\242A^\306\223\210@X\203\327@b\210\326 \210`@=\203\323\327 \262\202\327\307\240\210)\307\262\202\242AV\204
\242AU\203\242\206\364`Sf\330=\203\242S\206
`Sf\331=\203A@Z\332V\203\212Ab\210\333 \210\334\335
\336QA\337Z\307#\205;
\334\340A\337Z\341#?\205;
\242\327 \306\223)\204\212Ab\210\342\343!\210`)\212\211b\210i)
\242Z\212b\210\344\345 \327 \307#\205r
\346\225b\205r
\347\350!\205r
\346\225U)\306\212Ab\210\321 \240\210\351c\210\n\242`\306\223\210\317y\210\347\352
\353Q!\203\246
\346\225=\203\246
\354\225\337\225Z\262
\202\251
b\210\355\306x\210`U\204\242`X\203\275
\317\262\211\204\306
iZ\262
\356`\"\240\210\203\350
\211\203\342
@\203\342
\337\202\343
\354^\354]\262
\357\360\307#\210
\240\210\346Y\205\376
`^Z\262\202\306\262)\203b\210\266@X\2034\212@b\210\347\361A\362Q!\203/\327\337!\262\2023\307\240\210)\307\262\202\212\242AY\203VASb\210\321 \240\210\351c\210\242`\306\223\210@X\203r@Tb\210\347\363!\203o\346\225T\202p`\262)\307\262\202\212\310 \307\211\307\311\364\"\216\365 \210\333 \210`V\203\227`\262\366 \210\306y\210`\242W\203\254\242`\306\223\210,\210)\202\310 \307\211\307\311\367\"\216\212b\210`\242\206\314dW\203\337\214e\242\206\331d}\210\370 \210)\333 \210`\262\242b\210`\206\361eV\203\214\206\374ed}\210\371 \210)\306y\210\242`\306\223\210-\210\242\203\241\310 \307\211\307\311\372\"\216\373	\",\262
\262\374\375
\376Q	@\"\204?\377\201D	@\"\210\212@b\210\347	\201E=\203Q
\202SA!\203^\346\225b\210\202g\337u\210\201F\306w\210iAW\203yl\204y\354u\210\202gi`T\262`C\240\210\311\201G\"\216\201H\201I\n@\"\210\357\360iZ\307#\210)\210)\n\205CB\206\367	\201E=\205\367\201J\201C!\205\277C?\205\367\374\201K\201L		\242\"\206\326\201M\"?\205\367\310 \307\211\307\311\201N\"\216\206\363\373	\"@,\262
`W\203`Z\202`\242V\205`\242Z
B\214\242}\210\201O\f\f\")
\203@
\346W\2039	\\b\210\202@\242\\b\210)\266\202+\207" [c-lit-limits c-lit-type buffer-undo-list inhibit-read-only inhibit-modification-hooks c-current-comment-prefix nil t buffer-modified-p make-closure #[0 "\300?\205\301\302!\207" [V0 restore-buffer-modified-p nil] 2] c-literal-limits c-collect-line-comments c-literal-type (error) -1 forward-paragraph point-marker (error) backward-paragraph #[0 "\302\242:\203\302\242@\302\242A|\210\303\242\203Y\212\303\242b\210\307\310!\210)\304\242\203S\306`\240\210\303\242b\210\311\312!\210\304\242[u\210\300\204<\305\242\204F\313\314\304\242\315#\210\202J\305\242c\210\307\304\242!\210\306\242b\210\303\242\316\211\223\210\301\242\316\211\223\207" [V0 V1 V2 V3 V4 V5 V6 delete-char 1 skip-syntax-backward "^w " insert-char 32 t nil] 4] #s(hash-table size 4 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (c++ 170 c 222 string 570 pound 633)) back-to-indentation line-beginning-position 47 42 3 beginning-of-line search-forward-regexp "\\=[ 	]*\\(" "\\)" 2 "\\(\\s \\|\\sw\\)" limit skip-syntax-backward "^w " search-backward-regexp sentence-end 0 looking-at "[ 	]*" 10 "[ 	]*\\(\\(" "\\)[ 	]*\\)" 1 " 	
\n" delete-and-extract-region insert-char 120 "\\(" "\\)$" "\\\\$" #[0 "\300?\205\301\302!\207" [V0 restore-buffer-modified-p nil] 2] c-beginning-of-macro c-end-of-macro #[0 "\300?\205\301\302!\207" [V0 restore-buffer-modified-p nil] 2] c-forward-sws c-backward-sws #[0 "\300?\205\301\302!\207" [V0 restore-buffer-modified-p nil] 2] c-guess-fill-prefix string-match "\\`[ 	]*\\(" "\\)[ 	]*\\'" message sentence-end-double-space comment-start-skip fill-prefix filladapt-mode "Warning: Regexp from `c-comment-prefix-regexp' doesn't match the comment prefix %S" c++ " 	" #[0 "\300\242`\241\207" [V0] 2] insert-and-inherit "\n" boundp "\\`[ 	]*//" fill-context-prefix "" #[0 "\300?\205\301\302!\207" [V0 restore-buffer-modified-p nil] 2] apply] 22 (#$ . 90460)])
#@846 Like \[fill-paragraph] but handles C and C++ style comments.
If any of the current line is a comment or within a comment, fill the
comment or the paragraph of it that point is in, preserving the
comment indentation or line-starting decorations (see the
`c-comment-prefix-regexp' and `c-block-comment-prefix' variables for
details).

If point is inside multiline string literal, fill it.  This currently
does not respect escaped newlines, except for the special case when it
is the very first thing in the string.  The intended use for this rule
is in situations like the following:

char description[] = "\
A very long description of something that you want to fill to make
nicely formatted output.";

If point is in any other situation, i.e. in normal code, do nothing.

Optional prefix ARG means justify paragraph as well.

(fn &optional ARG)
(defalias 'c-fill-paragraph #[256 "\301=?\205\302\303\304\305$\210)\303\207" [fill-paragraph-function c-fill-paragraph c-mask-paragraph t nil fill-paragraph] 6 (#$ . 94906) "*P"])
(defalias 'c-do-auto-fill #[0 "\302\303\304\305#)\207" [fill-prefix c-auto-fill-prefix c-mask-paragraph nil t do-auto-fill] 4])
#@690 Break line at point and indent, continuing comment or macro if within one.
If inside a comment and `comment-multi-line' is non-nil, the
indentation and line prefix are preserved (see the
`c-comment-prefix-regexp' and `c-block-comment-prefix' variables for
details).  If inside a single line comment and `comment-multi-line' is
nil, a new comment of the same type is started on the next line and
indented as appropriate for comments.  If inside a macro, a line
continuation backslash is inserted and aligned as appropriate, and the
new line is indented according to `c-syntactic-indentation'.

If a fill prefix is specified, it overrides all the above.

(fn &optional SOFT ALLOW-AUTO-FILL)
(defalias 'c-indent-new-comment-line #[512 "\306	\n
\307 \310\211\3105\311\312\"\2166\310=\204\236	\204)\313\314\211\310#\n\2041\315	!9\203T\212\307 \310\211\3105\311\316\"\216\317 \205K`,\262
)\211\202U\203\\\320\202e\n\204d\321\202e\n7>\203p\310\202\2366\204\210\n\322=\203\210\323 	@X\203\210\314\202\236\n\324=\203\236\325\3268P\206\230\327\"\204\236\314,\210\310=\206h\203\265\211\"\210\330!\202h\307 \310\211\3105\311\331\"\216	\204\312\313 \n\204\322\315	!\n\332>,\262
\2039\204\360\212	@b\210\314\210`	AW)\203\252
\307 \310\211\3105\311\333\"\216\334\335	!\211\n\",\262
`\n\322=\203\"
\212	A\336Zb\210\337\340!\205
`)\206$
	AiAW\2035
l\2045
\341u\210\202$
`
V\203m
\323 	@V\203m
\342\310\"\262\343 \210\330@!\210\203]
\330\344!\210\202a
\345\341!\210
b\210
\314\211\223\266\203\202h`
V\203y
\211b\210\202\210
`	@\336\\W\203\210
	@\336\\b\210\"\210\330@!\210\337:!\205\245
`Sf\346>\205\245
\347u\266\203\202h;<\314
<;\n\322=\203\314
\325\350;\"\204\332
\351;\352<\202\332
\325\353;\"\204\332
\354;\327<\212\355 \210i)\262
\"\210<\203<\327\232\204\347u\210\330<!\210\341u\210\211j\210\330;!\210\356 *\266\203\202h9\2033\212\307 \310\211\3105\311\316\"\216\317 \205*`,\262
)\211\2024\203K\337\357!\204@\360 \210\361?\205G\341!\202h\212\343 \210\337\362!\203\\\347y\363U\204O\364 )
\"\210\211j\262
,\207" [fill-prefix c-lit-limits c-lit-type c-macro-start buffer-undo-list inhibit-read-only #[514 "\300 \210
\203\301\302!\207\303
?\205\304!\207" [delete-horizontal-space insert-and-inherit 10 newline 1] 4 "\n\n(fn SOFT ALLOW-AUTO-FILL)"] buffer-modified-p t make-closure #[0 "\300?\205\301\302!\207" [V0 restore-buffer-modified-p nil] 2] c-literal-limits nil c-literal-type #[0 "\300?\205\301\302!\207" [V0 restore-buffer-modified-p nil] 2] c-beginning-of-macro cpp code c line-beginning-position c++ string-match "\\`[ 	]*" "" insert-and-inherit #[0 "\300?\205\301\302!\207" [V0 restore-buffer-modified-p nil] 2] (c c++) #[0 "\300?\205\301\302!\207" [V0 restore-buffer-modified-p nil] 2] c-guess-fill-prefix c-collect-line-comments 2 looking-at "\\*/" 1 copy-marker beginning-of-line 10 newline (32 9) -1 "[ 	]*/\\*" "/* " " */" "[ 	]*//" "// " back-to-indentation indent-for-comment "[ 	]*\\\\$" delete-horizontal-space c-newline-and-indent "[ 	]*\\\\?$" 0 current-indentation inhibit-modification-hooks c-auto-fill-prefix c-ignore-auto-fill c-line-comment-starter comment-multi-line c-block-comment-ender-regexp comment-start comment-end] 11 (#$ . 96074) nil])
(byte-code "\300\301\302\"\210\303\301\302\304#\210\305\306!\204-\307\310!\210\311\312\313\314\310$\210\312\315\316\317\320B#\266\321\312\310\"\210\310\207" [defalias c-comment-line-break-function c-indent-new-comment-line make-obsolete "21.1" boundp comment-line-break-function (lambda (#1=#:def-tmp-var) (defvar c-inside-line-break-advice #1#)) nil ad-add-advice indent-new-comment-line (c-line-break-advice nil t (advice lambda nil "Call `c-indent-new-comment-line' if in CC Mode." (if (or c-inside-line-break-advice (not c-buffer-is-cc-mode)) ad-do-it (let ((c-inside-line-break-advice t)) (c-indent-new-comment-line (ad-get-arg 0)))))) around #[513 "\302\204		\204
!\207\303\304!\210)\207" [c-inside-line-break-advice c-buffer-is-cc-mode nil t c-indent-new-comment-line] 5 "\n\n(fn AD--ADDOIT-FUNCTION &optional SOFT)"] (nil (c-line-break-advice) nil subr2 (&optional soft) nil) ad-set-advice-info-field cache ad-activate] 8)
#@820 Do a line break suitable to the context.

When point is outside a comment or macro, insert a newline and indent
according to the syntactic context, unless `c-syntactic-indentation'
is nil, in which case the new line is indented as the previous
non-empty line instead.

When point is inside the content of a preprocessor directive, a line
continuation backslash is inserted before the line break and aligned
appropriately.  The end of the cpp directive doesn't count as inside
it.

When point is inside a comment, continue it with the appropriate
comment prefix (see the `c-comment-prefix-regexp' and
`c-block-comment-prefix' variables for details).  The end of a
C++-style line comment doesn't count as inside it.

When point is inside a string, only insert a backslash when it is also
inside a preprocessor directive.
(defalias 'c-context-line-break #[0 "\306\211\n\306\307 \310\211\310\311\312\"\216\313\306\211\310#\314!\211\315=\203*\316!\n9\203L\212\307 \310\211\310\311\317\"\216\320 \205D`,\262
)\202N\n\210,\210	\321=\204\231	\315=\203j\212\322\306w\210`)ASW\204\231\n\247\203\247	\323=\204\247\324\325!\203\203`Sf\326=\203\247\212\nb\210\324 !\203\222\327\225b\210`)`X\203\247\310\306!\"\330\306\310\"*\202\345	\323=\203\302\n\247\203\275`Sf\326=\204\275\326c\210\331 \202\345\332 \210\331 \210\212\333u\210\327y\210\324\334!\203\334\333y\327U\204\317\335 )\211j\266\336 ,\207" [c-lit-limits c-lit-type c-macro-start case-fold-search buffer-undo-list inhibit-read-only nil buffer-modified-p t make-closure #[0 "\300?\205\301\302!\207" [V0 restore-buffer-modified-p nil] 2] c-literal-limits c-literal-type c++ c-collect-line-comments #[0 "\300?\205\301\302!\207" [V0 restore-buffer-modified-p nil] 2] c-beginning-of-macro c " 	" string looking-at "\\s *$" 92 0 c-indent-new-comment-line newline delete-horizontal-space -1 "[ 	]*\\\\?$" current-indentation indent-according-to-mode inhibit-modification-hooks c-opt-cpp-start fill-prefix comment-multi-line] 6 (#$ . 100326) "*"])
#@203 Insert a line break suitable to the context and leave point before it.
This is the `c-context-line-break' equivalent to `open-line'
(bound to \[open-line]).  See `c-context-line-break' for the
details.
(defalias 'c-context-open-line #[0 "`\300\301\"\216\302c\210\303 )\207" [make-closure #[0 "\300b\210\301\302!\207" [V0 delete-char 1] 2] 120 c-context-line-break] 4 (#$ . 102368) "*"])
(provide 'cc-cmds)