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



(byte-code "\300\301\302\303\304\305\304\306&\210\307\310\311\312\313DD\314\315\316%\210\307\317\311\312\320DD\321\315\316%\210\307\322\311\312\323DD\324\315\325%\210\307\326\311\312\327DD\330\315\331%\210\307\332\311\312\333DD\334\315\316%\210\307\335\311\312\336DD\337\315\331%\210\307\340\311\312\341DD\342\315\331%\210\307\343\311\312\344DD\345\315\316%\210\307\346\311\312\347DD\350\315\331%\210\307\351\311\312\352DD\353\315\354%\207" [custom-declare-group completion nil "Dynamic word-completion code." :group matching convenience custom-declare-variable enable-completion funcall function #[0 "\300\207" [t] 1 #1=""] "Non-nil means enable recording and saving of completions.\nIf nil, no new words are added to the database or saved to the init file." :type boolean save-completions-flag #[0 "\300\207" [t] 1 #1#] "Non-nil means save most-used completions when exiting Emacs.\nSee also `save-completions-retention-time'." save-completions-file-name #[0 "\300\301\302\"\207" [locate-user-emacs-file "completions" ".completions"] 3 #1#] "The filename to save completions to." file save-completions-retention-time #[0 "\300\207" [336] 1 #1#] "Discard a completion if unused for this many hours.\n(1 day = 24, 1 week = 168).  If this is 0, non-permanent completions\nwill not be saved unless these are used.  Default is two weeks." integer completion-on-separator-character #[0 "\300\207" [nil] 1 #1#] "Non-nil means separator characters mark previous word as used.\nThis means the word will be saved as a completion." completions-file-versions-kept #[0 "\207" [kept-new-versions] 1 #1#] "Number of versions to keep for the saved completions file." completion-prompt-speed-threshold #[0 "\300\207" [4800] 1 #1#] "Minimum output speed at which to display next potential completion." completion-cdabbrev-prompt-flag #[0 "\300\207" [nil] 1 #1#] "If non-nil, the next completion prompt does a cdabbrev search.\nThis can be time consuming." completion-search-distance #[0 "\300\207" [15000] 1 #1#] "How far to search in the buffer when looking for completions.\nIn number of characters.  If nil, search the whole buffer." completions-merging-modes #[0 "\300\207" [(lisp c)] 1 #1#] "List of modes {`c' or `lisp'} for automatic completions merging.\nDefinitions from visited files which have these modes\nare automatically added to the completion database." (set (const lisp) (const c))] 8)
#@104 The minimum length of a stored completion.
DON'T CHANGE WITHOUT RECOMPILING !  This is used by macros.
(defvar completion-min-length 6 (#$ . 2475))
#@104 The maximum length of a stored completion.
DON'T CHANGE WITHOUT RECOMPILING !  This is used by macros.
(defvar completion-max-length 200 (#$ . 2630))
#@111 The minimum length of a completion search string.
DON'T CHANGE WITHOUT RECOMPILING !  This is used by macros.
(defvar completion-prefix-min-length 3 (#$ . 2787))
#@110 Set to t when the completion system is initialized.
Indicates that the old completion file has been read in.
(defvar cmpl-initialized-p nil (#$ . 2956))
#@105 Set to t as soon as the first completion has been accepted.
Used to decide whether to save completions.
(defvar cmpl-completions-accepted-p nil (#$ . 3116))
#@87 Return :capitalized, :up, :down, :mixed, or :neither for case of STRING.

(fn STRING)
(defalias 'cmpl-string-case-type #[257 "\301\302\303\"\203+\302\304\"\203'\211G\305V\203#\302\304\305#\204#\306\2027\307\2027\310\2027\302\304\"\2036\311\2027\312)\207" [case-fold-search nil string-match "[[:lower:]]" "[[:upper:]]" 1 :capitalized :mixed :down :up :neither] 5 (#$ . 3279)])
#@25 

(fn STRING CASE-TYPE)
(defalias 'cmpl-coerce-string-case #[514 "\211\300\267\202
\227\207
\226\207\301!\207
\207" [#s(hash-table size 3 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (:down 6 :up 9 :capitalized 12)) capitalize] 4 (#$ . 3675)])
#@38 

(fn STRING-TO-COERCE GIVEN-STRING)
(defalias 'cmpl-merge-string-cases #[514 "\300!\211\301>\203\302\300!\"\207\207" [cmpl-string-case-type (:down :up :capitalized) cmpl-coerce-string-case] 7 (#$ . 3947)])
(defalias 'cmpl-hours-since-origin #[0 "\300\301\302\303\"\304\"\207" [floor time-convert nil integer 3600] 4])
(defconst completion-standard-syntax-table (byte-code "\300 \301\302\262
\211\303W\203\304
\305#\210\211T\262
\202\302\262
\211\306W\2039\304\307\\\310#\210\304\311\\\310#\210\211T\262
\202\302\262
\211\312W\203Q\304\313\\\310#\210\211T\262
\202<\314\315
\211\203h\211@\304
\310#\210
A\266\202\202T\210\211\211\203~\211@\304
\316#\210
A\266\202\202j\266
\207" [make-syntax-table nil 0 256 modify-syntax-entry " " 26 97 "_" 65 10 48 (64 47 92 42 43 126 36 60 62 37) (95 45 58 46) "w"] 10))
(defvaralias 'cmpl-syntax-table 'completion-syntax-table)
#@58 This variable holds the current completion syntax table.
(defvar completion-syntax-table completion-standard-syntax-table (#$ . 4850))
(make-variable-buffer-local 'completion-syntax-table)
#@72 Holds first character of symbol, after any completion symbol function.
(defvar cmpl-symbol-start nil (#$ . 5045))
#@71 Holds last character of symbol, after any completion symbol function.
(defvar cmpl-symbol-end nil (#$ . 5165))
#@106 Return the symbol that the point is currently on.
But only if it is longer than `completion-min-length'.
(defalias 'symbol-under-point #[0 "\305 p\306\307#\216\310!\210gz\311>\205_`\312
T\313\"\312
\314\"	fz\315U\2034	b\210\316\314!\210`\211b\210\nSfz\315U\203I\nb\210\316\313!\210`\211b\210\n	ZX\205]\n	Z\fX\205]\317	\n\"\262
)\207" [completion-syntax-table cmpl-symbol-start cmpl-symbol-end completion-min-length completion-max-length syntax-table make-closure #[0 "r\301q\210\302\300!)\207" [V0 V1 set-syntax-table] 2] set-syntax-table (119 95) scan-sexps -1 1 119 forward-word-strictly buffer-substring-no-properties] 6 (#$ . 5283)])
#@125 Return a string of the symbol immediately before point.
Returns nil if there isn't one longer than `completion-min-length'.
(defalias 'symbol-before-point #[0 "\306 p\307\310#\216\311!\210hz\211\312U\203@`\313\n\314\"\211fz\315U\2031b\210\316\317!\210`\nb\210\n\f\\Y\205|\320\n\"\202|	\315U\205|`\313
\314\"\316\314!\210`fz\315U\203cb\210\316\317!\210`\211b\210\f\nZX\205z\nZ
X\205z\320\n\"\262
)\207" [completion-syntax-table cmpl-preceding-syntax cmpl-symbol-end cmpl-symbol-start completion-min-length completion-max-length syntax-table make-closure #[0 "r\301q\210\302\300!)\207" [V0 V1 set-syntax-table] 2] set-syntax-table 95 scan-sexps -1 119 forward-word-strictly 1 buffer-substring-no-properties] 7 (#$ . 5941)])
(defalias 'symbol-under-or-before-point #[0 "\301 p\302\303#\216\304!\210gz)\266\202\305>\203\306 \207\307 \207" [completion-syntax-table syntax-table make-closure #[0 "r\301q\210\302\300!)\207" [V0 V1 set-syntax-table] 2] set-syntax-table (119 95) symbol-under-point symbol-before-point] 6])
(defalias 'symbol-before-point-for-complete #[0 "\306 p\307\310#\216\311!\210hz\211\312>\205E`\313\n\314\"\211fz\315U\2031b\210\316\317!\210`\nb\210\f\nZX\205E\nZ
X\205E\320\n\")\207" [completion-syntax-table cmpl-preceding-syntax cmpl-symbol-end cmpl-symbol-start completion-prefix-min-length completion-max-length syntax-table make-closure #[0 "r\301q\210\302\300!)\207" [V0 V1 set-syntax-table] 2] set-syntax-table (95 119) scan-sexps -1 119 forward-word-strictly 1 buffer-substring-no-properties] 7])
(defconst cmpl-source-unknown 0)
(defconst cmpl-source-init-file 1)
(defconst cmpl-source-file-parsing 2)
(defconst cmpl-source-separator 3)
(defconst cmpl-source-cursor-moves 4)
(defconst cmpl-source-interactive 5)
(defconst cmpl-source-cdabbrev 6)
(defconst num-cmpl-sources 7)
(defvar current-completion-source cmpl-source-unknown)
(defvar cdabbrev-completions-tried nil)
(defvar cdabbrev-current-point 0)
(defvar cdabbrev-current-window nil)
(defvar cdabbrev-wrapped-p nil)
(defvar cdabbrev-abbrev-string "")
(defvar cdabbrev-start-point 0)
#@198 Reset the cdabbrev search to search for ABBREV-STRING.
INITIAL-COMPLETIONS-TRIED is a list of downcased strings to ignore
during the search.

(fn ABBREV-STRING &optional INITIAL-COMPLETIONS-TRIED)
(defalias 'reset-cdabbrev #[513 "

\227
B\302\303!\207" [cdabbrev-abbrev-string cdabbrev-completions-tried reset-cdabbrev-window t] 4 (#$ . 8059)])
(defalias 'set-cdabbrev-buffer #[0 "\301=\203\302 \202\303!q\207" [cdabbrev-current-window t other-buffer window-buffer] 2])
#@84 Reset the cdabbrev search to search for abbrev-string.

(fn &optional INITIALIZEP)
(defalias 'reset-cdabbrev-window #[256 "\211\203\n\306 \202&\307=\203\310\202&\203&\311!\211\306 =\203&\307\205D\212\312 \210`\211\203>e\nZ]\202?e\310\211)\207" [cdabbrev-current-window cdabbrev-current-point cdabbrev-start-point completion-search-distance cdabbrev-stop-point cdabbrev-wrapped-p selected-window t nil next-window set-cdabbrev-buffer] 5 (#$ . 8543)])
#@159 Return the next possible cdabbrev expansion or nil if there isn't one.
`reset-cdabbrev' must've been called already.
This is sensitive to `case-fold-search'.
(defalias 'next-cdabbrev #[0 "\205\272\306C\306C\306\211\211\211\211\212\307\310#\216\311 \210`\240\210\312 \240\210\313	!\210\nb\210\314\f\315#\203\204hz\211\262\316U\204S
\317U\205\200`\262
\320\321!\210hz\316U
b\210\205\200\322 \211\262\205\200
\262\227\262\203t@\230\204tA\262\202b\203\306\211\262\202\200\315?\202\241\204\244\203\230d\\^\202\231d\211b\210\315\211\204*\203\256
B`*\206\270\323 \210\324 \266\207\207" [cdabbrev-current-window completion-syntax-table cdabbrev-current-point cdabbrev-abbrev-string cdabbrev-stop-point cdabbrev-completions-tried nil make-closure #[0 "\302\301\242!\210\300\242b\207" [V0 V1 set-syntax-table] 2] set-cdabbrev-buffer syntax-table set-syntax-table search-backward t 32 119 forward-word-strictly -1 symbol-under-point reset-cdabbrev-window next-cdabbrev cdabbrev-wrapped-p completion-search-distance cdabbrev-start-point] 11 (#$ . 9024)])
(defconst cmpl-obarray-length 511)
#@115 An obarray used to store the downcased completion prefixes.
Each symbol is bound to a list of completion entries.
(defvar cmpl-prefix-obarray (make-vector cmpl-obarray-length 0) (#$ . 10165))
#@104 An obarray used to store the downcased completions.
Each symbol is bound to a single completion entry.
(defvar cmpl-obarray (make-vector cmpl-obarray-length 0) (#$ . 10364))
#@25 

(fn COMPLETION-ENTRY)
(defalias 'completion-string '(macro . #[257 "\300
D\207" [car] 3 (#$ . 10544)]))
#@25 

(fn COMPLETION-ENTRY)
(defalias 'completion-num-uses '(macro . #[257 "\300\301DD\207" [car cdr] 4 (#$ . 10656)]))
#@25 

(fn COMPLETION-ENTRY)
(defalias 'completion-last-use-time '(macro . #[257 "\300\301E\207" [nth 2] 4 (#$ . 10779)]))
#@25 

(fn COMPLETION-ENTRY)
(defalias 'completion-source '(macro . #[257 "\300\301E\207" [nth 3] 4 (#$ . 10904)]))
#@32 

(fn COMPLETION-ENTRY STRING)
(defalias 'set-completion-string '(macro . #[514 "\300E\207" [setcar] 5 (#$ . 11022)]))
#@34 

(fn COMPLETION-ENTRY NUM-USES)
(defalias 'set-completion-num-uses '(macro . #[514 "\300\301DE\207" [setcar cdr] 5 (#$ . 11149)]))
#@39 

(fn COMPLETION-ENTRY LAST-USE-TIME)
(defalias 'set-completion-last-use-time '(macro . #[514 "\300\301\211DDE\207" [setcar cdr] 6 (#$ . 11289)]))
#@41 Return a completion entry.

(fn STRING)
(defalias 'make-completion #[257 "\211\301\302F\207" [current-completion-source 0 nil] 5 (#$ . 11444)])
(byte-code "\300\301\302\"\210\300\303\304\"\207" [defalias cmpl-prefix-entry-head car cmpl-prefix-entry-tail cdr] 3)
#@30 

(fn PREFIX-ENTRY NEW-HEAD)
(defalias 'set-cmpl-prefix-entry-head '(macro . #[514 "\300E\207" [setcar] 5 (#$ . 11713)]))
#@30 

(fn PREFIX-ENTRY NEW-TAIL)
(defalias 'set-cmpl-prefix-entry-tail '(macro . #[514 "\300E\207" [setcdr] 5 (#$ . 11843)]))
#@87 Make a new prefix entry containing only completion-entry.

(fn COMPLETION-ENTRY-LIST)
(defalias 'make-cmpl-prefix-entry #[257 "\211
B\207" [] 3 (#$ . 11973)])
#@72 Initialize the completion storage.  All existing completions are lost.
(defalias 'clear-all-completions #[0 "\303\304\"\303\304\"\211\207" [cmpl-obarray-length cmpl-prefix-obarray cmpl-obarray make-vector 0] 3 (#$ . 12138) nil])
#@52 Return a list of all the known completion entries.
(defalias 'list-all-completions #[0 "\301C\302\303\304\"\"\210\211\242\207" [cmpl-prefix-obarray nil mapatoms make-closure #[257 "\301
!\205\300\302\303J!\300\242\"\240\207" [V0 boundp append cmpl-prefix-entry-head] 5 "\n\n(fn PREFIX-SYMBOL)"]] 5 (#$ . 12377)])
#@77 Return list of lists of known completion entries, organized by hash bucket.
(defalias 'list-all-completions-by-hash-bucket #[0 "\301C\302\303\304\"\"\210\211\242\207" [cmpl-prefix-obarray nil mapatoms make-closure #[257 "\301
!\205\300\302J!\300\242B\240\207" [V0 boundp cmpl-prefix-entry-head] 4 "\n\n(fn PREFIX-SYMBOL)"]] 5 (#$ . 12701)])
#@49 Set to a string that is pending its acceptance.
(defvar completion-to-accept nil (#$ . 13053))
#@70 Setup by `find-exact-completion', etc.  The given string, downcased.
(defvar cmpl-db-downcase-string nil (#$ . 13154))
#@93 The interned symbol corresponding to `cmpl-db-downcase-string'.
Set up by `cmpl-db-symbol'.
(defvar cmpl-db-symbol nil (#$ . 13279))
#@72 The interned prefix symbol corresponding to `cmpl-db-downcase-string'.
(defvar cmpl-db-prefix-symbol nil (#$ . 13418))
(defvar cmpl-db-entry nil)
#@45 Set to t if you want to debug the database.
(defvar cmpl-db-debug-p nil (#$ . 13570))
#@117 Return the completion entry for STRING or nil.
Sets up `cmpl-db-downcase-string' and `cmpl-db-symbol'.

(fn STRING)
(defalias 'find-exact-completion #[257 "\303\304\227\211	\"\211!\205\nJ\207" [cmpl-db-downcase-string cmpl-obarray cmpl-db-symbol boundp intern] 5 (#$ . 13663)])
#@202 Return the prefix entry for string.
Sets `cmpl-db-prefix-symbol'.
Prefix-string must be exactly `completion-prefix-min-length' long
and downcased.  Sets up `cmpl-db-prefix-symbol'.

(fn PREFIX-STRING)
(defalias 'find-cmpl-prefix-entry #[257 "\302\303\"\211!\205
	J\207" [cmpl-prefix-obarray cmpl-db-prefix-symbol boundp intern] 5 (#$ . 13953)])
(defvar inside-locate-completion-entry nil)
(byte-code "\300\301\302\303#\210\304\301\302\305#\207" [defalias locate-completion-entry completion-locate-entry nil make-obsolete "27.1"] 4)
#@220 Locate the completion entry.
Returns a pointer to the element before the completion entry or nil if
the completion entry is at the head.
Must be called after `find-exact-completion'.

(fn COMPLETION-ENTRY PREFIX-ENTRY)
(defalias 'completion-locate-entry #[514 "\304
!\305
@=?\205<
\203!A\211\262@=\204!\211\262\202\f
\206<\203.\306\307	\"\207\n\2035\310 \207\305L\210\311!\207" [cmpl-db-debug-p cmpl--completion-string inside-locate-completion-entry cmpl-db-symbol cmpl-prefix-entry-head nil error "Completion entry exists but not on prefix list - %s" completion-locate-db-error completion-locate-entry-retry] 7 (#$ . 14496)])
(byte-code "\300\301\302\303#\210\304\301\302\305#\207" [defalias locate-completion-entry-retry completion-locate-entry-retry nil make-obsolete "27.1"] 4)
#@18 

(fn OLD-ENTRY)
(defalias 'completion-locate-entry-retry #[257 "\303\304
@A@\3058#\210\306
@!\211\205\307	\310\nO!
\203,\211\203,\311\"\266\202\2020\312 \266\202)\207" [inside-locate-completion-entry cmpl-db-downcase-string completion-prefix-min-length t add-completion 2 find-exact-completion find-cmpl-prefix-entry 0 completion-locate-entry completion-locate-db-error] 6 (#$ . 15299)])
(byte-code "\300\301\302\303#\210\304\301\302\305#\207" [defalias locate-completion-db-error completion-locate-db-error nil make-obsolete "27.1"] 4)
(defalias 'completion-locate-db-error #[0 "\300\301\302!!\207" [error substitute-command-keys "Completion database corrupted.  Try \\[clear-all-completions].  Send bug report"] 3])
#@316 If STRING is not in the database add it to appropriate prefix list.
STRING is added to the end of the appropriate prefix list with
num-uses = 0.  The database is unchanged if it is there.  STRING must be
longer than `completion-prefix-min-length'.
This must be very fast.
Returns the completion entry.

(fn STRING)
(defalias 'add-completion-to-tail-if-new #[257 "\304
!\206-\305
!C\306\307	O!\211\203!\310
!\241\210\211\241\210\202'\n\311!L\210@L\266\202\207" [cmpl-db-downcase-string completion-prefix-min-length cmpl-db-prefix-symbol cmpl-db-symbol find-exact-completion make-completion find-cmpl-prefix-entry 0 cmpl-prefix-entry-tail make-cmpl-prefix-entry] 6 (#$ . 16035)])
#@365 If COMPLETION-STRING is not in the database, add it to prefix list.
We add COMPLETION-STRING to the head of the appropriate prefix list,
or to the head of the list.
COMPLETION-STRING must be longer than `completion-prefix-min-length'.
Updates the saved string with the supplied string.
This must be very fast.
Returns the completion entry.

(fn COMPLETION-STRING)
(defalias 'add-completion-to-head #[257 "\211	\203	\306 \210\307
!\211\203@\310\311\fO!\312\n\"\211A\n\240\210
\203:

A\241\2040\241\210\211\313!\241\210
\240\210\n\266\203\202h\314
!C\310\311\fO!\211\203[
\313!\241\210\211\240\210\202a
\315!L\210@L\266\202)\207" [cmpl--completion-string completion-to-accept cmpl-db-entry cmpl-db-downcase-string completion-prefix-min-length cmpl-db-prefix-symbol accept-completion find-exact-completion find-cmpl-prefix-entry 0 completion-locate-entry cmpl-prefix-entry-head make-completion make-cmpl-prefix-entry cmpl-db-symbol] 7 (#$ . 16729)])
#@125 Delete the completion from the database.
String must be longer than `completion-prefix-min-length'.

(fn COMPLETION-STRING)
(defalias 'delete-completion #[257 "\211	\203	\306 \210\307
!\211\203E\310\311\fO!\312\n\"
\313L\210\211\2033\211
AA\241\206@

\241\266\202\202I
\314!A\240\206@\313L\266\202\202I\315\316\")\207" [cmpl--completion-string completion-to-accept cmpl-db-entry cmpl-db-downcase-string completion-prefix-min-length cmpl-db-symbol accept-completion find-exact-completion find-cmpl-prefix-entry 0 completion-locate-entry nil cmpl-prefix-entry-head error "Unknown completion `%s'" cmpl-db-prefix-symbol] 6 (#$ . 17706)])
#@15 

(fn PROMPT)
(defalias 'interactive-completion-string-reader #[257 "\301 \302\303\"\"\211G\304U\203
\206\305\262
\211C\207" [cmpl-obarray symbol-under-or-before-point completing-read format-prompt 0 ""] 6 (#$ . 18362)])
#@15 

(fn STRING)
(defalias 'check-completion-length #[257 "\211GW\203\f\301\302\"\207\211C\207" [completion-min-length user-error "The string `%s' is too short to be saved as a completion"] 4 (#$ . 18596)])
#@194 Add STRING to completion list, or move it to head of list.
The completion is altered appropriately if NUM-USES and/or LAST-USE-TIME
are specified.

(fn STRING &optional NUM-USES LAST-USE-TIME)
(defalias 'add-completion #[769 "\302!\210\303\304!\203\202	\305!\203\211A\240\210
\205%\211AA\240)\207" [cmpl-source-interactive current-completion-source check-completion-length called-interactively-p interactive add-completion-to-head] 6 (#$ . 18810) (interactive-completion-string-reader "Completion to add")])
#@76 Add STRING if it isn't already listed, and mark it permanent.

(fn STRING)
(defalias 'add-permanent-completion #[257 "\302\303!\203\n\202	\304
\305\306#)\207" [cmpl-source-interactive current-completion-source called-interactively-p interactive add-completion nil t] 5 (#$ . 19338) (interactive-completion-string-reader "Completion to add permanently")])
#@15 

(fn STRING)
(defalias 'kill-completion #[257 "\300
!\210\301
!\207" [check-completion-length delete-completion] 3 (#$ . 19704) (interactive-completion-string-reader "Completion to kill")])
#@146 Accept the pending completion in `completion-to-accept'.
This bumps num-uses.  Called by `add-completion-to-head' and
`completion-search-reset'.
(defalias 'accept-completion #[0 "	\304
\304\305!\262
\211A
A@T\240\210\306\211)\207" [completion-to-accept cmpl-source-cdabbrev current-completion-source cmpl-completions-accepted-p nil add-completion-to-head t] 5 (#$ . 19902)])
#@76 Add the completion symbol underneath the point into the completion buffer.
(defalias 'use-completion-under-point #[0 "\205\303 	\211\205\304
!)\207" [enable-completion cmpl-source-cursor-moves current-completion-source symbol-under-point add-completion-to-head] 3 (#$ . 20288)])
#@68 Add the completion symbol before point into the completion buffer.
(defalias 'use-completion-before-point #[0 "\205\303 	\211\205\304
!)\207" [enable-completion cmpl-source-cursor-moves current-completion-source symbol-before-point add-completion-to-head] 3 (#$ . 20579)])
#@68 Add the completion symbol before point into the completion buffer.
(defalias 'use-completion-under-or-before-point #[0 "\205\303 	\211\205\304
!)\207" [enable-completion cmpl-source-cursor-moves current-completion-source symbol-under-or-before-point add-completion-to-head] 3 (#$ . 20864)])
#@174 Add the completion symbol before point into the completion buffer.
Completions added this way will automatically be saved if
`completion-on-separator-character' is non-nil.
(defalias 'use-completion-before-separator #[0 "\205\305 	\306
\205'\307!\262
\205'\211A@\310U\205'\211A\311\240\210\312\211)\207" [enable-completion cmpl-source-separator current-completion-source completion-on-separator-character cmpl-completions-accepted-p symbol-before-point nil add-completion-to-head 0 1 t] 5 (#$ . 21168)])
(defvar cmpl-test-string "")
(defvar cmpl-test-regexp "")
(defvar cmpl-last-index 0)
(defvar cmpl-cdabbrev-reset-p nil)
(defvar cmpl-next-possibilities nil)
(defvar cmpl-starting-possibilities nil)
(defvar cmpl-next-possibility nil)
(defvar cmpl-tried-list nil)
#@121 Set up the for completion searching for STRING.
STRING must be longer than `completion-prefix-min-length'.

(fn STRING)
(defalias 'completion-search-reset #[257 "\203\305 \210\306\307\310	O\227!!\211\311
!\312P\313 \207" [completion-to-accept completion-prefix-min-length cmpl-starting-possibilities cmpl-test-string cmpl-test-regexp accept-completion cmpl-prefix-entry-head find-cmpl-prefix-entry 0 regexp-quote "." completion-search-reset-1] 6 (#$ . 21952)])
(defalias 'completion-search-reset-1 #[0 "\306\211\307\306\211\207" [cmpl-starting-possibilities cmpl-next-possibilities cmpl-next-possibility cmpl-cdabbrev-reset-p cmpl-last-index cmpl-tried-list nil -1] 3])
#@175 Return the next completion entry.
If INDEX is out of sequence, reset and start from the top.
If there are no more entries, try cdabbrev and return only a string.

(fn INDEX)
(defalias 'completion-search-next #[257 "\211T\211U\203\304\305!\210\202h\211\306W\203N\307 \210\211\310	!\304\311!\2034\211T\211\262\306W\2034\311\202\n\203h\312U\203C	\202h	G\nGZ	\233\202h\307 \210\211\304\305!\203h\211S\211\262\306W\204h\311\202S\311\207" [cmpl-last-index cmpl-starting-possibilities cmpl-next-possibilities cmpl-next-possibility completion-search-peek t 0 completion-search-reset-1 reverse nil -1] 4 (#$ . 22642)])
#@295 Return the next completion entry without actually moving the pointers.
Calling this again or calling `completion-search-next' results in the same
string being returned.  Depends on `case-fold-search'.
If there are no more entries, try cdabbrev and then return only a string.

(fn USE-CDABBREV)
(defalias 'completion-search-peek #[257 "\206?	\203,\306\n	@@\"\307=\204	A\211\204	\203,	@\211@\227B	A\207\211\205?\f\204;\310
\"\210\311\312 \211\207" [cmpl-next-possibility cmpl-next-possibilities cmpl-test-regexp cmpl-tried-list cmpl-cdabbrev-reset-p cmpl-test-string string-match 0 reset-cdabbrev t next-cdabbrev] 5 (#$ . 23288)])
#@68 Toggle whether or not to add new words to the completion database.
(defalias 'completion-mode #[0 "?\301\302\203
\303\202\304\"\207" [enable-completion message "Completion mode is now %s." "ON" "OFF"] 3 (#$ . 23942) nil])
(defvar cmpl-current-index 0)
(defvar cmpl-original-string nil)
(defvar cmpl-last-insert-location -1)
(defvar cmpl-leave-point-at-start nil)
#@454 Fill out a completion of the word before point.
Point is left at end.  Consecutive calls rotate through all possibilities.
Prefix args ::
  control-u :: leave the point at the beginning of the completion rather
               than at the end.
  a number  :: rotate through the possible completions by that amount
  `-'       :: same as -1 (insert previous completion)
 {See the comments at the top of `completion.el' for more info.}

(fn &optional ARG)
(defalias 'complete #[256 "	=\203\n`|\210
\206\306\\\202R\f\204\307 \210
:\203*\310\262
\311\202-\312\313 \211\204=\314\315\316\"\210
\203E\211\202F\310\317!\210|\210 Y\205]\320 ?`\321!\312
\203\274
;\203o
\202q
@\262
\322
\"\262
\211c\210\211!\203\215`b\210\202\217\205\337\323\310!\205\337\324\"!\211\262\205\337
;\203\254
\202\256
@\262
\322
\"\262
\325\326\"\207c\210\312!\203\334\323\310!\203\334\325\327	=\203\331\330\202\332\331\"\210\314\211\207" [last-command this-command cmpl-last-insert-location cmpl-current-index cmpl-initialized-p current-prefix-arg 1 completion-initialize 0 t nil symbol-before-point-for-complete failed-complete error "To complete, point must be after a symbol at least %d character long" completion-search-reset window-minibuffer-p completion-search-next cmpl-merge-string-cases sit-for completion-search-peek message "Next completion: %s" "No %scompletions." "more " "" cmpl-leave-point-at-start cmpl-original-string completion-prefix-min-length cmpl-symbol-start cmpl-symbol-end baud-rate completion-prompt-speed-threshold completion-to-accept completion-cdabbrev-prompt-flag] 10 (#$ . 24318) "*p"])
#@77 Parse possible completions from a FILE and add them to database.

(fn FILE)
(defalias 'add-completions-from-file #[257 "\301
!\262
\302
!C\211\242\211\204\303
\304!\240\210)\305\306#\216r
\242q\210\307 *\207" [completions-merging-modes expand-file-name get-file-buffer nil find-file-noselect make-closure #[0 "\301?\205	\302\300\242!\207" [V0 V1 kill-buffer] 2] add-completions-from-buffer] 7 (#$ . 25985) "fFile: "])
(defalias 'add-completions-from-buffer #[0 "\n\303>\203
\304 \202\n\305=\203\306 \202\307\310\n\")\207" [cmpl-source-file-parsing current-completion-source major-mode (emacs-lisp-mode lisp-mode) add-completions-from-lisp-buffer c-mode add-completions-from-c-buffer error "Cannot parse completions in %s buffers"] 3 nil nil])
(defalias 'completion-find-file-hook #[0 "\205!	\303>\203\304\n>\203\305 \207	\306=\205!\307\n>\205!\305 \207" [enable-completion major-mode completions-merging-modes (emacs-lisp-mode lisp-mode) lisp add-completions-from-buffer c-mode c] 2])
#@46 Add completions from the current tags table.
(defalias 'add-completions-from-tags-table #[0 "\300 \210\212eb\210\301\3021%\303\304!\210\305u\210\306 \211\262\203\307
!\210\310u\210\202\f\210\301\262
)\207" [visit-tags-table-buffer nil (search-failed) search-forward "" -3 symbol-under-point add-completion-to-tail-if-new 3] 3 (#$ . 27000) nil])
#@50 A regexp that searches for Lisp definition form.
(defconst *lisp-def-regexp* "\n(\\(\\w*:\\)?def\\(\\w\\|\\s_\\)*\\s +(*" (#$ . 27357))
(defalias 'add-completions-from-lisp-buffer #[0 "\301\212eb\210\3021\303!\210\304 \211\262\203	\305
!\210\202	\210)\301\207" [*lisp-def-regexp* nil (search-failed) re-search-forward symbol-under-point add-completion-to-tail-if-new] 3])
(defconst completion-c-def-syntax-table (byte-code "\300 \301\302\303\304\262
\211\305W\203\306
\307#\210\211T\262
\202\211\2031\211@\306
\310#\210
A\266\202\202\210
\211\203G\211@\306
\311#\210
A\266\202\2023\210\306\312\313#\210\306\314\315#\210\306\316\317#\210\306\320\321#\210\207" [make-syntax-table (32 10 9 12 11 13) (44 42 61 40 59) nil 0 256 modify-syntax-entry "w" "_" " " 91 "(]" 123 "(}" 93 ")[" 125 "){"] 10))
#@47 A regexp that searches for a definition form.
(defconst *c-def-regexp* "\n[_a-zA-Z#]" (#$ . 28190))
(defalias 'add-completions-from-c-buffer #[0 "\302\211\211\212eb\210\3032\347\304 p\305\306#\216\307!\210\3101\313\3111\301\312	!\210h\313U\203E\314\315!\203 \316\317!\203 \320 \211\262\203 \321!\210\202 `\262\203 \322\323\"\211\262\203 b\210g\211\262\324U\203n\322`\323\"\211\262b\210\202Y\316\325!\210\326 \211\262\203\201\321!\210\202\227\314\327!\203\227\316\325!\210\326 \211\262\203\227\321!\210b\210z\330U\203\265z\330U\203H\322\323\"\262f\262\202\241\331U\204H\302\262\202H0\332\303\333\"\266\202\211A@\334\235\203\332\323y\266\202\335\336!\210\332\303\333\"\266\202)\207" [completion-c-def-syntax-table *c-def-regexp* nil finish-add-completions syntax-table make-closure #[0 "r\301q\210\302\300!)\207" [V0 V1 set-syntax-table] 2] set-syntax-table (error) (search-failed) re-search-forward 35 looking-at "\\(define\\|ifdef\\)\\>" forward-word-strictly 2 symbol-before-point add-completion-to-tail-if-new scan-sexps 1 42 -1 symbol-under-point "_AP" 40 44 throw t ("Containing expression ends prematurely" "Unbalanced parentheses") message "Error parsing C buffer for completions--please send bug report"] 9])
(defalias 'kill-emacs-save-completions #[0 "\205	\205\n\205\204\304\305!\207\306 \207" [save-completions-flag enable-completion cmpl-initialized-p cmpl-completions-accepted-p message "Completions database has not changed - not writing." save-completions-to-file] 2])
(defconst completion-version "11")
(defconst saved-cmpl-file-header ";;; Completion Initialization file.\n;; Version = %s\n;; Format is (<string> . <last-use-time>)\n;;  <string> is the completion\n;;  <last-use-time> is the time the completion was last used\n;;    If it is t, the completion will never be pruned from the file.\n;;    Otherwise it is in hours since origin.\n\n")
#@17 

(fn FILENAME)
(defalias 'completion-backup-filename #[257 "\211\300P\207" [".BAK"] 3 (#$ . 30126)])
#@131 Save completions in init file FILENAME.
If file name is not specified, use `save-completions-file-name'.

(fn &optional FILENAME)
(defalias 'save-completions-to-file #[256 "\306
\206!\262
\307
!\205\367	\204\310 \210\311\312\"\210\313\314\f\315\316 \314\211\211\317!r\320\321!q\210%\322p!\204K\311\323!\210\324\313\"\210\311\325\"\210\326 \210\327 \210\330&'\"c\210\331 \211\203\264\211@T\262\332
8\262\313=\203yT\211\262\204\236\211A@\314V\203\211\211\262	\202\233\203\255(\203\236Z(W\203\255T\262\333
@	B!\334\261\210
A\266\202\202[\210\3351\345\336!\211\203\324\336!\204\315\337\"\210\340	\313#\210\341 \210\211\205\336\342!\262
0\210\202\360\210\343\315!\210\311\344\"\210\315\211),\266\206\207" [save-completions-file-name cmpl-initialized-p delete-old-versions kept-old-versions completions-file-versions-kept kept-new-versions expand-file-name file-writable-p completion-initialize message "Saving completions to file %s" t 0 nil cmpl-hours-since-origin completion-backup-filename get-buffer-create " *completion-save-buffer*" verify-visited-file-modtime "Completion file has changed.  Merging. . ." load-completions-from-file "Merging finished.  Saving completions to file %s" clear-visited-file-modtime erase-buffer format list-all-completions 2 prin1-to-string "\n" (error) file-exists-p rename-file copy-file save-buffer delete-file set-buffer-modified-p "Couldn't save completion file `%s'" buffer-file-name saved-cmpl-file-header completion-version save-completions-retention-time cmpl-completions-accepted-p] 12 (#$ . 30235) nil])
#@142 Load a completion init file FILENAME.
If file is not specified, then use `save-completions-file-name'.

(fn &optional FILENAME NO-MESSAGE-P)
(defalias 'load-completions-from-file #[512 "\304\206!\262\305!\306
!\211\203
\262\306!\205
\204/\307\310\203*\311\202+\312#\210r\313\314!q\210\315 \210\316 \210p\317\211\211\211\211\n\320\211\3211
\322
\323\"0\210eb\210\3241\351\3251\341\326	!\262
T\262:\203\322@\211\262	;\203\322A\211\262\327=\203\216\211T\262
\323\211\262\202\236\323=\203\234\211T\211\262\202\236\250\203\322\330\331	!\211\2628\262\323=\204\310\332V\203^\323=\204^\203\310V\203^AA\240\210\202^\307\333\334	!\"\210\335\336!\210\202^0\210\307\337!\202\n
\210`dU\203\376?\205\n
\307\340\"\202\n
\307\337!\202\n
\210\307\341\")\266\211)\207" [save-completions-file-name buffer-file-name cmpl-source-init-file current-completion-source expand-file-name completion-backup-filename file-readable-p message "Loading completions from %sfile %s . . ." "backup " "" get-buffer-create " *completion-save-buffer*" clear-visited-file-modtime erase-buffer nil 0 (file-error) insert-file-contents t (end-of-file) (search-failed) read T 2 add-completion-to-tail-if-new 1000 "Error: invalid saved completion - %s" prin1-to-string search-forward "\n(" "End of file while reading completions." "Loading completions from file %s . . . Done." "File error trying to load completion file %s."] 17 (#$ . 31856) nil])
#@105 Load the default completions file.
Also sets up so that exiting Emacs will automatically save the file.
(defalias 'completion-initialize #[0 "?\205\301 \210\302\211\207" [cmpl-initialized-p load-completions-from-file t] 2 (#$ . 33342) nil])
#@645 Kill between point and mark.
The text is deleted but saved in the kill ring.
The command \[yank] can retrieve it from there.
(If you want to kill and then yank immediately, use \[copy-region-as-kill].)

This is the primitive for programs to kill text (as opposed to deleting it).
Supply two arguments, character positions indicating the stretch of text
 to be killed.
Any command that calls this function is a "kill command".
If the previous command was also a kill command,
the text killed this time appends to the text killed last time
to make one entry in the kill ring.
Patched to remove the most recent completion.

(fn &optional BEG END)
(defalias 'completion-kill-region #[512 "\304=\203`	|\210\nc\210\305\211\207\306\"\207" [last-command cmpl-last-insert-location cmpl-original-string completion-to-accept complete nil kill-region] 5 (#$ . 33594) "r"])
(defvar completion-separator-chars (append " !%^&()=`|{}[];\\'#,?" ".:" nil))
(defalias 'completion--post-self-insert #[0 "	>\205\302 \211\205\212\211Sb\210\303 )\262
\207" [last-command-event completion-separator-chars electric--after-char-pos use-completion-before-separator] 2])
#@170 Add a call to update the completion database before function execution.
TYPE is the type of the wrapper to be added.  Can be :before or :under.

(fn FUNCTION-NAME TYPE)
(defalias 'completion-def-wrapper #[514 "\300\301\302\236A#\207" [put completion-function ((:separator . use-completion-before-separator) (:before . use-completion-before-point) (:backward-under . use-completion-backward-under) (:backward . use-completion-backward) (:under . use-completion-under-point) (:under-or-before . use-completion-under-or-before-point) (:minibuffer-separator . use-completion-minibuffer-separator))] 7 (#$ . 34755)])
(defalias 'use-completion-minibuffer-separator #[0 "\302 )\207" [completion-standard-syntax-table completion-syntax-table use-completion-before-separator] 1])
(defalias 'use-completion-backward-under #[0 "\300 \207" [use-completion-under-point] 1])
(defalias 'use-completion-backward #[0 "\300\207" [nil] 1])
(defalias 'completion-before-command #[0 "9\203\301N\206\f\302 \207" [this-command completion-function use-completion-under-or-before-point] 2])
(defconst completion-lisp-syntax-table (byte-code "\301!\302\211\211\203\211@\303
\304#\210
A\266\202\202\210
\207" [completion-standard-syntax-table copy-syntax-table (33 38 63 61 94) modify-syntax-entry "_"] 8))
(defalias 'completion-lisp-mode-hook #[0 "\303\304!\210\305\302!\210\306\n\307\310\311\"\"\211\207" [completion-lisp-syntax-table completion-syntax-table completion-separator-chars require cl-lib make-local-variable cl-set-difference append "!&%?=^" nil] 5])
(defconst completion-c-syntax-table (byte-code "\301!\302\211\211\203\211@\303
\304#\210
A\266\202\202\210
\207" [completion-standard-syntax-table copy-syntax-table (43 42 47 58 37) modify-syntax-entry " "] 8))
(completion-def-wrapper 'electric-c-semi :separator)
(defalias 'completion-c-mode-hook #[0 "\303\302!\210\304\305\n\"\211\207" [completion-c-syntax-table completion-syntax-table completion-separator-chars make-local-variable append "+*/"] 3])
(defconst completion-fortran-syntax-table (byte-code "\301!\302\211\211\203\211@\303
\304#\210
A\266\202\202\210
\207" [completion-standard-syntax-table copy-syntax-table (43 45 42 47 58) modify-syntax-entry " "] 8))
(defalias 'completion-setup-fortran-mode #[0 "\303\302!\210\304\305\n\"\211\207" [completion-fortran-syntax-table completion-syntax-table completion-separator-chars make-local-variable append "+-*/"] 3])
(defvar completion-saved-bindings nil)
(byte-code "\300\301\302\303\304DD\305\306\307\310\311\312\313&	\207" [custom-declare-variable dynamic-completion-mode funcall function #[0 "\300\207" [nil] 1 ""] "Non-nil if Dynamic-Completion mode is enabled.\nSee the `dynamic-completion-mode' command\nfor a description of this minor mode.\nSetting this variable directly does not take effect;\neither customize it (see the info node `Easy Customization')\nor call the function `dynamic-completion-mode'." :set custom-set-minor-mode :initialize custom-initialize-default :type boolean] 10)
#@633 Toggle dynamic word-completion on or off.

This is a minor mode.  If called interactively, toggle the
`Dynamic-Completion mode' mode.  If the prefix argument is positive,
enable the mode, and if it is zero or negative, disable the mode.

If called from Lisp, toggle the mode if ARG is `toggle'.  Enable the
mode if ARG is nil, omitted, or is a positive number.  Disable the
mode if ARG is a negative number.

To check whether the minor mode is enabled in the current buffer,
evaluate `(default-value \='dynamic-completion-mode)'.

The mode's hook is called both when the mode is enabled and when it is
disabled.

(fn &optional ARG)
(defalias 'dynamic-completion-mode #[256 "\305 \306\302\307=\203\310\302!?\202!\247\203 \311W\203 \312\202!\313\"\210\314\300!\2038\315\302\"\310\302!\2038\302B\316	\317\320#\210\321\322B\323\324B\325\326B\327\330B\331\332B\333\334B\335\336B\257\211\203w\211@\n\203i\337
@A\"\210\202p\340
@A\"\210
A\266\202\202U\210\203\214\211A\242\341
@A\"\266\202x\n\203\264\342\211\203\260\211@\211@\343\f@\"BB\341
@A\"\210
A\266\202\202\221\210\344 \210\345\346\310\302!\203\300\347\202\301\350\"\210\351\352!\203\351\353\302!\210\305 \203\331\211\305 \232\203\351\354\355\310\302!\203\345\356\202\346\357\360#\210\210\361 \210\310\302!\207" [global-minor-modes function-key-map dynamic-completion-mode completion-saved-bindings global-map current-message set-default toggle default-value 1 nil t boundp delq define-key [C-return] [67108877] find-file-hook completion-find-file-hook pre-command-hook completion-before-command kill-emacs-hook kill-emacs-save-completions post-self-insert-hook completion--post-self-insert lisp-mode-hook completion-lisp-mode-hook c-mode-hook completion-c-mode-hook fortran-mode-hook completion-setup-fortran-mode add-hook remove-hook global-set-key (("\215" . complete) ([67108877] . complete) ([remap kill-region] . completion-kill-region)) lookup-key completion-initialize run-hooks dynamic-completion-mode-hook dynamic-completion-mode-on-hook dynamic-completion-mode-off-hook called-interactively-p any customize-mark-as-set message "Dynamic-Completion mode %sabled%s" "en" "dis" "" force-mode-line-update] 10 (#$ . 37797) (byte-code "\203\n\301!\202\302C\207" [current-prefix-arg prefix-numeric-value toggle] 2)])
(defvar dynamic-completion-mode-hook nil)
(byte-code "\301\302N\204\f\303\301\302\304#\210\303\301\305\306#\210\303\301\307\310C#\210\311\312\310\313\300!\205#\310\211%\210\314\315\316\"\210\314\317\316\"\210\314\320\316\"\210\314\321\322\"\210\314\323\316\"\210\314\324\316\"\210\314\325\326\"\210\314\327\326\"\210\314\330\326\"\210\314\331\326\"\210\314\332\326\"\210\314\333\326\"\210\314\334\326\"\210\314\335\326\"\210\314\336\326\"\210\314\337\340\"\210\314\341\340\"\210\314\342\340\"\210\314\343\344\"\210\314\345\344\"\210\346\347\350\"\210\351\352!\207" [dynamic-completion-mode-map dynamic-completion-mode-hook variable-documentation put "Hook run after entering or leaving `dynamic-completion-mode'.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it.  (This is true for all hook variables.)" custom-type hook standard-value nil add-minor-mode dynamic-completion-mode boundp completion-def-wrapper newline :separator newline-and-indent comint-send-input exit-minibuffer :minibuffer-separator eval-print-last-sexp eval-last-sexp next-line :under-or-before previous-line beginning-of-buffer end-of-buffer beginning-of-line end-of-line forward-char forward-word forward-sexp backward-char :backward-under backward-word backward-sexp delete-backward-char :backward delete-backward-char-untabify defalias initialize-completions completion-initialize provide completion] 6)