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



(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\"\210\300\303\304\"\207" [def-edebug-elem-spec pcase-PAT (&or (&interpose symbolp pcase--edebug-match-pat-args) sexp) pcase-FUN (&or lambda-expr (functionp &rest form) sexp)] 3)
#@16 

(fn HEAD PF)
(defalias 'pcase--edebug-match-pat-args #[514 "
@\262\300\301\"\206\302!

\205
9\205\303!!\262
\207" [alist-get ('sexp (or &rest pcase-PAT) (and &rest pcase-PAT) (guard form) (pred &or ("not" pcase-FUN) pcase-FUN) (app pcase-FUN pcase-PAT)) pcase--get-macroexpander edebug-get-spec] 6 (#$ . 482)])
#@68 Return the macroexpander for pcase pattern head S, or nil.

(fn S)
(defalias 'pcase--get-macroexpander #[257 "\211\300N\207" [pcase-macroexpander] 3 (#$ . 811)])
#@1744 Evaluate EXP to get EXPVAL; try passing control to one of CASES.
CASES is a list of elements of the form (PATTERN CODE...).
For the first CASE whose PATTERN "matches" EXPVAL,
evaluate its CODE..., and return the value of the last form.
If no CASE has a PATTERN that matches, return nil.

Each PATTERN expands, in essence, to a predicate to call
on EXPVAL.  When the return value of that call is non-nil,
PATTERN matches.  PATTERN can take one of the forms:

  _                matches anything.
  \='VAL             matches if EXPVAL is `equal' to VAL.
  KEYWORD          shorthand for \='KEYWORD
  INTEGER          shorthand for \='INTEGER
  STRING           shorthand for \='STRING
  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.
  (pred FUN)       matches if FUN called on EXPVAL returns non-nil.
  (pred (not FUN)) matches if FUN called on EXPVAL returns nil.
  (app FUN PAT)    matches if FUN called on EXPVAL matches PAT.
  (guard BOOLEXP)  matches if BOOLEXP evaluates to non-nil.
  (and PAT...)     matches if all the patterns match.
  (or PAT...)      matches if any of the patterns matches.

FUN in `pred' and `app' can take one of the forms:
  SYMBOL  or  (lambda ARGS BODY)
     call it with one argument
  (F ARG1 .. ARGn)
     call F with ARG1..ARGn and EXPVAL as n+1'th argument

FUN, BOOLEXP, and subsequent PAT can refer to variables
bound earlier in the pattern by a SYMBOL pattern.

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

See Info node `(elisp) Pattern-Matching Conditional' 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\207\302\"\303@BB#\210\207" [pcase--memoize gethash pcase--expand puthash] 9 (#$ . 981)]))
(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\310\"r\211q\210\311\312\"\216
A\206 c\210\313C\314\311\315\"!\210\316
\242\236

\317\242\"B\240\266\211\242\203l\211\242
\211\242A\240\210\242\211@
A\300
\302\"\320c\210\321\322!\313%\262
\323
\206e\324\261\266\202:\210\325 \203{\326
@\"\202|\211\262
*\207" [documentation pcase raw help-split-fundoc require help-fns generate-new-buffer " *temp*" t make-closure #[0 "\301\300!\205	\302\300!\207" [V0 buffer-name kill-buffer] 2] nil mapatoms #[257 "\301
!\211\205\300B\300\242B\240\207" [V0 pcase--get-macroexpander] 5 "\n\n(fn SYMBOL)"] \` delq "\n\n-- " help-fns--signature indirect-function "\n" "Not documented." buffer-string help-add-fundoc-usage] 14])
#@229 The exhaustive version of `pcase' (which see).
If EXP fails to match any of the patterns in CASES, an error is
signaled.

In contrast, `pcase' will return nil if there is no match, but
not signal an error.

(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 (#$ . 3894)]))
(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\242\237ABBC\"BB\207" [nil macroexp-parse-body mapcar make-closure #[257 "\2119\203\207\301\302\303\300\242G\"!\300D\300\242B\240\210\207" [V0 make-symbol format "arg%s"] 5 "\n\n(fn PAT)"] lambda append pcase-let*] 12 (#$ . 4468)]))
(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 (#$ . 5270)])
#@476 Like `let*', but supports destructuring BINDINGS using `pcase' patterns.
As with `pcase-let', BINDINGS are of the form (PATTERN EXP), but the
EXP in each binding in BINDINGS can use the results of the destructuring
bindings that precede it in BINDINGS' order.

Each EXP should match (i.e. be of compatible structure) to its
respective PATTERN; a mismatch may signal an error or may go
undetected, binding variables to arbitrary values, such as nil.

(fn BINDINGS &rest BODY)
(defalias 'pcase-let* '(macro . #[385 "\301\"\211@\232\203\211A\207\302\"\303B#\210\207" [pcase--memoize gethash pcase--let* puthash] 8 (#$ . 5548)]))
(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)
#@581 Like `let', but supports destructuring BINDINGS using `pcase' patterns.
BODY should be a list of expressions, and BINDINGS should be a list of
bindings of the form (PATTERN EXP).
All EXPs are evaluated first, and then used to perform destructuring
bindings by matching each EXP against its respective PATTERN.  Then
BODY is evaluated with those bindings in effect.

Each EXP should match (i.e. be of compatible structure) to its
respective PATTERN; a mismatch may signal an error or may go
undetected, binding variables to arbitrary values, such as nil.

(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 (#$ . 6359)]))
(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)
#@595 Eval BODY once for each set of bindings defined by PATTERN and LIST elements.
PATTERN should be a `pcase' pattern describing the structure of
LIST elements, and LIST is a list of objects that match PATTERN,
i.e. have a structure that is compatible with PATTERN.
For each element of LIST, this macro binds the variables in
PATTERN to the corresponding subfields of the LIST element, and
then evaluates BODY with these bindings in effect.  The
destructuring bindings of variables in PATTERN to the subfields
of the elements of LIST is performed as if by `pcase-let'.

(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 (#$ . 7439)]))
(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)
#@422 Assign values to variables by destructuring with `pcase'.
PATTERNS are normal `pcase' patterns, and VALUES are expression.

Evaluation happens sequentially as in `setq' (not in parallel).

An example: (pcase-setq `((,a) [(,b)]) '((1) [(2)]))

VAL is presumed to match PAT.  Failure to match may signal an error or go
undetected, binding variables to arbitrary values, such as nil.

(fn PATTERNS VALUE PATTERN VALUES ...)
(defalias 'pcase-setq '(macro . #[642 "\211\203=\211G\300
\301\"\302U\204\303\304\305\301\\D\"\210\210\306
\2033\305\211A\262\242\211A\262\242E
B\262
\202\307\305E\237BB\207\310!\203H\311E\207\312\313B\314B\"\207" [mod 2 0 signal wrong-number-of-arguments pcase-setq nil progn pcase--trivial-upat-p setq pcase-compile-patterns #[385 "\300\301\302\"B\207" [setq mapcan #[257 "\211@
A@

D\207" [] 5 "\n\n(fn VARVAL)"]] 6 "\n\n(fn VARVALS &rest _)"] ((pcase--dontcare . ignore))] 9 (#$ . 8363)]))
(put 'pcase-setq 'edebug-form-spec '(&rest [pcase-PAT form]))
#@13 

(fn UPAT)
(defalias 'pcase--trivial-upat-p #[257 "\2119\205	\211>?\207" [pcase--dontcare-upats] 3 (#$ . 9367)])
#@806 Compile the set of patterns in CASES.
EXP is the expression that will be matched against the patterns.
CASES is a list of elements (PAT . CODEGEN)
where CODEGEN is a function that returns the code to use when
PAT matches.  That code has to be in the form of a cons cell.

CODEGEN will be called with at least 2 arguments, VARVALS and COUNT.
VARVALS is a list of elements of the form (VAR VAL . RESERVED) where VAR
is a variable bound by the pattern and VAL is a duplicable expression
that returns the value this variable should be bound to.
If the pattern PAT uses `or', CODEGEN may be called multiple times,
in which case it may want to generate the code differently to avoid
a potential code explosion.  For this reason the COUNT argument indicates
how many time this CODEGEN is called.

(fn EXP CASES)
(defalias 'pcase-compile-patterns #[514 "\301!\203\n
\202
\302\303!\304C\305C\306\307\310\311$\"!\242\211\203\257\211@\211@A
A\304C
\211\203r\211@\211@\211\203j\211@\211@\242\236\211\203U
AA\203b\211\312\241\266\202c@AAB\242B\240\210\210
A\266\202\2028\210
A\266\202\2020\210\304\307\313\242\"\211\203\246\211@\211@\307\310\314#\"A	\nG\"

@\240\210

A\241\266
A\266\202\202z\266
A\266\202\202\"\210\211\203\326\211@\211\242\236\204\317\211@>\204\317\315\316\317@\"\"\262
A\266\202\202\261\210\266\202
=\203\340\207\320DC\"\207" [pcase--dontwarn-upats macroexp-copyable-p make-symbol "val" nil 0 pcase--u mapcar make-closure #[257 "\303\300\304@!\"\305\306\301\302$D\207" [V0 V1 V2 pcase--match pcase--macroexpand make-closure #[257 "\302\300\242\236\211\204\300\302C\211\262\300\242B\240\210\303\301\211\242T\240B
BAB\241\210\207" [V0 V1 V2 pcase--placeholder] 6 "\n\n(fn VARS)"]] 7 "\n\n(fn CASE)"] used car #[257 "\211
\301\236A@\300\242\236AE\207" [V0 V1] 5 "\n\n(fn V)"] macroexp-warn-and-return format "pcase pattern %S shadowed by previous pcase pattern" macroexp-let*] 21 (#$ . 9490)])
#@18 

(fn EXP CASES)
(defalias 'pcase--expand #[514 "\300C\301\302\"\303\304\301\305\"\"\"\306\242\"\207" [nil make-closure #[257 "\211\301\235\203\302\207\303C\304\305\300$\207" [V0 (nil (nil) ('nil)) #[128 "\300\207" ['nil] 2 "\n\n(fn &rest _)"] nil make-closure #[642 "\303\304\305\306\"\"\211\205\307
BC\310W\204\311\301!\203)\312\305\313\"\314\301\"BB\207\302\242\204N\302\315\316\317\300\242G\"!\240\210\300\302\242\320\305\321	\"\314\301\"BBD\300\242B\240\210\322\302\242\305\323\"BB\207" [V0 V1 V2 delq nil mapcar #[257 "\300
8\205\211@\207" [2] 3 "\n\n(fn VV)"] ignore 2 pcase--small-branch-p let #[257 "\211@
A@D\207" [] 3 "\n\n(fn VV)"] append make-symbol format "pcase-%d" lambda car funcall cadr] 12 "\n\n(fn VARVALS COUNT &rest _)"]] 7 "\n\n(fn CODE)"] pcase-compile-patterns mapcar #[257 "\211@\300A!B\207" [V0] 4 "\n\n(fn CASE)"] macroexp-let*] 10 (#$ . 11460)])
#@46 Expands all macro-patterns in PAT.

(fn PAT)
(defalias 'pcase--macroexpand #[257 "\211\242\211\300\267\202)\301!\203\302D\207
\207
\207\211\303\304A\"B\207\305A@\304\3068!E\207\307
!\211\2055\310
A\"\211\204H\311\203B\312\202C\313#\207\304
!\207" [#s(hash-table size 7 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (nil 8 pred 20 guard 20 quote 20 or 22 and 22 app 30)) pcase--self-quoting-p quote mapcar pcase--macroexpand app 2 pcase--get-macroexpander apply error "Unexpandable %s pattern: %S" "Unknown %s pattern: %S"] 8 (#$ . 12371)])
#@273 Define a new kind of pcase PATTERN, by macro expansion.
Patterns of the form (NAME ...) will be expanded according
to this macro.

By convention, DOC should use "EXPVAL" to stand
for the result of evaluating EXP (first arg to `pcase').

(fn NAME ARGS [DOC] &rest BODY...)
(defalias 'pcase-defmacro '(macro . #[642 "\300\301\302\"!\303\236\211\203\304
\"\262\305\306\307BBBD\310\311D\312\311\313\236A@DF\310\311	D\314\315DFF\207" [intern format "%s--pcase-macroexpander" declare remove progn eval-and-compile defun define-symbol-prop quote 'edebug-form-spec debug 'pcase-macroexpander function] 13 (#$ . 12953)]))
(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\"A\"B\207\304BB\207" [(or and) mapcar make-closure #[257 "\301\300\"\207" [V0 pcase--match] 4 "\n\n(fn UPAT)"] match] 7 (#$ . 13766)])
#@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 (#$ . 14059)])
#@23 

(fn TEST THEN ELSE)
(defalias 'pcase--if #[771 "\211\300=\203
\301\302DE\207
\300=\203\301\302DE\207\303#\207" [:pcase--dontcare progn ignore macroexp-if] 7 (#$ . 14249)])
#@539 Expand matcher for rules BRANCHES.
Each BRANCH has the form (MATCH CODE . VARS) where
CODE is the code generator for that branch.
MATCH is the pattern that needs to be matched, of the form:
  (match VAR . PAT)
  (and MATCH ...)
  (or MATCH ...)
VARS is the set of vars already bound by earlier matches.
It is a list of (NAME VAL . USED) where NAME is the variable's symbol,
VAL is the expression to which it should be bound and USED is a boolean
recording whether the var has been referenced by earlier parts of the 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 (#$ . 14440)])
#@22 

(fn MATCH MATCHES)
(defalias 'pcase--and #[514 "\211\203\n\300BB\207
\207" [and] 5 (#$ . 15121)])
(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 (#$ . 15992)])
#@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 "Unknown MATCH %s"] 13 (#$ . 16149)])
#@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 (#$ . 16822)])
#@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 (#$ . 17090)])
#@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 (#$ . 17463)])
#@432 Indicate the overlap or mutual-exclusion between UPAT and PAT.
More specifically returns a pair (A . B) where A indicates whether PAT
can match when UPAT has matched, and B does the same for the case
where UPAT failed to match.
A and B can be one of:
- nil if we don't know
- `:pcase--fail' if UPAT match's result implies that PAT can't match
- `:pcase--succeed' if UPAT match's result implies that PAT matches

(fn VARS UPAT PAT)
(defalias 'pcase--split-pred #[771 "\300\232\203 @\301=\203A@9\204\302A@\"\204 \303\207
\242\301=\203G
A@\242\304=\203G
A@A@\305\301D#\306\211@!
A!B\207@\301=\204P\300\207A@\242\304=\203kA@A@\305\301D#\211A
@B\207
\242\301=\203x
A@\202\256
\242\307=\204\203\300\202\256
A@:\203\216\310\202\256
A@;\203\231\311\202\256\312A@!\203\245\312\202\256\313A@!\205\256\313\314A@\"\262
\203\273\315\207A@\242\316=\203\363A@A@\317>\203\363\320A@8\242\307=\203\363
\242\307=\203\363\320A@8A@A@
\235\203\361\321\207\322\207
\242\307=\205>
A@9\205>

A@9\204

A@;\204

A@\247\205>
A@\323N\205>
\32411
A@A@!C\211\2620\2023
\210\300\205>
\211@\203=
\325\207\326\207" [nil pred macroexp--fgrep (:pcase--succeed . :pcase--fail) not pcase--split-pred #[257 "\211\300\267\202\n\301\207\302\207\303\207" [#s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (:pcase--succeed 6 :pcase--fail 8)) :pcase--fail :pcase--succeed nil] 3 "\n\n(fn X)"] quote consp stringp vectorp byte-code-function-p pcase--mutually-exclusive-p (:pcase--fail) pcase--flip (memq member memql) 2 (nil . :pcase--fail) (:pcase--fail) side-effect-free (error) (nil . :pcase--fail) (:pcase--fail)] 10 (#$ . 17850)])
#@13 

(fn UPAT)
(defalias 'pcase--self-quoting-p #[257 "\300
!\206
\211\250\206
\211;\207" [keywordp] 3 (#$ . 19544)])
#@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>\203G@\305\306\307$A\"B\207\310>\203O\207\311\312\"\207" [match app pcase--match 2 (or and) mapcar make-closure #[257 "\303
\300\301\302$\207" [V0 V1 V2 pcase--app-subst-match] 6 "\n\n(fn MATCH)"] (:pcase--succeed :pcase--fail) error "Unknown MATCH %s"] 11 (#$ . 19667)])
#@26 

(fn REST SYM FUN NSYM)
(defalias 'pcase--app-subst-rest #[1028 "\300\301\302$\"\207" [mapcar make-closure #[257 "\303
@\300\301\302$
AB\207" [V0 V1 V2 pcase--app-subst-match] 6 "\n\n(fn BRANCH)"]] 10 (#$ . 20123)])
#@12 

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

(fn FUN ARG1 ARG2)
(defalias 'pcase--flip '(macro . #[771 "
E\207" [] 6 (#$ . 20612)]))
(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\242\300=\203\300\301A@#D\207\302\303\304\"\"
\236\2034\305\306!\211DB\262\262\307!\204?:\204H\310\311DE\202M\312C\"
\204R\207\313E\207" [not pcase--funcall mapcar #[257 "\211A\300\241\210\211@
A@D\207" [used] 3 "\n\n(fn X)"] macroexp--fgrep gensym "x" functionp funcall function append let*] 8 (#$ . 20829)])
#@60 Build an expression that will evaluate EXP.

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

\236\211\203\211A\300\241\210\211A@\207\301\"\211\203 \302\303\304\"\"\207\207" [used macroexp--fgrep macroexp-let* mapcar #[257 "\211A\300\241\210\211@
A@D\207" [used] 3 "\n\n(fn X)"]] 8 (#$ . 21282)])
#@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\255\211\203\254\211@\211@\307=\203\240
A@=\203\240\211AA\211\242\312=\262
\203\240\211AAA@\211\250\203\216\311=\203\226\313\262\202\226\2119\204\226\314\262\211B\262\210\202\245\211B\262
A\266\202\202W\210\204\272\315\316!\210\301!\207G\317V\203\377\303\307\320\321\312	DEF\nAB		\204\336	\202\375\322A\203\355\306\237B\202\360@A\"\f\fBB\nB$\207\303\211A\262\242\nAB		\204
\315\316!\210	\202:
\322	A\203*
\306\nB\202-
	@A\"\f\fBB\nB$\207@@\307=\203\366\211A\262\242\211@\210\310
A\211@
A\211\323\267\202t
\303				$
\324=\203k
\207\325\326\"\207\266\327\207\211\242\330>\203\310
\211@\320=\203\217

\2119\205\215
\331
\332\333#\266\334\335\336\n##\211@
A\337@\320=\203\262
\340A@
#\202\271
\341A@\f\"\303$\301!#\207\2119\203\211\203
\2119\205\334
\331
\332\333#\266\211\236\211\204\366
\303\n\nDB\n$\207\211A\342\241\210\303\307\320\343A@DFB\n\n\n$\207\211\242\344=\203Y
\2119\205\"\331
\332\333#\266\211A@\345\346!\303\347\3508\"\fB\351\f	$$
\332N\204K\207\352\340#DC\"\207\211\242\312=\203\315
\2119\205k\331
\332\333#\266\211A@\334\335\353\"	#\211@
A\337\204\211\354D\202\276\250\203\227\343E\202\2769\203\266\355!\203\253\356E\202\276\356\312DE\202\276\357\312DE\303$\301!#\207\211\242\360=\203\361\303\307A@BBC\335\361	\"	\304
B\f\fBBC$\207\315\362\"\207\315\363@\"\207" [:pcase--fail pcase--u :pcase--succeed pcase--u1 and append or match nil memq quote memql member error "Please avoid it" 1 pred pcase--flip pcase--and #s(hash-table size 3 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (t 346 _ 346 pcase--dontcare 368)) _ macroexp-warn-and-return "Pattern t is deprecated.  Use `_' instead" :pcase--dontcare (guard pred) put pcase-used t pcase--split-rest make-closure #[257 "\302\300\301#\207" [V0 V1 pcase--split-pred] 5 "\n\n(fn PAT)"] pcase--if pcase--funcall pcase--eval used eql app gensym "x" pcase--match 2 pcase--app-subst-rest macroexp-let* #[257 "\301\300\"\207" [V0 pcase--split-equal] 4 "\n\n(fn PAT)"] null pcase--self-quoting-p eq equal not #[257 "\301\300!\207" [V0 pcase--u] 3 "\n\n(fn VARS)"] "Unknown pattern `%S'" "Incorrect MATCH %S"] 20 (#$ . 21591)])
(def-edebug-elem-spec 'pcase-QPAT '(&or ("," pcase-PAT) (pcase-QPAT [&rest [&not ","] pcase-QPAT] . [&or nil pcase-QPAT]) (vector &rest pcase-QPAT) sexp))
#@1089 Backquote-style pcase patterns: \=`QPAT
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.
  SYMBOL                matches if EXPVAL is `equal' to SYMBOL.
  KEYWORD               likewise for KEYWORD.
  NUMBER                likewise for NUMBER.
  STRING                likewise for STRING.

The list or vector QPAT is a template.  The predicate formed
by a backquote-style pattern is a combination of those
formed by any sub-patterns, wrapped in a top-level condition:
EXPVAL must be "congruent" with the template.  For example:

  \=`(technical ,forum)

The predicate is the logical-AND of:
 - Is EXPVAL a list of two elements?
 - Is the first element the symbol `technical'?
 - True!  (The second element can be anything, and for the sake
   of the body forms, its value is bound to the symbol `forum'.)

(fn QPAT)
(defalias '\`--pcase-macroexpander #[257 "\211\242\300=\203\211A@\207\301
!\203C\302\303\304\305GE\306G\307\211W\2039\304\310\311E\312	HDEB\262\211T\262
\202\266\211\237\262
BBB\207\211:\203[\302\313\304\314\312@DE\304\315\312ADEF\207\211;\204j\211\247\204j\2119\203n\316
D\207\317\320\"\207" [\, vectorp and (pred vectorp) app length nil 0 pcase--flip aref \` (pred consp) car-safe cdr-safe quote error "Unknown QPAT: %S"] 12 (#$ . 24438)])
(byte-code "\300\301\302\303#\300\304\305\301#\300\207" [define-symbol-prop \`--pcase-macroexpander edebug-form-spec (pcase-QPAT) \` pcase-macroexpander] 5)
#@45 Matches if EXPR matches PAT.

(fn PAT EXPR)
(defalias 'let--pcase-macroexpander #[514 "\300\301\302EE\207" [app lambda (_)] 6 (#$ . 26154)])
(byte-code "\300\301\302\303#\300\304\305\301#\306\307!\207" [define-symbol-prop let--pcase-macroexpander edebug-form-spec (pcase-PAT form) let pcase-macroexpander provide pcase] 5)