HOME

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

;;; This file uses dynamic docstrings, first added in Emacs 19.29.

;;; This file does not contain utf-8 non-ASCII characters,
;;; and so can be loaded in Emacs versions earlier than 23.

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


(require 'macroexp)
(defconst pcase--memoize (make-hash-table :weakness 'key :test 'eq))
(defconst pcase--dontcare-upats '(t _ pcase--dontcare))
(defvar pcase--dontwarn-upats '(pcase--dontcare))
(byte-code "\300\301\302\303#\210\300\304\302\305#\210\300\306\302\307#\207" [put pcase-PAT edebug-form-spec (&or symbolp ("or" &rest pcase-PAT) ("and" &rest pcase-PAT) ("guard" form) ("let" pcase-PAT form) ("pred" pcase-FUN) ("app" pcase-FUN pcase-PAT) pcase-MACRO sexp) pcase-FUN (&or lambda-expr (functionp &rest form) sexp) pcase-MACRO pcase--edebug-match-macro] 4)
#@15 

(fn CURSOR)
(defalias 'pcase--edebug-match-macro #[257 "\300C\301\302\303\304\305\306!\307\"\310\311%!\210\312\313\242B\"\207" [nil mapatoms make-byte-code 257 "\211\301N\211\205\302
!\205\300\303!\302!B\300\242B\240\207" vconcat vector [pcase-macroexpander get-edebug-spec symbol-name] 6 "\n\n(fn S)" edebug-match &or] 9 (#$ . 973)])
#@2596 Evaluate EXP and attempt to match it against structural patterns.
CASES is a list of elements of the form (PATTERN CODE...).

A structural PATTERN describes a template that identifies a class
of values.  For example, the pattern \=`(,foo ,bar) matches any
two element list, binding its elements to symbols named `foo' and
`bar' -- in much the same way that `cl-destructuring-bind' would.

A significant difference from `cl-destructuring-bind' is that, if
a pattern match fails, the next case is tried until either a
successful match is found or there are no more cases.  The CODE
expression corresponding to the matching pattern determines the
return value.  If there is no match the returned value is nil.

Another difference is that pattern elements may be quoted,
meaning they must match exactly: The pattern \='(foo bar)
matches only against two element lists containing the symbols
`foo' and `bar' in that order.  (As a short-hand, atoms always
match themselves, such as numbers or strings, and need not be
quoted.)

Lastly, a pattern can be logical, such as (pred numberp), that
matches any number-like element; or the symbol `_', that matches
anything.  Also, when patterns are backquoted, a comma may be
used to introduce logical patterns inside backquoted patterns.

The complete list of standard patterns is as follows:

  _		matches anything.
  SYMBOL	matches anything and binds it to SYMBOL.
                If a SYMBOL is used twice in the same pattern
                the second occurrence becomes an `eq'uality test.
  (or PAT...)	matches if any of the patterns matches.
  (and PAT...)	matches if all the patterns match.
  \='VAL		matches if the object is `equal' to VAL.
  ATOM		is a shorthand for \='ATOM.
		   ATOM can be a keyword, an integer, or a string.
  (pred FUN)	matches if FUN applied to the object returns non-nil.
  (guard BOOLEXP)	matches if BOOLEXP evaluates to non-nil.
  (let PAT EXP)	matches if EXP matches PAT.
  (app FUN PAT)	matches if FUN applied to the object matches PAT.

Additional patterns can be defined using `pcase-defmacro'.

The FUN argument in the `app' pattern may have the following forms:
  SYMBOL or (lambda ARGS BODY)  in which case it's called with one argument.
  (F ARG1 .. ARGn) in which case F gets called with an n+1'th argument
                        which is the value being matched.
So a FUN of the form SYMBOL is equivalent to (FUN).
FUN can refer to variables bound earlier in the pattern.

See Info node `(elisp) Pattern matching case statement' in the
Emacs Lisp manual for more information and examples.

(fn EXP &rest CASES)
(defalias 'pcase '(macro . #[385 "\301
@\"
@\232\203

A@\232\203\211AA\202,\302\"\303@BB#\210\211\262
\207" [pcase--memoize gethash pcase--expand puthash] 9 (#$ . 1328)]))
(byte-code "\300\301\302\303#\304\301\305\306#\210\304\301\307\310#\207" [function-put pcase lisp-indent-function 1 put edebug-form-spec (form &rest (pcase-PAT body)) function-documentation (pcase--make-docstring)] 5)
(defalias 'pcase--make-docstring #[0 "\300\301K\302\"\303
\301\"\304\305!\210\306\307!r\211q\210\310\311\312\313\314!\315\"\316$\216
A\206&c\210\317\320!\210\321 \203:\322
@\"\202;\211\262
*\262
\207" [documentation pcase raw help-split-fundoc require help-fns generate-new-buffer " *temp*" make-byte-code 0 "\301\300!\205	\302\300!\207" vconcat vector [buffer-name kill-buffer] 2 mapatoms #[257 "\211\300N\211\205$\301c\210\302
\303\"\304\305!\306%\262
\307
\206 \310\261\262
\207" [pcase-macroexpander "\n\n-- " documentation raw help-fns--signature indirect-function nil "\n" "Not documented."] 9 "\n\n(fn SYMBOL)"] buffer-string help-add-fundoc-usage] 9])
#@144 The exhaustive version of `pcase' (which see).
If EXP fails to match any of the patterns in CASES, an error is signaled.

(fn EXP &rest CASES)
(defalias 'pcase-exhaustive '(macro . #[385 "\301\302!\211B\303\304\305\306EDC\"\")\207" [pcase--dontwarn-upats gensym "x" pcase--expand append error "No clause matching `%S'"] 11 (#$ . 5010)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put pcase-exhaustive lisp-indent-function 1 put edebug-form-spec pcase] 5)
#@258 Like `lambda' but allow each argument to be a pattern.
I.e. accepts the usual &optional and &rest keywords, but every
formal argument can be any pattern accepted by `pcase' (a mere
variable name being but a special case of it).

(fn LAMBDA-LIST &rest BODY)
(defalias 'pcase-lambda '(macro . #[385 "\300C\301!\302\303\304\305\306\307!\310\"\311\312%\"\313
\314@\315\242\237ABBC\"BB\207" [nil macroexp-parse-body mapcar make-byte-code 257 "\2119\203\207\301\302\303\300\242G\"!\300D\300\242B\240\210\211\207" vconcat vector [make-symbol format "arg%s"] 5 "\n\n(fn PAT)" lambda append pcase-let*] 12 (#$ . 5499)]))
(byte-code "\300\301\302\303#\300\301\304\305#\306\301\307\310#\207" [function-put pcase-lambda doc-string-elt 2 lisp-indent-function defun put edebug-form-spec (&define (&rest pcase-PAT) lambda-doc def-body)] 6)
#@22 

(fn BINDINGS BODY)
(defalias 'pcase--let* #[514 "
\204\300
!\207\301@@!\203\302@C\303A\"\"\207
\211A\262\242\304
A@@\303\"D\305B\"\207" [macroexp-progn pcase--trivial-upat-p macroexp-let* pcase--let* pcase--expand ((pcase--dontcare nil))] 9 (#$ . 6343)])
#@187 Like `let*' but where you can use `pcase' patterns for bindings.
BODY should be an expression, and BINDINGS should be a list of bindings
of the form (PAT EXP).

(fn BINDINGS &rest BODY)
(defalias 'pcase-let* '(macro . #[385 "\301\"\211@\232\203\211A\202\302\"\303B#\210\211\262
\207" [pcase--memoize gethash pcase--let* puthash] 8 (#$ . 6621)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put pcase-let* lisp-indent-function 1 put edebug-form-spec ((&rest (pcase-PAT &optional form)) body)] 5)
#@349 Like `let' but where you can use `pcase' patterns for bindings.
BODY should be a list of expressions, and BINDINGS should be a list of bindings
of the form (PAT EXP).
The macro is expanded and optimized under the assumption that those
patterns *will* match, so a mismatch may go undetected or may cause
any kind of error.

(fn BINDINGS &rest BODY)
(defalias 'pcase-let '(macro . #[385 "
A\204\301BB\207\302\302\262\211\203Z\211@\211@>\203*\303\304!
ABB\262\202S\305
@!\2039\211B\262\202S\303\306\307G\"!\211ABB\262
@
DB\262\210
A\266\202\202\210\310\237\301BBE\207" [pcase--dontcare-upats pcase-let* nil make-symbol "_" pcase--trivial-upat-p format "x%d" let] 9 (#$ . 7154)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put pcase-let lisp-indent-function 1 put edebug-form-spec pcase-let*] 5)
#@92 Like `dolist' but where the binding can be a `pcase' pattern.

(fn (PATTERN LIST) BODY...)
(defalias 'pcase-dolist '(macro . #[385 "\300@!\203
\301BB\207\302\303!\301
AB\304@DCBBE\207" [pcase--trivial-upat-p dolist gensym "x" pcase-let*] 8 (#$ . 8001)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put pcase-dolist lisp-indent-function 1 put edebug-form-spec ((pcase-PAT form) body)] 5)
#@13 

(fn UPAT)
(defalias 'pcase--trivial-upat-p #[257 "\2119\205	\211>?\207" [pcase--dontcare-upats] 3 (#$ . 8421)])
#@18 

(fn EXP CASES)
(defalias 'pcase--expand #[514 "
\301
!\203\211\202\302\303!\304C\304C\305\306\307\310\311\"\312\"\313\314%\304C\315\316\305\317\320\310\311		#\321\"\322\323%	\"!\211\203]\211@\211\242>\204V\211@>\204V\324\325@\"\210
A\266\202\202<\210\326\242\"\266\205
=\203o\211\202v\326DC\"\207" [pcase--dontwarn-upats macroexp-copyable-p make-symbol "val" nil make-byte-code 514 "\211C\301\242\236\211\204 \302\242\"\301\242E\301\242B\240\210\211\262
\202\202\211@
A\211@
A\211@\2119\204`\303\304\305\300\242G\"!\300
\306\307\310\"	BBD\300\242B\240\210
\311\240\210

\307\312\"B\241\210AA
\240\210\262
\313\242!\240\210\307\314\315\316\317\320\f!\321\"\322\323%\"\311BB\262
\266\205\262
\207" vconcat vector [pcase-codegen make-symbol format "pcase-%d" lambda mapcar car funcall cdr copy-sequence make-byte-code 257 "\211@\300\242\236\300\301\300\242\"\240\210\211A\207" vconcat vector [delq] 6 "\n\n(fn PA)"] 16 "\n\n(fn CODE VARS)" pcase--u mapcar 257 "\303\300\304@!\"\305\306\307\310\311\301\302#\312\"\313\314%D\207" [pcase--match pcase--macroexpand make-byte-code 257 "\302\301\242>\204\301\302\301\242B\240\210\303\302A!\203\304\202\300\302A\"\207" vconcat vector [pcase--small-branch-p pcase-codegen] 4 "\n\n(fn VARS)"] 10 "\n\n(fn CASE)" message "Redundant pcase pattern: %S" macroexp-let*] 18 (#$ . 8543)])
#@46 Expands all macro-patterns in PAT.

(fn PAT)
(defalias 'pcase--macroexpand #[257 "\211\242\211\204\300!\203\301D\202}
\202}\211\302>\203 
\202}\211\303>\2030\211\304\305A\"B\202}\211\306=\203D\306\305A@!AABB\202}\211\307=\203W\307A@\305\3108!E\202}\211\311N\211\205c\312
A\"\211\204x\313\203p\314\202q\315#\202{\305
!\266\202\207" [pcase--self-quoting-p quote (pred guard quote) (or and) mapcar pcase--macroexpand let app 2 pcase-macroexpander apply error "Unexpandable %s pattern: %S" "Unknown %s pattern: %S"] 8 (#$ . 9936)])
#@158 Define a new kind of pcase PATTERN, by macro expansion.
Patterns of the form (NAME ...) will be expanded according
to this macro.

(fn NAME ARGS &rest BODY)
(defalias 'pcase-defmacro '(macro . #[642 "\300\301\302\"!\303\236\211\203\304
\"\262\305\306BBB\307\310D\311\310\312\236A@DF\307\310	D\313\314DFF\207" [intern format "%s--pcase-macroexpander" declare remove progn defun define-symbol-prop quote 'edebug-form-spec debug 'pcase-macroexpander function] 13 (#$ . 10502)]))
(byte-code "\300\301\302\303#\304\301\305\306#\210\300\301\307\310#\300\207" [function-put pcase-defmacro lisp-indent-function 2 put edebug-form-spec defun doc-string-elt 3] 5)
#@80 Build a MATCH structure, hoisting all `or's and `and's outside.

(fn VAL UPAT)
(defalias 'pcase--match #[514 "\211\242\300>\203\211@\301\302\303\304\305\306!\307\"\310\311%A\"B\207\312BB\207" [(or and) mapcar make-byte-code 257 "\301\300\"\207" vconcat vector [pcase--match] 4 "\n\n(fn UPAT)" match] 10 (#$ . 11178)])
#@18 

(fn CODE VARS)
(defalias 'pcase-codegen #[514 "\211\203
\300\301\302\"BB\207\303B\207" [let mapcar #[257 "\211@
AD\207" [] 3 "\n\n(fn B)"] progn] 6 (#$ . 11510)])
#@13 

(fn CODE)
(defalias 'pcase--small-branch-p #[257 "\211G\300U\205*\211@:?\206*\301
@\211\203&\211@\211:\203\302\262
A\266\202\202\210\211\262
\207" [1 t nil] 5 (#$ . 11685)])
#@23 

(fn TEST THEN ELSE)
(defalias 'pcase--if #[771 "\211\300=\203
\207
\300=\203\301 \210\207\302#\207" [:pcase--dontcare debug macroexp-if] 7 (#$ . 11875)])
#@319 Expand matcher for rules BRANCHES.
Each BRANCH has the form (MATCH CODE . VARS) where
CODE is the code generator for that branch.
VARS is the set of vars already bound by earlier matches.
MATCH is the pattern that needs to be matched, of the form:
  (match VAR . PAT)
  (and MATCH ...)
  (or MATCH ...)

(fn BRANCHES)
(defalias 'pcase--u #[257 "\300\301\"\211\262\205\211@\211@
A\211@
A\302C	A$\266\205\207" [delq nil pcase--u1] 11 (#$ . 12045)])
#@22 

(fn MATCH MATCHES)
(defalias 'pcase--and #[514 "\211\203\n\300BB\207
\207" [and] 5 (#$ . 12506)])
(defconst pcase-mutually-exclusive-predicates '((symbolp . integerp) (symbolp . numberp) (symbolp . consp) (symbolp . arrayp) (symbolp . vectorp) (symbolp . stringp) (symbolp . byte-code-function-p) (symbolp . recordp) (integerp . consp) (integerp . arrayp) (integerp . vectorp) (integerp . stringp) (integerp . byte-code-function-p) (integerp . recordp) (numberp . consp) (numberp . arrayp) (numberp . vectorp) (numberp . stringp) (numberp . byte-code-function-p) (numberp . recordp) (consp . arrayp) (consp . atom) (consp . vectorp) (consp . stringp) (consp . byte-code-function-p) (consp . recordp) (arrayp . byte-code-function-p) (vectorp . byte-code-function-p) (vectorp . recordp) (stringp . vectorp) (stringp . recordp) (stringp . byte-code-function-p)))
#@20 

(fn PRED1 PRED2)
(defalias 'pcase--mutually-exclusive-p #[514 "

B\235\206
\211B\235\207" [pcase-mutually-exclusive-predicates] 4 (#$ . 13377)])
#@27 

(fn SYM SPLITTER MATCH)
(defalias 'pcase--split-match #[771 "\211\242\300=\203&
A@=\204\211
B\207

AA!\211@\206

A\206$B\207\211\242\301>\203\277\302\211@\303=\203:\304\202;\305@\303=\203F\305\202G\304A\211\203z\211@\306		#\211@=\204d\211@B\262\211A=\204r\211AB\262\210
A\266\202\202I\210\211>\203\205\211\202\234\204\215
\202\234A\204\227@\202\234@\237B
>\203\246
\202\275\204\256\202\275A\204\270@\202\275@\237BB\207\211\307>\203\311\211
B\207\310\311\"\207" [match (or and) nil or :pcase--fail :pcase--succeed pcase--split-match (:pcase--succeed :pcase--fail) error "Uknown MATCH %s"] 13 (#$ . 13534)])
#@26 

(fn SYM SPLITTER REST)
(defalias 'pcase--split-rest #[771 "\300\211\211\203=\211@\211@
A\301		#\211@\302=\204$\211@BB\262\211A\302=\2044\211ABB\262\266
A\266\202\202\210
\237
\237B\207" [nil pcase--split-match :pcase--fail] 13 (#$ . 14206)])
#@17 

(fn ELEM PAT)
(defalias 'pcase--split-equal #[514 "\211\242\300=\203\211A@\232\203\301\207\211\242\300=\203\302\207\211\242\303=\205E\211A@9\205E\211A@\304N\205E\3051C\211A@!\203@\306\202A\3070\207\210\310\207" [quote (:pcase--succeed . :pcase--fail) (:pcase--fail) pred side-effect-free (error) (:pcase--succeed) (:pcase--fail) nil] 4 (#$ . 14474)])
#@18 

(fn ELEMS PAT)
(defalias 'pcase--split-member #[514 "\211\242\300=\203\211A@\235\203\301\207\211\242\300=\203\302\207\211\242\303=\205\\\211A@9\205\\\211A@\304N\205\\\3051V\211A@\306\211\203O\211@
!\204H\301\262
A\266\202\2029\210\262
0\202X\210\301\205\\\307\207" [quote nil (:pcase--fail) pred side-effect-free (error) t (:pcase--succeed)] 8 (#$ . 14847)])
#@22 

(fn VARS UPAT PAT)
(defalias 'pcase--split-pred #[771 "\300\232\203&@\301=\203A@9\204\"\302\303\304\"A@\"\204&\305\202\323@\301=\203
\242\301=\203:
A@\202p
\242\306=\204E\300\202p
A@:\203P\307\202p
A@;\203[\310\202p\311A@!\203g\311\202p\312A@!\205p\312\313A@\"\262
\203\314\202\323@\301=\205\323
\242\306=\205\323A@9\205\323
A@9\204\251
A@;\204\251
A@\247\205\323A@\315N\205\323\3161\304A@A@!C\211\2620\202\306\210\300\205\323\211@\203\322\317\202\323\320\207" [nil pred pcase--fgrep mapcar car (:pcase--succeed . :pcase--fail) quote consp stringp vectorp byte-code-function-p pcase--mutually-exclusive-p (:pcase--fail) side-effect-free (error) (nil . :pcase--fail) (:pcase--fail)] 8 (#$ . 15233)])
#@65 Check which of the symbols VARS appear in SEXP.

(fn VARS SEXP)
(defalias 'pcase--fgrep #[514 "\300
:\203+\301\211A\262\242\"\211\203'\211@\211>\204 \211B\262
A\266\202\202\210\202

>\203<

>\204<

B\262
\211\207" [nil pcase--fgrep] 7 (#$ . 15992)])
#@13 

(fn UPAT)
(defalias 'pcase--self-quoting-p #[257 "\300
!\206
\211\250\206
\211;\207" [keywordp] 3 (#$ . 16263)])
#@27 

(fn MATCH SYM FUN NSYM)
(defalias 'pcase--app-subst-match #[1028 "\242\300=\203.A@=\203,AA\242\301=\203,
AAA@\232\203,\302
\303AA8\"\207\207\242\304>\203O@\305\306\307\310\311\312			#\313\"\314\315%A\"B\207\316>\203W\207\317\320\"\207" [match app pcase--match 2 (or and) mapcar make-byte-code 257 "\303
\300\301\302$\207" vconcat vector [pcase--app-subst-match] 6 "\n\n(fn MATCH)" (:pcase--succeed :pcase--fail) error "Uknown MATCH %s"] 14 (#$ . 16386)])
#@26 

(fn REST SYM FUN NSYM)
(defalias 'pcase--app-subst-rest #[1028 "\300\301\302\303\304\305#\306\"\307\310%\"\207" [mapcar make-byte-code 257 "\303
@\300\301\302$
AB\207" vconcat vector [pcase--app-subst-match] 6 "\n\n(fn BRANCH)"] 13 (#$ . 16873)])
#@12 

(fn SYM)
(defalias 'pcase--mark-used #[257 "\2119\205\n\300
\301\302#\207" [put pcase-used t] 5 (#$ . 17135)])
(put 'pcase--mark-used 'byte-optimizer 'byte-compile-inline-expand)
#@91 Helper function, used internally to avoid (funcall (lambda ...) ...).

(fn FUN ARG1 ARG2)
(defalias 'pcase--flip '(macro . #[771 "
E\207" [] 6 (#$ . 17323)]))
(put 'pcase--flip 'edebug-form-spec '(sexp body))
#@63 Build a function call to FUN with arg ARG.

(fn FUN ARG VARS)
(defalias 'pcase--funcall #[771 "9\203	D\207\300\301\302\"\"\301\303\304\305\306\307!\310\"\311\312%\">\2032\313\314!\211DB\262\262\315!\203B\316\317DE\202G\320C\"\204O\211\202S\321E\207" [pcase--fgrep mapcar car make-byte-code 257 "\211
\300\236AD\207" vconcat vector [] 4 "\n\n(fn VAR)" gensym "x" functionp funcall function append let*] 11 (#$ . 17540)])
#@60 Build an expression that will evaluate EXP.

(fn EXP VARS)
(defalias 'pcase--eval #[514 "

\236\211\203\f\211A\2022\300\301\302\"\"\301\303\304\305\306\307!\310\"\311\312%\"\211\203/\313
\"\2020\266\202\207" [pcase--fgrep mapcar car make-byte-code 257 "\211
\300\236AD\207" vconcat vector [] 4 "\n\n(fn V)" macroexp-let*] 11 (#$ . 17995)])
#@192 Return code that runs CODE (with VARS) if MATCHES match.
Otherwise, it defers to REST which is a list of branches of the form
(ELSE-MATCH ELSE-CODE . ELSE-VARS).

(fn MATCHES CODE VARS REST)
(defalias 'pcase--u1 #[1028 "\204!\207@\300=\203\301
!\207@\302=\203\"\303A$\207@@\304=\2038\303\305@AA\"$\207@@\306=\203@
@A\211@@\307=\205O\211@A@\310\211\311\203\245\211\203\244\211@\211@\307=\203\230
A@=\203\230\211AA\211\242\312=\262
\203\230\211AAA@\211\250\204\212\2119\204\212\310\262
AAA@B\262\210\202\235\211B\262
A\266\202\202W\210\204\264\313\314!\210\301!\202?
G\315V\203
\303\307\316\317\203\310\320\202\311\321\312	DEF\nAB		\204\340	\202\377\322A\203\357\306\237B\202\362@A\"\f\fBB\nB$\202?
\303\211A\262\242\nAB		\204 
\313\314!\210	\202>
\322	A\203.
\306\nB\2021
	@A\"\f\fBB\nB$\207@@\307=\203h\211A\262\242\211@
A\211@
A\211\323>\203y
\303				$
\324=\203p
\211\202t
\325\326\"\262
\202g\211\327=\203\203
\330\202g\211\242\331>\203\344
\211@\316=\203\236

\2119\205\234
\332
\333\311#\266\334\335\336\337\340\341
\"\342\"\343\344%#\211@
A\345@\316=\203\312
\346A@
#\202\321
\347A@\f\"\303$\301!#\266\203\202g\2119\203+\211\203+
\2119\205\370
\332
\333\311#\266\211\236\204\303		B\nB	$\202g\303\307\316\350\f\236ADF\nB			$\202g\211\242\351=\203m\347\3528\"\353
!\203C\211\202F\354\355!\303\356A@\"\fB$
=\203a\211\202h\357DC\"\266\203\202g\211\242\360=\203\275
\2119\205\332
\333\311#\266\211A@\361\362!\303\356\3528\"\fB\363\f	$$
\333N\204\253\211\202\270\357\346#DC\"\266\203\202g\211\242\312=\2035
\2119\205\317\332
\333\311#\266\211A@\334\335\336\364\340\341!\365\"\366\344%	#\211@
A\345\204\366\367D\202\"\250\2049\203\370!\203\350E\202\"\350\312DE\202\"\371\312DE\303$\301!#\266\204\202g\211\242\372=\203c\303\307A@BBC\335\336\373\340\341\f!\374\"\375\376%	\304
B\f\fBBC$\202g\313\377\"\207\313\201@@\"\207" [:pcase--fail pcase--u :pcase--succeed pcase--u1 and append or match nil t quote error "Please avoid it" 1 pred pcase--flip memq member pcase--and (t _) _ macroexp--warn-and-return "Pattern t is deprecated.  Use `_' instead" pcase--dontcare :pcase--dontcare (guard pred) put pcase-used pcase--split-rest make-byte-code 257 "\302\300\301#\207" vconcat vector [pcase--split-pred] 5 "\n\n(fn PAT)" pcase--if pcase--funcall pcase--eval eq let 2 macroexp-copyable-p make-symbol "sym" pcase--match macroexp-let* app gensym "x" pcase--app-subst-rest "\301\300\"\207" [pcase--split-equal] 4 null pcase--self-quoting-p equal not "\301\300!\207" [pcase--u] 3 "\n\n(fn VARS)" "Unknown pattern `%S'" "Incorrect MATCH %S"] 20 (#$ . 18354)])
(put 'pcase-QPAT 'edebug-form-spec '(&or ("," pcase-PAT) (pcase-QPAT [&rest [&not ","] pcase-QPAT] . [&or nil pcase-QPAT]) (vector &rest pcase-QPAT) sexp))
#@482 Backquote-style pcase patterns.
QPAT can take the following forms:
  (QPAT1 . QPAT2)       matches if QPAT1 matches the car and QPAT2 the cdr.
  [QPAT1 QPAT2..QPATn]  matches a vector of length n and QPAT1..QPATn match
                           its 0..(n-1)th elements, respectively.
  ,PAT                  matches if the pcase pattern PAT matches.
  ATOM                  matches if the object is `equal' to ATOM.
			   ATOM can be a symbol, an integer, or a string.

(fn QPAT)
(defalias '\`--pcase-macroexpander #[257 "\211\242\300=\203\211A@\207\301
!\203E\302\303\304\305GE\306G\307\211W\203;\211\304\310\311E\312\nHDEB\262\210\211T\262
\202\266\211\237\262
BBB\207\211:\203]\302\313\304\314\312@DE\304\315\312ADEF\207\211;\204l\211\250\204l\2119\203p\316
D\207\317\320\"\207" [\, vectorp and (pred vectorp) app length nil 0 pcase--flip aref \` (pred consp) car cdr quote error "Unknown QPAT: %S"] 13 (#$ . 21321)])
(byte-code "\300\301\302\303#\300\304\305\301#\306\307!\207" [define-symbol-prop \`--pcase-macroexpander edebug-form-spec (pcase-QPAT) \` pcase-macroexpander provide pcase] 5)