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



(byte-code "\300\301!\210\302\303\304\305\306\307%\207" [require prog-mode custom-declare-group smie nil "Simple Minded Indentation Engine." :group languages] 6)
(defvar smie-warning-count 0)
#@41 

(fn TABLE X Y VAL &optional OVERRIDE)
(defalias 'smie-set-prec2tab #[1284 "\203\204\f\301\302!\210B\303
\"\211\203G\211=\204G\2034\303\"\2034\304\303\"	#\207\305\306\307\310		%\"\210T\211\207\304	#\207" [smie-warning-count cl--assertion-failed (and x y) gethash puthash display-warning smie format "Conflict: %s %s/%s %s"] 15 (#$ . 276)])
#@336 Compute a 2D precedence table from a list of precedences.
PRECS should be a list, sorted by precedence (e.g. "+" will
come before "*"), of elements of the form (left OP ...)
or (right OP ...) or (nonassoc OP ...) or (assoc OP ...).  All operators in
one of those elements share the same precedence level and associativity.

(fn PRECS)
(defalias 'smie-precs->prec2 #[257 "\300\301\302\"
\211\203\214\211@\211A\211\203\204\211@@\303\236A\211\2035A\211\2034\211@\304$\210
A\266\202\202\210\210\305\306\211\203{\211@
=\203P\306\262\305\262\202t\211A\211\203s\211@\304$\210\304		$\210
A\266\202\202R\210
A\266\202\202:\266
A\266\202\202
\210
A\266\202\202\210\207" [make-hash-table :test equal ((left . >) (right . <) (assoc . =)) smie-set-prec2tab < >] 17 (#$ . 656)])
(byte-code "\300\301\302\303#\300\207" [function-put smie-precs->prec2 pure t] 4)
#@21 

(fn &rest TABLES)
(defalias 'smie-merge-prec2s #[128 "\211A\204\211@\207\300\301\302\"
\211\203\"\211@\303\304\305\"\"\210
A\266\202\202
\210\207" [make-hash-table :test equal maphash make-closure #[514 "
:\203\301\300@A$\207\302\300\"\203#\302\300\"
\232\204#\303\304\"\207\305\300#\207" [V0 smie-set-prec2tab gethash error "Conflicting values for %s property" puthash] 7 "\n\n(fn K V)"]] 8 (#$ . 1551)])
(byte-code "\300\301\302\303#\300\207" [function-put smie-merge-prec2s pure t] 4)
#@1223 Convert the BNF grammar into a prec2 table.
BNF is a list of nonterminal definitions of the form:
  (NONTERM RHS1 RHS2 ...)
where each RHS is a (non-empty) list of terminals (aka tokens) or non-terminals.
Not all grammars are accepted:
- an RHS cannot be an empty list (this is not needed, since SMIE allows all
  non-terminals to match the empty string anyway).
- an RHS cannot have 2 consecutive non-terminals: between each non-terminal
  needs to be a terminal (aka token).  This is a fundamental limitation of
  the parsing technology used (operator precedence grammar).
Additionally, conflicts can occur:
- The returned prec2 table holds constraints between pairs of
  token, and for any given pair only one constraint can be
  present, either: T1 < T2, T1 = T2, or T1 > T2.
- A token can either be an `opener' (something similar to an open-paren),
  a `closer' (like a close-paren), or `neither' of the two (e.g. an infix
  operator, or an inner token like "else").
Conflicts can be resolved via RESOLVERS, which is a list of elements that can
be either:
- a precs table (see `smie-precs->prec2') to resolve conflicting constraints,
- a constraint (T1 REL T2) where REL is one of = < or >.

(fn BNF &rest RESOLVERS)
(defalias 'smie-bnf->prec2 #[385 "\301\302\"\303\211\211\211\304\305\306\307\"\303\305\306\307\"\211\203U\211@\211G\310U\2039\211A@\311>\2039\312@\3138A@$\210\202N\211@@\314>\203I\211B\262\202N\315\316\"\210
A\266\202\202\210\317\320\301\321\"#\266\202\303	\211\203\200
\211@\211@\303\211\211\211A\211\203V
\211@\211:\204\204\322\323\324D\"\210\211@\235\204\244\211@\325
\"\203\232\210\202\345\211B\262\210\202\345\211@\325
\"\203\261\210\202\267\211B\262\210\211A:\203\345\211A@\235\203\317\315\326@A@#\210\211A@\325
\"\203\336\210\202\345\211B\262\210\327
!\211@\235\204\n
\211@\325
	\"\203\377\266\202O
\211B\262\266\202O
\211@\325
\"\203
\210\202
\211B\262\210\211A:\203N
\211A@\235\2037
\315\326A@@#\210\211A@\325
	\"\203G
\266\202O
\211B\262\210\210
A\266\202\202r\210BB\262B
B\262

B\fB\262\fBB\262\266
A\266\202\202d\210\330\262
\211\303\262\203\335
\211\203\331
\211@\211
A\262\242\331
\"\211\203\320
\211@\331
\"A\211\203\310
\211@\211\235\204\301
\330\262	
AB\241\210
A\266\202\202\252
\210
A\266\202\202\236
\266
A\266\202\202\214
\210\202\204
\330\262
\211\303\262\2039\211\2035\211@\211
A\262\242\331
\n\"\211\203,\211@\331

\"A\211\203$\211@\211\235\204\330\262	
AB\241\210
A\266\202\202\210
A\266\202\202\372
\266
A\266\202\202\350
\210\202\340
	\211\203\350\211@\211A\211\203\340\211@\211A\203\331\211@\f\235\203z\331
@\"A\211\203v\211@\312	A@\332\f%\210
A\266\202\202]\210\202\322\211A@\f\235\203\305\331
A@\f\"A\211\203\243\211@\312	@\333\f%\210
A\266\202\202\213\210\211AA\203\322\211AA@\f\235\204\322\312@AA@\334\n%\210\202\322\312@A@\334\n%\210\211A\262
\202I
A\266\202\202C\210
A\266\202\202;\210\335\336\337\f!#\210\335\340\341\f!#\210\304V\203	\342\343\344\345\"\"\210)\207" [smie-warning-count mapcar car nil 0 make-hash-table :test equal 3 (= < >) smie-set-prec2tab 2 (left right assoc nonassoc) error "Unknown resolver %S" apply smie-merge-prec2s smie-precs->prec2 signal wrong-type-argument consp memql "Adjacent non-terminals: %s %s" reverse t assoc > < = puthash :smie-open/close-alist smie-bnf--classify :smie-closer-alist smie-bnf--closer-alist display-warning smie format "Total: %d warnings"] 24 (#$ . 2067)])
(byte-code "\300\301\302\303#\300\207" [function-put smie-bnf->prec2 pure t] 4)
#@272 Build a closer-alist from a BNF table.
The return value is in the same form as `smie-closer-alist'.
NO-INNERS if non-nil means that inner keywords will be excluded
from the table, e.g. the table will not include things like ("if" . "else").

(fn BNF &optional NO-INNERS)
(defalias 'smie-bnf--closer-alist #[513 "\300\301\"\302\211\203\217\211@\211A\211\203\207\211@\211G\303W\204\200\211@\235\204\200\203O\304
!@\211\235\204K
@
B\211\235\203C\202G\211B\262
\262\210\202\200\305
A!\211\203\211@\211\235\204x@
B\211\235\203p\202t\211B\262
\262
A\266\202\202S\210
A\266\202\202\210
A\266\202\202\210\211\237\207" [mapcar car nil 2 last reverse] 13 (#$ . 5700)])
#@26 

(fn TABLE TOKEN CLASS)
(defalias 'smie-bnf--set-class #[771 "\300#\301=\203\202)\302=\203\302\202)\303\304\305\306$\"\210\307#\207" [gethash puthash t display-warning smie format "token %s is both %s and %s" neither] 13 (#$ . 6409)])
#@116 Return a table classifying terminals.
Each terminal can either be an `opener', a `closer', or `neither'.

(fn BNF)
(defalias 'smie-bnf--classify #[257 "\300\301\302\"\303C\211\203\211@\304
@\305#\210
A\266\202\202\210\211\203{\211@\211A\211\203s\211@\211A\204@\306\211A\262\242\307#\210\202l\306\211A\262\242\310#\210\211A\203`\306\211A\262\242\307#\210\202L\306\211A\262\242\311#\210
A\266\202\202&\210
A\266\202\202\210\312\313\314\"\"\210\211\242\207" [make-hash-table :test equal nil puthash t smie-bnf--set-class neither opener closer maphash make-closure #[514 "\211\301>\205\300B\300\242B\240\207" [V0 (closer opener)] 5 "\n\n(fn TOK V)"]] 11 (#$ . 6674)])
#@112 Return a cycle in CSTS, assuming there's one.
CSTS is a list of pairs representing arcs in a graph.

(fn CSTS)
(defalias 'smie-debug--prec2-cycle #[257 "\300\301\"\302\211\204Q
\302\262\211\203M\211@\211\203E\211@\211@A@=\203>\211A@=\2031\262\202>@
AABBB\262
A\266\202\202\210
A\266\202\202
\210\202\211@
A\237B\207" [mapcar #[257 "\211@
AD\207" [] 3 "\n\n(fn PAIR)"] nil] 10 (#$ . 7384)])
#@20 

(fn TABLE CYCLE)
(defalias 'smie-debug--describe-cycle #[514 "\300\301\302\"\"\303\304\305\211@C\"\306#\207" [mapcar make-closure #[257 "\301\300\211\203.\211@\211A=\203\302
@PB\262\211AA=\203'\211@\302PB\262
A\266\202\202\210\211\2047\303\304!\210\207" [V0 nil "." cl--assertion-failed res] 6 "\n\n(fn VAL)"] mapconcat #[257 "\300\301\302#\207" [mapconcat identity "="] 5 "\n\n(fn ELEMS)"] append " < "] 8 (#$ . 7803)])
#@162 Take a 2D precedence table and turn it into an alist of precedence levels.
PREC2 is a table as returned by `smie-precs->prec2' or
`smie-bnf->prec2'.

(fn PREC2)
(defalias 'smie-prec2->grammar #[257 "\300C\300C\300C\301\302\303$\"\210\211\242\211\203v\211@@
@AA\262\211=\204q\211\203J\211@
A=\2038\211\241\210
@=\203C\211\240\210
A\266\202\202'\210\242\211\203p\211@
A=\203^\211\241\210
@=\203i\211\240\210
A\266\202\202M\210\266\202\210\304\242\203\322\305\306\242\"\300\242\211\203\265\211@\211@>\204\256\307\262\211@@\204\244\211@\240\210T\262\310	\242\"\240\210
A\266\202\202\205\210\211\204\310\311\312\313\242\314	\242!\"\"\210\266\211\315\\\262
\202x
\242\237\211\203\f
\211@\211A@\204\352\211A\240\210T\262\211@@\203\376\211@@
A@=\204\376\316\317!\210\211@
A@\240\210
A\266\202\202\325\210\242\211\203?
\211@\211A@\204&
\211A\211\240\266T\262\320
8\2048
\211AA\211\240\266T\262
A\266\202\202
\266\321\322\"\211\203\212
\211@\211@
A\211\323\267\202j
\324\242\"AA\202k
\324\242\"A\202k
\300\262
\211\203\201
\211@\247\204{
\316\325!\210\211
@C\240\210\266
A\266\202\202E
\210\321\326\"\211\203\234
\326B\242B\240\210\210\242\207" [nil maphash make-closure #[514 "
:\205v\303@\300\242\"\304\211\203AA\262\202)\304C\262\300@\304BB\300\242B\240\210\303A\300\242\"\211\262\203<A\262
\202L\304\211CB\262
\300AB\300\242B\240\210\305\267\202m\302B\302\242B\240\207\301B\301\242B\240\207\301
B\301\242B\240\207\306\307#\266\203\207" [V0 V1 V2 assoc nil #s(hash-table size 3 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (= 82 < 91 > 100)) error "SMIE error: prec2 has %S↦%S which ∉ {<,+,>}"] 9 "\n\n(fn K V)"] 0 mapcar cdr t delq error "Can't resolve the precedence cycle: %s" smie-debug--describe-cycle smie-debug--prec2-cycle 10 cl--assertion-failed (or (null (caar eq)) (eq (caar eq) (cadr eq))) 2 gethash :smie-open/close-alist #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (closer 341 opener 352)) assoc (numberp (car cons)) :smie-closer-alist] 13 (#$ . 8250)])
(byte-code "\300\301\302\303#\300\207" [function-put smie-prec2->grammar pure t] 4)
#@503 List of token parsing info.
This list is normally built by `smie-prec2->grammar'.
Each element is of the form (TOKEN LEFT-LEVEL RIGHT-LEVEL).
Parsing is done using an operator precedence parser.
LEFT-LEVEL and RIGHT-LEVEL can be either numbers or a list, where a list
means that this operator does not bind on the corresponding side,
e.g. a LEFT-LEVEL of nil means this is a token that behaves somewhat like
an open-paren, whereas a RIGHT-LEVEL of nil would correspond to something
like a close-paren.
(defvar smie-grammar 'unset (#$ . 10479))
#@288 Function to scan forward for the next token.
Called with no argument should return a token and move to its end.
If no token is found, return nil or the empty string.
It can return nil when bumping into a parenthesis, which lets SMIE
use syntax-tables to handle them in efficient C code.
(defvar smie-forward-token-function 'smie-default-forward-token (#$ . 11030))
#@175 Function to scan backward the previous token.
Same calling convention as `smie-forward-token-function' except
it should move backward to the beginning of the previous token.
(defvar smie-backward-token-function 'smie-default-backward-token (#$ . 11402))
(byte-code "\300\301\302\"\210\300\303\304\"\207" [defalias smie-op-left car smie-op-right cadr] 3)
(defalias 'smie-default-backward-token #[0 "\300`[!\210\301`\302\303!\304U\203\302\305!\210`\"\207" [forward-comment buffer-substring-no-properties skip-syntax-backward "." 0 "w_'"] 4])
(defalias 'smie-default-forward-token #[0 "\300d!\210\301`\302\303!\304U\203\302\305!\210`\"\207" [forward-comment buffer-substring-no-properties skip-syntax-forward "." 0 "w_'"] 4])
#@18 

(fn TOKLEVELS)
(defalias 'smie--associative-p #[257 "\300
!\301!=\207" [smie-op-left smie-op-right] 4 (#$ . 12135)])
#@1105 Skip over one sexp.
NEXT-TOKEN is a function of no argument that moves forward by one
token (after skipping comments if needed) and returns it.
NEXT-SEXP is a lower-level function to skip one sexp.
OP-FORW is the accessor to the forward level of the level data.
OP-BACK is the accessor to the backward level of the level data.
HALFSEXP if non-nil, means skip over a partial sexp if needed.  I.e. if the
first token we see is an operator, skip over its left-hand-side argument.
HALFSEXP can also be a token, in which case it means to parse as if
we had just successfully passed this token.
Possible return values:
  (FORW-LEVEL POS TOKEN): we couldn't skip TOKEN because its back-level
    is too high.  FORW-LEVEL is the forw-level of TOKEN,
    POS is its start position in the buffer.
  (t POS TOKEN): same thing when we bump on the wrong side of a paren.
    Instead of t, the `car' can also be some other non-nil non-number value.
  (nil POS TOKEN): we skipped over a paren-like pair.
  nil: we skipped over an identifier, matched parentheses, ...

(fn NEXT-TOKEN NEXT-SEXP OP-FORW OP-BACK HALFSEXP)
(defalias 'smie-next-sexp #[1285 "\3012v
\211;\205-\302
\"A\206)\303\304\"\203%\305\225\203!\306\202)\307\202)\310\311\"C\312\262` \302
\"A\211\204\221
G\313U\203g
\3141N\305!0\210\202\201\315
8`
X\203]\3168\202^\211b\210\317\301\320`U?\205}\321\211`W\203z\322\202{\305\\\"E\"\266`=\203g
\317\301\320`D\"\210\202g

!\247\204\254
!\247\204\244\323\324!\210\211B\262\202g
\203\303
!@!W\203\303A\262\202\254\204\360\203\333
!\247\203\333\211B\262\202g
\317\301!\206\345\320`Eb\210\"\210\202g
\211\203
!@!U\203
A\262\203
!\247\203f

B\262\210\202g
!\247\2041
\317\301\312`E\"\266\202g
\325!\204@

B\262\210\202g
\211\203c
\325
@!\203c
\317\301	!\206U
\320`Eb\210\"\266\202g
\211\262\210\266\203\205s
\312\262\202-\262
0\207" [smie-grammar return assoc string-match "\\`\\s(\\|\\s)\\(\\)\\'" 1 (0 nil) (nil 0) error "Unknown token: %S" nil 0 (scan-error) 2 3 throw t buffer-substring-no-properties -1 cl--assertion-failed (numberp (funcall op-forw toklevels)) smie--associative-p] 21 (#$ . 12263)])
#@793 Skip over one sexp.
HALFSEXP if non-nil, means skip over a partial sexp if needed.  I.e. if the
first token we see is an operator, skip over its left-hand-side argument.
HALFSEXP can also be a token, in which case we should skip the text
assuming it is the left-hand-side argument of that token.
Possible return values:
  (LEFT-LEVEL POS TOKEN): we couldn't skip TOKEN because its right-level
    is too high.  LEFT-LEVEL is the left-level of TOKEN,
    POS is its start position in the buffer.
  (t POS TOKEN): same thing but for an open-paren or the beginning of buffer.
    Instead of t, the `car' can also be some other non-nil non-number value.
  (nil POS TOKEN): we skipped over a paren-like pair.
  nil: we skipped over an identifier, matched parentheses, ...

(fn &optional HALFSEXP)
(defalias 'smie-backward-sexp #[256 "\301\302!\303\302\304!\302\305!%\207" [smie-backward-token-function smie-next-sexp indirect-function #[257 "o\203\f\300\301\302``E\"\207\303
!\207" [signal scan-error "Beginning of buffer" backward-sexp] 6 "\n\n(fn N)"] smie-op-left smie-op-right] 7 (#$ . 14471)])
#@789 Skip over one sexp.
HALFSEXP if non-nil, means skip over a partial sexp if needed.  I.e. if the
first token we see is an operator, skip over its right-hand-side argument.
HALFSEXP can also be a token, in which case we should skip the text
assuming it is the right-hand-side argument of that token.
Possible return values:
  (RIGHT-LEVEL POS TOKEN): we couldn't skip TOKEN because its left-level
    is too high.  RIGHT-LEVEL is the right-level of TOKEN,
    POS is its end position in the buffer.
  (t POS TOKEN): same thing but for a close-paren or the end of buffer.
    Instead of t, the `car' can also be some other non-nil non-number value.
  (nil POS TOKEN): we skipped over a paren-like pair.
  nil: we skipped over an identifier, matched parentheses, ...

(fn &optional HALFSEXP)
(defalias 'smie-forward-sexp #[256 "\301\302!\302\303!\302\304!\302\305!%\207" [smie-forward-token-function smie-next-sexp indirect-function forward-sexp smie-op-right smie-op-left] 7 (#$ . 15575)])
#@51 Move backward through N logical elements.

(fn N)
(defalias 'smie-backward-sexp-command #[257 "\300
[!\207" [smie-forward-sexp-command] 3 (#$ . 16570) "^p"])
#@50 Move forward through N logical elements.

(fn N)
(defalias 'smie-forward-sexp-command #[257 "\211\301V\302
\301U?\205O

\203\303\202\304Z\262`
\203$\305\306!\202'\307\306!\211@\203J
`U\203J\203:m\202;o\204J\310\311\312A@A@E\"\210\266\202)\207" [forward-sexp-function 0 nil 1 -1 smie-forward-sexp halfsexp smie-backward-sexp signal scan-error "Containing expression ends prematurely"] 9 (#$ . 16734) "^p"])
#@53 Alist giving the closer corresponding to an opener.
(defvar smie-closer-alist nil (#$ . 17166))
#@38 Close the closest surrounding block.
(defalias 'smie-close-block #[0 "\212\303\304!\210\305\306!\203\307\310`!A!\202\226 \311
	\"A\311\n\"C\312\211\206\224\313\232\2044@A@\247\203<\314\315!\266\205\202\226\203\204\211A\262\242\n\211\203\211@\3168
A@=\203x\211>\204x\211B\262\316
8\247\203r\211B\262\202x\211@B\262
A\266\202\202G\266\202<\211\204\222\314\317\"\266\205\202\226\211@\266\205)\212\320\312x\210n)\204\244\321 \210\211c\210\212\320\312w\210l)\203\264\322 \207\323 \207" [smie-forward-token-function smie-closer-alist smie-grammar backward-up-list 1 looking-at "\\s(" string syntax-after assoc nil (nil) error "Doesn't look like a block" 2 "No known closer for opener %s" " 	" newline indent-according-to-mode reindent-then-newline-and-indent] 10 (#$ . 17268) nil])
#@256 Move forward down one level paren-like blocks.  Like `down-list'.
With argument ARG, do this that many times.
A negative argument means move backward but still go down a level.
This command assumes point is not in a string or comment.

(fn &optional ARG)
(defalias 'smie-down-list #[256 "`
\303W\203\304\202\f\305\303W\203\305\202\303\303W\203!\202\"	\303U?\205\246Z\262`
 \306
\n\"
G\303U\203k\303W\203J\307\310`S\"\202M\311\310!\203]b\210\312!\266\202\"\313!\210`U?\266\203\202\240\211\203|T
8\247\204|\266\202\"\211\203\235\314Z
8\247\204\235`b\210\315\316\317E\"\262
\266\203\202\240\266\320\204.\202\"\207" [smie-backward-token-function smie-forward-token-function smie-grammar 0 -1 1 assoc looking-back "\\s(\\|\\s)" looking-at down-list forward-sexp 2 signal scan-error "Containing expression ends prematurely" t] 14 (#$ . 18091) "p"])
#@305 Chars which might trigger `blink-matching-open'.
These can include the final chars of end-tokens, or chars that are
typically inserted right after an end token.
I.e. a good choice can be:
    (delete-dups
     (mapcar (lambda (kw) (aref (cdr kw) (1- (length (cdr kw)))))
             smie-closer-alist))
(defvar smie-blink-matching-triggers '(32 10) (#$ . 18990))
(byte-code "\300\301\302\303\304DD\305\306\307%\207" [custom-declare-variable smie-blink-matching-inners funcall function #[0 "\300\207" [t] 1 ""] "Whether SMIE should blink to matching opener for inner keywords.\nIf non-nil, it will blink not only for \"begin..end\" but also for \"if...else\"." :type boolean] 6)
#@18 

(fn START END)
(defalias 'smie-blink-matching-check #[514 "\212\211b\210 \211\203\303
	\"\204\304\"\202;\204 \305\202;\303
	\"@\305=\203.\306\202;b\210\n \211B	\235?\262
\262
)\207" [smie-backward-token-function smie-closer-alist smie-forward-token-function rassoc blink-matching-check-mismatch t nil] 6 (#$ . 19675)])
#@125 Blink the matching opener when applicable.
This uses SMIE's tables and is expected to be placed on `post-self-insert-hook'.
(defalias 'smie-blink-matching-open #[0 "`\306\205\260	\205\260`Sf\n=\2042\212\307\306x\210`\262`Sf\n=\206.\310\306x\210`\262`Sf\n=)\205\260\n>\205\260\311\312 8?\205\260\212\f \262
`S=\203a\211G\313U\203a\314
	\"\204a`\262\f \262
\314
	\"\205\257
 \210\212\306f\n=\203v\313u\210\n\315=\203\200\307\306w\210`Y)\205\257`Sf\n=\204\230`Sf>?\205\257\204\251\316\317\"8\247?\205\257\320\321 ))\207" [blink-matching-paren smie-closer-alist last-command-event smie-blink-matching-triggers smie-backward-token-function smie-forward-token-function nil " 	" " \n	" 8 syntax-ppss 1 rassoc 10 2 assoc smie-blink-matching-check blink-matching-open smie-blink-matching-inners smie-grammar blink-matching-check-function] 6 (#$ . 20018)])
(defvar smie--matching-block-data-cache nil nil)
(make-variable-buffer-local 'smie--matching-block-data-cache)
#@107 Return (OPENER TOKEN START END) or nil.
OPENER is non-nil if TOKEN is an opener and nil if it's a closer.
(defalias 'smie--opener/closer-at-point #[0 "` \210\303	 `\211Y\203'\304\n\"\203' \210`W\205o\303`F
b\210\207\211V\203C\305\n\"\203C \210`X\205o\306`F\207\211X\205o	 `\211W\203W\266\303\207\305\n\"\205m \210`X\205m\306`F\266\202\207" [smie-backward-token-function smie-forward-token-function smie-closer-alist nil rassoc assoc t] 10 (#$ . 21016)])
#@87 A function suitable for `show-paren-data-function' (which see).

(fn ORIG &rest ARGS)
(defalias 'smie--matching-block-data #[385 "\203`\306 B	@\232\203	A\206\336\307\"\207`\306 BC\310\311 8\204\331\3121\323\313 \211\205\314\n\204I\211@\203<\314\202=\315\316A@\"8\247?\205\314\211@\203l\317\320!`
@?\205g\f \210A@\3158B\235`E\266\202\202\267\321\320!
A@
@\203\245\315\316\"8\3158\316
\"A@\247\205\240
=\205\240A@b\210`
 \210\322
`E\262
\266\205\202\267`
 \210\3158B\235
`E\262
\266\202	\3158\3238A@\3158@?\257\241\262
\262
0\210\202\324\210	@@b\210\307\324#\207" [smie-closer-alist smie--matching-block-data-cache smie-blink-matching-inners smie-grammar smie-backward-token-function smie-forward-token-function buffer-chars-modified-tick apply 8 syntax-ppss (scan-error) smie--opener/closer-at-point 1 2 assoc smie-forward-sexp halfsexp smie-backward-sexp t 3 smie--matching-block-data] 12 (#$ . 21509)])
(byte-code "\300\301\302\303\304DD\305\306\307%\207" [custom-declare-variable smie-indent-basic funcall function #[0 "\300\207" [4] 1 ""] "Basic amount of indentation." :type integer] 6)
#@1710 Function providing the indentation rules.
It takes two arguments METHOD and ARG where the meaning of ARG
and the expected return value depends on METHOD.
METHOD can be:
- :after, in which case ARG is a token and the function should return the
  OFFSET to use for indentation after ARG.
- :before, in which case ARG is a token and the function should return the
  OFFSET to use to indent ARG itself.
- :elem, in which case the function should return either:
  - the offset to use to indent function arguments (ARG = `arg')
  - the basic indentation step (ARG = `basic').
  - the token to use (when ARG = `empty-line-token') when we don't know how
    to indent an empty line.
- :list-intro, in which case ARG is a token and the function should return
  non-nil if TOKEN is followed by a list of expressions (not separated by any
  token) rather than an expression.
- :close-all, in which case ARG is a close-paren token at indentation and
  the function should return non-nil if it should be aligned with the opener
  of the last close-paren token on the same line, if there are multiple.
  Otherwise, it will be aligned with its own opener.

When ARG is a token, the function is called with point just before that token.
A return value of nil always means to fallback on the default behavior, so the
function should return nil for arguments it does not expect.

OFFSET can be:
nil				use the default indentation rule.
(column . COLUMN)		indent to column COLUMN.
NUMBER				offset by NUMBER, relative to a base token
				which is the current token for :after and
				its parent for :before.

The functions whose name starts with "smie-rule-" are helper functions
designed specifically for use in this function.
(defvar smie-rules-function 'ignore (#$ . 22656))
(defvar smie--hanging-eolp-function #[0 "\300\301w\210l\206\302d!\207" [" 	" nil forward-comment] 2])
(defalias 'smie-rule-hanging-p 'smie-indent--hanging-p)
#@148 Return non-nil if the current token is "hanging".
A hanging keyword is one that's at the end of a line except it's not at
the beginning of a line.
(defalias 'smie-indent--hanging-p #[0 "\302 ?\205\212\303  G\304U\203m\204\305u\210	 \210`X)\207" [smie-forward-token-function smie--hanging-eolp-function smie-indent--bolp line-end-position 0 1] 3 (#$ . 24582)])
(defalias 'smie-rule-bolp 'smie-indent--bolp)
#@63 Return non-nil if the current token is the first on the line.
(defalias 'smie-indent--bolp #[0 "\212\300\301x\210n)\207" [" 	" nil] 2 (#$ . 25001)])
#@95 Return non-nil if the current token is the first on the line.
Comments are treated as spaces.
(defalias 'smie-indent--bolp-1 #[0 "\300 \212\301`[!\210`
X)\207" [line-beginning-position forward-comment] 3 (#$ . 25156)])
#@70 Like `current-column', but if there's a comment before us, use that.
(defalias 'smie-indent--current-column #[0 "`\300 \212\301\302!\203`
Y\204
b\210i)\207" [line-beginning-position forward-comment -1] 4 (#$ . 25381)])
(defalias 'smie-indent--parent #[0 "\2061\212`	 \303
\n\"A@\247\204
b\210\304\305!\206,\306\304 \211\262\203\306`\3078E\262
\211\266\202)\207" [smie--parent smie-forward-token-function smie-grammar assoc smie-backward-sexp halfsexp nil 2] 7])
#@147 Return non-nil if the current token's parent is among PARENTS.
Only meaningful when called from within `smie-rules-function'.

(fn &rest PARENTS)
(defalias 'smie-rule-parent-p #[128 "\300\301 8
\235\207" [2 smie-indent--parent] 3 (#$ . 25864)])
#@133 Return non-nil if the next token is among TOKENS.
Only meaningful when called from within `smie-rules-function'.

(fn &rest TOKENS)
(defalias 'smie-rule-next-p #[128 "\212\204\n\301 \210`b\210\301 )\211@\235\207" [smie--after smie-indent-forward-token] 4 (#$ . 26116)])
#@74 Return non-nil if the previous token is among TOKENS.

(fn &rest TOKENS)
(defalias 'smie-rule-prev-p #[128 "\212\300 )\211@\235\207" [smie-indent-backward-token] 4 (#$ . 26397)])
#@116 Return non-nil if the parent is actually a sibling.
Only meaningful when called from within `smie-rules-function'.
(defalias 'smie-rule-sibling-p #[0 "\302 @\303	\"A@=\207" [smie--token smie-grammar smie-indent--parent assoc] 4 (#$ . 26584)])
#@184 Align with parent.
If non-nil, OFFSET should be an integer giving an additional offset to apply.
Only meaningful when called from within `smie-rules-function'.

(fn &optional OFFSET)
(defalias 'smie-rule-parent #[256 "\212\300 A@b\210\301
\206
\302\303 \\)B\207" [smie-indent--parent column 0 smie-indent-virtual] 4 (#$ . 26835)])
(defvar smie-rule-separator-outdent 2)
(defalias 'smie-indent--separator-outdent #[0 "\212 \211\204\3031\304\305	\"0\266\202\306\307\"\266\210\310\311w\210l?\205&`)\211\2038\211\312 W\2038\211`Z\2069\n\207" [smie-forward-token-function smie--token smie-rule-separator-outdent (debug error) error "smie-rule-separator: Can't skip token %s" message "Error: %S" " " nil line-end-position] 5])
#@712 Indent current token as a "separator".
By "separator", we mean here a token whose sole purpose is to separate
various elements within some enclosing syntactic construct, and which does
not have any semantic significance in itself (i.e. it would typically no exist
as a node in an abstract syntax tree).
Such a token is expected to have an associative syntax and be closely tied
to its syntactic parent.  Typical examples are "," in lists of arguments
(enclosed inside parentheses), or ";" in sequences of instructions (enclosed
in a {..} or begin..end block).
METHOD should be the method name that was passed to `smie-rules-function'.
Only meaningful when called from within `smie-rules-function'.

(fn METHOD)
(defalias 'smie-rule-separator #[257 "\211\301=\203-\302 \203-\303 \204-\304 A\212A@b\210\305 \210\306d!\210i)\307\211\310 Z^]B\207\211\311=\205:\312 \205:\310 \207" [smie--parent :before smie-rule-bolp smie-rule-sibling-p smie-rule-parent smie-indent-forward-token forward-comment column smie-indent--separator-outdent :after smie-indent--bolp] 8 (#$ . 27578)])
#@13 

(fn ELEM)
(defalias 'smie-indent--offset #[257 "\302\"\206\211\303=\204\302\303\"\206	\207" [smie-rules-function smie-indent-basic :elem basic] 4 (#$ . 28666)])
#@354 Compute indentation column according to `smie-rules-function'.
METHOD and TOKEN are passed to `smie-rules-function'.
AFTER is the position after TOKEN, if known.
PARENT is the parent info returned by `smie-backward-sexp', if known.
BASE-POS is the position relative to which offsets should be applied.

(fn METHOD TOKEN &optional AFTER PARENT BASE-POS)
(defalias 'smie-indent--rule #[1282 "\212\300$\211\204\301\202H\211\242\302=\203\211A\202H\211\250\203D\211\204)\303\202@b\210\2035@\203:\304 \203?\305 \202@i\\\202H\306\307\"\262
)\207" [smie-indent--rule-1 nil column 0 smie-indent--hanging-p smie-indent-virtual error "Unknown indentation offset %s"] 10 (#$ . 28845)])
#@44 

(fn METHOD TOKEN &optional AFTER PARENT)
(defalias 'smie-indent--rule-1 #[1026 "\211\"+\207" [smie--after smie--token smie--parent smie-rules-function] 7 (#$ . 29548)])
#@163 Skip token forward and return it, along with its levels.
Point should be between tokens when calling this function (i.e.,
not in the middle of a string/comment).
(defalias 'smie-indent-forward-token #[0 " \302
GW\203\303
	\"\207\304\305!\203(\306u\210\307`S`\"\306\225\203%\310\202&\311B\207\304\312!\2034\313\306!\210\314\207m\203:\314\207\315\316\"\207" [smie-forward-token-function smie-grammar 0 assoc looking-at "\\s(\\|\\s)\\(\\)" 1 buffer-substring-no-properties (0 nil) (nil 0) "\\s\"\\|\\s|" forward-sexp nil error "Bumped into unknown token: %S"] 4 (#$ . 29734)])
#@59 Skip token backward and return it, along with its levels.
(defalias 'smie-indent-backward-token #[0 " \302\303GW\203\304	\"\207\305\306`S!!\211\262\307>\2032\310u\210\311``T\"
\312=\203/\313\2020\314B\207\211\315>\203>\316\317!\210\302\207o\203D\302\207\320\321!\207" [smie-backward-token-function smie-grammar nil 0 assoc syntax-class syntax-after (4 5) -1 buffer-substring-no-properties 4 (nil 0) (0 nil) (7 15) backward-sexp 1 error "Bumped into unknown token"] 5 (#$ . 30323)])
#@247 Compute the virtual indentation to use for point.
This is used when we're not trying to indent point but just
need to compute the column at which point should be indented
in order to figure out the indentation of some other (further down) point.
(defalias 'smie-indent-virtual #[0 "\300 \203i\207\301 \207" [smie-indent--bolp smie-indent-calculate] 1 (#$ . 30823)])
(defalias 'smie-indent-fixindent #[0 "\302 \205\212\303 \210\304\305\306	\307\260\310 T\311#)\205i\207" [comment-start-skip comment-end-skip smie-indent--bolp comment-normalize-vars re-search-forward "\\(?:" "\\)fixindent\\(?:" "\\)" line-end-position t] 6])
(defalias 'smie-indent-bob #[0 "\212\300`[!\210o\205\f\301 )\207" [forward-comment prog-first-column] 2])
(defalias 'smie-indent-close #[0 "\212\300\301!\2056\302\303\304``T\"`T#\203#\305\306!\307U\204&\310\311w\210\202\312u\210\31314\314\312!\210\315 0\2026\210\311)\207" [looking-at "\\s)" smie-indent--rule-1 :close-all buffer-substring-no-properties skip-syntax-forward ")" 0 " 	" nil 1 (scan-error) backward-sexp smie-indent-virtual] 5])
#@286 Indent point based on the token that follows it immediately.
If TOKEN is non-nil, assume that that is the token that follows point.
Returns either a column number or nil if it considers that indentation
should not be computed on the basis of the following token.

(fn &optional TOKEN)
(defalias 'smie-indent-keyword #[256 "\212`
\203
\301\"\202B\302 
\303 W\2058\212`b\210\304y\210\3051*
\302 \2320\202/\210\306\2025\2055`
=\262
)?\205@
b\210\211\262
\211
A\262\242\262\211A\204U\266\306\202\357\211@\247\204y\307\310\"\206\355\311 \203m\266\306\202\357\312 ?\205\355i\266\202\202\357\313!`W\204\224\211A@\203\220\211A@W\204\224\306\202\353\212b\210\307\310\306\211A@%)\206\353\211@@=\203\323\314 \203\311`U\204\311\212\211A@bb\210\314 )\204\311i\202\353\211A@b\210\315 \202\353`U\205\333\314 ?\205\353\211@\203\351\316 \202\353\315 \262
\266\202)\207" [smie-grammar assoc smie-indent-forward-token line-beginning-position 1 (error) nil smie-indent--rule :before smie-indent--bolp-1 smie-indent--hanging-p smie-backward-sexp smie-indent--bolp smie-indent-virtual smie-indent--current-column] 10 (#$ . 31914)])
#@35 Compute indentation of a comment.
(defalias 'smie-indent-comment #[0 "\303 \205P`\212\304 \210\305\306 \307#\205\211\310\225\206\311\224=)\262
\205P\212\312d!\210\313\314w\210\212	 \211G\311U\203Bm\206F\315`!@\316=\206F\317
\n\"\262
)?\205O\320 )\207" [comment-start-skip smie-forward-token-function smie-closer-alist smie-indent--bolp beginning-of-line re-search-forward line-end-position t 1 0 forward-comment " 	
\n" nil syntax-after 5 rassoc smie-indent-calculate] 5 (#$ . 33078)])
(defalias 'smie-indent-comment-continue #[0 "\205	\302\303\211#\304
GW\205n\305\306!!\205n\307\310 8\205n\310 \212\311y\210\312
8`
X\203\\\211b\210	\203;\305	!\204A\313u\210\202X\304\225b\210\314\315x\210`
T=\203T\211\202V\211Tb\210i\202i\314\315w\210\305\306!!\205ii\262
)\262
\207" [comment-continue comment-start-skip comment-string-strip t 0 looking-at regexp-quote 4 syntax-ppss -1 8 1 " 	" nil] 6])
(defalias 'smie-indent-comment-close #[0 "\302\300!\205N\205N\303\304!?\205N\303!\205N\305\306!\307\310 8\205L\212\311\310 8b\210\303	!\205K\305\306!\312\313\314Q\"\203Hi\306\224\\\315\224\315\225Z\\\202Ii\262
)\262
\207" [comment-end-skip comment-start-skip boundp looking-at " 	*$" match-string 0 4 syntax-ppss 8 string-match "\\(.+\\).*\n\\(.*?\\)\\1" "\n" 2] 7])
(defalias 'smie-indent-comment-inside #[0 "\300\301 8\205\302\207" [4 syntax-ppss noindent] 2])
(defalias 'smie-indent-inside-string #[0 "\300\301 8\205\302\207" [3 syntax-ppss noindent] 2])
(defalias 'smie-indent-after-keyword #[0 "\212`\301 \211@
\204\266\302\202D\303\304\302`%\206B\3058\247\204'\266\302\202D
A@\247\2035\306
\"\203@\307 \310\311!\\\266\203\202D\307 \266\203)\207" [smie-closer-alist smie-indent-backward-token nil smie-indent--rule :after 2 rassoc smie-indent-virtual smie-indent--offset basic] 9])
#@56 Indentation rule when there's nothing yet on the line.
(defalias 'smie-indent-empty-line #[0 "l\205\302\303\"\304
	\"\205\305
!\262
\207" [smie-rules-function smie-grammar :elem empty-line-token assoc smie-indent-keyword] 4 (#$ . 34920)])
(defalias 'smie-indent-exps #[0 "\212\302\211\303 @\204`B\211\262\203\304 \203\212\303 @?\206$\305	 \"\262
)
\2041\266\302\202a\211\203@
@b\210\306 \266\202\202a
A\203Q
A@b\210\306 \266\202\202a
\205_
@b\210\307\310!\306 \\\266\202)\207" [smie-rules-function smie-backward-token-function nil smie-backward-sexp smie-indent--bolp :list-intro smie-indent--current-column smie-indent--offset args] 5])
#@258 Functions to compute the indentation.
Each function is called with no argument, shouldn't move point, and should
return either nil if it has no opinion, or an integer representing the column
to which that point should be aligned, if we were to reindent it.
(defvar smie-indent-functions '(smie-indent-fixindent smie-indent-bob smie-indent-close smie-indent-comment smie-indent-comment-continue smie-indent-comment-close smie-indent-comment-inside smie-indent-inside-string smie-indent-keyword smie-indent-after-keyword smie-indent-empty-line smie-indent-exps) (#$ . 35588))
(defalias 'smie--funcall 'funcall)
#@43 Compute the indentation to use for point.
(defalias 'smie-indent-calculate #[0 "\300\301\302\"\207" [run-hook-wrapped smie-indent-functions smie--funcall] 3 (#$ . 36203)])
#@56 Indent current line using the SMIE indentation engine.
(defalias 'smie-indent-line #[0 "`\3001!\212\301y\210\302\303w\210`
Y\203\303\262
\304 \206\301)0\202)\305\306\"\210\303\262
\206-\301\211\247\2043\207\211\301W\203<\301\262

\203F\212\307
!)\207\307
!\207" [(debug error) 0 " 	" nil smie-indent-calculate message "Error: %S" indent-line-to] 5 (#$ . 36381) nil])
#@21 

(fn DO-AUTO-FILL)
(defalias 'smie-auto-fill #[257 "\300 \211\205\205i
V\205\205\301\212\302\303 !)8\204}\304\212\305!\210\302 )8\204}\3061l\212`\307\310\311 \210\312 \210`X\203XiX\203X\313\307w\210\314 i
Z\211V\203S\211\262`\262\266\202/\211\310V\205e
b\210\315 \210\316\266\203)0\202t\317\320\"\210\307\262
\203}i
V\204$i
V\205\205
 \207" [current-fill-column 8 syntax-ppss line-beginning-position 4 move-to-column (debug error) nil 0 beginning-of-line smie-indent-forward-token " 	" smie-indent-calculate newline-and-indent done message "Error: %S"] 9 (#$ . 36765)])
#@342 Setup SMIE navigation and indentation.
GRAMMAR is a grammar table generated by `smie-prec2->grammar'.
RULES-FUNCTION is a set of indentation rules for use on `smie-rules-function'.
KEYWORDS are additional arguments, which can use the following keywords:
- :forward-token FUN
- :backward-token FUN

(fn GRAMMAR RULES-FUNCTION &rest KEYWORDS)
(defalias 'smie-setup #[642 "\306\300!\210
\306\301!\210\306\302!\210\307\310\311\312\313B\314\315$\210\306\303!\210\316\211\203R\211
A\262\242
\211A\262\242
\317\267\202I\306\304!\210\210\202!\306\305!\210\210\202!\320\321\"\266\202!\322\236A\211\205\266\306\323!\210\211\306\324!\210\325\326\327\330\331\332$\210\310\311\333\334B\335\315$\210\336\337\340\"\341\"\315\211\211A\262\242\211\262\203\246\203\232\342
@\"\204\202\211
GSHB\262\202\202\306\343!\210\331#\344!\"\211#\266\203\207" [smie-rules-function smie-grammar indent-line-function forward-sexp-function smie-forward-token-function smie-backward-token-function make-local-variable smie-indent-line advice--add-function :around #[0 "\300\301!\207" [advice--buffer-local normal-auto-fill-function] 2] #[257 "\300\301\"\207" [advice--set-buffer-local normal-auto-fill-function] 4 "\n\n(fn GV--VAL)"] smie-auto-fill nil smie-forward-sexp-command #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (:forward-token 55 :backward-token 64)) message "smie-setup: ignoring unknown keyword %s" :smie-closer-alist smie-closer-alist blink-matching-check-function smie-blink-matching-check add-hook post-self-insert-hook smie-blink-matching-open append local #[0 "\300\301!\207" [advice--buffer-local show-paren-data-function] 2] #[257 "\300\301\"\207" [advice--set-buffer-local show-paren-data-function] 4 "\n\n(fn GV--VAL)"] smie--matching-block-data sort mapcar cdr string-lessp string-prefix-p smie-blink-matching-triggers delete-dups] 11 (#$ . 37365)])
#@50 Instrument the `smie-rules-function' for Edebug.
(defalias 'smie-edebug #[0 "\301\302!\2109\203
\303!\207\304\305!\207" [smie-rules-function require edebug edebug-instrument-function error "Sorry, don't know how to instrument a lambda expression"] 2 (#$ . 39293) nil])
#@68 Go to the next line that needs to be reindented (and reindent it).
(defalias 'smie--next-indent-change #[0 "\300 \301 \210\211\300 =\262
\205\302y\210\202\207" [buffer-chars-modified-tick indent-according-to-mode 1] 3 (#$ . 39571) nil])
#@107 Indentation config rules installed for this major mode.
Typically manipulated from the major-mode's hook.
(defvar smie-config--mode-local nil (#$ . 39819))
(make-variable-buffer-local 'smie-config--mode-local)
#@118 Indentation config rules installed for this very buffer.
E.g. provided via a file-local call to `smie-config-local'.
(defvar smie-config--buffer-local nil (#$ . 40036))
(make-variable-buffer-local 'smie-config--buffer-local)
#@56 Variable used to trace calls to `smie-rules-function'.
(defvar smie-config--trace nil (#$ . 40267))
#@24 

(fn ORIG KIND TOKEN)
(defalias 'smie-config--advice #[771 "\"E\303
\"\303	\"\n\203
\206\211
\203!
@\207\211\203(\211@\207\207" [smie-config--buffer-local smie-config--mode-local smie-config--trace rassoc] 9 (#$ . 40373)])
#@14 

(fn RULES)
(defalias 'smie-config--mode-hook #[257 "\301
\"\302\303\304\305B\306\307$\207" [smie-config--mode-local append advice--add-function :around #[0 "\300\301!\207" [advice--buffer-local smie-rules-function] 2] #[257 "\300\301\"\207" [advice--set-buffer-local smie-rules-function] 4 "\n\n(fn GV--VAL)"] smie-config--advice nil] 6 (#$ . 40619)])
(defvar smie-config--modefuns nil)
#@18 

(fn VAR VALUE)
(defalias 'smie-config--setter #[514 "\301\"\210\302
\211\2038\211@\211\242
\243\211\303\304\305\"!\211\306\307\"M\210\211B\310\303\304\311\"!\"\266
A\266\202\202	\210\211\211\205Q\211@\211>\204J\211\312M\210
A\266\202\202:\207" [smie-config--modefuns set-default nil intern format "smie-config--modefun-%s" make-closure #[0 "\301\300!\207" [V0 smie-config--mode-hook] 2] add-hook "%s-hook" ignore] 14 (#$ . 41017)])
(byte-code "\300\301\302\303\304DD\305\306\307\310\311\312\313\314\315&\207" [custom-declare-variable smie-config funcall function #[0 "\300\207" [nil] 1 ""] "User configuration of SMIE indentation.\nThis is a list of elements (MODE . RULES), where RULES is a list\nof elements describing when and how to change the indentation rules.\nEach RULE element should be of the form (NEW KIND TOKEN NORMAL),\nwhere KIND and TOKEN are the elements passed to `smie-rules-function',\nNORMAL is the value returned by `smie-rules-function' and NEW is the\nvalue with which to replace it." :version "24.4" :type (choice (const nil) (alist :key-type symbol)) :initialize custom-initialize-set :set smie-config--setter] 12)
#@166 Add RULES as local indentation rules to use in this buffer.
These replace any previous local rules, but supplement the rules
specified in `smie-config'.

(fn RULES)
(defalias 'smie-config-local #[257 "\211\301\302\303\304B\305\306$\207" [smie-config--buffer-local advice--add-function :around #[0 "\300\301!\207" [advice--buffer-local smie-rules-function] 2] #[257 "\300\301\"\207" [advice--set-buffer-local smie-rules-function] 4 "\n\n(fn GV--VAL)"] smie-config--advice nil] 6 (#$ . 42186)])
(put 'smie-config-local 'safe-local-eval-function t)
(defalias 'smie-config--get-trace #[0 "\212\300y\210\301\302w\210\302C\303\304\"\303\305\"\216\306\307\310\311B\302$\210\312 \242)B\266\202)\207" [0 " 	" nil make-closure #[771 "`\302\"\300	:\203	\257\202F\300\242B\240\210)\207" [V0 smie-config--trace t] 11 "\n\n(fn ORIG KIND TOKEN)"] #[0 "\301\302\303!\300\"\211\302\303!=?\205\304\303\"\207" [V0 advice--remove-function advice--buffer-local smie-rules-function advice--set-buffer-local] 4] advice--add-function :around #[0 "\300\301!\207" [advice--buffer-local smie-rules-function] 2] #[257 "\300\301\"\207" [advice--set-buffer-local smie-rules-function] 4 "\n\n(fn GV--VAL)"] smie-indent-calculate] 7])
#@185 Display the SMIE rules that are used to indent the current line.
If prefix ARG is given, then move briefly point to the buffer
position corresponding to each rule.

(fn &optional ARG)
(defalias 'smie-config-show-indent #[256 "\301 A\211\204\302\303!\207
\204\302\304\305\306\307#\"\207\212\211\211\205^\211@\211\242
\243\211\242
\243\211\242
\243\211\242
\243\211\242
\243\302\310	\204E\311\202L\312\313\314	8\"%\210	b\210\315!\266
A\266\202\202\262
)\207" [blink-matching-delay smie-config--get-trace message "No SMIE rules involved" "Rules used: %s" mapconcat #[257 "\211\242
\243\211\242
\243\211\242
\243\211\242
\243\211\242
\243\300\301\302\n	\204&\303\202-\301\304\305\n8\"%\207" [nil format "%S %S -> %S%s" #1="" "(via %S)" 3] 21 "\n\n(fn ELEM)"] ", " "%S %S -> %S%s" #1# format "(via %S)" 3 sit-for] 23 (#$ . 43423) "P"])
#@12 

(fn SIG)
(defalias 'smie-config--guess-value #[257 "\301\302\303\304B\305\306$\210\307
B\211B\310 \311 
Z\240\210\311 =\205$

Z)\207" [smie-config--buffer-local advice--add-function :around #[0 "\300\301!\207" [advice--buffer-local smie-rules-function] 2] #[257 "\300\301\"\207" [advice--set-buffer-local smie-rules-function] 4 "\n\n(fn GV--VAL)"] smie-config--advice nil 0 current-indentation smie-indent-calculate] 8 (#$ . 44290)])
#@55 Add a rule to adjust the indentation of current line.
(defalias 'smie-config-set-indent #[0 "\301 A\211\204\302\303!\210\304
A\204>
@\211\242
\243\211\242
\243\211\242
\243\211\242
\243\211\242
\243\304\3058\2064E\262
\266\212\262
\202\245\306\307\310\311\"\304\312\304\211\211&\313\314\315Q!@\3162\243\211\205\240\211@\211\242
\243\211\242
\243\211\242
\243\211\242
\243\211\242
\243\304@=\203\227A@\232\203\227\317\316\n	\3058\206\224E\"\210\266
A\266\202\202W\262
0\266\202\320
!\321\322\323@A@\3248%\304\211\325\326\"$\313
!@\327\"\211\203\320\330
\"\210\211BB\331\332@A@\324	8%\210\333\334\335\336B\337\304$\207" [smie-config--buffer-local smie-config--get-trace error "No SMIE rules involved" nil 3 completing-read "Adjust rule: " mapcar #[257 "\300\301\302A@!\303\304O\3058#\207" [format "%s %S" symbol-name 1 nil 2] 6 "\n\n(fn ELEM)"] t read-from-string "(:" ")" found throw smie-config--guess-value read-string format-prompt "Adjust rule (%S %S -> %S) to" 2 format "%S" rassoc remove message "Added rule %S %S -> %S (via %S)" advice--add-function :around #[0 "\300\301!\207" [advice--buffer-local smie-rules-function] 2] #[257 "\300\301\"\207" [advice--set-buffer-local smie-rules-function] 4 "\n\n(fn GV--VAL)"] smie-config--advice] 23 (#$ . 44739) nil])
#@16 

(fn BEG END)
(defalias 'smie-config--guess #[514 "\302\303\304\"\305\211\306\307#
\212b\210\310y\210`W\203g\311\305w\210l\204a\211`\305
\247\2035
@Y\205:\312#\266\313 \211@\314\315A\"\316 \247\203_\211ZB\317
\320\f\310#T#\266\266\321y\210\202)\322
!\210\323\324!\210\302\303\304\"\325\326\327\"\"\210\330
!\323\331!\210\262
*\207" [smie-config--mode-local smie-config--buffer-local make-hash-table :test equal nil make-progress-reporter "Analyzing the buffer" 0 " 	" progress-reporter-do-update smie-config--get-trace mapcar cdr current-indentation puthash gethash 1 progress-reporter-done message "Guessing..." maphash make-closure #[514 "
@A\301
\211\203$\211
A\262\242\302
8\250\203 \211\235\203 \303\262\210\202\210\211?\205\216
\211\205\214\211@\302
8\250\203\205\304
\300\"\206L\305\301\211E\306\300#\210\211\262
\211
@\\\240\210B
AA\211@B\240\266
A@\236\206|\305B
A\211@B\240\266\211\262
\211
A	\\\241\266
A\266\202\202+\262
\207" [V0 nil 2 t gethash 0 puthash] 13 "\n\n(fn OTRACE COUNT)"] smie-config--guess-1 "Guessing...done"] 17 (#$ . 46071)])
#@13 

(fn SIGS)
(defalias 'smie-config--guess-1 #[257 "\300C\300\301\302\303\"\"\210
\304\242\305\"\240\210
\242\203\334
\242\211\242A\240\210\242\211\242
\243\211\242
\243\211\242
\243\211\242
\243\306\307\310\311\"\"U\204B\312\313!\210\304\314\"\211@@\211\315U\204\327\211\3168\\\nB\fB\262\f\211\203\326\211@\211\242
\243\211\242
\243A\211	Z\240\266\211\211\203\315\211@\211\242\236A\211\203\305
A@\236Z\211A@\236\206\250\211\315BA\211@B\240\266\211\262
A\nY\204\264\312\317!\210\211AZ\241\210\211
A\\\241\266\210
A\266\202\202w\266
A\266\202\202^\210\266\202\207" [nil maphash make-closure #[514 "\300B\300\242B\240\207" [V0] 5 "\n\n(fn SIG SIG-DATA)"] sort #[514 "
A@
A@V\207" #1=[] 4 "\n\n(fn SD1 SD2)"] apply + mapcar cdr cl--assertion-failed (= total (apply #'+ (mapcar #'cdr off-alist))) #[514 "
A
AV\207" #1# 4 "\n\n(fn X Y)"] 0 2 (>= (cdr ooff-data) count)] 30 (#$ . 47201)])
#@120 Try and figure out this buffer's indentation settings.
To save the result for future sessions, use `smie-config-save'.
(defalias 'smie-config-guess #[0 "\302=\203\n\303\304!\210\305ed\"\211\204\306\307!\207	\204\"\310
!\210\306\311!\207\312\313!\2030\306\314!\210\310
!\207\312\315!\203A\306\316!\210\310\317	\"!\207\306\320\"\207" [smie-grammar smie-config--buffer-local unset user-error "This buffer does not seem to be using SMIE" smie-config--guess message "Nothing to change" smie-config-local "Local rules set" y-or-n-p "Replace existing local config? " "Local rules replaced" "Merge with existing local config? " "Local rules adjusted" append "Rules guessed: %S"] 5 (#$ . 48142) nil])
#@116 Save local rules for use with this major mode.
One way to generate local rules is the command `smie-config-guess'.
(defalias 'smie-config-save #[0 "\204\304\305!\207	\n\236\211\204\304\306!\210\202:\307\310!\203%\304\311!\210\202:\307\312!\2037\304\313!\210\314A\"\202:\315\316!
\203E

\241\210\202K	
B\nB\211\317\300!\210\320\302!\207" [smie-config--buffer-local major-mode smie-config smie-config--mode-local message "No local rules to save" "Local rules saved in `smie-config'" y-or-n-p "Replace the existing mode's config? " "Mode rules replaced in `smie-config'" "Merge with existing mode's config? " "Mode rules adjusted in `smie-config'" append error "Abort" kill-local-variable customize-mark-as-set] 4 (#$ . 48850) nil])
(provide 'smie)