;ELC   
;;; Compiled
;;; in Emacs version 25.3.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.

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


#@181 Loop over a sequence.
Similar to `dolist' but can be applied to lists, strings, and vectors.

Evaluate BODY with VAR bound to each element of SEQ, in turn.

(fn (VAR SEQ) BODY...)
(defalias 'seq-doseq '(macro . #[385 "\300\301!\300\302!\300\303!\304A@D\305\306D\307\310DFD\305\311FDE\312\305\313	E\314DF\315	@\305	\316\317E\320\321\322BBEE\323\nDFDC	BBEE\207" [make-symbol "length" "seq" "index" let* if listp nil seq-length 0 while < consp let prog1 seq-elt setq + (1) pop] 20 (#$ . 411)]))
(byte-code "\300\301\302\303#\210\304\301\305\306#\207" [function-put seq-doseq lisp-indent-function 1 put edebug-form-spec ((symbolp form &optional form) body)] 4)
#@214 Bind the variables in ARGS to the elements of SEQUENCE then evaluate BODY.

ARGS can also include the `&rest' marker followed by a variable
name to be bound to the rest of SEQUENCE.

(fn ARGS SEQUENCE &rest BODY)
(defalias 'seq-let '(macro . #[642 "\300\301!\302D\303\"BBB\207" [make-symbol "seq" let* seq--make-bindings] 9 (#$ . 1107)]))
(byte-code "\300\301\302\303#\210\304\301\305\306#\207" [function-put seq-let lisp-indent-function 2 put edebug-form-spec t] 4)
#@195 Return a subsequence of SEQUENCE without its first N elements.
The result is a sequence of the same type as SEQUENCE.

If N is a negative integer or zero, SEQUENCE is returned.

(fn SEQUENCE N)
(defalias 'seq-drop #[514 "\211\300X\203 \207<\203 \301\"\207\302!\303^#\207" [0 seq--drop-list seq-length seq-subseq] 7 (#$ . 1587)])
#@201 Return a subsequence of SEQUENCE with its first N elements.
The result is a sequence of the same type as SEQUENCE.

If N is a negative integer or zero, an empty sequence is
returned.

(fn SEQUENCE N)
(defalias 'seq-take #[514 "<\203\n \300\"\207\301\302\302]\303!^#\207" [seq--take-list seq-subseq 0 seq-length] 8 (#$ . 1934)])
#@172 Return a sequence from the first element for which (PREDICATE element) is nil in SEQUENCE.
The result is a sequence of the same type as SEQUENCE.

(fn PREDICATE SEQUENCE)
(defalias 'seq-drop-while #[514 "\211<\203\n \300\"\207\301\302\"\"\207" [seq--drop-while-list seq-drop seq--count-successive] 7 (#$ . 2276)])
#@166 Return the successive elements for which (PREDICATE element) is non-nil in SEQUENCE.
The result is a sequence of the same type as SEQUENCE.

(fn PREDICATE SEQUENCE)
(defalias 'seq-take-while #[514 "\211<\203\n \300\"\207\301\302\"\"\207" [seq--take-while-list seq-take seq--count-successive] 7 (#$ . 2602)])
#@114 Return a list of all the elements for which (PREDICATE element) is non-nil in SEQUENCE.

(fn PREDICATE SEQUENCE)
(defalias 'seq-filter #[514 "\300\301!\302\303\304\305\306\307\310\n	\"\311\"\312\313%\"\"\207" [make-symbol "exclude" delq seq-map make-byte-code 257 "\300!\203 \207\301\207" vconcat vector [] 3 "\n\n(fn ELT)"] 13 (#$ . 2922)])
#@205 Return the result of applying FUNCTION to each element of SEQUENCE.
Unlike `seq-map', FUNCTION takes two arguments: the element of
the sequence, and its index within the sequence.

(fn FUNCTION SEQUENCE)
(defalias 'seq-map-indexed #[514 "\300C\301\302\303\304\305\306\"\307\"\310\311%\"\207" [0 seq-map make-byte-code 257 "\300\301\242\"\301\211\242T\240\210\207" vconcat vector [] 4 "\n\n(fn ELT)"] 11 (#$ . 3277)])
#@110 Return a list of all the elements for which (PREDICATE element) is nil in SEQUENCE.

(fn PREDICATE SEQUENCE)
(defalias 'seq-remove #[514 "\300\301\302\303\304\305!\306\"\307\310%\"\207" [seq-filter make-byte-code 257 "\300!?\207" vconcat vector [] 3 "\n\n(fn ELT)"] 9 (#$ . 3707)])
#@416 Reduce the function FUNCTION across SEQUENCE, starting with INITIAL-VALUE.

Return the result of calling FUNCTION with INITIAL-VALUE and the
first element of SEQUENCE, then calling FUNCTION with that result and
the second element of SEQUENCE, then with that result and the third
element of SEQUENCE, etc.

If SEQUENCE is empty, return INITIAL-VALUE and FUNCTION is not called.

(fn FUNCTION SEQUENCE INITIAL-VALUE)
(defalias 'seq-reduce #[771 "\300!\203 \207\211\211<?\205 \301!\211\203 \302\202 \203% \211W\202' \211:\203J \2039 \303\"T\262\202? \211A\262\242\"\262\210\202 \266\211\207" [seq-empty-p seq-length 0 seq-elt] 11 (#$ . 4000)])
#@110 Return the first value for which if (PREDICATE element) is non-nil for in SEQUENCE.

(fn PREDICATE SEQUENCE)
(defalias 'seq-some #[514 "\3002P \211\211<?\205 \301!\211\203 \302\202 \203! \211W\202# \211:\203L \2035 \303\"T\262\202; \211A\262\242!\211\203G \304\300\"\210\266\202 \266\3050\207" [seq--break seq-length 0 seq-elt throw nil] 10 (#$ . 4672)])
#@302 Return the first element for which (PREDICATE element) is non-nil in SEQUENCE.
If no element is found, return DEFAULT.

Note that `seq-find' has an ambiguity if the found element is
identical to DEFAULT, as it cannot be known if an element was
found or not.

(fn PREDICATE SEQUENCE &optional DEFAULT)
(defalias 'seq-find #[770 "\3002O \211<?\205 \301!\211\203 \302\202 \203! \211W\202# \211:\203K \2035 \303\"T\262\202; \211A\262\242!\203G \304\300\"\210\210\202 \266\2110\207" [seq--break seq-length 0 seq-elt throw] 10 (#$ . 5054)])
#@118 Return non-nil if (PREDICATE element) is non-nil for all elements of the sequence SEQUENCE.

(fn PREDICATE SEQUENCE)
(defalias 'seq-every-p #[514 "\3002N \211\211<?\205 \301!\211\203 \302\202 \203! \211W\202# \211:\203J \2035 \303\"T\262\202; \211A\262\242!\204F \304\300\305\"\210\210\202 \266\3060\207" [seq--break seq-length 0 seq-elt throw nil t] 9 (#$ . 5617)])
#@110 Return the number of elements for which (PREDICATE element) is non-nil in SEQUENCE.

(fn PREDICATE SEQUENCE)
(defalias 'seq-count #[514 "\300\211<?\205 \301!\211\203 \300\202 \203 \211W\202  \211:\203G \2032 \302\"T\262\2028 \211A\262\242!\203C T\262\210\202 \266\211\207" [0 seq-length seq-elt] 9 (#$ . 6009)])
#@81 Return non-nil if the sequence SEQUENCE is empty, nil otherwise.

(fn SEQUENCE)
(defalias 'seq-empty-p #[257 "\211<\203 \211?\207\300!\301U\207" [seq-length 0] 3 (#$ . 6350)])
#@158 Return a sorted sequence comparing using PREDICATE the elements of SEQUENCE.
The result is a sequence of the same type as SEQUENCE.

(fn PREDICATE SEQUENCE)
(defalias 'seq-sort #[514 "\211<\203\f \300\301!\"\207\302\303\304\"\"\305\306!\"\207" [sort seq-copy seq-sort append nil seq-into type-of] 7 (#$ . 6535)])
#@197 Sort SEQUENCE using PRED as a comparison function.
Elements of SEQUENCE are transformed by FUNCTION before being
sorted.  FUNCTION must be a function of one argument.

(fn FUNCTION PRED SEQUENCE)
(defalias 'seq-sort-by #[771 "\300\301\302\303\304\305\"\306\"\307\310%\"\207" [seq-sort make-byte-code 514 "\301\300!\300!\"\207" vconcat vector [] 6 "\n\n(fn A B)"] 11 (#$ . 6861)])
#@157 Return the first element in SEQUENCE that equals to ELT.
Equality is defined by TESTFN if non-nil or by `equal' if nil.

(fn SEQUENCE ELT &optional TESTFN)
(defalias 'seq-contains #[770 "\300\301\302\303\304\305\"\306\"\307\310%\"\207" [seq-some make-byte-code 257 "\301\206 \302\300\"\207" vconcat vector [equal] 4 "\n\n(fn E)"] 11 (#$ . 7255)])
#@197 Return non-nil if SEQUENCE1 and SEQUENCE2 contain the same elements, regardless of order.
Equality is defined by TESTFN if non-nil or by `equal' if nil.

(fn SEQUENCE1 SEQUENCE2 &optional TESTFN)
(defalias 'seq-set-equal-p #[770 "\300\301\302\303\304\305\"\306\"\307\310%\"\205' \300\301\302\303\304\305\"\311\"\307\312%\"\207" [seq-every-p make-byte-code 257 "\302\300\301#\207" vconcat vector [seq-contains] 5 "\n\n(fn ITEM1)" [seq-contains] "\n\n(fn ITEM2)"] 11 (#$ . 7616)])
#@172 Return the index of the first element in SEQUENCE that is equal to ELT.
Equality is defined by TESTFN if non-nil or by `equal' if nil.

(fn SEQUENCE ELT &optional TESTFN)
(defalias 'seq-position #[770 "\300\3012Z \211<?\205 \302!\211\203 \300\202 \203\" \211W\202$ \211:\203V \2036 \303\"T\262\202< \211A\262\242\206A \304\"\203N \305\301\"\210T\262\210\202 \266\3060\207" [0 seq--break seq-length seq-elt equal throw nil] 11 (#$ . 8113)])
#@165 Return a list of the elements of SEQUENCE with duplicates removed.
TESTFN is used to compare elements, or `equal' if TESTFN is nil.

(fn SEQUENCE &optional TESTFN)
(defalias 'seq-uniq #[513 "\300\211<?\205 \301!\211\203 \302\202 \203 \211W\202  \211:\203J \2032 \303\"T\262\2028 \211A\262\242\304#\204F \211B\262\210\202 \266\211\237\207" [nil seq-length 0 seq-elt seq-contains] 11 (#$ . 8585)])
#@205 Return the subsequence of SEQUENCE from START to END.
If END is omitted, it defaults to the length of the sequence.
If START or END is negative, it counts from the end.

(fn SEQUENCE START &optional END)
(defalias 'seq-subseq #[770 ";\204 \300!\203 O\207<\203\225 \301\302\303#\2030 \304W\2030 \305!\211\262\\\262\304W\203E \206B \305!\211\262\\\262\304V\203^ S\233\262\204Z \306\307\"\210A\262\203\221 \301S\211\262Y\203~ \203~ \211A\262\242B\262\202c TU\204\212 \306\307\"\210\211\237\262\202\224 \310!\207\306\311\"\207" [vectorp nil format "Bad bounding indices: %s, %s" 0 seq-length error "%s" seq-copy "Unsupported sequence: %s"] 9 (#$ . 9012)])
#@151 Concatenate, into a sequence of type TYPE, the sequences SEQS.
TYPE must be one of following symbols: vector, string or list.


(fn TYPE SEQUENCE...)
(defalias 'seq-concatenate #[385 "\300=\203 \301\302\"\207\303=\203 \301\304\"\207\305=\203$ \301\306\211\307\"\"\207\310\311\"\207" [vector apply vconcat string concat list append (nil) error "Not a sequence type name: %S"] 7 (#$ . 9718)])
#@178 Concatenate the result of applying FUNCTION to each element of SEQUENCE.
The result is a sequence of type TYPE, or a list if TYPE is nil.

(fn FUNCTION SEQUENCE &optional TYPE)
(defalias 'seq-mapcat #[770 "\300\301\206 \302\303\"#\207" [apply seq-concatenate list seq-map] 9 (#$ . 10125)])
#@208 Like `seq-map' but FUNCTION is mapped over all SEQS.
The arity of FUNCTION must match the number of SEQS, and the
mapping stops on the shortest sequence.
Return a list of the results.

(fn FUNCTION SEQS...)
(defalias 'seq-mapn #[642 "\300\301\302B\"\300>\204! \303\301\304\"\"B\262\301\305\"\262\202 \237\207" [nil seq-map #[257 "\300\301\"\207" [seq-into list] 4 "\n\n(fn S)"] apply car cdr] 10 (#$ . 10428)])
#@203 Return a list of the elements of SEQUENCE grouped into sub-sequences of length N.
The last sequence may contain less than N elements.  If N is a
negative integer or 0, nil is returned.

(fn SEQUENCE N)
(defalias 'seq-partition #[514 "\211\300W?\205# \301\302!\204 \303\"B\262\304\"\262\202 \211\237\262\207" [1 nil seq-empty-p seq-take seq-drop] 6 (#$ . 10858)])
#@162 Return a list of the elements that appear in both SEQ1 and SEQ2.
Equality is defined by TESTFN if non-nil or by `equal' if nil.

(fn SEQ1 SEQ2 &optional TESTFN)
(defalias 'seq-intersection #[770 "\300\301\302\303\304\305\"\306\"\307\310%\311!\312#\207" [seq-reduce make-byte-code 514 "\302\300\301#\203\f \211B\207\207" vconcat vector [seq-contains] 6 "\n\n(fn ACC ELT)" seq-reverse nil] 11 (#$ . 11239)])
#@164 Return a list of the elements that appear in SEQ1 but not in SEQ2.
Equality is defined by TESTFN if non-nil or by `equal' if nil.

(fn SEQ1 SEQ2 &optional TESTFN)
(defalias 'seq-difference #[770 "\300\301\302\303\304\305\"\306\"\307\310%\311!\312#\207" [seq-reduce make-byte-code 514 "\302\300\301#\204\f \211B\207\207" vconcat vector [seq-contains] 6 "\n\n(fn ACC ELT)" seq-reverse nil] 11 (#$ . 11660)])
#@178 Apply FUNCTION to each element of SEQUENCE.
Separate the elements of SEQUENCE into an alist using the results as
keys.  Keys are compared using `equal'.

(fn FUNCTION SEQUENCE)
(defalias 'seq-group-by #[514 "\300\301\302\303\304\305!\306\"\307\310%\311!\312#\207" [seq-reduce make-byte-code 514 "\300!\301\"\211\203 \211\211AB\241\262\241\210\202! DB\262\207" vconcat vector [assoc] 9 "\n\n(fn ACC ELT)" seq-reverse nil] 9 (#$ . 12081)])
(byte-code "\300\301\3021 \303\304!0\202 \210\202 \203 \303\202 \305\"\207" [defalias seq-reverse (error) reverse [1 2] #[257 "\300C\301\302\303\304\305\306!\307\"\310\311%\"\210<\203 \211\242\202$ \312\242\313!\"\207" [nil seq-map make-byte-code 257 "\300\300\242B\240\207" vconcat vector [] 4 "\n\n(fn ELT)" seq-into type-of] 9 "Return the reversed copy of list, vector, or string SEQUENCE.\nSee also the function `nreverse', which is used more often.\n\n(fn SEQUENCE)"]] 4)
#@147 Convert the sequence SEQUENCE into a sequence of type TYPE.
TYPE can be one of the following symbols: vector, string or list.

(fn SEQUENCE TYPE)
(defalias 'seq-into #[514 "\211\300=\203\n \301!\207\211\302=\203 \303!\207\211\304=\203 \305!\207\306\307\"\207" [vector seq--into-vector string seq--into-string list seq--into-list error "Not a sequence type name: %S"] 5 (#$ . 13032)])
#@108 Return the smallest element of SEQUENCE.
SEQUENCE must be a sequence of numbers or markers.

(fn SEQUENCE)
(defalias 'seq-min #[257 "\300\301\302\303\"\"\207" [apply min seq-into list] 6 (#$ . 13429)])
#@107 Return the largest element of SEQUENCE.
SEQUENCE must be a sequence of numbers or markers.

(fn SEQUENCE)
(defalias 'seq-max #[257 "\300\301\302\303\"\"\207" [apply max seq-into list] 6 (#$ . 13639)])
#@93 Return a random element from SEQUENCE.
Signal an error if SEQUENCE is empty.

(fn SEQUENCE)
(defalias 'seq-random-elt #[257 "\300!\203\n \301\302!\207\303\304\305!!\"\207" [seq-empty-p error "Sequence cannot be empty" seq-elt random seq-length] 6 (#$ . 13847)])
#@117 Return a list from LIST without its first N elements.
This is an optimization for lists in `seq-drop'.

(fn LIST N)
(defalias 'seq--drop-list #[514 "\211\233\207" [] 4 (#$ . 14119)])
#@117 Return a list from LIST made of its first N elements.
This is an optimization for lists in `seq-take'.

(fn LIST N)
(defalias 'seq--take-list #[514 "\300\203 \301V\203 S\262\211A\262\242B\262\202 \211\237\207" [nil 0] 5 (#$ . 14310)])
#@160 Return a list from the first element for which (PREDICATE element) is nil in LIST.
This is an optimization for lists in `seq-drop-while'.

(fn PREDICATE LIST)
(defalias 'seq--drop-while-list #[514 "\211\203 @!\203 \211A\262\202  \207" [] 4 (#$ . 14563)])
#@158 Return the successive elements for which (PREDICATE element) is non-nil in LIST.
This is an optimization for lists in `seq-take-while'.

(fn PREDICATE LIST)
(defalias 'seq--take-while-list #[514 "\300\203 @!\203 \211A\262\242B\262\202 \211\237\207" [nil] 5 (#$ . 14830)])
#@121 Return the number of successive elements for which (PREDICATE element) is non-nil in SEQUENCE.

(fn PREDICATE SEQUENCE)
(defalias 'seq--count-successive #[514 "\300\301!W\203 \302\"!\203 T\262\202 \207" [0 seq-length seq-elt] 8 (#$ . 15119)])
#@194 Return a list of bindings of the variables in ARGS to the elements of a sequence.
if BINDINGS is non-nil, append new bindings to it, and return
BINDINGS.

(fn ARGS SEQUENCE &optional BINDINGS)
(defalias 'seq--make-bindings #[770 "\300\301\211<?\205\f \302!\211\203 \300\202 \203 \211W\202! \211:\203\214 \2033 \303\"T\262\2029 \211A\262\242\204\204 \304!\203X \305\306\n\"\306\n	E	#\262\202\204 \211\307=\203w \306	T\"\310	EDB\262\311\262\202\204 \211\306	EDB\262T\262\210\202 \266\207" [0 nil seq-length seq-elt seqp seq--make-bindings seq--elt-safe &rest seq-drop t] 14 (#$ . 15381)])
#@97 Return element of SEQUENCE at the index N.
If no element is found, return nil.

(fn SEQUENCE N)
(defalias 'seq--elt-safe #[514 "<\204 \300!\205 \301!V\205 \302\"\207" [sequencep seq-length seq-elt] 5 (#$ . 16019)])
#@62 Activate font-lock keywords for some symbols defined in seq.
(defalias 'seq--activate-font-lock-keywords #[0 "\300\301\302\"\207" [font-lock-add-keywords emacs-lisp-mode ("\\<seq-doseq\\>" "\\<seq-let\\>")] 3 (#$ . 16249)])
(byte-code "\300\301\302\"\210\300\303\304\"\210\300\305\306\"\210\300\307\310\"\210\300\311\307\"\210\300\312\313\"\210\300\314\315\"\207" [defalias seq-copy copy-sequence seq-elt elt seq-length length seq-do mapc seq-each seq-map mapcar seqp sequencep] 3)
#@66 Concatenate the elements of SEQUENCE into a list.

(fn SEQUENCE)
(defalias 'seq--into-list #[257 "\211<\203 \207\300\301\"\207" [append nil] 4 (#$ . 16737)])
#@68 Concatenate the elements of SEQUENCE into a vector.

(fn SEQUENCE)
(defalias 'seq--into-vector #[257 "\300!\203 \207\301!\207" [vectorp vconcat] 3 (#$ . 16903)])
#@68 Concatenate the elements of SEQUENCE into a string.

(fn SEQUENCE)
(defalias 'seq--into-string #[257 "\211;\203 \207\211\260\207" [] 2 (#$ . 17074)])
(byte-code "\300\301!\204 \302\303\304\"\210\305\306!\207" [fboundp elisp--font-lock-flush-elisp-buffers add-hook emacs-lisp-mode-hook seq--activate-font-lock-keywords provide seq-24] 3)