;ELC   
;;; Compiled
;;; in Emacs version 28.0.50
;;; with all optimizations.


(byte-code "\300\301!\210\300\302!\207" [require dash gv] 2)
#@127 Create a hash table with the key-value pairs given.
Keys are compared with `equal'.

(fn (KEY-1 VALUE-1) (KEY-2 VALUE-2) ...)
(defalias 'ht '(macro . #[128 "\300\301!\302\303\304\"\"\305\306BC\307C\"BB\207" [make-symbol "ht-temp" mapcar make-closure #[257 "\301\300BB\207" [V0 ht-set!] 4 "\n\n(fn PAIR)"] let ((ht-create)) append] 8 (#$ . 149)]))
#@58 Associate KEY in TABLE with VALUE.

(fn TABLE KEY VALUE)
(defalias 'ht-set! #[771 "\300\301#\210\207" [nil puthash] 8 (#$ . 508)])
(byte-code "\300\301\302\303#\300\207" [function-put ht-set! compiler-macro ht-set!--inliner] 4)
#@37 

(fn INLINE--FORM TABLE KEY VALUE)
(defalias 'ht-set!--inliner #[1028 "\3002 \301\302\303FE0\207" [inline--just-use prog1 nil puthash] 10 (#$ . 746)])
(defalias 'ht-set 'ht-set!)
#@225 Create an empty hash table.

TEST indicates the function used to compare the hash
keys.  Default is `equal'.  It can be `eq', `eql', `equal' or a
user-supplied test created via `define-hash-table-test'.

(fn &optional TEST)
(defalias 'ht-create #[256 "\300\301\206 \302\"\207" [make-hash-table :test equal] 4 (#$ . 938)])
(byte-code "\300\301\302\303#\300\301\304\305#\300\207" [function-put ht-create compiler-macro ht-create--inliner side-effect-free t] 5)
#@36 

(fn INLINE--FORM &optional TEST)
(defalias 'ht-create--inliner #[513 "\3002 \301\302\303\304\305DEE0\207" [inline--just-use make-hash-table :test or quote equal] 8 (#$ . 1405)])
#@263 Create a hash table with initial values according to ALIST.

TEST indicates the function used to compare the hash
keys.  Default is `equal'.  It can be `eq', `eql', `equal' or a
user-supplied test created via `define-hash-table-test'.

(fn ALIST &optional TEST)
(defalias 'ht<-alist #[513 "\300\301\206 \302\"\303!\211\203$ \211@\211@A\304#\266A\266\202\202 \207" [make-hash-table :test equal reverse puthash] 11 (#$ . 1594)])
(byte-code "\300\301\302\303#\304\305\301\"\207" [function-put ht<-alist side-effect-free t defalias ht-from-alist] 4)
#@263 Create a hash table with initial values according to PLIST.

TEST indicates the function used to compare the hash
keys.  Default is `equal'.  It can be `eq', `eql', `equal' or a
user-supplied test created via `define-hash-table-test'.

(fn PLIST &optional TEST)
(defalias 'ht<-plist #[513 "\300\301\206 \302\"\303\304\"\237\211\203' \211@\211@A@\305#\266A\266\202\202 \207" [make-hash-table :test equal -partition 2 puthash] 11 (#$ . 2159)])
(byte-code "\300\301\302\303#\304\305\301\"\207" [function-put ht<-plist side-effect-free t defalias ht-from-plist] 4)
#@149 Look up KEY in TABLE, and return the matching value.
If KEY isn't present, return DEFAULT (nil if not specified).

(fn TABLE KEY &optional DEFAULT)
(defalias 'ht-get #[770 "\300#\207" [gethash] 7 (#$ . 2739)])
(byte-code "\300\301\302\303#\300\301\304\305#\300\207" [function-put ht-get compiler-macro ht-get--inliner side-effect-free t] 5)
#@49 

(fn INLINE--FORM TABLE KEY &optional DEFAULT)
(defalias 'ht-get--inliner #[1027 "\3002\n \301F0\207" [inline--just-use gethash] 8 (#$ . 3089)])
(byte-code "\300\301\302\303#\300\207" [function-put ht-get gv-expander #[385 "\300\301\302$\207" [gv--defsetter ht-get #[771 "\300F\207" [puthash] 7 "\n\n(fn VALUE TABLE KEY)"]] 7 "\n\n(fn DO &rest ARGS)"]] 4)
#@193 Look up KEYS in nested hash tables, starting with TABLE.
The lookup for each key should return another hash table, except
for the final key, which may return any value.

(fn TABLE &rest KEYS)
(defalias 'ht-get* #[385 "\211\203 \300\211A\262\242\301#\262\202  \207" [gethash nil] 6 (#$ . 3461)])
(byte-code "\300\301\302\303#\300\301\304\305#\300\207" [function-put ht-get* compiler-macro ht-get*--inliner side-effect-free t] 5)
#@38 

(fn INLINE--FORM TABLE &rest KEYS)
(defalias 'ht-get*--inliner #[642 "\3002] \301!\203 \211\202 \302\303!\301!\203 \211\202  \302\304!\305\306\307\310\311DEEEE=\203> \211\266\203\202G \312DC\"\266\203=\203S \211\266\203\202\\ \312DC\"\266\2030\207" [inline--just-use macroexp-copyable-p make-symbol "table" "keys" progn while setf ht-get pop macroexp-let*] 16 (#$ . 3901)])
(put 'ht-get* 'compiler-macro #[642 "\300\301\211\203! \211A\262\242\262\262T\262\302E\262\202 \266\207" [0 nil ht-get] 11 "\n\n(fn _ TABLE &rest KEYS)"])
#@86 Update TABLE according to every key-value pair in FROM-TABLE.

(fn TABLE FROM-TABLE)
(defalias 'ht-update! #[514 "\300\301\302\"\"\210\303\207" [maphash make-closure #[514 "\301\300#\207" [V0 puthash] 6 "\n\n(fn KEY VALUE)"] nil] 6 (#$ . 4478)])
(defalias 'ht-update 'ht-update!)
#@170 Crete a new tables that includes all the key-value pairs from TABLES.
If multiple have tables have the same key, the value in the last
table is used.

(fn &rest TABLES)
(defalias 'ht-merge #[128 "\300\301\302\"\303\304\305\"\"\210\207" [make-hash-table :test equal mapc make-closure #[257 "\301\300\"\207" [V0 ht-update!] 4 "\n\n(fn TABLE)"]] 6 (#$ . 4769)])
#@40 Remove KEY from TABLE.

(fn TABLE KEY)
(defalias 'ht-remove! #[514 "\300\"\207" [remhash] 5 (#$ . 5137)])
(byte-code "\300\301\302\303#\300\207" [function-put ht-remove! compiler-macro ht-remove!--inliner] 4)
#@31 

(fn INLINE--FORM TABLE KEY)
(defalias 'ht-remove!--inliner #[771 "\3002	 \301E0\207" [inline--just-use remhash] 6 (#$ . 5354)])
(defalias 'ht-remove 'ht-remove!)
#@41 Remove all keys from TABLE.

(fn TABLE)
(defalias 'ht-clear! #[257 "\300\301!\210\207" [nil clrhash] 4 (#$ . 5526)])
(byte-code "\300\301\302\303#\300\207" [function-put ht-clear! compiler-macro ht-clear!--inliner] 4)
#@27 

(fn INLINE--FORM TABLE)
(defalias 'ht-clear!--inliner #[514 "\3002 \301\302\303DE0\207" [inline--just-use prog1 nil clrhash] 6 (#$ . 5751)])
(defalias 'ht-clear 'ht-clear!)
#@156 Apply FUNCTION to each key-value pair of TABLE, and make a list of the results.
FUNCTION is called with two arguments, KEY and VALUE.

(fn FUNCTION TABLE)
(defalias 'ht-map #[514 "\300C\301\302\303#\"\210\211\242\207" [nil maphash make-closure #[514 "\301\300\"\301\242B\240\207" [V0 V1] 6 "\n\n(fn KEY VALUE)"]] 8 (#$ . 5935)])
#@218 Anaphoric version of `ht-map'.
For every key-value pair in TABLE, evaluate FORM with the
variables KEY and VALUE bound.  If you don't use both of
these variables, then use `ht-map' to avoid warnings.

(fn FORM TABLE)
(defalias 'ht-amap '(macro . #[514 "\300\301\302EE\207" [ht-map lambda (key value)] 6 (#$ . 6276)]))
#@53 Return a list of all the keys in TABLE.

(fn TABLE)
(defalias 'ht-keys #[257 "\300\301\"\207" [ht-map #[514 "\207" [] 3 "\n\n(fn KEY VALUE)"]] 4 (#$ . 6602)])
(byte-code "\300\301\302\303#\300\207" [function-put ht-keys side-effect-free t] 4)
#@55 Return a list of all the values in TABLE.

(fn TABLE)
(defalias 'ht-values #[257 "\300\301\"\207" [ht-map #[514 "\207" [] 3 "\n\n(fn KEY VALUE)"]] 4 (#$ . 6853)])
(byte-code "\300\301\302\303#\300\207" [function-put ht-values side-effect-free t] 4)
#@73 Return a list of two-element lists '(key value) from TABLE.

(fn TABLE)
(defalias 'ht-items #[257 "\300\301\"\207" [ht-map #[514 "D\207" [] 4 "\n\n(fn KEY VALUE)"]] 4 (#$ . 7109)])
(byte-code "\300\301\302\303#\304\305\306\307#\207" [function-put ht-items side-effect-free t defalias ht-each maphash "Apply FUNCTION to each key-value pair of TABLE.\nReturns nil, used for side-effects only."] 5)
#@139 Anaphoric version of `ht-each'.
For every key-value pair in TABLE, evaluate FORM with the
variables key and value bound.

(fn FORM TABLE)
(defalias 'ht-aeach '(macro . #[514 "\300\301\302EE\207" [ht-each lambda (key value)] 6 (#$ . 7515)]))
#@71 Return a copy of TABLE with only the specified KEYS.

(fn TABLE KEYS)
(defalias 'ht-select-keys #[514 "\300\301\302\303!\"\262\211\203, \211@\304\305#\305=\204% \306\304\"#\210A\266\202\202\n \207" [nil make-hash-table :test hash-table-test gethash key-not-found puthash] 10 (#$ . 7764)])
(byte-code "\300\301\302\303#\300\207" [function-put ht-select-keys side-effect-free t] 4)
#@279 Return a flat list '(key1 value1 key2 value2...) from TABLE.

Note that hash tables are unordered, so this cannot be an exact
inverse of `ht<-plist'.  The following is not guaranteed:

(let ((data '(a b c d)))
  (equalp data
          (ht->plist (ht<-plist data))))

(fn TABLE)
(defalias 'ht->plist #[257 "\300\301\302!\"\207" [apply append ht-items] 5 (#$ . 8164)])
(byte-code "\300\301\302\303#\304\305\301\"\207" [function-put ht->plist side-effect-free t defalias ht-to-plist] 4)
#@74 Return a shallow copy of TABLE (keys and values are shared).

(fn TABLE)
(defalias 'ht-copy #[257 "\300!\207" [copy-hash-table] 3 (#$ . 8655)])
(byte-code "\300\301\302\303#\300\301\304\305#\300\207" [function-put ht-copy compiler-macro ht-copy--inliner side-effect-free t] 5)
#@27 

(fn INLINE--FORM TABLE)
(defalias 'ht-copy--inliner #[514 "\3002 \301D0\207" [inline--just-use copy-hash-table] 4 (#$ . 8939)])
#@288 Return a list of two-element lists '(key . value) from TABLE.

Note that hash tables are unordered, so this cannot be an exact
inverse of `ht<-alist'.  The following is not guaranteed:

(let ((data '((a . b) (c . d))))
  (equalp data
          (ht->alist (ht<-alist data))))

(fn TABLE)
(defalias 'ht->alist #[257 "\300\301\"\207" [ht-map #[514 "B\207" [] 4 "\n\n(fn KEY VALUE)"]] 4 (#$ . 9078)])
(byte-code "\300\301\302\303#\304\305\301\"\210\304\306\307\"\210\304\310\307\"\207" [function-put ht->alist side-effect-free t defalias ht-to-alist ht\? hash-table-p ht-p] 4)
#@50 Return 't if TABLE contains KEY.

(fn TABLE KEY)
(defalias 'ht-contains\? #[514 "\300\301!\302#=?\207" [make-symbol "ht--not-found" gethash] 7 (#$ . 9660)])
(byte-code "\300\301\302\303#\300\301\304\305#\300\207" [function-put ht-contains\? compiler-macro ht-contains\?--inliner side-effect-free t] 5)
#@31 

(fn INLINE--FORM TABLE KEY)
(defalias 'ht-contains\?--inliner #[771 "\3002 \301\302\303\304DDC\305\306\307\302F\302EDE0\207" [inline--just-use let not-found-symbol make-symbol "ht--not-found" not eq ht-get] 11 (#$ . 9972)])
(defalias 'ht-contains-p 'ht-contains\?)
#@59 Return the actual number of entries in TABLE.

(fn TABLE)
(defalias 'ht-size #[257 "\300!\207" [hash-table-count] 3 (#$ . 10250)])
(byte-code "\300\301\302\303#\300\301\304\305#\300\207" [function-put ht-size compiler-macro ht-size--inliner side-effect-free t] 5)
#@27 

(fn INLINE--FORM TABLE)
(defalias 'ht-size--inliner #[514 "\3002 \301D0\207" [inline--just-use hash-table-count] 4 (#$ . 10521)])
#@75 Return true if the actual number of entries in TABLE is zero.

(fn TABLE)
(defalias 'ht-empty\? #[257 "\300!\301U\207" [hash-table-count 0] 3 (#$ . 10661)])
(byte-code "\300\301\302\303#\300\301\304\305#\300\207" [function-put ht-empty\? compiler-macro ht-empty\?--inliner side-effect-free t] 5)
#@27 

(fn INLINE--FORM TABLE)
(defalias 'ht-empty\?--inliner #[514 "\3002\n \301\302DD0\207" [inline--just-use zerop ht-size] 5 (#$ . 10964)])
(defalias 'ht-empty-p 'ht-empty\?)
#@172 Return a hash table containing all entries in TABLE for which
FUNCTION returns a truthy value.

FUNCTION is called with two arguments, KEY and VALUE.

(fn FUNCTION TABLE)
(defalias 'ht-select #[514 "\300\301\302\"\303\304\305#\"\210\207" [make-hash-table :test equal ht-each make-closure #[514 "\300\"\205 \302\303\301#\210\207" [V0 V1 nil puthash] 7 "\n\n(fn KEY VALUE)"]] 8 (#$ . 11146)])
#@171 Return a hash table containing all entries in TABLE for which
FUNCTION returns a falsy value.

FUNCTION is called with two arguments, KEY and VALUE.

(fn FUNCTION TABLE)
(defalias 'ht-reject #[514 "\300\301\302\"\303\304\305#\"\210\207" [make-hash-table :test equal ht-each make-closure #[514 "\300\"?\205 \302\303\301#\210\207" [V0 V1 nil puthash] 7 "\n\n(fn KEY VALUE)"]] 8 (#$ . 11552)])
#@145 Delete entries from TABLE for which FUNCTION returns a falsy value.

FUNCTION is called with two arguments, KEY and VALUE.

(fn FUNCTION TABLE)
(defalias 'ht-reject! #[514 "\300\301\302#\"\210\303\207" [ht-each make-closure #[514 "\300\"\205 \302\301\"\207" [V0 V1 remhash] 5 "\n\n(fn KEY VALUE)"] nil] 7 (#$ . 11958)])
(defalias 'ht-delete-if 'ht-reject!)
#@173 Return (key, value) from TABLE for which FUNCTION returns a truthy value.
Return nil otherwise.

FUNCTION is called with two arguments, KEY and VALUE.

(fn FUNCTION TABLE)
(defalias 'ht-find #[514 "\3002\f \301\302\303\"\"0\207" [break ht-each make-closure #[514 "\300\"\205 \301\302D\"\207" [V0 throw break] 6 "\n\n(fn KEY VALUE)"]] 6 (#$ . 12329)])
#@120 Return t if TABLE1 and TABLE2 have the same keys and values.
Does not compare equality predicates.

(fn TABLE1 TABLE2)
(defalias 'ht-equal\? #[514 "\300!\300!\301\302!GG\232\205W \303\304\305\211\211\203N \211A\262\242\262\262\211\262\203N \306\f\305#\306\f\n#\232\211\262\203N \262\262T\262\202 \266\211\262\205W \303\207" [ht-keys make-symbol "ht-sentinel" t 0 nil gethash] 16 (#$ . 12694)])
(byte-code "\300\301\302\303#\304\305\301\"\210\306\307!\207" [function-put ht-equal\? side-effect-free t defalias ht-equal-p provide ht] 4)