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



#@682 Return the boundaries of text on which COLLECTION will operate.
STRING is the string on which completion will be performed.
SUFFIX is the string after point.
If COLLECTION is a function, it is called with 3 arguments: STRING,
PRED, and a cons cell of the form (boundaries . SUFFIX).

The result is of the form (START . END) where START is the position
in STRING of the beginning of the completion field and END is the position
in SUFFIX of the end of the completion field.
E.g. for simple completion tables, the result is always (0 . (length SUFFIX))
and for file names the result is the positions delimited by
the closest directory separators.

(fn STRING COLLECTION PRED SUFFIX)
(defalias 'completion-boundaries #[1028 "\300!\205
\301B#\211\242\301=\204\302\262
\211A@\206\303
AA\206&GB\207" [functionp boundaries nil 0] 9 (#$ . 85)])
#@1644 Return the metadata of elements to complete at the end of STRING.
This metadata is an alist.  Currently understood keys are:
- `category': the kind of objects returned by `all-completions'.
   Used by `completion-category-overrides'.
- `annotation-function': function to add annotations in *Completions*.
   Takes one argument (STRING), which is a possible completion and
   returns a string to append to STRING.
- `affixation-function': function to prepend/append a prefix/suffix to
   entries.  Takes one argument (COMPLETIONS) and should return a list
   of annotated completions.  The elements of the list must be
   three-element lists: completion, its prefix and suffix.  This
   function takes priority over `annotation-function' when both are
   provided, so only this function is used.
- `group-function': function for grouping the completion candidates.
   Takes two arguments: a completion candidate (COMPLETION) and a
   boolean flag (TRANSFORM).  If TRANSFORM is nil, the function
   returns the group title of the group to which the candidate
   belongs.  The returned title may be nil.  Otherwise the function
   returns the transformed candidate.  The transformation can remove a
   redundant prefix, which is displayed in the group title.
- `display-sort-function': function to sort entries in *Completions*.
   Takes one argument (COMPLETIONS) and should return a new list
   of completions.  Can operate destructively.
- `cycle-sort-function': function to sort entries when cycling.
   Works like `display-sort-function'.
The metadata of a completion table should be constant between two boundaries.

(fn STRING TABLE PRED)
(defalias 'completion-metadata #[771 "\300!\205
\301#\301
\242\301=\205
AB\207" [functionp metadata] 7 (#$ . 942)])
#@20 

(fn FIELD-START)
(defalias 'completion--field-metadata #[257 "\302\303`\"	#\207" [minibuffer-completion-table minibuffer-completion-predicate completion-metadata buffer-substring-no-properties] 5 (#$ . 2714)])
#@22 

(fn METADATA PROP)
(defalias 'completion-metadata-get #[514 "\211\236A\207" [] 4 (#$ . 2934)])
#@114 Apply FUN to each element of XS in turn.
Return the first non-nil returned value.
Like CL's `some'.

(fn FUN XS)
(defalias 'completion--some #[514 "\300\211\211\204,\203,\3011\211A\262\242!\211\2620\210\202?\205'\211\211\262\266\202\211\206:
\205:\302@A\"\207" [nil (debug error) signal] 7 (#$ . 3039)])
#@517 Perform completion according to ACTION.
STRING, COLLECTION and PREDICATE are used as in `try-completion'.

If COLLECTION is a function, it will be called directly to
perform completion, no matter what ACTION is.

If ACTION is `metadata' or a list where the first element is
`boundaries', return nil.  If ACTION is nil, this function works
like `try-completion'; if it is t, this function works like
`all-completion'; and any other value makes it work like
`test-completion'.

(fn ACTION COLLECTION STRING PREDICATE)
(defalias 'complete-with-action #[1028 "\300!\203
#\207\242\301=\203\302\207\303=\203\302\207\304\267\202,\305\202-\306\202-\307#\207" [functionp boundaries nil metadata #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (nil 36 t 40)) try-completion all-completions test-completion] 8 (#$ . 3371)])
#@1017 Use function FUN as a dynamic completion table.
FUN is called with one argument, the string for which completion is requested,
and it should return a completion table containing all the intended possible
completions.
This table is allowed to include elements that do not actually match the
string: they will be automatically filtered out.
The completion table returned by FUN can use any of the usual formats of
completion tables such as lists, alists, and hash-tables.

If SWITCH-BUFFER is non-nil and completion is performed in the
minibuffer, FUN will be called in the buffer from which the minibuffer
was entered.

The result of the `completion-table-dynamic' form is a function
that can be used as the COLLECTION argument to `try-completion' and
`all-completions'.  See Info node `(elisp)Programmed Completion'.
The completion table returned by `completion-table-dynamic' has empty
metadata and trivial boundaries.

See also the related function `completion-table-with-cache'.

(fn FUN &optional SWITCH-BUFFER)
(defalias 'completion-table-dynamic #[513 "\300\301#\207" [make-closure #[771 "\211\242\302=\206\n\211\303=?\2053r\301\204p\202(\304 \305
!\203%\306
!\202&p\262
q\210\307
\300!$)\207" [V0 V1 boundaries metadata minibuffer-selected-window window-live-p window-buffer complete-with-action] 8 "\n\n(fn STRING PRED ACTION)"]] 6 (#$ . 4249)])
#@498 Create dynamic completion table from function FUN, with cache.
This is a wrapper for `completion-table-dynamic' that saves the last
argument-result pair from FUN, so that several lookups with the
same argument (or with an argument that starts with the first one)
only need to call FUN once.  This can be useful when FUN performs a
relatively slow operation, such as calling an external process.

When IGNORE-CASE is non-nil, FUN is expected to be case-insensitive.

(fn FUN &optional IGNORE-CASE)
(defalias 'completion-table-with-cache #[513 "\300C\300C\301\302%\303
!\207" [nil make-closure #[257 "\302\242\203\304\302\242\301#\203\303\242\207\303\300!\240\302\240\210\207" [V0 V1 V2 V3 string-prefix-p] 5 "\n\n(fn ARG)"] completion-table-dynamic] 10 (#$ . 5622)])
#@565 Initialize variable VAR as a lazy completion table.
If the completion table VAR is used for the first time (e.g., by passing VAR
as an argument to `try-completion'), the function FUN is called with no
arguments.  FUN must return the completion table that will be stored in VAR.
If completion is requested in the minibuffer, FUN will be called in the buffer
from which the minibuffer was entered.  The return value of
`lazy-completion-table' must be used to initialize the value of VAR.

You should give VAR a non-nil `risky-local-variable' property.

(fn VAR FUN)
(defalias 'lazy-completion-table '(macro . #[514 "\300\301!\302\303C\304\305D\306\307\310\nDDEEF\311BB\207" [make-symbol "string" completion-table-dynamic lambda when functionp setq funcall function ('do-switch-buffer)] 13 (#$ . 6406)]))
(put 'lazy-completion-table 'edebug-form-spec '(symbolp lambda-expr))
#@170 Return new completion TABLE that is case insensitive.
If DONT-FOLD is non-nil, return a completion table that is
case sensitive instead.

(fn TABLE &optional DONT-FOLD)
(defalias 'completion-table-case-fold #[513 "\300\301#\207" [make-closure #[771 "\301?\303
\300$)\207" [V0 V1 completion-ignore-case complete-with-action] 8 "\n\n(fn STRING PRED ACTION)"]] 6 (#$ . 7293)])
#@233 Return a completion table from TABLE with S1 replaced by S2.
The result is a completion table which completes strings of the
form (concat S1 S) in the same way as TABLE completes strings of
the form (concat S2 S).

(fn TABLE S1 S2)
(defalias 'completion-table-subvert #[771 "\300\301$\207" [make-closure #[771 "\304\301#\205\302\301G\305OP\211\205\306\300$\211\204%\242\307=\205\230\242\307=\203V\211\242\307=\2039\211A@\206:\310\307G\301G\301G\302GZ\\]^\242\307=\205SAABB\207\211;\203k\304\302#\205\230\301
\302G\305OP\207\311=\203\227\312\300\313$\211@\302GY\203\202
\207\314\315\302@\305O!P\316\305\317\320\321\"\"\"\207\211\207" [V0 V1 V2 completion-ignore-case string-prefix-p nil complete-with-action boundaries 0 t completion-boundaries "" "\\`" regexp-quote delq mapcar make-closure #[257 "\301\300\"\205\f\211\302\225\303O\207" [V0 string-match 0 nil] 4 "\n\n(fn C)"]] 13 "\n\n(fn STRING PRED ACTION)"]] 8 (#$ . 7679)])
#@40 

(fn PREFIX TABLE STRING PRED ACTION)
(defalias 'completion-table-with-context #[1285 "\300!\204\n
\202=\301!\203\302\303#\202=\304!\203(\302\305#\202=\300!\2037\302\306#\202=\302\307#
\242\310=\203YG\311A$\310
@\\ABB\207\312$\211;\203k
P\207\207" [functionp vectorp make-closure #[257 "\301\300\302!P!\207" [V0 V1 symbol-name] 5 "\n\n(fn SYM)"] hash-table-p #[514 "\301\300P!\207" [V0 V1] 5 "\n\n(fn S V)"] #[257 "\301\300P!\207" [V0 V1] 4 "\n\n(fn S)"] #[257 "\301\300:\203\f@\202
P!\207" [V0 V1] 4 "\n\n(fn S)"] boundaries completion-boundaries complete-with-action] 12 (#$ . 8657)])
#@866 Construct a completion table like TABLE but with an extra TERMINATOR.
This is meant to be called in a curried way by first passing TERMINATOR
and TABLE only (via `apply-partially').
TABLE is a completion table, and TERMINATOR is a string appended to TABLE's
completion if it is complete.  TERMINATOR is also used to determine the
completion suffix's boundary.
TERMINATOR can also be a cons cell (TERMINATOR . TERMINATOR-REGEXP)
in which case TERMINATOR-REGEXP is a regular expression whose submatch
number 1 should match TERMINATOR.  This is used when there is a need to
distinguish occurrences of the TERMINATOR strings which are really terminators
from others (e.g. escaped).  In this form, the car of TERMINATOR can also be,
instead of a string, a function that takes the completion and returns the
"terminated" string.

(fn TERMINATOR TABLE STRING PRED ACTION)
(defalias 'completion-table-with-terminator #[1285 "\211\242\300=\2038\211A\301$:\203A\202 \302!\211\205(\303
\"\300@A\2064G^BB\207\211\304\267\202\235\305#:\203L@\262\211\306=\203b\307!\203]!\207P\207\211;\203\232\211G\310U\204\232\301
\311$\211@GW\262
\203\232\305
#\306=\203\232\307!\203\225
!\207\211P\207\207\312\207\313
$\207" [boundaries completion-boundaries regexp-quote string-match #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (nil 62 lambda 155)) try-completion t functionp 0 "" nil complete-with-action] 13 (#$ . 9304)])
#@636 Make a completion table equivalent to TABLE but filtered through PRED1.
PRED1 is a function of one argument which returns non-nil if and
only if the argument is an element of TABLE which should be
considered for completion.  STRING, PRED2, and ACTION are the
usual arguments to completion tables, as described in
`try-completion', `all-completions', and `test-completion'.  If
STRICT is non-nil, the predicate always applies; if nil it only
applies if it does not reduce the set of possible completions to
nothing.  Note: TABLE needs to be a proper completion table which
obeys predicates.

(fn TABLE PRED1 STRICT STRING PRED2 ACTION)
(defalias 'completion-table-with-predicate #[1542 "\204\211\300=\203\301#\207\302
\203\204(\206/\202/\303\304\n#$\206C?\205C\205C\302
$\207" [lambda test-completion complete-with-action make-closure #[257 "\300
!\205	\301
!\207" [V0 V1] 3 "\n\n(fn X)"]] 14 (#$ . 10810)])
#@87 Create a completion table that tries each table in TABLES in turn.

(fn &rest TABLES)
(defalias 'completion-table-in-turn #[128 "\300\301\"\207" [make-closure #[771 "\301\302\303$\300\"\207" [V0 completion--some make-closure #[257 "\303\302\300\301$\207" [V0 V1 V2 complete-with-action] 6 "\n\n(fn TABLE)"]] 9 "\n\n(fn STRING PRED ACTION)"]] 4 (#$ . 11759)])
#@89 Create a completion table that collects completions from all TABLES.

(fn &rest TABLES)
(defalias 'completion-table-merge #[128 "\300\301\"\207" [make-closure #[771 "\211\301\267\2025\302\303\304#\300\"
\235\203\207\305\302\303\306\"\307\310\"\"#\207\311\312\302\303\313#\300\"\"\207\314\303\315$\300\"\207" [V0 #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (nil 6 t 39)) mapcar make-closure #[257 "\302\300\301#\207" [V0 V1 try-completion] 5 "\n\n(fn TABLE)"] try-completion #[257 "\211\301=\203\300\207\207" [V0 t] 3 "\n\n(fn VALUE)"] delq nil apply append #[257 "\302\300\301#\207" [V0 V1 all-completions] 5 "\n\n(fn TABLE)"] completion--some #[257 "\303\302\300\301$\207" [V0 V1 V2 complete-with-action] 6 "\n\n(fn TABLE)"]] 11 "\n\n(fn STRING PRED ACTION)"]] 4 (#$ . 12129)])
#@635 Return a new completion table operating on quoted text.
TABLE operates on the unquoted text.
UNQUOTE is a function that takes a string and returns a new unquoted string.
REQUOTE is a function of 2 args (UPOS QSTR) where
  QSTR is a string entered by the user (and hence indicating
  the user's preferred form of quoting); and
  UPOS is a position within the unquoted form of QSTR.
REQUOTE should return a pair (QPOS . QFUN) such that QPOS is the
position corresponding to UPOS but in QSTR, and QFUN is a function
of one argument (a string) which returns that argument appropriately quoted
for use at QPOS.

(fn TABLE UNQUOTE REQUOTE)
(defalias 'completion-table-with-quoting #[771 "\300\301$\207" [make-closure #[771 "\211\303\267\202\304\305\300#\306\"\207\301!\307
\300#\207\211\242\310=\203x\301!
A\211G\311U\203/
\2024\301P!\312\"\203C\211G\313O\202D
\314\300$\302
@	\"@
A\311U\203]\311\202r
AG\\\302
P\"@\nGZ\262
\310BB\207\211\315\267\202
\301!\316
\300#\211;\204\214\207\317\311\301\302&@\207\301!\320
\300#\314\300\321$@\322\301\302&\323
!\211:\203\275\211\313\241\210
\207\301!\301\311O!\312
\"\203\324\211G\202\372\301\313O!\324
\"\203\351G
GZ\202\370
GG^GGZ\311]\\\325\245\262
\300\326\327\301\302\f\n%F\207\211\242\310=\205i
\301!
A\211G\311U\203

\202$
\301P!\312\"\2033
\211G\313O\2024

\314\300$\302
@	\"@
A\311U\203M
\311\202b

AG\\\302
P\"@\nGZ\262
\310BB\266\207\207" [V0 V1 V2 #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (metadata 6 lambda 15)) append completion-metadata ((completion--unquote-requote . t)) test-completion boundaries 0 string-prefix-p nil completion-boundaries #s(hash-table size 3 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (nil 126 t 151 completion--unquote 191)) try-completion completion--twq-try all-completions "" completion--twq-all last string-suffix-p 2 make-closure #[514 "\211\304\267\2026
\242;\204
\207\305\302\303@A\300\301&\207\306!\211A\206#\307
\2055
\310\241\210\311\302\303\300\301&\207\310\207" [V0 V1 V2 V3 #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (1 6 2 26)) completion--twq-try last 0 nil completion--twq-all] 11 "\n\n(fn UNQUOTED-RESULT OP)"]] 15 "\n\n(fn STRING PRED ACTION)"]] 8 (#$ . 12982)])
#@56 

(fn STRING USTRING COMPLETION POINT UNQUOTE REQUOTE)
(defalias 'completion--twq-try #[1542 "\300\"G]\301OG	\"\211\242
\243GV\205'\211	G\nO!
!\f\302OQ\n\302U\203=\302\202U\nGV\203MG\\\202U\"@\n!
\232\203c

B\207
!\211
GB\207" [fill-common-string-prefix nil 0] 18 (#$ . 15360)])
#@14 

(fn S1 S2)
(defalias 'completion--string-equal-p #[514 "\300\301\211\301\211\302&\303=\207" [compare-strings nil ignore-case t] 10 (#$ . 15688)])
#@60 

(fn STRING USTRING COMPLETIONS BOUNDARY UNQUOTE REQUOTE)
(defalias 'completion--twq-all #[1542 "\205U\301\302\303\301OB\")
G\\\"\211\242
\243\211\n\304O	
\"@\211X\2046\305\306!\210\301\307\301O\310\311#\312\313\314$\"\244\262
\266\203\262
\266\204\207" [completion-regexp-list nil try-completion "" 0 cl--assertion-failed (<= qboundary qfullpos) propertize face completions-common-part mapcar make-closure #[257 "\304\300\305#\204\306\307\310\300D\310$\210\211\300G\310O\301
!\204!\302\202=\311\300GO\301
!\312\302\"\203:\313
\314\315#\266\202\202=\266\302\211P\207" [V0 V1 V2 completion-ignore-case string-prefix-p ignore-case cl--assertion-failed (string-prefix-p prefix completion 'ignore-case) nil 0 completion--string-equal-p propertize face completions-common-part] 9 "\n\n(fn COMPLETION)"]] 21 (#$ . 15845)])
(custom-declare-group 'minibuffer nil "Controlling the behavior of the minibuffer." :link '(custom-manual "(emacs)Minibuffer") :group 'environment)
#@66 Text properties added to the text shown by `minibuffer-message'.
(defvar minibuffer-message-properties nil (#$ . 16860))
#@330 Temporarily display MESSAGE at the end of the minibuffer.
The text is displayed for `minibuffer-message-timeout' seconds,
or until the next input event arrives, whichever comes first.
Enclose MESSAGE in [...] if this is not yet the case.
If ARGS are provided, then pass MESSAGE through `format-message'.

(fn MESSAGE &rest ARGS)
(defalias 'minibuffer-message #[385 "\304p\305\"\204%\211\203\306\307#\210\202\307\310\"\210\311\206\312!\307\313!\210\207\307\313!\210\211\204C\314\313\305\315#)\266\203\203C\316!\202G\317\320Q\262\211\203T\306\321#\262\n\203f\322\323\"\204f\306\324\n#\262\325 \326
\211\313\305\211%\305\327\330\"\216G\323U\204\206\331\323\332\333\305%\210\334
\335#\210\334
\336\337#\210\311\206\231\312!*\207" [minibuffer-message-timeout inhibit-changing-match-data minibuffer-message-properties inhibit-quit minibufferp t apply message "%s" sit-for 1000000 nil "\\` *\\[.+\\]\\'" string-match copy-sequence " [" "]" format-message text-properties-at 0 propertize minibuffer--message-overlay-pos make-overlay make-closure #[0 "\301\300!\207" [V0 delete-overlay] 2] put-text-property 1 cursor overlay-put after-string priority 1100] 10 (#$ . 16988)])
(byte-code "\300\301\302\303\304DD\305\306\307\310\311&\207" [custom-declare-variable minibuffer-message-clear-timeout funcall function #[0 "\300\207" [nil] 1 ""] "How long to display an echo-area message when the minibuffer is active.\nIf the value is a number, it is the time in seconds after which to\nremove the echo-area message from the active minibuffer.\nIf the value is not a number, such messages are never removed,\nand their text is displayed until the next input event arrives.\nUnlike `minibuffer-message-timeout' used by `minibuffer-message',\nthis option affects the pair of functions `set-minibuffer-message'\nand `clear-minibuffer-message' called automatically via\n`set-message-function' and `clear-message-function'." :type (choice (const :tag "Never time out" nil) (integer :tag "Wait for the number of seconds" 2)) :version "27.1"] 8)
(defvar minibuffer-message-timer nil)
(defvar minibuffer-message-overlay nil)
#@171 Return position where minibuffer message functions shall put message overlay.
The minibuffer message functions include `minibuffer-message' and
`set-minibuffer-message'.
(defalias 'minibuffer--message-overlay-pos #[0 "`\300
\301\"\211\203
\207\302\301\303d$\207" [get-text-property minibuffer-message next-single-property-change nil] 7 (#$ . 19138)])
#@506 Temporarily display MESSAGE at the end of the minibuffer.
If some part of the minibuffer text has the `minibuffer-message' property,
the message will be displayed before the first such character, instead of
at the end of the minibuffer.
The text is displayed for `minibuffer-message-clear-timeout' seconds
(if the value is a number), or until the next input event arrives,
whichever comes first.
Unlike `minibuffer-message', this function is called automatically
via `set-message-function'.

(fn MESSAGE)
(defalias 'set-minibuffer-message #[257 "\306 \307
!\205\310
!?\205\221\307!\205\221\310 
=\204&\311
\312\"\313=\205\221r\314!q\210\315\316\317\320#)\266\203\203B\321!\202F\322\323Q\262\n\203Z\324\325\"\204Z\326\327\n#\262\330 \210\331 \332
\211\316\317\211%\210G\325U\204x\333\325\334\335\317%\210\336\337#\210\336\340\341#\210\f\247\203\217\342\f\316\330#)\317\207" [noninteractive inhibit-changing-match-data minibuffer-message-properties minibuffer-message-overlay minibuffer-message-clear-timeout minibuffer-message-timer active-minibuffer-window window-live-p window-frame frame-parameter minibuffer only window-buffer "\\` *\\[.+\\]\\'" nil t string-match copy-sequence " [" "]" text-properties-at 0 apply propertize clear-minibuffer-message minibuffer--message-overlay-pos make-overlay put-text-property 1 cursor overlay-put after-string priority 1100 run-with-timer] 10 (#$ . 19499)])
(byte-code "\301\211\207" [set-message-function set-minibuffer-message] 2)
#@79 Clear minibuffer message.
Intended to be called via `clear-message-function'.
(defalias 'clear-minibuffer-message #[0 "?\205\303	!\203\304	!\210\305\306\n!\205\307\n!\210\305\211\207" [noninteractive minibuffer-message-timer minibuffer-message-overlay timerp cancel-timer nil overlayp delete-overlay] 2 (#$ . 21014)])
(byte-code "\301\211\207" [clear-message-function clear-minibuffer-message] 2)
#@200 Return the user input in a minibuffer before point as a string.
In Emacs 22, that was what completion commands operated on.
If the current buffer is not a minibuffer, return everything before point.
(defalias 'minibuffer-completion-contents #[0 "\300 `{\207" [minibuffer-prompt-end] 2 (#$ . 21428)])
(make-obsolete 'minibuffer-completion-contents nil "24.4")
#@110 Delete all user input in a minibuffer.
If the current buffer is not a minibuffer, erase its entire contents.
(defalias 'delete-minibuffer-contents #[0 "\300 d|\207" [minibuffer-prompt-end] 2 (#$ . 21794) nil])
(defalias 'minibuffer--completion-prompt-end #[0 "\300 `
W\203\f\301\302!\207\207" [minibuffer-prompt-end user-error "Can't complete in prompt"] 3])
#@62 If non-nil, print helpful inline messages during completion.
(defvar completion-show-inline-help t (#$ . 22160))
(byte-code "\300\301\302\303\304DD\305\306\307%\207" [custom-declare-variable completion-auto-help funcall function #[0 "\300\207" [t] 1 ""] "Non-nil means automatically provide help for invalid completion input.\nIf the value is t the *Completions* buffer is displayed whenever completion\nis requested but cannot be done.\nIf the value is `lazy', the *Completions* buffer is only displayed after\nthe second failed attempt to complete." :type (choice (const nil) (const t) (const lazy))] 6)
#@501 List of available completion styles.
Each element has the form (NAME TRY-COMPLETION ALL-COMPLETIONS DOC):
where NAME is the name that should be used in `completion-styles',
TRY-COMPLETION is the function that does the completion (it should
follow the same calling convention as `completion-try-completion'),
ALL-COMPLETIONS is the function that lists the completions (it should
follow the calling convention of `completion-all-completions'),
and DOC describes the way this style of completion works.
(defconst completion-styles-alist '((emacs21 completion-emacs21-try-completion completion-emacs21-all-completions "Simple prefix-based completion.\nI.e. when completing \"foo_bar\" (where _ is the position of point),\nit will consider all completions candidates matching the glob\npattern \"foobar*\".") (emacs22 completion-emacs22-try-completion completion-emacs22-all-completions "Prefix completion that only operates on the text before point.\nI.e. when completing \"foo_bar\" (where _ is the position of point),\nit will consider all completions candidates matching the glob\npattern \"foo*\" and will add back \"bar\" to the end of it.") (basic completion-basic-try-completion completion-basic-all-completions "Completion of the prefix before point and the suffix after point.\nI.e. when completing \"foo_bar\" (where _ is the position of point),\nit will consider all completions candidates matching the glob\npattern \"foo*bar*\".") (partial-completion completion-pcm-try-completion completion-pcm-all-completions "Completion of multiple words, each one taken as a prefix.\nI.e. when completing \"l-co_h\" (where _ is the position of point),\nit will consider all completions candidates matching the glob\npattern \"l*-co*h*\".\nFurthermore, for completions that are done step by step in subfields,\nthe method is applied to all the preceding fields that do not yet match.\nE.g. C-x C-f /u/mo/s TAB could complete to /usr/monnier/src.\nAdditionally the user can use the char \"*\" as a glob pattern.") (substring completion-substring-try-completion completion-substring-all-completions "Completion of the string taken as a substring.\nI.e. when completing \"foo_bar\" (where _ is the position of point),\nit will consider all completions candidates matching the glob\npattern \"*foo*bar*\".") (flex completion-flex-try-completion completion-flex-all-completions "Completion of an in-order subset of characters.\nWhen completing \"foo\" the glob \"*f*o*o*\" is used, so that\n\"foo\" can complete to \"frodo\".") (initials completion-initials-try-completion completion-initials-all-completions "Completion of acronyms and initialisms.\nE.g. can complete M-x lch to list-command-history\nand C-x C-f ~/sew to ~/src/emacs/work.") (shorthand completion-shorthand-try-completion completion-shorthand-all-completions "Completion of symbol shorthands setup in `read-symbol-shorthands'.\nE.g. can complete \"x-foo\" to \"xavier-foo\" if the shorthand\n((\"x-\" . \"xavier-\")) is set up in the buffer of origin.")) (#$ . 22773))
(defconst completion--styles-type (byte-code "\301\302\303\304\305\306\"BF\207" [completion-styles-alist repeat :tag "insert a new menu to add more styles" choice mapcar #[257 "\300
@D\207" [const] 3 "\n\n(fn X)"]] 7))
(defconst completion--cycling-threshold-type '(choice (const :tag "No cycling" nil) (const :tag "Always cycle" t) (integer :tag "Threshold")))
(byte-code "\301\302\303\304\305DD\306\307\310\311&\207" [completion--styles-type custom-declare-variable completion-styles funcall function #[0 "\300\207" [(basic partial-completion emacs22)] 1 ""] "List of completion styles to use.\nThe available styles are listed in `completion-styles-alist'.\n\nNote that `completion-category-overrides' may override these\nstyles for specific categories, such as files, buffers, etc.\n\nNote that Tramp host name completion (e.g., \"/ssh:ho<TAB>\")\ncurrently doesn't work if this list doesn't contain at least one\nof `basic', `emacs22' or `emacs21'." :type :version "23.1"] 8)
#@420 Default settings for specific completion categories.
Each entry has the shape (CATEGORY . ALIST) where ALIST is
an association list that can specify properties such as:
- `styles': the list of `completion-styles' to use for that category.
- `cycle': the `completion-cycle-threshold' to use for that category.
Categories are symbols such as `buffer' and `file', used when
completing buffer and file names, respectively.
(defvar completion-category-defaults '((buffer (styles basic substring)) (unicode-name (styles basic substring)) (project-file (styles substring)) (xref-location (styles substring)) (info-menu (styles basic substring)) (symbol-help (styles basic shorthand substring))) (#$ . 26791))
(byte-code "\302\303\304\305\306DD\307\310\311\312\313\314\315\316\317\320\321\322\320\323\324\257\322\320\325\326	\257\257\257&\207" [completion--styles-type completion--cycling-threshold-type custom-declare-variable completion-category-overrides funcall function #[0 "\300\207" [nil] 1 ""] "List of category-specific user overrides for completion styles.\nEach override has the shape (CATEGORY . ALIST) where ALIST is\nan association list that can specify properties such as:\n- `styles': the list of `completion-styles' to use for that category.\n- `cycle': the `completion-cycle-threshold' to use for that category.\nCategories are symbols such as `buffer' and `file', used when\ncompleting buffer and file names, respectively.\nThis overrides the defaults specified in `completion-category-defaults'." :version "25.1" :type alist :key-type (choice :tag "Category" (const buffer) (const file) (const unicode-name) (const bookmark) symbol) :value-type set :tag "Properties to override" cons "Completion Styles" (const :tag "Select a style from the menu;" styles) "Completion Cycling" (const :tag "Select one value from the menu." cycle)] 20)
#@21 

(fn CATEGORY TAG)
(defalias 'completion--category-override #[514 "\211\236A\236\206\211	\236A\236\207" [completion-category-overrides completion-category-defaults] 5 (#$ . 28650)])
#@17 

(fn METADATA)
(defalias 'completion--styles #[257 "\301
\302\"\303
\304\"\211\203\305\306A\307!\"!\207\207" [completion-styles completion-metadata-get category completion--category-override styles delete-dups append copy-sequence] 8 (#$ . 28844)])
#@84 Call the Nth method of completion styles.

(fn N STRING TABLE PRED POINT METADATA)
(defalias 'completion--nth-completion #[1542 "CCC\206\300\242\301\242O\242#\302
\303\"\205\\\304\242!\205\\\242\242\242\305#
\211A\262\242\240\210
\211A\262\242\240\210
\211A\262\242\240\210\242\242GX\204T\306\307!\210\211
A\262\242\262
\310\311\312

	&\313!\"\211A\314N\211\203\205\203\205
	!A\241\210\203\220@\"\207
@\207" [completion-metadata 0 completion-metadata-get completion--unquote-requote functionp completion--unquote cl--assertion-failed (<= point (length string)) completion--some make-closure #[257 "\300

\2368\301\242\302\242\303\304\242$\211\205\211B\207" [V0 V1 V2 V3 V4 completion-styles-alist] 6 "\n\n(fn STYLE)"] completion--styles completion--adjust-metadata] 19 (#$ . 29105)])
#@459 Try to complete STRING using completion table TABLE.
Only the elements of table that satisfy predicate PRED are considered.
POINT is the position of point within STRING.
The return value can be either nil to indicate that there is no completion,
t to indicate that STRING is the only possible completion,
or a pair (NEWSTRING . NEWPOINT) of the completed result string together with
a new position for point.

(fn STRING TABLE PRED POINT &optional METADATA)
(defalias 'completion-try-completion #[1284 "\300\301&\207" [completion--nth-completion 1] 12 (#$ . 29948)])
#@325 List the possible completions of STRING in completion table TABLE.
Only the elements of table that satisfy predicate PRED are considered.
POINT is the position of point within STRING.
The return value is a list of completions and may contain the base-size
in the last `cdr'.

(fn STRING TABLE PRED POINT &optional METADATA)
(defalias 'completion-all-completions #[1284 "\300\301&\207" [completion--nth-completion 2] 12 (#$ . 30533)])
#@35 

(fn MODIFIED COMPLETIONS EXACT)
(defalias 'minibuffer--bitset #[771 "\300\203	\301\202\n\302\203\303\202\302\203\304\202\302#\207" [logior 4 0 2 1] 7 (#$ . 30984)])
#@121 Replace the buffer text between BEG and END with NEWTEXT.
Moves point to the end of the new text.

(fn BEG END NEWTEXT)
(defalias 'completion--replace #[771 "\203\301\302G\303$\210\202\304\302G\305$\210\302\211GW\2039
\\W\2039
\\fH=\2039\211T\262
\202\211\302U\204J
\\\262

\305O\262\210\302\211GW\203vZW\203v
Z\206b`Sf\211GZSH=\203v\211T\262
\202L\211\302U\204\210
Z\262
\302[O\262b\210Z\306!\210``\\|\266\211u\207" [minibuffer-allow-text-properties remove-text-properties 0 (face completion-score) set-text-properties nil insert-and-inherit] 8 (#$ . 31171)])
(byte-code "\301\302\303\304\305DD\306\307\310\311&\210\301\312\303\304\313DD\314\311\315\307\316&\210\301\317\303\304\320DD\321\311\322\307\316&\210\301\323\303\304\324DD\325\311\326\307\316&\210\327\330\331\332\307\316%\210\327\333\334\335\307\316%\207" [completion--cycling-threshold-type custom-declare-variable completion-cycle-threshold funcall function #[0 "\300\207" [nil] 1 #1=""] "Number of completion candidates below which cycling is used.\nDepending on this setting `completion-in-region' may use cycling,\nwhereby invoking a completion command several times in a row\ncompletes to each of the candidates in turn, in a cyclic manner.\nIf nil, cycling is never used.\nIf t, cycling is always used.\nIf an integer, cycling is used so long as there are not more\ncompletion candidates than this number." :version "24.1" :type completions-group #[0 "\300\207" [nil] 1 #1#] "Enable grouping of completion candidates in the *Completions* buffer.\nSee also `completions-group-format' and `completions-group-sort'." boolean "28.1" completions-group-sort #[0 "\300\207" [nil] 1 #1#] "Sort groups in the *Completions* buffer.\n\nThe value can either be nil to disable sorting, `alphabetical' for\nalphabetical sorting or a custom sorting function.  The sorting\nfunction takes and returns an alist of groups, where each element is a\npair of a group title string and a list of group candidate strings." (choice (const :tag "No sorting" nil) (const :tag "Alphabetical sorting" alphabetical) function) completions-group-format #[0 "\300\301\302\303#\300\304\302\305#\300\306\302\303\307\310%Q\207" [propertize "    " face completions-group-separator " %s " completions-group-title " " display (space :align-to right)] 8 #1#] "Format string used for the group title." string custom-declare-face completions-group-title ((t :inherit shadow :slant italic)) "Face used for the title text of the candidate group headlines." completions-group-separator ((t :inherit shadow :strike-through t)) "Face used for the separator lines between the candidate groups."] 8)
#@17 

(fn METADATA)
(defalias 'completion--cycle-threshold #[257 "\301
\302\"\303
\304\"\211\203\211A\207\207" [completion-cycle-threshold completion-metadata-get category completion--category-override cycle] 5 (#$ . 33848)])
(defvar completion-all-sorted-completions nil nil)
(make-variable-buffer-local 'completion-all-sorted-completions)
(defvar completion--all-sorted-completions-location nil nil)
(make-variable-buffer-local 'completion--all-sorted-completions-location)
(defvar completion-cycling nil)
(defvar completion-tab-width nil)
#@49 If non-nil, stay quiet when there  is no match.
(defvar completion-fail-discreetly nil (#$ . 34395))
#@12 

(fn MSG)
(defalias 'completion--message #[257 "\205\301
!\207" [completion-show-inline-help minibuffer-message] 3 (#$ . 34502)])
#@735 Do the completion and return a summary of what happened.
M = completion was performed, the text was Modified.
C = there were available Completions.
E = after completion we now have an Exact match.

 MCE
 000  0 no possible completion
 001  1 was already an exact and unique completion
 010  2 no completion happened
 011  3 was already an exact completion
 100  4 ??? impossible
 101  5 ??? impossible
 110  6 some completion happened
 111  7 completed to an exact completion

TRY-COMPLETION-FUNCTION is a function to use in place of `try-completion'.
EXPECT-EXACT, if non-nil, means that there is no need to tell the user
when the buffer's text is already an exact match.

(fn BEG END &optional TRY-COMPLETION-FUNCTION EXPECT-EXACT)
(defalias 'completion--do-completion #[1026 "{\306!\206\307	`\nZ%\211\310\267\202F\311 \210\n\204(\312 \210\313\314!\210\315\316\211\211#\207\311 \210b\210\317\320?\205>\321#\210\315\316\211\322#\207\211A
@\323
\316\211\316\211\322&\322=?\323\316\211	\316\211\211&\322=\211\203p	b\210\202\324#\210\nG\\\262\nGZu\210\211\204\230
\204\230\325$\207\326	#\327!\211\205\300\203\272\330\331O	\332$@W\205\300\333

\"\334 \210\211A:\203\362\3351\325

\233:0\202\327\210\316\204\362\322\262\322\262\336#\210\337\"\210\202V
\203
\311 \210\203V
\317GW\203

\340\202
\341\"\210\202V
\2048
\342=\203#
\f
=\202$
\2031
\343\"\210\202V
\313\344!\210\202V
\f
=\203I
\203I
\343\"\210\317\340
?\205T
\345#\210\315\322#\207" [minibuffer-completion-table minibuffer-completion-predicate completion-fail-discreetly completion-auto-help this-command last-command completion--field-metadata completion-try-completion #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (nil 26 t 46)) minibuffer-hide-completions ding completion--message "No match" minibuffer--bitset nil completion--done finished "Sole completion" t compare-strings completion--replace completion--do-completion test-completion completion--cycle-threshold completion-boundaries 0 "" completion-all-sorted-completions completion--flush-all-sorted-completions (error) completion--cache-all-sorted-completions minibuffer-force-complete exact unknown lazy minibuffer-completion-help "Next char not unique" "Complete, but not unique"] 18 (#$ . 34643)])
#@283 Complete the minibuffer contents as far as possible.
Return nil if there is no valid completion, else t.
If no characters can be completed, display a list of possible completions.
If you repeat this command after it displayed such a list,
scroll the window of possible completions.
(defalias 'minibuffer-complete #[0 "\302\303 d	$\207" [minibuffer-completion-table minibuffer-completion-predicate completion-in-region minibuffer--completion-prompt-end] 5 (#$ . 37012) nil])
#@16 

(fn BEG END)
(defalias 'completion--in-region-1 #[514 "\305	\305=\204
\306 \210\307\310\n!\203K\311\312\n!!\313=\203K\nr\314
!q\210\315d\"\2034\316
e\307#\210\202H\317
!r\320\321\"\216\322
@\323\"\210\324 \210*\210)\307\207\203Z\f\203Z\325\"\210\313\207\326\"\211\327=?\205f\313\207" [this-command last-command minibuffer-scroll-window completion-cycling completion-all-sorted-completions completion-at-point completion--flush-all-sorted-completions nil window-live-p frame-visible-p window-frame t window-buffer pos-visible-in-window-p set-window-start internal--before-with-selected-window make-closure #[0 "\301\300!\207" [V0 internal--after-with-selected-window] 2] select-window norecord scroll-up minibuffer-force-complete completion--do-completion 0] 7 (#$ . 37493)])
#@22 

(fn BEG END COMPS)
(defalias 'completion--cache-all-sorted-completions #[771 "\302\303\304\305\306$\210\307!\307!B\211\211\207" [completion--all-sorted-completions-location completion-all-sorted-completions add-hook after-change-functions completion--flush-all-sorted-completions nil t copy-marker] 8 (#$ . 38293)])
#@32 

(fn &optional START END LEN)
(defalias 'completion--flush-all-sorted-completions #[768 "\205
\205AV\206
@W?\205)\303\304\305\306#\210	\203&	\307 \210\307\211\207" [completion--all-sorted-completions-location completion-cycling completion-all-sorted-completions remove-hook after-change-functions completion--flush-all-sorted-completions t nil] 7 (#$ . 38621)])
#@43 

(fn STRING BASE MD-AT-POINT TABLE PRED)
(defalias 'completion--metadata #[1285 "\300\301$\211@=\203\207\302\303O#\207" [completion-boundaries "" completion-metadata 0] 10 (#$ . 39004)])
#@147 Return ELEMS sorted by increasing value of their KEYFUN.
KEYFUN takes an element of ELEMS and should return a numerical value.

(fn ELEMS KEYFUN)
(defalias 'minibuffer--sort-by-key #[514 "\300\301\302\300\303\304\"\"\305\"\"\207" [mapcar cdr sort make-closure #[257 "\300
!
B\207" [V0] 3 "\n\n(fn X)"] car-less-than-car] 9 (#$ . 39212)])
#@56 Sort ELEMS by their position in HIST.

(fn HIST ELEMS)
(defalias 'minibuffer--sort-by-position #[514 "\300\301\302\303G$\304\211\203(\211@\305
\"\204\306
#\210T\262
A\266\202\202	\210\307\310\311\"\"\207" [make-hash-table :test equal :size 0 gethash puthash minibuffer--sort-by-key make-closure #[257 "\302
\300	#\207" [V0 most-positive-fixnum gethash] 5 "\n\n(fn X)"]] 10 (#$ . 39560)])
#@62 Sort ELEMS first by length, then alphabetically.

(fn ELEMS)
(defalias 'minibuffer--sort-by-length-alpha #[257 "\300
\301\"\207" [sort #[514 "
G
GW\206
G
GU\205

\231\207" [] 4 "\n\n(fn C1 C2)"]] 4 (#$ . 39968)])
#@92 Preprocess history.
Remove completion BASE prefix string from history elements.

(fn BASE)
(defalias 'minibuffer--sort-preprocess-history #[257 ";\203	\202\242	\302=?\205	JG\203 B\202!
\262\211\303U\203+
\207\304\305\306\307\310#\"\"\207" [minibuffer-default minibuffer-history-variable t 0 delq nil mapcar make-closure #[257 "\302\300\"\205\211\301\303O\207" [V0 V1 string-prefix-p nil] 4 "\n\n(fn C)"]] 11 (#$ . 40191)])
#@86 Group ELEMS by GROUP-FUN and sort groups by SORT-FUN.

(fn GROUP-FUN SORT-FUN ELEMS)
(defalias 'minibuffer--group-by #[771 "\300
\211\203/\211@
\300\"\301
\"\211\203\211AB\241\266\202(
DB\262\266
A\266\202\202\210\211\237\262
\302\303\"\262

!\262
\304\305\"\207" [nil assoc mapc #[257 "\211
A\237\241\207" [] 3 "\n\n(fn X)"] mapcan cdr] 11 (#$ . 40644)])
#@28 

(fn &optional START END)
(defalias 'completion-all-sorted-completions #[512 "\206\213
\206\n\304 
\206d

{\305!\306	\n`Z%\307
!\211A\206(\310\311\312`\"	\n%\313
\314\"\313\315\"\205\211\316\241\210\317!\262\307!\262
\203]
!\262\202~\203e\211\204~\320!\262\321 \203~\322\323	\310O!\"\262\324\n\n\244#\266\212\207" [completion-all-sorted-completions minibuffer-completion-table minibuffer-completion-predicate completions-group minibuffer-prompt-end completion--field-metadata completion-all-completions last 0 completion--metadata buffer-substring-no-properties completion-metadata-get cycle-sort-function group-function nil delete-dups minibuffer--sort-by-length-alpha minibufferp minibuffer--sort-by-position minibuffer--sort-preprocess-history completion--cache-all-sorted-completions] 17 (#$ . 41024)])
#@61 Complete the minibuffer with first of the matches and exit.
(defalias 'minibuffer-force-complete-and-exit #[0 "\204\n\301\302\211\303#\210\304\305 d\306\307$\207" [completion-cycling minibuffer-force-complete nil dont-cycle completion--complete-and-exit minibuffer--completion-prompt-end exit-minibuffer #[0 "\203\301\302!\207\303 \207" [minibuffer--require-match completion--message "Incomplete" exit-minibuffer] 2]] 5 (#$ . 41888) nil])
#@186 Complete the minibuffer to an exact match.
Repeated uses step through the possible completions.
DONT-CYCLE tells the function not to setup cycling.

(fn &optional START END DONT-CYCLE)
(defalias 'minibuffer-force-complete #[768 "\306\307\206	\310 !\206d\311\"\312!A\206\313\\
:\204.\314\203+\315\202,\316!\207
A:\204T
@\317\"\232\211\204F\320@#\210\321\317`\"\322\205R\323#\207\320
@#\210\211@G\\\262\321\317`\"\324\"\210\325?\205\251\312!\211@AB\241\210\326A#\266\n\f\327\330%\331\332 \333
\334#\210\333
\335
!#\210\211\262
!\211\266\204\207" [minibuffer-scroll-window this-command minibuffer-completion-table minibuffer-completion-predicate completion-extra-properties last-command-event nil copy-marker minibuffer--completion-prompt-end completion-all-sorted-completions last 0 completion--message "No more completions" "No completions" buffer-substring-no-properties completion--replace completion--done finished "Sole completion" sole completion-at-point completion--cache-all-sorted-completions make-closure #[0 "\303\305\300`\301\302$)\207" [V0 V1 V2 V3 completion-extra-properties completion-in-region] 5 "Cycle through the possible completions." nil] set-transient-map make-sparse-keymap define-key [remap completion-at-point] vector completion-cycling] 17 (#$ . 42339) nil])
#@117 List of commands which cause an immediately following
`minibuffer-complete-and-exit' to ask for extra confirmation.
(defvar minibuffer-confirm-exit-commands '(completion-at-point minibuffer-complete minibuffer-complete-word PC-complete PC-complete-word) (#$ . 43684))
#@53 Value of REQUIRE-MATCH passed to `completing-read'.
(defvar minibuffer--require-match nil (#$ . 43958))
#@60 Buffer that was current when `completing-read' was called.
(defvar minibuffer--original-buffer nil (#$ . 44068))
#@574 Exit if the minibuffer contains a valid completion.
Otherwise, try to complete the minibuffer contents.  If
completion leads to a valid completion, a repetition of this
command will exit.

If `minibuffer-completion-confirm' is `confirm', do not try to
 complete; instead, ask for confirmation and accept any input if
 confirmed.
If `minibuffer-completion-confirm' is `confirm-after-completion',
 do not try to complete; instead, ask for confirmation if the
 preceding minibuffer command was a member of
 `minibuffer-confirm-exit-commands', and accept the input
 otherwise.
(defalias 'minibuffer-complete-and-exit #[0 "\300\301 d\302#\207" [completion-complete-and-exit minibuffer--completion-prompt-end exit-minibuffer] 4 (#$ . 44188) nil])
#@30 

(fn BEG END EXIT-FUNCTION)
(defalias 'completion-complete-and-exit #[771 "\300\301\302$$\207" [completion--complete-and-exit make-closure #[0 "\3041\305\300\301\306\307$0\202\210\310\211\311\267\202&\302 \207\204 \302 \207\312\313!\210\306\207\306\207" [V0 V1 V2 minibuffer-completion-confirm (error) completion--do-completion nil expect-exact 1 #s(hash-table size 3 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (3 22 1 22 7 25)) minibuffer-message "Confirm"] 5]] 12 (#$ . 44935)])
#@180 Exit from `require-match' minibuffer.
COMPLETION-FUNCTION is called if the current buffer's content does not
appear to be a match.

(fn BEG END EXIT-FUNCTION COMPLETION-FUNCTION)
(defalias 'completion--complete-and-exit #[1028 "U\203	
 \207\306{	#\203?\n\203<{\307
	#\211;\203:

\232\204:
G
GU\203:\310#\210\266
 \207\311>\203a\f
=\204X\312=\203[\f>\204[
 \207\313\314!\210\315\207\211 \207" [minibuffer-completion-table minibuffer-completion-predicate completion-ignore-case minibuffer-completion-confirm last-command this-command test-completion try-completion completion--replace (confirm confirm-after-completion) confirm-after-completion minibuffer-message "Confirm" nil minibuffer-confirm-exit-commands] 10 (#$ . 45461)])
#@40 

(fn STRING TABLE PREDICATE POINT MD)
(defalias 'completion--try-word-completion #[1285 "\300%\211:\204
\207G
@GU\203Q\301\302\303\"\304O\305O\305\203G\211:\204G\300\211A\262\242Q\n\n\nT\n%\262
\202%\211:\203O\211\262\266\211A
@\304O\211\306Q\307\310\"\203\325\311\312\"
\304\225\305O	\305O\307\313\306Q\"\205\203\311\312\"\211\204\216
G\304U\203\323\307\314\315!\316\203\237\315!\202\240\317R\"\203\323\312\225=\203\323\307\320\312\224#\203\323\304\225V\203\323\304\225\304O\n\305OP\262\262\266B\207" [completion-try-completion mapcar #[257 "\300
\301\302#\207" [propertize completion-try-word t] 5 "\n\n(fn STR)"] (" " "-") 0 nil "\n" string-match "\\(.+\\)\n.*?\\1" match-string 1 "\\`\\(.+\\).*\n.*\\1" ".*" regexp-quote "\\(.*?\\)" "\\'" "\\W"] 20 (#$ . 46223)])
#@234 Complete the minibuffer contents at most a single word.
After one word is completed as much as possible, a space or hyphen
is added, provided that matches some possible completion.
Return nil if there is no valid completion, else t.
(defalias 'minibuffer-complete-word #[0 "\300\301 d\"\207" [completion-in-region--single-word minibuffer--completion-prompt-end] 3 (#$ . 47074) nil])
#@16 

(fn BEG END)
(defalias 'completion-in-region--single-word #[514 "\300\301#\211\302=?\205
\303\207" [completion--do-completion completion--try-word-completion 0 t] 6 (#$ . 47463)])
(byte-code "\300\301\302\303#\210\304\305\306\307\310DD\311\312\313\314\315&\210\304\316\306\307\317DD\320\312\321\314\322&\207" [custom-declare-face completions-annotations ((t :inherit (italic shadow))) "Face to use for annotations in the *Completions* buffer.\nThis face is only used if the strings used for completions\ndoesn't already specify a face." custom-declare-variable completions-format funcall function #[0 "\300\207" [horizontal] 1 #1=""] "Define the appearance and sorting of completions.\nIf the value is `vertical', display completions sorted vertically\nin columns in the *Completions* buffer.\nIf the value is `horizontal', display completions sorted in columns\nhorizontally in alphabetical order, rather than down the screen.\nIf the value is `one-column', display completions down the screen\nin one column." :type (choice (const horizontal) (const vertical) (const one-column)) :version "23.2" completions-detailed #[0 "\300\207" [nil] 1 #1#] "When non-nil, display completions with details added as prefix/suffix.\nThis makes some commands (for instance, \\[describe-symbol]) provide a\ndetailed view with more information prepended or appended to\ncompletions." boolean "28.1"] 8)
#@349 Insert a list of STRINGS into the current buffer.
The candidate strings are inserted into the buffer depending on the
completions format as specified by the variable `completions-format'.
Runs of equal candidate strings are eliminated.  GROUP-FUN is a
`group-function' used for grouping the completion candidates.

(fn STRINGS &optional GROUP-FUN)
(defalias 'completion--insert-strings #[513 "
:\205\\\303\304\305\306\"\"\307p\310\"\211\203\311
!S\202\312\313
\313\\\245]\314G\313\245]^

\245\204G	\203G\315
	\"\310U\204G\211\315	\"Z\262
\316\317\320\n\"!&\266\205\207" [tab-stop-list completion-tab-width completions-format apply max mapcar #[257 "\211:\203
\300\301\302\303\"\"\207\303
!\207" [apply + mapcar string-width] 6 "\n\n(fn S)"] get-buffer-window 0 window-width 79 2 1 mod intern format "completion--insert-%s"] 14 (#$ . 48864)])
#@57 

(fn STRINGS GROUP-FUN LENGTH WWIDTH COLWIDTH COLUMNS)
(defalias 'completion--insert-horizontal #[1542 "\301\302\303\211	\211\205\247\211@
\232\204\240\211\262\n\203N\n
:\203&
@\202'
\303\"\211\232\204M\211\262\211\203M\203>\304\202?\305\306\"\305\261\210\301\262\302\262\210\204\212	:\203h\307\310\311\312\"\"\202k\312!]\\W\203z\305c\210\301\262\202\212\313c\210\314`S`\315\316\317ED#\210\303\262\320
\f\"\210\321\f\"_\\\262
A\266\202\202\207" [completions-group-format 0 t nil "" "\n" format apply + mapcar string-width " 	" set-text-properties display space :align-to completion--insert ceiling] 20 (#$ . 49740)])
#@57 

(fn STRINGS GROUP-FUN LENGTH WWIDTH COLWIDTH COLUMNS)
(defalias 'completion--insert-vertical #[1542 "\205\n
\301\302\211\301\211	\203Y\n@\n
:\203
@\202
\301\"\f\203O\211\f@:\2036@@\2029@\301\"\232\203O\f@B\262\fA\262
\202 \237\262\266\202`\n\262\301\262G\245\262	\203\216@\n
:\203z
@\202{
\301\"\211\203\214db\210\303\"\304\261\210\266\211\203
\211@
\232\204\376\211\262V\203\262\305Zy\210\302\262	\\\262\302V\203\345\301\210iV\203\325m\203\314\304c\210\202\273\306y\210\301\210\202\273\307c\210\310`S`\311\312\313ED#\210\314

\"\210\302V\203\367\301y\210\202\372\304c\210T\262
A\266\202\202\217\266\202\207" [completions-group-format nil 0 format "\n" -1 1 " 	" set-text-properties display space :align-to completion--insert] 20 (#$ . 50415)])
#@34 

(fn STRINGS GROUP-FUN &rest _)
(defalias 'completion--insert-one-column #[642 "\301\211\211\205J\211@
\232\204C\211\262\203:
:\203!
@\202\"
\301\"\211\232\2049\211\262\211\2039\302\"\303\261\210\210\304
\"\210\303c\210
A\266\202\202\207" [completions-group-format nil format "\n" completion--insert] 11 (#$ . 51253)])
#@22 

(fn STR GROUP-FUN)
(defalias 'completion--insert #[514 "
:\204\300`\203\301\"\202c\210`\302\303\304F#\207\3058\205'
A@\3058\2060A@
\203A`c\210`\306\302\307$\266\310@\"\210`
c\210`\306\302\307$\210\206`\311\312G\313\307%?\205j\314\313\315$\207" [add-text-properties transform mouse-face highlight completion--string 2 put-text-property nil completion--insert text-property-not-all 0 face font-lock-prepend-text-property completions-annotations] 12 (#$ . 51600)])
#@300 Normal hook run at the end of setting up a completion list buffer.
When this hook is run, the current buffer is the one in which the
command to display the completion list buffer was run.
The completion list buffer is available as the value of `standard-output'.
See also `display-completion-list'.
(defvar completion-setup-hook nil (#$ . 52105))
(byte-code "\300\301\302\303#\210\300\304\305\306#\207" [custom-declare-face completions-first-difference ((t (:inherit bold))) "Face for the first character after point in completions.\nSee also the face `completions-common-part'." completions-common-part ((((class color) (min-colors 16) (background light)) :foreground "blue3") (((class color) (min-colors 16) (background dark)) :foreground "lightblue")) "Face for the parts of completions which matched the pattern.\nSee also the face `completions-first-difference'."] 4)
#@505 Apply font-lock highlighting to a list of completions, COMPLETIONS.
PREFIX-LEN is an integer.  BASE-SIZE is an integer or nil (meaning zero).

This adds the face `completions-common-part' to the first
(PREFIX-LEN - BASE-SIZE) characters of each completion, and the face
`completions-first-difference' to the first character after that.

It returns a list with font-lock properties applied to each element,
and with BASE-SIZE appended as the last element.

(fn COMPLETIONS PREFIX-LEN &optional BASE-SIZE)
(defalias 'completion-hilit-commonality #[770 "\205

\206\n\300Z\301\302\303\"\"\244\262
\207" [0 mapcar make-closure #[257 "\211:\203\301
@!
AB\211\262@\202\301
!\211\262\302\303\300G^\304\305%\210\211G\300V\2034\302\300\211T\304\306%\210\210\207" [V0 copy-sequence font-lock-prepend-text-property 0 face completions-common-part completions-first-difference] 8 "\n\n(fn ELEM)"]] 8 (#$ . 52985)])
#@681 Display the list of completions, COMPLETIONS, using `standard-output'.
Each element may be just a symbol or string
or may be a list of two strings to be printed as if concatenated.
If it is a list of two strings, the first is the actual completion
alternative, the second serves as annotation.
`standard-output' must be a buffer.
The actual completion alternatives, as inserted, are given `mouse-face'
properties of `highlight'.
At the end, this runs the normal hook `completion-setup-hook'.
It can find the completion buffer in `standard-output'.
GROUP-FUN is a `group-function' used for grouping the completion
candidates.

(fn COMPLETIONS &optional COMMON-SUBSTRING GROUP-FUN)
(defalias 'display-completion-list #[769 "
\203\f\302G\303#\262\304!\2044\305\306\307\"r\211q\210\310\311\"\216p\303\312#\210*\313\314 !\210*\210\202Nrq\210db\210\204E\315c\210\202M\316c\210\317\"\210)\320\301!\210\303\207" [standard-output completion-setup-hook completion-hilit-commonality nil bufferp generate-new-buffer " *temp*" t make-closure #[0 "\301\300!\205	\302\300!\207" [V0 buffer-name kill-buffer] 2] display-completion-list princ buffer-string "There are no possible completions of what you have typed." "Possible completions are:\n" completion--insert-strings run-hooks] 8 (#$ . 53910)])
(set-advertised-calling-convention 'display-completion-list '(completions) "24.4")
#@1339 Property list of extra properties of the current completion job.
These include:

`:annotation-function': Function to annotate the completions buffer.
   The function must accept one argument, a completion string,
   and return either nil or a string which is to be displayed
   next to the completion (but which is not part of the
   completion).  The function can access the completion data via
   `minibuffer-completion-table' and related variables.

`:affixation-function': Function to prepend/append a prefix/suffix to
   completions.  The function must accept one argument, a list of
   completions, and return a list of annotated completions.  The
   elements of the list must be three-element lists: completion, its
   prefix and suffix.  This function takes priority over
   `:annotation-function' when both are provided, so only this
   function is used.

`:exit-function': Function to run after completion is performed.

   The function must accept two arguments, STRING and STATUS.
   STRING is the text to which the field was completed, and
   STATUS indicates what kind of operation happened:
     `finished' - text is now complete
     `sole'     - text cannot be further completed but
                  completion is not finished
     `exact'    - text is a valid completion but may be further
                  completed.
(defvar completion-extra-properties nil (#$ . 55305))
#@297 Function to add annotations in the *Completions* buffer.
The function takes a completion and should either return nil, or a string that
will be displayed next to the completion.  The function can access the
completion table and predicates via `minibuffer-completion-table' and related
variables.
(defvar completion-annotate-function nil (#$ . 56704))
(make-obsolete-variable 'completion-annotate-function 'completion-extra-properties "24.1")
#@42 

(fn STRING &optional FINISHED MESSAGE)
(defalias 'completion--done #[769 "\303\304\"\211\205\n\305 \306>\204\307\310!\210
\2034\311=\203/\312	\n#\313=\203,\314\202-\315\262
\"\210\205F\211\205?\305 \232\205F\316!\207" [completion-extra-properties minibuffer-completion-table minibuffer-completion-predicate plist-get :exit-function current-message #1=(exact sole finished unknown) cl--assertion-failed (memq finished '#1#) unknown try-completion t finished exact completion--message] 9 (#$ . 57152)])
#@102 Display a list of possible completions of the current minibuffer contents.

(fn &optional START END)
(defalias 'minibuffer-completion-help #[512 "\306\307!\210
\206\n\310 
\206d

{\311!\312	`Z%C\306\313!\210\211\242\2038\211\242A:\204N\211\242@\232\203N\314 \210\315 \210\316
\242\203H\317\202I\320!\210\202\367\321
\242!\211A\206X\322\211\322U?\205c\322O\323\324	`\"	%\325
\326\"\206~\327\n\330\"\206~\325\331\"\206\211\327\n\332\"\325\333\"\325\334\"p\335\336\337\340\341 \342 =\203\243\343\202\244\344F
\203\255\345\202\256\346
\205\263\347\350\351\352&\fBF\353\354!\211/\313\211rq\210\313\262
\355\"\262)\356\313!\203\361\313\"\210)\266)\266	\313\207" [minibuffer-completion-table minibuffer-completion-predicate completion-extra-properties completion-annotate-function display-buffer-mark-dedicated temp-buffer-resize-mode message "Making completion list..." minibuffer--completion-prompt-end completion--field-metadata completion-all-completions nil minibuffer-hide-completions ding completion--message "Sole completion" "No completions" last 0 completion--metadata buffer-substring-no-properties completion-metadata-get annotation-function plist-get :annotation-function affixation-function :affixation-function display-sort-function group-function soft display-buffer--maybe-same-window display-buffer-reuse-window display-buffer--maybe-pop-up-frame selected-window minibuffer-window display-buffer-at-bottom display-buffer-below-selected (window-height . resize-temp-buffer-window) (window-height . fit-window-to-buffer) (preserve-size nil . t) body-function make-closure #[257 "r\312q\210\303\203\f\303\313\241\210\302\310\203\310\302\242!\202\314\302\242\315\"\240\210\311\203<\302\316\311\317\267\2025\320\2027\321\2027\302\242#\240\210\307\203J\302\307\302\242!\240\210\202Y\306\203Y\302\322\323\324\306\"\302\242\"\240\210rq\210\325\326!\210\300\304\\\301D\325\327!\210\323\330\305%\266\203)\331\302\242\313\311#)\207" [V0 V1 V2 V3 V4 V5 V6 V7 V8 V9 V10 nil sort string-lessp minibuffer--group-by #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (nil 45 alphabetical 49)) identity #[257 "\300
\301\"\207" [sort #[514 "
@
@\231\207" [] 4 "\n\n(fn X Y)"]] 4 "\n\n(fn GROUPS)"] mapcar make-closure #[257 "\300
!\211\203

D\207
\207" [V0] 4 "\n\n(fn S)"] make-local-variable completion-base-position completion-list-insert-choice-function #[771 "\300G\306U\204\300\307e\300GZ]\"\232\204\310\311!\210\312#\210\301\302\303\300
P\313
\301\302\314$\315@G=\203=\316\202>\317\"+\207" [V0 V1 V2 V3 minibuffer-completion-table minibuffer-completion-predicate 0 buffer-substring-no-properties message "*Completions* out of date" completion--replace completion-boundaries "" completion--done exact finished completion-extra-properties] 9 "\n\n(fn START END CHOICE)"] display-completion-list completions-group-sort standard-output minibuffer-completion-table minibuffer-completion-predicate completion-extra-properties] 10 "\n\n(fn WINDOW)"] temp-buffer-window-setup "*Completions*" temp-buffer-window-show functionp standard-output] 33 (#$ . 57682) nil])
#@49 Get rid of an out-of-date *Completions* buffer.
(defalias 'minibuffer-hide-completions #[0 "\300\301\302\"\211\205\303
!r\304\305\"\216\306
@\307\"\210\310 *\262
\207" [get-buffer-window "*Completions*" 0 internal--before-with-selected-window make-closure #[0 "\301\300!\207" [V0 internal--after-with-selected-window] 2] select-window norecord bury-buffer] 5 (#$ . 60899)])
#@37 Terminate this minibuffer argument.
(defalias 'exit-minibuffer #[0 "\301 \203\302 \204\303\304\305\"\210\306 \204\303\304\307\"\210\310\311\312\310\"\207" [deactivate-mark minibufferp minibuffer-innermost-command-loop-p error "%s" "Not in most nested command loop" innermost-minibuffer-p "Not in most nested minibuffer" nil throw exit] 3 (#$ . 61282) nil])
#@219 Restore some windows on exit from minibuffer.
When `read-minibuffer-restore-windows' is nil, then this function
added to `minibuffer-exit-hook' will remove at least the window
that displays the "*Completions*" buffer.
(defalias 'minibuffer-restore-windows #[0 "?\205\301 \207" [read-minibuffer-restore-windows minibuffer-hide-completions] 1 (#$ . 61653)])
(add-hook 'minibuffer-exit-hook 'minibuffer-restore-windows)
#@251 Quit the command that requested this recursive edit or minibuffer input.
Do so without terminating keyboard macro recording or execution.
LEVELS specifies the number of nested recursive edits to quit.
If nil, it defaults to 1.

(fn &optional LEVELS)
(defalias 'minibuffer-quit-recursive-edit #[256 "\211C\211\242\204\211\300\240\210\211\242\300V\203\301\302\303\304\"\"\207\301\302\305\"\207" [1 throw exit make-closure #[0 "\301\300\242S!\207" [V0 minibuffer-quit-recursive-edit] 2] #[0 "\300\301\302\"\207" [signal minibuffer-quit nil] 3]] 7 (#$ . 62080)])
#@29 Terminate minibuffer input.
(defalias 'self-insert-and-exit #[0 "\301!\203
\302\303!\210\202\304 \210\305 \207" [last-command-event characterp call-interactively self-insert-command ding exit-minibuffer] 2 (#$ . 62650) nil])
#@105 Wrapper hook around `completion--in-region'.
(See `with-wrapper-hook' for details about wrapper hooks.)
(defvar completion-in-region-functions nil (#$ . 62886))
(make-obsolete-variable 'completion-in-region-functions 'completion-in-region-function "24.4")
#@214 Function to perform the job of `completion-in-region'.
The function is called with 4 arguments: START END COLLECTION PREDICATE.
The arguments and expected return value are as specified for
`completion-in-region'.
(defvar completion-in-region-function 'completion--in-region (#$ . 63149))
(defvar completion-in-region--data nil)
#@205 Predicate to tell `completion-in-region-mode' when to exit.
It is called with no argument and should return nil when
`completion-in-region-mode' should exit (and hence pop down
the *Completions* buffer).
(defvar completion-in-region-mode-predicate nil (#$ . 63484))
#@169 Copy of the value of `completion-in-region-mode-predicate'.
This holds the value `completion-in-region-mode-predicate' had when
we entered `completion-in-region-mode'.
(defvar completion-in-region-mode--predicate nil (#$ . 63757))
#@466 Complete the text between START and END using COLLECTION.
Point needs to be somewhere between START and END.
PREDICATE (a function called with no arguments) says when to exit.
This calls the function that `completion-in-region-function' specifies
(passing the same four arguments that it received) to do the work,
and returns whatever it does.  The return value should be nil
if there was no valid completion, else t.

(fn START END COLLECTION &optional PREDICATE)
(defalias 'completion-in-region #[1027 "`X\204\301\302\303`D\303$\210$\207" [completion-in-region-function cl--assertion-failed (<= start (point)) nil] 9 (#$ . 63995)])
(byte-code "\300\301\302\303\304DD\305\306\307\310\311&\207" [custom-declare-variable read-file-name-completion-ignore-case funcall function #[0 "\301>\205\302\207" [system-type (ms-dos windows-nt darwin cygwin) t] 2 ""] "Non-nil means when reading a file name completion ignores case." :type boolean :version "22.1"] 8)
#@318 Default function to use for `completion-in-region-function'.
Its arguments and return value are as specified for `completion-in-region'.
Also respects the obsolete wrapper hook `completion-in-region-functions'.
(See `with-wrapper-hook' for details about wrapper hooks.)

(fn START END COLLECTION &optional PREDICATE)
(defalias 'completion--in-region #[1027 "\301C\211\302\303\"\240\210\211\242\304\300!\205\305\300!F#\207" [completion-in-region-functions nil make-closure #[771 ":\203(@\301=\203\300\242\302A\"\303#\207\304@\305\306\307\300\"A##\207\304\310\"\207" [V0 t append nil apply apply-partially make-closure #[642 "\300\242#\207" [V0] 7 "\n\n(fn FUNS GLOBAL &rest ARGS)"] #[1028 "

\n\203!\304!\203\202\305!\305\306\"F\307\310!\210\311\"*\207" [minibuffer-completion-predicate minibuffer-completion-table completion-in-region-mode-predicate completion-in-region--data markerp copy-marker t completion-in-region-mode 1 completion--in-region-1] 8 "\n\n(fn START END COLLECTION PREDICATE)"]] 9 "\n\n(fn FUNS GLOBAL ARGS)"] local-variable-p default-value] 12 (#$ . 64971)])
#@49 Keymap activated during `completion-in-region'.
(defvar completion-in-region-mode-map (byte-code "\300 \301
\302\303#\210\301
\304\305#\210\207" [make-sparse-keymap define-key "\277" completion-help-at-point "	" completion-at-point] 5) (#$ . 66102))
(defalias 'completion-in-region--postch #[0 "\206.	\203+\303	@!p=\203+`	@Y\203+`\212	A@b\210\304 )X\203+\n \206.\305\306!\207" [unread-command-events completion-in-region--data completion-in-region-mode--predicate marker-buffer line-end-position completion-in-region-mode -1] 2])
(defvar completion-in-region-mode nil)
#@633 Transient minor mode used during `completion-in-region'.

This is a minor mode.  If called interactively, toggle the
`Completion-In-Region 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 `completion-in-region-mode'.

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

(fn &optional ARG)
(defalias 'completion-in-region-mode #[256 "\306 
\307=\203
?\202
\247\203
\310W\203\311\202\312\313\301!\2031\314\300	\"\2031\300	B\315\316\317\"\210\314\300\n\236\n\"\204R\311\320\321 !\322\232\204h\323 \210\202h\f\204Z\324\304!\210\f\325\316\317\"\210\300\"B\nB\326\327\203r\330\202s\331\"\210\332\333!\203\225\306 \203\207\211\306 \232\203\225\334\335\203\221\336\202\222\337\340#\210\210\341 \210\207" [completion-in-region-mode global-minor-modes minor-mode-overriding-map-alist completion-in-region--data completion-in-region-mode-predicate completion-in-region-mode--predicate current-message toggle 1 nil t boundp delq remove-hook post-command-hook completion-in-region--postch buffer-name window-buffer "*Completions*" minibuffer-hide-completions cl--assertion-failed add-hook run-hooks completion-in-region-mode-hook completion-in-region-mode-on-hook completion-in-region-mode-off-hook called-interactively-p any message "Completion-In-Region mode %sabled%s" "en" "dis" "" force-mode-line-update completion-in-region-mode-map] 6 (#$ . 66685) (byte-code "\203\n\301!\202\302C\207" [current-prefix-arg prefix-numeric-value toggle] 2)])
(defvar completion-in-region-mode-hook nil)
(byte-code "\302\303N\204\f\304\302\303\305#\210\304\302\306\307#\210\304\302\310\311C#\210\312\313\311\314\300!\205#\311\211%\210\315\313	\236	\"\311\207" [completion-in-region-mode-map minor-mode-map-alist completion-in-region-mode-hook variable-documentation put "Hook run after entering or leaving `completion-in-region-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 completion-in-region-mode boundp delq] 6)
#@1324 Special hook to find the completion table for the entity at point.
Each function on this hook is called in turn without any argument and
should return either nil, meaning it is not applicable at point,
or a function of no arguments to perform completion (discouraged),
or a list of the form (START END COLLECTION . PROPS), where:
 START and END delimit the entity to complete and should include point,
 COLLECTION is the completion table to use to complete the entity, and
 PROPS is a property list for additional information.
Currently supported properties are all the properties that can appear in
`completion-extra-properties' plus:
 `:predicate'	a predicate that completion candidates need to satisfy.
 `:exclusive'	value of `no' means that if the completion table fails to
   match the text at point, then instead of reporting a completion
   failure, the completion should try the next completion function.
As is the case with most hooks, the functions are responsible for
preserving things like point and current buffer.

NOTE: These functions should be cheap to run since they're sometimes
run from `post-command-hook'; and they should ideally only choose
which kind of completion table to use, and not pre-filter it based
on the current text between START and END (e.g., they should not
obey `completion-styles').
(defvar completion-at-point-functions '(tags-completion-at-point-function) (#$ . 69111))
#@201 List of functions found on `completion-at-point-functions' that misbehave.
These are functions that neither return completion data nor a completion
function but instead perform completion right away.
(defvar completion--capf-misbehave-funs nil (#$ . 70530))
#@188 List of well-behaved functions found on `completion-at-point-functions'.
These are functions which return proper completion data rather than
a completion function or god knows what else.
(defvar completion--capf-safe-funs nil (#$ . 70795))
#@18 

(fn FUN WHICH)
(defalias 'completion--capf-wrapper #[514 "\211\302\267\202\202
\235\202
	\235?\202\303\205x
 \211:\203U\304
!\204U\235\2041B\305\306\233\307\"\310=\203o\311\312@`\"\3138\305\306\233\314\"#\204o\303\262
\202o\211<\204o\304
!\204o	\235\204o\315\316\"\210	B\211\205v
B\262
\207" [completion--capf-safe-funs completion--capf-misbehave-funs #s(hash-table size 3 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (all 6 safe 9 optimist 15)) nil functionp plist-get 3 :exclusive no try-completion buffer-substring-no-properties 2 :predicate message "Completion function %S uses a deprecated calling convention"] 9 (#$ . 71041)])
#@118 Perform completion on the text around point.
The completion method is determined by `completion-at-point-functions'.
(defalias 'completion-at-point #[0 "\302\303\304\305#\306
:\203l
\242\243\307
!\203\211 \207\211:\203h\211\242
\243\211:\203c\211\242
\243\211:\203]\211\242
\243C\310
\242!\204F\211\311\242!\240\210\312\313#\314
\242\315\316\"$*\207!\207!\207!\207\211!\207" [completion-extra-properties completion-in-region-mode-predicate run-hook-wrapped completion-at-point-functions completion--capf-wrapper all #[257 "\211A\203\300\301@\"\210\211A\207" [message "Warning: %S failed to return valid completion data!"] 4 "\n\n(fn RES)"] functionp markerp copy-marker make-closure #[0 "\300 \242\211\205\211\301\242U\207" [V0 V1] 3] completion-in-region plist-get :predicate] 19 (#$ . 71736) nil])
#@123 Display the completions on the text around point.
The completion method is determined by `completion-at-point-functions'.
(defalias 'completion-help-at-point #[0 "\305\306\307\310#\311
:\203\200
\242\243\312
!\203\313\314\"\207\211:\203|\211\242
\243\211:\203x\211\242
\243\211:\203r\211\242
\243C\315
\242!\204H\211\316\242!\240\210\317\320\"\321\322#\211\242\316\323\"\317\320\"F\324\325!\210\326
\242\",\207!\207!\207!\207\313\327!\207" [minibuffer-completion-table minibuffer-completion-predicate completion-extra-properties completion-in-region-mode-predicate completion-in-region--data run-hook-wrapped completion-at-point-functions completion--capf-wrapper optimist #[257 "\300\301\"\210\302\207" [message "%s already performed completion!" nil] 4 "\n\n(fn HOOKFUN)"] functionp message "Don't know how to show completions for %S" markerp copy-marker plist-get :predicate make-closure #[0 "\300 \242\211\205\211\301\242U\207" [V0 V1] 3] t completion-in-region-mode 1 minibuffer-completion-help "Nothing to complete at point"] 18 (#$ . 72582) nil])
(byte-code "\301
\302\303#\210\301
\304\305#\210\301
\306\307#\210\301
\310\307#\210\207" [minibuffer-local-map define-key "" abort-minibuffers "\274" minibuffer-beginning-of-buffer "\n" exit-minibuffer "
"] 5)
#@52 Local keymap for minibuffer input with completion.
(defvar minibuffer-local-completion-map (byte-code "\301 \302
\"\210\303
\304\305#\210\303
\306\307#\210\303
\310\311#\210\303
\312\313#\210\303
\314\313#\210\303
\315\313#\210\207" [minibuffer-local-map make-sparse-keymap set-keymap-parent define-key "	" minibuffer-complete " " minibuffer-complete-word "?" minibuffer-completion-help [prior] switch-to-completions "\366" "\347\343"] 5) (#$ . 73897))
#@69 Local keymap for minibuffer input with completion, for exact match.
(defvar minibuffer-local-must-match-map (byte-code "\301 \302
\"\210\303
\304\305#\210\303
\306\305#\210\207" [minibuffer-local-completion-map make-sparse-keymap set-keymap-parent define-key "
" minibuffer-complete-and-exit "\n"] 5) (#$ . 74357))
#@169 Local keymap for minibuffer input with completion for filenames.
Gets combined either with `minibuffer-local-completion-map' or
with `minibuffer-local-must-match-map'.
(defvar minibuffer-local-filename-completion-map (byte-code "\300 \301
\302\303#\210\207" [make-sparse-keymap define-key " " nil] 5) (#$ . 74680))
(defvar minibuffer-local-filename-must-match-map (make-sparse-keymap))
(make-obsolete-variable 'minibuffer-local-filename-must-match-map nil "24.1")
#@62 Local keymap for the minibuffer when spaces are not allowed.
(defvar minibuffer-local-ns-map (byte-code "\301 \302
\"\210\303
\304\305#\210\303
\306\305#\210\303
\307\310#\210\207" [minibuffer-local-map make-sparse-keymap set-keymap-parent define-key " " exit-minibuffer "	" "?" self-insert-and-exit] 5) (#$ . 75150))
#@726 Read a string from the terminal, not allowing blanks.
Prompt with PROMPT.  Whitespace terminates the input.  If INITIAL is
non-nil, it should be a string, which is used as initial input, with
point positioned at the end, so that SPACE will accept the input.
(Actually, INITIAL can also be a cons of a string and an integer.
Such values are treated as in `read-from-minibuffer', but are normally
not useful in this function.)

Third arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits
the current input method and the setting of `enable-multibyte-characters'.

If `inhibit-interaction' is non-nil, this function will signal an
`inhibited-interaction' error.

(fn PROMPT &optional INITIAL INHERIT-INPUT-METHOD)
(defalias 'read-no-blanks-input #[769 "\301\302\303\302&\207" [minibuffer-local-ns-map read-from-minibuffer nil minibuffer-history] 11 (#$ . 75476)])
#@212 Keymap for use in the minibuffer when it is not active.
The non-mouse bindings in this keymap can only be used in minibuffer-only
frames, since the minibuffer can normally not be selected when it is
not active.
(defvar minibuffer-inactive-mode-map (byte-code "\300 \301
!\210\302
\303\304#\210\302
\305\304#\210\302
\306\307#\210\302
\310\311#\210\302
\312\313#\210\302
\314\315#\210\302
\316\317#\210\302
\320\321#\210\207" [make-keymap suppress-keymap define-key "e" find-file-other-frame "f" "b" switch-to-buffer-other-frame "i" info "m" mail "n" make-frame [mouse-1] view-echo-area-messages [down-mouse-1] ignore] 5) (#$ . 76364))
(defvar minibuffer-inactive-mode-hook nil)
(byte-code "\300\301N\204\f\302\300\301\303#\210\304\305!\204\302\305\306\307#\210\300\207" [minibuffer-inactive-mode-hook variable-documentation put "Hook run after entering InactiveMinibuffer mode.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it.  (This is true for all hook variables.)" boundp minibuffer-inactive-mode-map definition-name minibuffer-inactive-mode] 4)
(defvar minibuffer-inactive-mode-map (make-sparse-keymap))
(byte-code "\300\301N\204\302\300\301\303\304!#\210\305\306!\204\302\306\307\310#\210\311\312 !\210\306\301N\204-\302\306\301\303\313!#\210\302\310\314\315#\207" [minibuffer-inactive-mode-map variable-documentation put purecopy "Keymap for `minibuffer-inactive-mode'." boundp minibuffer-inactive-mode-syntax-table definition-name minibuffer-inactive-mode (lambda (#1=#:def-tmp-var) (defvar minibuffer-inactive-mode-syntax-table #1#)) make-syntax-table "Syntax table for `minibuffer-inactive-mode'." derived-mode-parent nil] 5)
#@261 Major-mode.
Uses keymap `minibuffer-inactive-mode-map' and syntax-table
`minibuffer-inactive-mode-syntax-table'.

This mode runs the hook `minibuffer-inactive-mode-hook', as the final
or penultimate step during initialization.

\{minibuffer-inactive-mode-map}
(defalias 'minibuffer-inactive-mode #[0 "\305\300!\210\306\307 \210\310\311\312!\210\313\f!\210)\314\315!\207" [delay-mode-hooks major-mode mode-name minibuffer-inactive-mode-map minibuffer-inactive-mode-syntax-table make-local-variable t kill-all-local-variables minibuffer-inactive-mode "InactiveMinibuffer" use-local-map set-syntax-table run-mode-hooks minibuffer-inactive-mode-hook] 2 (#$ . 78052) nil])
(defvaralias 'minibuffer-mode-map 'minibuffer-local-map)
(defvar minibuffer-mode-hook nil)
(byte-code "\300\301N\204\f\302\300\301\303#\210\304\305!\204\302\305\306\307#\210\300\207" [minibuffer-mode-hook variable-documentation put "Hook run after entering Minibuffer mode.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it.  (This is true for all hook variables.)" boundp minibuffer-mode-map definition-name minibuffer-mode] 4)
(defvar minibuffer-mode-map (make-sparse-keymap))
(byte-code "\300\301N\204\302\300\301\303\304!#\210\302\305\306\307#\207" [minibuffer-mode-map variable-documentation put purecopy "Keymap for `minibuffer-mode'." minibuffer-mode derived-mode-parent nil] 5)
#@309 Major mode used for active minibuffers.

For customizing this mode, it is better to use
`minibuffer-setup-hook' and `minibuffer-exit-hook' rather than
the mode hook of this mode.

This mode runs the hook `minibuffer-mode-hook', as the final or
penultimate step during initialization.

\{minibuffer-mode-map}
(defalias 'minibuffer-mode #[0 "\304\300!\210\305\306 \210\307\310\311!\210)\312\313!\207" [delay-mode-hooks major-mode mode-name minibuffer-mode-map make-local-variable t kill-all-local-variables minibuffer-mode "Minibuffer" use-local-map run-mode-hooks minibuffer-mode-hook] 2 (#$ . 79458)])
#@12 

(fn STR)
(defalias 'minibuffer--double-dollars #[257 "\300\301\302#\207" [replace-regexp-in-string "\\$" #[257 "\211
P\207" [] 3 "\n\n(fn DOLLAR)"]] 5 (#$ . 80070)])
#@142 Protect FILENAME from `substitute-in-file-name', as needed.
Useful to give the user default values that won't be substituted.

(fn FILENAME)
(defalias 'minibuffer-maybe-quote-filename #[257 "\211\303\211?\205\304\305\306!\")\266\202\204c\307
!\203c	\310>\203%\311\202&\312\306!\303\313\314#)\266\203\203c\211\303\211?\205?

\211?\205H\304\305\306!\")\266\202\203Y
\202a\315!\305\306!Q)\207\316
!\207" [file-name-handler-alist system-type inhibit-changing-match-data nil string-prefix-p "/:" file-local-name file-name-absolute-p (windows-nt ms-dos) "[/\\]~" "/~" t string-match file-remote-p minibuffer--double-dollars] 9 (#$ . 80246)])
(defalias 'completion--make-envvar-table #[0 "\301\302\"\207" [process-environment mapcar #[257 "\211\300\301\302\"O\207" [0 string-search "="] 6 "\n\n(fn ENVENTRY)"]] 3])
(defconst completion--embedded-envvar-re "\\(?:^\\|[^$]\\(?:\\$\\$\\)*\\)\\$\\([[:alnum:]_]*\\|{\\([^}]*\\)\\)\\'")
#@182 Completion table for envvars embedded in a string.
The envvar syntax (and escaping) rules followed by this table are the
same as `substitute-in-file-name'.

(fn STRING PRED ACTION)
(defalias 'completion--embedded-envvar-table #[771 "\302\"\205y\303\224\206\304\224\305 \306O\307=\203\266\310\207\242\311=\204+\312=\203W\313\310O\310#\205w\312=\203A\266\314\207A\311\303\224\206K\304\224\302\315\"\205T\306\224BB\207SH\316=\203g\317\320\321#\262\310\322
\310O\310%)\266\203\207" [completion--embedded-envvar-re completion-ignore-case string-match 2 1 completion--make-envvar-table 0 lambda nil boundaries metadata try-completion (metadata (category . environment-variable)) "[^[:alnum:]_]" 123 apply-partially completion-table-with-terminator "}" completion-table-with-context] 12 (#$ . 81205)])
#@59 Completion table for file names.

(fn STRING PRED ACTION)
(defalias 'completion-file-name-table #[771 "\3021\331\211\303=\203\304\202\327\305\306\307\310#)\266\203\203/\311\312\313\314\315 \"\316\306O%\202\327\211\242\317=\203M\320!G\321\322A\"\317G^BB\266\202\202\327\211\323=\203eG\324U?\205\327
\206`\325!\202\327\326!\320!\211\206p	\327\267\266\202\326\330#\211;\203\211
P\202\212\211\262
\266\203\202\327\331\"\332>\204\314\306\333=\203\247\334\202\251\335!\211\203\306\211@
!\203\277\211B\262
A\266\202\202\256\210)
\237\266\203\211\262
\266\203\202\327\266\3060\207\210\306\207" [inhibit-changing-match-data default-directory (file-error) metadata (metadata (category . file)) "\\`~[^/\\]*\\'" nil t string-match completion-table-with-context "~" mapcar #[257 "\211\300P\207" ["/"] 3 "\n\n(fn U)"] system-users 1 boundaries file-name-directory string-search "/" lambda 0 file-exists-p file-name-nondirectory #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (nil 120 t 145)) file-name-completion file-name-all-completions (nil file-exists-p) file-directory-p #[257 "\211G\211\300V\205

SH\301=\207" [0 47] 4 "\n\n(fn S)"] expand-file-name] 13 (#$ . 82046)])
#@18 

(fn UPOS QSTR)
(defalias 'completion--sifn-requote #[514 "\300
!\211\301O\302\303\304\"\211\205\301O\262\305\300!\"\262
\203'\211\262\202G\211\301V\203D\305\300\301SO!\"\203D\211S\262
\202)\211\306B\207" [substitute-in-file-name 0 nil string-match "\\(\\$+{?\\)?\\w+\\W*\\'" string-prefix-p minibuffer-maybe-quote-filename] 12 (#$ . 83317)])
(byte-code "\300\301\302\303\304\305#\306#\210\300\307\310\311\301\"\312#\207" [defalias completion--file-name-table completion-table-with-quoting completion-file-name-table substitute-in-file-name completion--sifn-requote "Internal subroutine for `read-file-name'.  Do not call this.\nThis is a completion table for file names, like `completion-file-name-table'\nexcept that it passes the file name through `substitute-in-file-name'." read-file-name-internal completion-table-in-turn completion--embedded-envvar-table "Internal subroutine for `read-file-name'.  Do not call this."] 6)
#@114 The function called by `read-file-name' to do its work.
It should accept the same arguments as `read-file-name'.
(defvar read-file-name-function 'read-file-name-default (#$ . 84275))
(byte-code "\300\301\302\303\304DD\305\306\307%\210\300\310\302\303\311DD\312\313\314\306\307&\207" [custom-declare-variable insert-default-directory funcall function #[0 "\300\207" [t] 1 #1=""] "Non-nil means when reading a filename start with default dir in minibuffer.\n\nWhen the initial minibuffer contents show a name of a file or a directory,\ntyping RETURN without editing the initial contents is equivalent to typing\nthe default file name.\n\nIf this variable is non-nil, the minibuffer contents are always\ninitially non-empty, and typing RETURN without editing will fetch the\ndefault name, if one is provided.  Note however that this default name\nis not necessarily the same as initial contents inserted in the minibuffer,\nif the initial contents is just the default directory.\n\nIf this variable is nil, the minibuffer often starts out empty.  In\nthat case you may have to explicitly fetch the next history element to\nrequest the default name; typing RETURN without editing will leave\nthe minibuffer empty.\n\nFor some commands, exiting with an empty minibuffer has a special meaning,\nsuch as making the current buffer visit no file in the case of\n`set-visited-file-name'." :type boolean minibuffer-beginning-of-buffer-movement #[0 "\300\207" [nil] 1 #1#] "Control how the `M-<' command in the minibuffer behaves.\nIf non-nil, the command will go to the end of the prompt (if\npoint is after the end of the prompt).  If nil, it will behave\nlike the `beginning-of-buffer' command." :version "27.1"] 8)
#@30 

(fn &optional DIR INITIAL)
(defalias 'read-file-name--defaults #[512 "\211\203\n\302!\202\205\302!\303\304!\211\203&\305\306\307\310\311D\"\"!\262\312	<\2030	\2022	C<\203;\202=C\"\207" [buffer-file-name minibuffer-default abbreviate-file-name run-hook-with-args-until-success file-name-at-point-functions delete-dups delete "" delq nil append] 11 (#$ . 85989)])
#@2690 Read file name, prompting with PROMPT and completing in directory DIR.
The return value is not expanded---you must call `expand-file-name' yourself.

DIR is the directory to use for completing relative file names.
It should be an absolute directory name, or nil (which means the
current buffer's value of `default-directory').

DEFAULT-FILENAME specifies the default file name to return if the
user exits the minibuffer with the same non-empty string inserted
by this function.  If DEFAULT-FILENAME is a string, that serves
as the default.  If DEFAULT-FILENAME is a list of strings, the
first string is the default.  If DEFAULT-FILENAME is omitted or
nil, then if INITIAL is non-nil, the default is DIR combined with
INITIAL; otherwise, if the current buffer is visiting a file,
that file serves as the default; otherwise, the default is simply
the string inserted into the minibuffer.

If the user exits with an empty minibuffer, return an empty
string.  (This happens only if the user erases the pre-inserted
contents, or if `insert-default-directory' is nil.)

Fourth arg MUSTMATCH can take the following values:
- nil means that the user can exit with any input.
- t means that the user is not allowed to exit unless
  the input is (or completes to) an existing file.
- `confirm' means that the user can exit with any input, but she needs
  to confirm her choice if the input is not an existing file.
- `confirm-after-completion' means that the user can exit with any
  input, but she needs to confirm her choice if she called
  `minibuffer-complete' right before `minibuffer-complete-and-exit'
  and the input is not an existing file.
- anything else behaves like t except that typing RET does not exit if it
  does non-null completion.

Fifth arg INITIAL specifies text to start with.

Sixth arg PREDICATE, if non-nil, should be a function of one
argument; then a file name is considered an acceptable completion
alternative only if PREDICATE returns non-nil with the file name
as its argument.

If this command was invoked with the mouse, use a graphical file
dialog if `use-dialog-box' is non-nil, and the window system or X
toolkit in use provides a file dialog box, and DIR is not a
remote file.  For graphical file dialogs, any of the special values
of MUSTMATCH `confirm' and `confirm-after-completion' are
treated as equivalent to nil.  Some graphical file dialogs respect
a MUSTMATCH value of t, and some do not (or it only has a cosmetic
effect, and does not actually prevent the user from entering a
non-existent file).

See also `read-file-name-completion-ignore-case'
and `read-file-name-function'.

(fn PROMPT &optional DIR DEFAULT-FILENAME MUSTMATCH INITIAL PREDICATE)
(defalias 'read-file-name #[1537 "\206\301&\207" [read-file-name-function read-file-name-default] 13 (#$ . 86381)])
#@63 Syntax table used when reading a file name in the minibuffer.
(defvar minibuffer-local-filename-syntax (byte-code "\300 \301\302\303\304#\"\210\305\303\306\"\307\"\210
\207" [make-syntax-table 1 map-char-table make-closure #[514 "\211@\301=\205\f\302\303\300#\207" [V0 V1 modify-syntax-entry "_"] 6 "\n\n(fn C SYNTAX)"] mapc #[257 "\301
\302\300#\207" [V0 modify-syntax-entry "."] 5 "\n\n(fn C)"] (47 58 92)] 7) (#$ . 89208))
#@167 Default method for reading file names.
See `read-file-name' for the meaning of the arguments.

(fn PROMPT &optional DIR DEFAULT-FILENAME MUSTMATCH INITIAL PREDICATE)
(defalias 'read-file-name-default #[1537 "\204\206	\306\262\307!\204\310!\262\204/
\311\267\202(	\202-\202-\310\"\262\312!\262\203I:\203D\313\312\"\202G\312!\262\n\203j;\203j
\203d\314P!\314!GB\202s\314!\202s
\205s\314!\315B\316\206z\317\320\321 \203\211\322\n!\203\305\323\310!!\324\325	%\326\327!\211\324\330#M\210\324\331\"\216\332\333\"\210\334\335\f\305&)\266\202\262
\202
\336\n!\337>?\n\204\343
G\315U\204\343
\262\340\f!\262\f\n\203\374\310:\203\365@\202\367
\"\262\316\262\341


\f\342=%\266\202
\242
=\n:\203
\n@\262
=\203.
\211\204+
\316\262\343\262
\2046
\344\345!\210\n\203R

:\203H
@\202J
\230\203R
\n\262\346!\262\211\203\204
\314!)\203k

\347
A\"\241\210\211
A@\230\203|

\210
A\210\202\217


\240\266\202\217
\203\217
\350\305\314!\"\210
\266\202)\207" [default-directory buffer-file-name insert-default-directory read-file-name-completion-ignore-case minibuffer-completing-file-name file-name-history "~/" file-name-absolute-p expand-file-name #s(hash-table size 2 test equal rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (nil 32 #1="" 36)) abbreviate-file-name mapcar minibuffer-maybe-quote-filename 0 t file-exists-p nil next-read-file-uses-dialog-p file-remote-p file-name-as-directory make-closure #[0 "\303\301\242\206\301
\242\206
\232\203
\243\306\307!\210\302\306\310!\210\311\312\300\303#\313\f!\207" [V0 V1 V2 V3 default-directory minibuffer-default make-local-variable completion-ignore-case minibuffer-default-add-function make-closure #[0 "r\302\303 !q\210\304\301\300\")\207" [V0 V1 window-buffer minibuffer-selected-window read-file-name--defaults] 3] set-syntax-table minibuffer-local-filename-syntax] 4] make-symbol "minibuffer-setup" #[0 "\302\303\301\"\210\300 \207" [V0 V1 remove-hook minibuffer-setup-hook] 3] #[0 "\301\302\300\"\207" [V0 remove-hook minibuffer-setup-hook] 3] add-hook minibuffer-setup-hook completing-read read-file-name-internal file-name-nondirectory (nil confirm confirm-after-completion) file-name-directory x-file-dialog file-directory-p #1# error "No file name specified" substitute-in-file-name delete add-to-history history-delete-duplicates] 22 (#$ . 89647)])
#@206 Perform completion on all buffers excluding BUFFER.
BUFFER nil or omitted means use the current buffer.
Like `internal-complete-buffer', but removes BUFFER from the completion list.

(fn &optional BUFFER)
(defalias 'internal-complete-buffer-except #[256 "\211;\203	\211\202\f\300
!\301\302\303\304\305\"\306$\207" [buffer-name apply-partially completion-table-with-predicate internal-complete-buffer make-closure #[257 "\211:\203\n\211@\202\211\300\232?\207" [V0] 3 "\n\n(fn NAME)"] nil] 8 (#$ . 92096)])
#@32 

(fn STRING TABLE PRED POINT)
(defalias 'completion-emacs21-try-completion #[1028 "\300#\211;\203\211
GB\207\207" [try-completion] 8 (#$ . 92613)])
#@32 

(fn STRING TABLE PRED POINT)
(defalias 'completion-emacs21-all-completions #[1028 "\300\301#G\302\303$@#\207" [completion-hilit-commonality all-completions completion-boundaries ""] 12 (#$ . 92773)])
#@32 

(fn STRING TABLE PRED POINT)
(defalias 'completion-emacs22-try-completion #[1028 "
\300O\301\302O#\211;\204\207\211G\302U\2048\211
GSH\303=\2038
G\302U\2048
\302H\303=\2038
\304\300O\262\211P
GB\207" [nil try-completion 0 47 1] 9 (#$ . 92991)])
#@32 

(fn STRING TABLE PRED POINT)
(defalias 'completion-emacs22-all-completions #[1028 "\300O\301\302#\303\304$@#\207" [0 completion-hilit-commonality all-completions completion-boundaries ""] 13 (#$ . 93257)])
#@170 Merge end of COMPLETION with beginning of SUFFIX.
Simple generalization of the "merge trailing /" done in Emacs-22.
Return the new suffix.

(fn COMPLETION POINT SUFFIX)
(defalias 'completion--merge-suffix #[771 "\211G\300U\204#\301\302\303Q#\203#\304\225G=\203#\211\304\225\304\224Z\305O\207\207" [0 string-match "\\(.+\\)\n\\1" "\n" 1 nil] 8 (#$ . 93485)])
#@38 

(fn BEFOREPOINT AFTERPOINT BOUNDS)
(defalias 'completion-basic--pattern #[771 "
@\300O\301\302AOE\207" [nil point 0] 8 (#$ . 93856)])
#@32 

(fn STRING TABLE PRED POINT)
(defalias 'completion-basic-try-completion #[1028 "\301O\302O\303$\211A\301U\2031\304#\211;\204$\207\211\305#P
GB\207

A\302O\301@O\306\307#!\310$\203V\311
!\262
\312$\207" [minibuffer-completing-file-name 0 nil completion-boundaries try-completion completion--merge-suffix completion-pcm--optimize-pattern completion-basic--pattern completion-pcm--all-completions completion-pcm--filename-try-filter completion-pcm--merge-try] 16 (#$ . 94001)])
#@32 

(fn STRING TABLE PRED POINT)
(defalias 'completion-basic-all-completions #[1028 "\300O\301O\302$\300@O\303\304@\301O\305\300AOE\"\306\n\n$\307
@#\207" [0 nil completion-boundaries delete "" point completion-pcm--all-completions completion-hilit-commonality] 15 (#$ . 94527)])
#@404 Regular expression matching delimiters controlling the partial-completion.
Typically, this regular expression simply matches a delimiter, meaning
that completion can add something at (match-beginning 0), but if it has
a submatch 1, then completion can add something at (match-end 1).
This is used when the delimiter needs to be of size zero (e.g. the transition
from lowercase to uppercase characters).
(defvar completion-pcm--delim-wild-regex nil (#$ . 94838))
#@15 

(fn DELIMS)
(defalias 'completion-pcm--prepare-delim-re #[257 "\301
\302Q\211\207" [completion-pcm--delim-wild-regex "[" "*]"] 4 (#$ . 95306)])
(byte-code "\300\301\302\303\304DD\305\306\307\310\311\312\313&	\210\300\314\302\303\315DD\316\317\320\312\321&\207" [custom-declare-variable completion-pcm-word-delimiters funcall function #[0 "\300\207" ["-_./:| "] 1 #1=""] "A string of characters treated as word delimiters for completion.\nSome arcane rules:\nIf `]' is in this string, it must come first.\nIf `^' is in this string, it must not come first.\nIf `-' is in this string, it must come first or right after `]'.\nIn other words, if S is this string, then `[S]' must be a valid Emacs regular\nexpression (not containing character ranges like `a-z')." :set #[514 "\300\"\210\301
!\207" [set-default completion-pcm--prepare-delim-re] 5 "\n\n(fn SYMBOL VALUE)"] :initialize custom-initialize-reset :type string completion-pcm-complete-word-inserts-delimiters #[0 "\300\207" [nil] 1 #1#] "Treat the SPC or - inserted by `minibuffer-complete-word' as delimiters.\nThose chars are treated as delimiters if this variable is non-nil.\nI.e. if non-nil, M-x SPC will just insert a \"-\" in the minibuffer, whereas\nif nil, it will list all possible commands in *Completions* because none of\nthe commands start with a \"-\" or a SPC." :version "24.1" boolean] 10)
#@16 

(fn PATTERN)
(defalias 'completion-pcm--pattern-trivial-p #[257 "\211@;\205#\300
A\211\203\211@\211\301\235\204\302\262
A\266\202\202	\210\211\262
\207" [t (point "") nil] 6 (#$ . 96680)])
#@171 Split STRING into a pattern.
A pattern is a list where each element is either a string
or a symbol, see `completion-pcm--merge-completions'.

(fn STRING &optional POINT)
(defalias 'completion-pcm--string->pattern #[513 "\211\203\211GW\203
\302O\303O\304\305!\306\305!#\207\303\302\211\303\307#\211\262\203\227	\204:\310\311#\204\227\312\225\203C\312\225\262
U\204Z\211\203R\211B\262OB\262\303\262
H\313=\203q\314B\262T\262\202\221\315B\262\312\225\203\201\262\202\221\302\225OB\262\316\262
\302\225\262
\262\202!GV\203\257\211\203\247\211B\262\303OB\262\237\207" [completion-pcm--delim-wild-regex completion-pcm-complete-word-inserts-delimiters 0 nil append completion-pcm--string->pattern (point) string-match get-text-property completion-try-word 1 42 star any any-delim] 10 (#$ . 96885)])
#@10 

(fn P)
(defalias 'completion-pcm--optimize-pattern #[257 "\211C\211\300\301\242\"\240\210\302C
\242\203y\303\242:\203p\242\242\211\304\267\202g\242\243\211:\203F\211\242\211\305>\203;\211\242A\240\266\202\f\"\266\202\f\"\266\202\f\242\243\211\204^\302\240\266\202\f\"\266\202\f
\"\266\202\f\211\"\266\202\f\211\242\237\207" [delete "" nil #[514 "\211\242\211\242A\240\210\242\242B\240\207" [] 6 "\n\n(fn P N)"] #s(hash-table size 3 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (any-delim 33 any 33 point 79)) (point any)] 10 (#$ . 97748)])
#@32 

(fn PATTERN &optional GROUP)
(defalias 'completion-pcm--pattern->regex #[513 "\300\301\302\303\"\304#P\305\306\"\203\307\304\310\211\311%\262
\202\n\207" ["\\`" mapconcat make-closure #[257 "\211;\203	\302
!\207\211\303=\203	\304P\202\305\300:\203!
\300>\202\"\300\203*\306
\307Q\207\207" [V0 completion-pcm--delim-wild-regex regexp-quote any-delim "*?" ".*?" "\\(" "\\)"] 5 "\n\n(fn X)"] "" string-match "\\.\\*\\?\\(?:\\\\[()]\\)*\\(\\.\\*\\?\\)" replace-match t 1] 9 (#$ . 98360)])
#@124 Return index of subgroup corresponding to `point' element of PATTERN.
Return nil if there's no such element.

(fn PATTERN)
(defalias 'completion-pcm--pattern-point-idx #[257 "\300\301\211\203\"\211@\211;\204T\262\211\302=\203\262
A\266\202\202\210
\207" [nil 0 point] 7 (#$ . 98869)])
#@150 Find all completions for PATTERN in TABLE obeying PRED.
PATTERN is as returned by `completion-pcm--string->pattern'.

(fn PREFIX PATTERN TABLE PRED)
(defalias 'completion-pcm--all-completions #[1028 "\304!\203\305@P#\207\306!\211\nB\305@;\203%@\202&\307P#\310!\2044\211\202]\311
\211\203X\211@
\311\312\313#)\266\203\203Q\211B\262
A\266\202\2026\210\211\237\262
*\207" [completion-ignore-case case-fold-search completion-regexp-list inhibit-changing-match-data completion-pcm--pattern-trivial-p all-completions completion-pcm--pattern->regex "" functionp nil t string-match] 16 (#$ . 99173)])
#@565 Controls how the `flex' completion style scores its matches.

Value is a positive number.  A number smaller than 1 makes the
scoring formula reward matches scattered along the string, while
a number greater than one make the formula reward matches that
are clumped together.  I.e "foo" matches both strings
"fbarbazoo" and "fabrobazo", which are of equal length, but
only a value greater than one will score the former (which has
one large "hole" and a clumped-together "oo" match) higher
than the latter (which has two "holes" and three
one-letter-long matches).
(defvar flex-score-match-tightness 3 (#$ . 99804))
#@431 Show where and how well PATTERN matches COMPLETIONS.
PATTERN, a list of symbols and strings as seen
`completion-pcm--merge-completions', is assumed to match every
string in COMPLETIONS.  Return a deep copy of COMPLETIONS where
each string is propertized with `completion-score', a number
between 0 and 1, and with faces `completions-common-part',
`completions-first-difference' in the relevant segments.

(fn PATTERN COMPLETIONS)
(defalias 'completion-pcm--hilit-commonality #[514 "\211\203?
\302\211\211:\203$@\262;\211\262?\211\262\203$A\262\202\266\203\203?\303\304\"\305!\302C\306\307\310$\")\207\207" [completion-ignore-case case-fold-search nil completion-pcm--pattern->regex group completion-pcm--pattern-point-idx mapcar make-closure #[257 "\211C\211\303\242!\240\210\304\300\242\"\204\305\306\300\242#\210\301\203!\301\224\202#\307\225\307\225\302\310\311\302\242\"\240AA\307\242G\307C\307C\307C\312\203\\\211\n\n\f\211A\262\242&\210\211A\262\242\262\2029U\204p\211\n\n
&\210	\242G	V\203\206\313	\211T\314\315\242%\210	\242G\307U\204\245\316\307\317\320\321\242\n	\242T_\322#\242%\210\266	\211\242\207" [V0 V1 V2 copy-sequence string-match error "Internal error: %s does not match %s" 0 match-data t #[1542 "\301\302\303\n\242%\210\211\242Z\\\240\210
\242U\204<\242\304U\204<
\242GU\204<\211\242T\305\242ZS\306\245\"\\\240\210
\240\207" [flex-score-match-tightness add-face-text-property completions-common-part nil 0 expt 1.0] 12 "Update score and face given match range (A B).\n\n(fn STR SCORE-NUMERATOR SCORE-DENOMINATOR LAST-B A B)"] add-face-text-property completions-first-difference nil put-text-property 1 completion-score / 1.0] 19 "\n\n(fn STR)"]] 11 (#$ . 100426)])
#@294 Find all completions for STRING at POINT in TABLE, satisfying PRED.
POINT is a position inside STRING.
FILTER is a function applied to the return value, that can be used, e.g. to
filter out additional entries (because TABLE might not obey PRED).

(fn STRING TABLE PRED POINT &optional FILTER)
(defalias 'completion-pcm--find-all-completions #[1284 "\211\204\300\262
\301O\302O\303$\301@OA\302O\302\n@	A\\O\262@Z\304\305
\"!\3061O\307$!0\202U\211\262\302\262
\211\204n
@\301V\203n
\3101q\311#0\202s\210\302\204n
\301\312O\313
G%\211\242
\243\211\242
\243\211\242
\243\211\242
\243\302\211GSH\302C	\302\262\211\203\301\211@
\211GSH=\203\272\211B\262
A\266\202\202\244\210\203S
@\301OQG@G\\\303$A
A=\203\361\211@=\204#
\211@W\204#

A\302O\262
@\302O\301AOP\262@O\240\210\304\305 G@Z\"!\262\211\203Q
\211@\314\315\316#\307\242Q%%$!\"\244\262
A\266\202\202%
\266\317\f\320\321!D\242\205c
\242C$\262\262\266\211\204}
\203}
\322@A\"\207

F\207" [identity 0 nil completion-boundaries completion-pcm--optimize-pattern completion-pcm--string->pattern (debug error) completion-pcm--all-completions (error) try-completion -1 completion-pcm--find-all-completions mapcar make-closure #[257 "\301\300\242Q\207" [V0 V1] 4 "\n\n(fn S)"] append any string signal] 41 (#$ . 102209)])
#@32 

(fn STRING TABLE PRED POINT)
(defalias 'completion-pcm-all-completions #[1028 "\300$\211\242
\243\211\242
\243\211\242
\243\211\242
\243\301\205%\302	\"G\244\207" [completion-pcm--find-all-completions nil completion-pcm--hilit-commonality] 17 (#$ . 103627)])
#@58 Return the common suffix of the strings STRS.

(fn STRS)
(defalias 'completion--common-suffix #[257 "\300\301\302\303\"\"\237\207" [try-completion "" mapcar reverse] 6 (#$ . 103905)])
#@770 Extract the commonality in STRS, with the help of PATTERN.
PATTERN can contain strings and symbols chosen among `star', `any', `point',
and `prefix'.  They all match anything (aka ".*") but are merged differently:
`any' only grows from the left (when matching "a1b" and "a2b" it gets
  completed to just "a").
`prefix' only grows from the right (when matching "a1b" and "a2b" it gets
  completed to just "b").
`star' grows from both ends and is reified into a "*"  (when matching "a1b"
  and "a2b" it gets completed to "a*b").
`point' is like `star' except that it gets reified as the position of point
  instead of being reified as a "*" character.
The underlying idea is that we should return a string which still matches
the same set of elements.

(fn STRS PATTERN)
(defalias 'completion-pcm--merge-completions #[514 "
A\204	
@C\207\302
\303\"\304\211\203[\211@\305\"\204%\306\307#\210\304\310\311\304
\225\211\262\203COB\262\211\262
T\262\202)\304OB\262\237B\262\266
A\266\202\202\210)\304\312\313\314\"\211\203
\211@\211;\203v
P\262\202
\304\304\262\211\203\225\211@\211@B\262\211AB\262
A\266\202\202{\210\237\262\315\"\211\316=\203\253\211\262\206\261\315
\"\316=\317=\204\303
\312\232\204\303
B\262\211\204\n
B\262\320>\203\n
\321\316#\204\n
\322G\310U\203\347\202\363G\323\324\325\"\"\262
!\211;\204\375\326\327!\210\211\312\232\204	
\211B\262\210\312\262\266
A\266\202\202c\210
\207" [completion-ignore-case case-fold-search completion-pcm--pattern->regex group nil string-match error "Internal error: %s doesn't match %s" 0 1 "" append (any) try-completion t prefix (star point prefix) assoc-string completion--common-suffix mapcar make-closure #[257 "\211\300\301O\207" [V0 nil] 4 "\n\n(fn STR)"] cl--assertion-failed (stringp suffix)] 17 (#$ . 104097)])
#@16 

(fn PATTERN)
(defalias 'completion-pcm--pattern->string #[257 "\300\301\302#\207" [mapconcat #[257 "\211;\203\207\211\300=\203\301\207\302\207" [star "*" #1=""] 3 "\n\n(fn X)"] #1#] 5 (#$ . 105953)])
#@76 Filter to adjust `all' file completion to the behavior of `try'.

(fn ALL)
(defalias 'completion-pcm--filename-try-filter #[257 "\211\2057\302\303\304!\305Q\211\203.\211@
\302\306\307#)\266\203\204'\211B\262
A\266\202\202\f\210
\237\2065\266\202\207" [completion-ignored-extensions inhibit-changing-match-data nil "\\(?:\\`\\.\\.?/\\|" regexp-opt "\\)\\'" t string-match] 12 (#$ . 106166)])
#@34 

(fn PATTERN ALL PREFIX SUFFIX)
(defalias 'completion-pcm--merge-try #[1028 ":\204\207A:\204\300!@\232\203\301\207\302\"\303
>\206/\304
>\206/\305
>\206/\211\300
!G\300\237!\306
\307GS]#\262
QG\\B\207" [completion-pcm--pattern->string t completion-pcm--merge-completions point any star completion--merge-suffix 0] 12 (#$ . 106578)])
#@32 

(fn STRING TABLE PRED POINT)
(defalias 'completion-pcm-try-completion #[1028 "\301\205\n\302%\211\242
\243\211\242
\243\211\242
\243\211\242
\243\303$\207" [minibuffer-completing-file-name completion-pcm--find-all-completions completion-pcm--filename-try-filter completion-pcm--merge-try] 18 (#$ . 106945)])
#@263 Match the presumed substring STRING to the entries in TABLE.
Respect PRED and POINT.  The pattern used is a PCM-style
substring pattern, but it be massaged by TRANSFORM-PATTERN-FN, if
that is non-nil.

(fn STRING TABLE PRED POINT &optional TRANSFORM-PATTERN-FN)
(defalias 'completion-substring--all-completions #[1284 "\300O\301O\302$

A\301O\300@O\303#\211@;\204)\211\202,\304
B\305\2039!\202:
!\306$\211\n@\257\207" [0 nil completion-boundaries completion-basic--pattern prefix completion-pcm--optimize-pattern completion-pcm--all-completions] 19 (#$ . 107275)])
#@32 

(fn STRING TABLE PRED POINT)
(defalias 'completion-substring-try-completion #[1028 "\301$\211\242
\243\211\242
\243\211\242
\243\211\242
\243\211\242
\243	\302\203'\303\f!\262\304\n\n	$\207" [minibuffer-completing-file-name completion-substring--all-completions nil completion-pcm--filename-try-filter completion-pcm--merge-try] 22 (#$ . 107883)])
#@32 

(fn STRING TABLE PRED POINT)
(defalias 'completion-substring-all-completions #[1028 "\300$\211\242
\243\211\242
\243\211\242
\243\211\242
\243\211\242
\243\301\211\205+\302\n
\"G\244\207" [completion-substring--all-completions nil completion-pcm--hilit-commonality] 20 (#$ . 108252)])
(byte-code "\300\301\302\303\304DD\305\306\307\310\311&\210\312\313\314\315#\207" [custom-declare-variable completion-flex-nospace funcall function #[0 "\300\207" [nil] 1 ""] "Non-nil if `flex' completion rejects spaces in search pattern." :version "27.1" :type boolean put flex completion--adjust-metadata completion--flex-adjust-metadata] 8)
#@71 If `flex' is actually doing filtering, adjust sorting.

(fn METADATA)
(defalias 'completion--flex-adjust-metadata #[257 "\300 ?\206\nd\301 V\302\303\"\302\304\"\305\306\307\205$\303\206!\310!BC\2054\304\2061\310!BCA#B\207" [window-minibuffer-p minibuffer-prompt-end completion-metadata-get display-sort-function cycle-sort-function #[257 "\300\301\"\207" [make-closure #[257 "\301\300!\302\"\207" [V0 sort #[514 "\300\301\302#\300\301\302#
\206\301
\206\301V\207" [get-text-property 0 completion-score] 7 "\n\n(fn C1 C2)"]] 4 "\n\n(fn COMPLETIONS)"]] 4 "\n\n(fn EXISTING-SORT-FN)"] metadata append identity] 11 (#$ . 108901)])
#@236 Convert PCM-style PATTERN into PCM-style flex pattern.

This turns
    (prefix "foo" point)
into
    (prefix "f" any "o" any "o" any point)
which is at the core of flex logic.  The extra
'any' is optimized away later on.

(fn PATTERN)
(defalias 'completion-flex--make-flex-pattern #[257 "\300\301\"\207" [mapcan #[257 "\211;\203\n\300\301\"\207\211C\207" [mapcan #[257 "\300
!\301D\207" [string any] 3 "\n\n(fn CHAR)"]] 4 "\n\n(fn ELEM)"]] 4 (#$ . 109561)])
#@90 Try to flex-complete STRING in TABLE given PRED and POINT.

(fn STRING TABLE PRED POINT)
(defalias 'completion-flex-try-completion #[1028 "\205\302\303\"?\205A\304\305%\211\242
\243\211\242
\243\211\242
\243\211\242
\243\211\242
\243	\306	\2034\307\f!\262\310\n\n	$\266\214\262
\207" [completion-flex-nospace minibuffer-completing-file-name string-search " " completion-substring--all-completions completion-flex--make-flex-pattern nil completion-pcm--filename-try-filter completion-pcm--merge-try] 22 (#$ . 110028)])
#@94 Get flex-completions of STRING in TABLE, given PRED and POINT.

(fn STRING TABLE PRED POINT)
(defalias 'completion-flex-all-completions #[1028 "\205\301\302\"?\205<\303\304%\211\242
\243\211\242
\243\211\242
\243\211\242
\243\211\242
\243\305\211\2058\306\n
\"G\244\266\214\262
\207" [completion-flex-nospace string-search " " completion-substring--all-completions completion-flex--make-flex-pattern nil completion-pcm--hilit-commonality] 20 (#$ . 110569)])
#@23 

(fn STR TABLE PRED)
(defalias 'completion-initials-expand #[771 "\301\302$G\303U\206\304@#?\205D\211@\303U\203$\305\306\307#\207\211@\310W\205D
@S@O\303@O\305\306@\311O#P\262
\207" [completion-pcm--delim-wild-regex completion-boundaries "" 0 string-match mapconcat string "-" 3 nil] 11 (#$ . 111049)])
#@32 

(fn STRING TABLE PRED POINT)
(defalias 'completion-initials-all-completions #[1028 "\300#\211\205\301
G$\207" [completion-initials-expand completion-pcm-all-completions] 10 (#$ . 111380)])
#@32 

(fn STRING TABLE PRED POINT)
(defalias 'completion-initials-try-completion #[1028 "\300#\211\205\301
G$\207" [completion-initials-expand completion-pcm-try-completion] 10 (#$ . 111585)])
#@96 Try completion with `read-symbol-shorthands' of original buffer.

(fn STRING TABLE PRED POINT)
(defalias 'completion-shorthand-try-completion #[1028 "\302rq\210	)\302\211\211\211\211\211:\203v@\262\211A\262\242\262GV\205C\303
\"\205C\304
G\302OP\211\262\n\f\f#\262\203g\305\306!\210G\nGZG\\]B\262
\302\211\262\202h\307\203vA\262\302\262\202
\207" [minibuffer--original-buffer read-symbol-shorthands nil string-prefix-p try-completion message "Shorthand expansion" t] 17 (#$ . 111788)])
#@32 

(fn STRING TABLE PRED POINT)
(defalias 'completion-shorthand-all-completions #[1028 "\300\207" [nil] 5 (#$ . 112324)])
#@116 The function called by `completing-read' to do its work.
It should accept the same arguments as `completing-read'.
(defvar completing-read-function 'completing-read-default (#$ . 112452))
#@223 Default method for reading from the minibuffer with completion.
See `completing-read' for the meaning of the arguments.

(fn PROMPT COLLECTION &optional PREDICATE REQUIRE-MATCH INITIAL-INPUT HIST DEF INHERIT-INPUT-METHOD)
(defalias 'completing-read-default #[2050 ":\203
@ATB\262\203\202	\n\304>\203 \211\202$\305\"p\306\307%\310\311!\211\306\312#M\210\306\313\"\216\314\315\"\210\316
\n\317\f\f\f&)\266\202\211\320\232\203n\203n:\203k@\202l\262
\207" [minibuffer-local-must-match-map minibuffer-local-completion-map minibuffer-completing-file-name minibuffer-local-filename-completion-map (nil lambda) make-composed-keymap make-closure #[0 "\306\304!\210\300\306\305!\210\301\306\307!\210\302\310=?\205\302\306\311!\210\302	\306\312!\210\303\211\n\207" [V0 V1 V2 V3 minibuffer-completion-table minibuffer-completion-predicate make-local-variable minibuffer-completion-confirm t minibuffer--require-match minibuffer--original-buffer] 2] make-symbol "minibuffer-setup" #[0 "\302\303\301\"\210\300 \207" [V0 V1 remove-hook minibuffer-setup-hook] 3] #[0 "\301\302\300\"\207" [V0 remove-hook minibuffer-setup-hook] 3] add-hook minibuffer-setup-hook read-from-minibuffer nil ""] 21 (#$ . 112647)])
#@74 Get a file name at point in original buffer and insert it to minibuffer.
(defalias 'minibuffer-insert-file-name-at-point #[0 "r\300\301 !q\210\302\303!)\211\205\211c\207" [window-buffer minibuffer-selected-window run-hook-with-args-until-success file-name-at-point-functions] 2 (#$ . 113896) nil])
#@238 Move to the logical beginning of the minibuffer.
This command behaves like `beginning-of-buffer', but if point is
after the end of the prompt, move to the end of the prompt.
Otherwise move to the start of the buffer.

(fn &optional ARG)
(defalias 'minibuffer-beginning-of-buffer #[256 "\211:\204\n\301 \203
\302 \210\211\203%\211:\204%eTdeZ\303!_\304\245\\\2026\2030`\305 X\2034e\2026\305 b\210\211\205D\211:?\205D\306y\207" [minibuffer-beginning-of-buffer-movement region-active-p push-mark prefix-numeric-value 10 minibuffer-prompt-end 1] 5 (#$ . 114203) "^P"])
(byte-code "\300\301\302\303#\300\207" [function-put minibuffer-beginning-of-buffer interactive-only "use `(goto-char (point-min))' instead."] 4)
#@214 Execute the forms in BODY from the minibuffer in its original window.
When used in a minibuffer window, select the window selected just before
the minibuffer was activated, and execute the forms.

(fn &rest BODY)
(defalias 'with-minibuffer-selected-window '(macro . #[128 "\300\301\302\303\304\303BBEE\207" [let ((window (minibuffer-selected-window))) when window with-selected-window] 8 (#$ . 114932)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put with-minibuffer-selected-window lisp-indent-function 0 put edebug-form-spec t] 5)
#@91 Run `recenter-top-bottom' from the minibuffer in its original window.

(fn &optional ARG)
(defalias 'minibuffer-recenter-top-bottom #[256 "\300 \211\205\301
!r\302\303\"\216\304
@\305\"\210\306!*\262
\207" [minibuffer-selected-window internal--before-with-selected-window make-closure #[0 "\301\300!\207" [V0 internal--after-with-selected-window] 2] select-window norecord recenter-top-bottom] 6 (#$ . 115493) "P"])
#@89 Run `scroll-up-command' from the minibuffer in its original window.

(fn &optional ARG)
(defalias 'minibuffer-scroll-up-command #[256 "\300 \211\205\301
!r\302\303\"\216\304
@\305\"\210\306!*\262
\207" [minibuffer-selected-window internal--before-with-selected-window make-closure #[0 "\301\300!\207" [V0 internal--after-with-selected-window] 2] select-window norecord scroll-up-command] 6 (#$ . 115919) "^P"])
#@91 Run `scroll-down-command' from the minibuffer in its original window.

(fn &optional ARG)
(defalias 'minibuffer-scroll-down-command #[256 "\300 \211\205\301
!r\302\303\"\216\304
@\305\"\210\306!*\262
\207" [minibuffer-selected-window internal--before-with-selected-window make-closure #[0 "\301\300!\207" [V0 internal--after-with-selected-window] 2] select-window norecord scroll-down-command] 6 (#$ . 116340) "^P"])
#@91 Run `scroll-other-window' from the minibuffer in its original window.

(fn &optional ARG)
(defalias 'minibuffer-scroll-other-window #[256 "\300 \211\205\301
!r\302\303\"\216\304
@\305\"\210\306!*\262
\207" [minibuffer-selected-window internal--before-with-selected-window make-closure #[0 "\301\300!\207" [V0 internal--after-with-selected-window] 2] select-window norecord scroll-other-window] 6 (#$ . 116767) "P"])
#@96 Run `scroll-other-window-down' from the minibuffer in its original window.

(fn &optional ARG)
(defalias 'minibuffer-scroll-other-window-down #[256 "\300 \211\205\301
!r\302\303\"\216\304
@\305\"\210\306!*\262
\207" [minibuffer-selected-window internal--before-with-selected-window make-closure #[0 "\301\300!\207" [V0 internal--after-with-selected-window] 2] select-window norecord scroll-other-window-down] 6 (#$ . 117193) "^P"])
(byte-code "\300\301\302\303\304DD\305\306\307\310\311&\207" [custom-declare-variable minibuffer-default-prompt-format funcall function #[0 "\300\207" [" (default %s)"] 1 ""] "Format string used to output \"default\" values.\nWhen prompting for input, there will often be a default value,\nleading to prompts like \"Number of articles (default 50): \".\nThe \"default\" part of that prompt is controlled by this\nvariable, and can be set to, for instance, \" [%s]\" if you want\na shorter displayed prompt, or \"\", if you don't want to display\nthe default at all.\n\nThis variable is used by the `format-prompt' function." :version "28.1" :type string] 8)
#@530 Format PROMPT with DEFAULT according to `minibuffer-default-prompt-format'.
If FORMAT-ARGS is nil, PROMPT is used as a plain string.  If
FORMAT-ARGS is non-nil, PROMPT is used as a format control
string, and FORMAT-ARGS are the arguments to be substituted into
it.  See `format' for details.

If DEFAULT is a list, the first element is used as the default.
If not, the element is used as is.

If DEFAULT is nil or an empty string, no "default value" string
is included in the return value.

(fn PROMPT DEFAULT &rest FORMAT-ARGS)
(defalias 'format-prompt #[642 "\211\204\202
\301\302#\205+;\203\303\304\"\205+\302:\203)@\202*\"\305Q\207" [minibuffer-default-prompt-format apply format length> 0 ": "] 7 (#$ . 118295)])
(provide 'minibuffer)