HOME

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

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

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

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


(require 'generator)
#@67 compiler-macro for inlining `avl-tree-p'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'avl-tree-p--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block avl-tree-p (and (memq (type-of cl-x) cl-struct-avl-tree--tags) t)) nil] 9 (#$ . 429)])
(put 'avl-tree-p 'compiler-macro 'avl-tree-p--cmacro)
#@13 

(fn CL-X)
(defalias 'avl-tree-p #[257 "\301
!>\205	\302\207" [cl-struct-avl-tree--tags type-of t] 3 (#$ . 751)])
(byte-code "\300\301\302\303#\304\305\306\301#\207" [function-put avl-tree-p side-effect-free error-free put avl-tree- cl-deftype-satisfies] 5)
#@76 compiler-macro for inlining `avl-tree--dummyroot'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'avl-tree--dummyroot--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block avl-tree--dummyroot (or (avl-tree-p cl-x) (signal 'wrong-type-argument (list 'avl-tree- cl-x))) (aref cl-x 1)) nil] 9 (#$ . 1018)])
(put 'avl-tree--dummyroot 'compiler-macro 'avl-tree--dummyroot--cmacro)
#@171 Access slot "dummyroot" of `(avl-tree- :named (:constructor nil) (:constructor avl-tree--create (cmpfun)) (:predicate avl-tree-p) (:copier nil))' struct CL-X.

(fn CL-X)
(defalias 'avl-tree--dummyroot #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-avl-tree--tags type-of signal wrong-type-argument avl-tree- 1] 5 (#$ . 1422)])
(byte-code "\300\301\302\303#\300\207" [function-put avl-tree--dummyroot side-effect-free t] 4)
#@73 compiler-macro for inlining `avl-tree--cmpfun'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'avl-tree--cmpfun--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block avl-tree--cmpfun (or (avl-tree-p cl-x) (signal 'wrong-type-argument (list 'avl-tree- cl-x))) (aref cl-x 2)) nil] 9 (#$ . 1871)])
(put 'avl-tree--cmpfun 'compiler-macro 'avl-tree--cmpfun--cmacro)
#@168 Access slot "cmpfun" of `(avl-tree- :named (:constructor nil) (:constructor avl-tree--create (cmpfun)) (:predicate avl-tree-p) (:copier nil))' struct CL-X.

(fn CL-X)
(defalias 'avl-tree--cmpfun #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-avl-tree--tags type-of signal wrong-type-argument avl-tree- 2] 5 (#$ . 2260)])
(byte-code "\300\301\302\303#\300\207" [function-put avl-tree--cmpfun side-effect-free t] 4)
#@75 compiler-macro for inlining `avl-tree--create'.

(fn CL-WHOLE-ARG CMPFUN)
(defalias 'avl-tree--create--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cmpfun) (cl-block avl-tree--create (record 'avl-tree- (avl-tree--node-create nil nil nil 0) cmpfun)) nil] 9 (#$ . 2700)])
(put 'avl-tree--create 'compiler-macro 'avl-tree--create--cmacro)
#@59 Constructor for objects of type `avl-tree-'.

(fn CMPFUN)
(defalias 'avl-tree--create #[257 "\300\301\302\303\211\211\304$#\207" [record avl-tree- avl-tree--node-create nil 0] 8 (#$ . 3067)])
(cl-struct-define 'avl-tree- nil 'cl-structure-object 'record nil '((cl-tag-slot) (dummyroot (avl-tree--node-create nil nil nil 0)) (cmpfun)) 'cl-struct-avl-tree--tags 'avl-tree- t)
#@13 

(fn TREE)
(defalias 'avl-tree--root '(macro . #[257 "\300\301DD\207" [avl-tree--node-left avl-tree--dummyroot] 4 (#$ . 3448)]))
#@76 compiler-macro for inlining `avl-tree--node-left'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'avl-tree--node-left--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block avl-tree--node-left (aref cl-x 0)) nil] 9 (#$ . 3585)])
(put 'avl-tree--node-left 'compiler-macro 'avl-tree--node-left--cmacro)
#@177 Access slot "left" of `(avl-tree--node (:type vector) (:constructor nil) (:constructor avl-tree--node-create (left right data balance)) (:copier nil))' struct CL-X.

(fn CL-X)
(defalias 'avl-tree--node-left #[257 "\211\300H\207" [0] 3 (#$ . 3913)])
(byte-code "\300\301\302\303#\300\207" [function-put avl-tree--node-left side-effect-free t] 4)
#@77 compiler-macro for inlining `avl-tree--node-right'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'avl-tree--node-right--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block avl-tree--node-right (aref cl-x 1)) nil] 9 (#$ . 4264)])
(put 'avl-tree--node-right 'compiler-macro 'avl-tree--node-right--cmacro)
#@178 Access slot "right" of `(avl-tree--node (:type vector) (:constructor nil) (:constructor avl-tree--node-create (left right data balance)) (:copier nil))' struct CL-X.

(fn CL-X)
(defalias 'avl-tree--node-right #[257 "\211\300H\207" [1] 3 (#$ . 4597)])
(byte-code "\300\301\302\303#\300\207" [function-put avl-tree--node-right side-effect-free t] 4)
#@76 compiler-macro for inlining `avl-tree--node-data'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'avl-tree--node-data--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block avl-tree--node-data (aref cl-x 2)) nil] 9 (#$ . 4951)])
(put 'avl-tree--node-data 'compiler-macro 'avl-tree--node-data--cmacro)
#@177 Access slot "data" of `(avl-tree--node (:type vector) (:constructor nil) (:constructor avl-tree--node-create (left right data balance)) (:copier nil))' struct CL-X.

(fn CL-X)
(defalias 'avl-tree--node-data #[257 "\211\300H\207" [2] 3 (#$ . 5279)])
(byte-code "\300\301\302\303#\300\207" [function-put avl-tree--node-data side-effect-free t] 4)
#@79 compiler-macro for inlining `avl-tree--node-balance'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'avl-tree--node-balance--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block avl-tree--node-balance (aref cl-x 3)) nil] 9 (#$ . 5630)])
(put 'avl-tree--node-balance 'compiler-macro 'avl-tree--node-balance--cmacro)
#@180 Access slot "balance" of `(avl-tree--node (:type vector) (:constructor nil) (:constructor avl-tree--node-create (left right data balance)) (:copier nil))' struct CL-X.

(fn CL-X)
(defalias 'avl-tree--node-balance #[257 "\211\300H\207" [3] 3 (#$ . 5973)])
(byte-code "\300\301\302\303#\300\207" [function-put avl-tree--node-balance side-effect-free t] 4)
#@97 compiler-macro for inlining `avl-tree--node-create'.

(fn CL-WHOLE-ARG LEFT RIGHT DATA BALANCE)
(defalias 'avl-tree--node-create--cmacro #[1285 "\300\301\302\303\211\211				&	\207" [cl--defsubst-expand (left right data balance) (cl-block avl-tree--node-create (vector left right data balance)) nil] 15 (#$ . 6333)])
(put 'avl-tree--node-create 'compiler-macro 'avl-tree--node-create--cmacro)
#@81 Constructor for objects of type `avl-tree--node'.

(fn LEFT RIGHT DATA BALANCE)
(defalias 'avl-tree--node-create #[1028 "\300$\207" [vector] 9 (#$ . 6735)])
(byte-code "\300\301\302\303#\304\305\306\211\307\306\310\311\305\306&	\210\312\313\314\315#\210\300\313\316\317#\306\207" [function-put avl-tree--node-create side-effect-free t cl-struct-define avl-tree--node nil vector ((left) (right) (data) (balance)) cl-struct-avl-tree--node-tags defalias avl-tree--node-branch aref "Get value of a branch of a node.\nNODE is the node, and BRANCH is the branch.\n0 for left pointer, 1 for right pointer and 2 for the data.\n\n(fn BRANCH NODE)" gv-expander #[385 "\300\301\302$\207" [gv--defsetter avl-tree--node-branch #[385 "\300\301C\"B\207" [aset append] 6 "\n\n(fn VAL &rest ARGS)"]] 7 "\n\n(fn DO &rest ARGS)"]] 11)
#@67 Return opposite direction to DIR (0 = left, 1 = right).

(fn DIR)
(defalias 'avl-tree--switch-dir '(macro . #[257 "\300\301E\207" [- 1] 4 (#$ . 7565)]))
#@59 Convert direction (0,1) to sign factor (-1,+1).

(fn DIR)
(defalias 'avl-tree--dir-to-sign '(macro . #[257 "\300\301\302ED\207" [1- * 2] 5 (#$ . 7725)]))
#@59 Convert sign factor (-x,+x) to direction (0,1).

(fn DIR)
(defalias 'avl-tree--sign-to-dir '(macro . #[257 "\300\301\302BB\303BB\207" [if < (0) (0 1)] 5 (#$ . 7886)]))
#@238 Rebalance a tree after deleting a node.
The deletion was done from the left (DIR=0) or right (DIR=1) sub-tree of the
left (BRANCH=0) or right (BRANCH=1) child of NODE.
Return t if the height of the tree has shrunk.

(fn NODE BRANCH DIR)
(defalias 'avl-tree--del-balance #[771 "\300\"\301Z\302_S\303\211\211\211\304H_\305V\203&\211\304\305I\266\306\202 
\304H\305U\203=\211\304[I\266\303\202 
\300\"\262\304H\262_\305X\203\245

\300
\"I\266

\nI\266		

I\266\305U\203\222\211\304[I\266\211\304I\266\303\202 
\211\304\305I\266\211\304\305I\266\306\202 
\300	\"\262
\304H\262


\300\"I\266


I\266

\300
\"I\266


\nI\266\211\304_\305W\203\364\202\365\305I\266\211\304_\305V\203\n
[\202
\305I\266		

I\266
\211\304\305I\266\306\207" [avl-tree--node-branch 1 2 nil 3 0 t] 17 (#$ . 8062)])
#@22 

(fn NODE BRANCH Q)
(defalias 'avl-tree--do-del-internal #[771 "\300\"\211\301H\203\302
\301#\205.\303\301#\202.
\211\304\304HI\266

\305HI\266\306\207" [avl-tree--node-branch 1 avl-tree--do-del-internal avl-tree--del-balance 2 0 t] 10 (#$ . 8967)])
#@267 Delete DATA from BRANCH of node ROOT.
(See `avl-tree-delete' for TEST and NILFLAG).

Return cons cell (SHRUNK . DATA), where SHRUNK is t if the
height of the tree has shrunk and nil otherwise, and DATA is
the related data.

(fn CMPFUN ROOT BRANCH DATA TEST NILFLAG)
(defalias 'avl-tree--do-delete #[1542 "\300\"\211\204\301B\202\301\302H\"\2039\303\304&\211@\2051\305\304#
AB\262
\202\301
\302H\"\203d\303\306&\211@\205\\\305\306#
AB\262
\202\301\203v
\302H!\204v\301B\202\301\211\306H\204\216

\304HI\266\307
\302HB\202\301\211\304H\204\246

\306HI\266\307
\302HB\202\301\310
\304#\203\274\305\304#
\302HB\202\301\301
\302HB\207" [avl-tree--node-branch nil 2 avl-tree--do-delete 0 avl-tree--del-balance 1 t avl-tree--do-del-internal] 14 (#$ . 9240)])
#@209 Rebalance tree after an insertion
into the left (DIR=0) or right (DIR=1) sub-tree of the
left (BRANCH=0) or right (BRANCH=1) child of NODE.
Return t if the height of the tree has grown.

(fn NODE BRANCH DIR)
(defalias 'avl-tree--enter-balance #[771 "\300\"\301Z\302_S\303\211\211\304H_\305W\203$\211\304\305I\266\303\202\363\304H\305U\2038\211\304I\266\306\202\363\300\"\262\304H_\305V\203v

\300\n\"I\266

	I\266\211\304\305I\266

I\266\202\345\300\"\262
\304H\262


\300\f\"I\266


I\266

\300\n\"I\266


	I\266\211\304_\305V\203\302[\202\303\305I\266\211\304_\305W\203\327\202\330\305I\266

I\266\300		\"\211\211\304\305I\266\303\207" [avl-tree--node-branch 1 2 nil 3 0 t] 16 (#$ . 10071)])
#@256 Enter DATA in BRANCH of ROOT node.
(See `avl-tree-enter' for UPDATEFUN).

Return cons cell (GREW . DATA), where GREW is t if height
of tree ROOT has grown and nil otherwise, and DATA is the
inserted data.

(fn CMPFUN ROOT BRANCH DATA &optional UPDATEFUN)
(defalias 'avl-tree--do-enter #[1284 "\300\"\211\204

\301\302\211	\303$I\266\304B\202\230\305H\"\203C\306\303%\211@\205;\307\303#
AB\262
\202\230
\305H\"\203j\306\310%\211@\205b\307\310#
AB\262
\202\230
\203w
\305H\"\202x
\"\204\210\"\203\214\311\312!\210
\211\305I\266\302
B\262
\207" [avl-tree--node-branch vector nil 0 t 2 avl-tree--do-enter avl-tree--enter-balance 1 error "avl-tree-enter: updated data does not match existing data"] 15 (#$ . 10871)])
#@38 Check the tree's balance.

(fn TREE)
(defalias 'avl-tree--check #[257 "\301\302!>\204\303\304\305D\"\210
\306H\307H!\207" [cl-struct-avl-tree--tags avl-tree--check-node type-of signal wrong-type-argument avl-tree- 1 0] 6 (#$ . 11648)])
#@13 

(fn NODE)
(defalias 'avl-tree--check-node #[257 "\211\204\300\207\301
\300H!\301\302H!\211Z\303HU\204\304\305!\210

]T\207" [0 avl-tree--check-node 1 3 cl--assertion-failed (= (- dr dl) (avl-tree--node-balance node))] 6 (#$ . 11895)])
#@246 Apply MAP-FUNCTION to all nodes in the tree starting with ROOT.
The function is applied in-order, either ascending (DIR=0) or
descending (DIR=1).

Note: MAP-FUNCTION is applied to the node and not to the data
itself.

(fn MAP-FUNCTION ROOT DIR)
(defalias 'avl-tree--mapc #[771 "
\300\301\300B\262\205K\211\203%\302\"\203%B\262\302\"\262\202!\210\302\303Z\"\211\262\203@\302\303Z\"\202F
\211A\262\242\262\202\207" [nil t avl-tree--node-branch 1] 10 (#$ . 12146)])
#@68 Copy the AVL tree with ROOT as root.  Highly recursive.

(fn ROOT)
(defalias 'avl-tree--do-copy #[257 "\211\205\300
\301H!\300\302H!\303H\304H\305$\266\204\207" [avl-tree--do-copy 0 1 2 3 vector] 10 (#$ . 12646)])
#@74 compiler-macro for inlining `avl-tree--stack-p'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'avl-tree--stack-p--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block avl-tree--stack-p (and (memq (type-of cl-x) cl-struct-avl-tree--stack-tags) t)) nil] 9 (#$ . 12875)])
(put 'avl-tree--stack-p 'compiler-macro 'avl-tree--stack-p--cmacro)
#@13 

(fn CL-X)
(defalias 'avl-tree--stack-p #[257 "\301
!>\205	\302\207" [cl-struct-avl-tree--stack-tags type-of t] 3 (#$ . 13240)])
(byte-code "\300\301\302\303#\304\305\306\301#\207" [function-put avl-tree--stack-p side-effect-free error-free put avl-tree--stack cl-deftype-satisfies] 5)
#@80 compiler-macro for inlining `avl-tree--stack-reverse'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'avl-tree--stack-reverse--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block avl-tree--stack-reverse (or (avl-tree--stack-p cl-x) (signal 'wrong-type-argument (list 'avl-tree--stack cl-x))) (aref cl-x 1)) nil] 9 (#$ . 13535)])
(put 'avl-tree--stack-reverse 'compiler-macro 'avl-tree--stack-reverse--cmacro)
#@239 Access slot "reverse" of `(avl-tree--stack (:constructor nil) (:constructor avl-tree--stack-create (tree &optional reverse &aux (store (if (avl-tree-empty tree) nil (list (avl-tree--root tree)))))) (:copier nil))' struct CL-X.

(fn CL-X)
(defalias 'avl-tree--stack-reverse #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-avl-tree--stack-tags type-of signal wrong-type-argument avl-tree--stack 1] 5 (#$ . 13973)])
(byte-code "\300\301\302\303#\300\207" [function-put avl-tree--stack-reverse side-effect-free t] 4)
#@78 compiler-macro for inlining `avl-tree--stack-store'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'avl-tree--stack-store--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block avl-tree--stack-store (or (avl-tree--stack-p cl-x) (signal 'wrong-type-argument (list 'avl-tree--stack cl-x))) (aref cl-x 2)) nil] 9 (#$ . 14511)])
(put 'avl-tree--stack-store 'compiler-macro 'avl-tree--stack-store--cmacro)
#@237 Access slot "store" of `(avl-tree--stack (:constructor nil) (:constructor avl-tree--stack-create (tree &optional reverse &aux (store (if (avl-tree-empty tree) nil (list (avl-tree--root tree)))))) (:copier nil))' struct CL-X.

(fn CL-X)
(defalias 'avl-tree--stack-store #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-avl-tree--stack-tags type-of signal wrong-type-argument avl-tree--stack 2] 5 (#$ . 14939)])
(byte-code "\300\301\302\303#\300\207" [function-put avl-tree--stack-store side-effect-free t] 4)
#@81 Constructor for objects of type `avl-tree--stack'.

(fn TREE &optional REVERSE)
(defalias 'avl-tree--stack-create #[641 "\301!?\205\302!>\204\303\304\305D\"\210\306H\307HC
\203*\303\310\311\312G\\D\"\210\313\314#\207" [cl-struct-avl-tree--tags avl-tree-empty type-of signal wrong-type-argument avl-tree- 1 0 wrong-number-of-arguments avl-tree--stack-create 2 record avl-tree--stack] 9 (#$ . 15471)])
(byte-code "\300\301\302\303#\304\305\306\307\310\306\311\312\305\303&	\210\313\314\315\316#\207" [function-put avl-tree--stack-create side-effect-free t cl-struct-define avl-tree--stack nil cl-structure-object record ((cl-tag-slot) (reverse) (store)) cl-struct-avl-tree--stack-tags defalias avl-tree-stack-p avl-tree--stack-p "Return t if OBJ is an avl-tree-stack, nil otherwise.\n\n(fn OBJ)"] 11)
#@14 

(fn STACK)
(defalias 'avl-tree--stack-repopulate #[257 "\301
!>\204\302\303\304D\"\210\211\305H@\301!>\204\"\302\303\304D\"\210
\306H\203,\306\202-\307
\205X\310\"\211\262\205X\301!>\204J\302\303\304D\"\210\211\305\305HBI\266\2021\207" [cl-struct-avl-tree--stack-tags type-of signal wrong-type-argument avl-tree--stack 2 1 0 avl-tree--node-branch] 9 (#$ . 16289)])
(byte-code "\300\301\302\303#\210\300\304\305\306#\207" [defalias avl-tree-create avl-tree--create "Create an empty AVL tree.\nCOMPARE-FUNCTION is a function which takes two arguments, A and B,\nand returns non-nil if A is less than B, and nil otherwise.\n\n(fn COMPARE-FUNCTION)" avl-tree-compare-function avl-tree--cmpfun "Return the comparison function for the AVL tree TREE.\n\n(fn TREE)"] 4)
#@70 Return t if AVL tree TREE is empty, otherwise return nil.

(fn TREE)
(defalias 'avl-tree-empty #[257 "\301
!>\204\302\303\304D\"\210\211\305H\306H?\207" [cl-struct-avl-tree--tags type-of signal wrong-type-argument avl-tree- 1 0] 5 (#$ . 17083)])
#@558 Insert DATA into the AVL tree TREE.

If an element that matches DATA (according to the tree's
comparison function, see `avl-tree-create') already exists in
TREE, it will be replaced by DATA by default.

If UPDATEFUN is supplied and an element matching DATA already
exists in TREE, UPDATEFUN is called with two arguments: DATA, and
the matching element.  Its return value replaces the existing
element.  This value *must* itself match DATA (and hence the
pre-existing data), or an error will occur.

Returns the new data.

(fn TREE DATA &optional UPDATEFUN)
(defalias 'avl-tree-enter #[770 "\301\302!>\204\303\304\305D\"\210\306H\302!>\204$\303\304\305D\"\210\307H\310%A\207" [cl-struct-avl-tree--tags avl-tree--do-enter type-of signal wrong-type-argument avl-tree- 2 1 0] 9 (#$ . 17340)])
#@672 Delete the element matching DATA from the AVL tree TREE.
Matching uses the comparison function previously specified in
`avl-tree-create' when TREE was created.

Returns the deleted element, or nil if no matching element was
found.

Optional argument NILFLAG specifies a value to return instead of
nil if nothing was deleted, so that this case can be
distinguished from the case of a successfully deleted null
element.

If supplied, TEST specifies a test that a matching element must
pass before it is deleted.  If a matching element is found, it is
passed as an argument to TEST, and is deleted only if the return
value is non-nil.

(fn TREE DATA &optional TEST NILFLAG)
(defalias 'avl-tree-delete #[1026 "\301\302!>\204\303\304\305D\"\210\306H\302!>\204%\303\304\305D\"\210\307H\310&A\207" [cl-struct-avl-tree--tags avl-tree--do-delete type-of signal wrong-type-argument avl-tree- 2 1 0] 11 (#$ . 18151)])
#@475 Return the element in the AVL tree TREE which matches DATA.
Matching uses the comparison function previously specified in
`avl-tree-create' when TREE was created.

If there is no such element in the tree, nil is
returned.  Optional argument NILFLAG specifies a value to return
instead of nil in this case.  This allows non-existent elements to
be distinguished from a null element.  (See also
`avl-tree-member-p', which does this for you.)

(fn TREE DATA &optional NILFLAG)
(defalias 'avl-tree-member #[770 "\301!>\204\302\303\304D\"\210\305H\306H\301!>\204$\302\303\304D\"\210\307H\3102]
\203[\211\307H\"\203@
\306H\262\202+\211\307H\"\203Q
\305H\262\202+\311\310\307H\"\210\202+0\207" [cl-struct-avl-tree--tags type-of signal wrong-type-argument avl-tree- 1 0 2 found throw] 9 (#$ . 19086)])
#@209 Return t if an element matching DATA exists in the AVL tree TREE.
Otherwise return nil.  Matching uses the comparison function
previously specified in `avl-tree-create' when TREE was created.

(fn TREE DATA)
(defalias 'avl-tree-member-p #[514 "\300\301#
=?\207" [(nil) avl-tree-member] 7 (#$ . 19914)])
#@280 Modify all elements in the AVL tree TREE by applying FUNCTION.

Each element is replaced by the return value of FUNCTION applied
to that element.

FUNCTION is applied to the elements in ascending order, or
descending order if REVERSE is non-nil.

(fn FUN TREE &optional REVERSE)
(defalias 'avl-tree-map #[770 "\301\302\303\304\305\306!\307\"\310\311%\312!>\204\313\314\315D\"\210\316H\317H\203+\316\202,\317#\207" [cl-struct-avl-tree--tags avl-tree--mapc make-byte-code 257 "\211\211\301\300\301H!I\207" vconcat vector [2] 7 "\n\n(fn NODE)" type-of signal wrong-type-argument avl-tree- 1 0] 10 (#$ . 20227)])
#@205 Apply FUNCTION to all elements in AVL tree TREE,
for side-effect only.

FUNCTION is applied to the elements in ascending order, or
descending order if REVERSE is non-nil.

(fn FUN TREE &optional REVERSE)
(defalias 'avl-tree-mapc #[770 "\301\302\303\304\305\306!\307\"\310\311%\312!>\204\313\314\315D\"\210\316H\317H\203+\316\202,\317#\207" [cl-struct-avl-tree--tags avl-tree--mapc make-byte-code 257 "\300
\301H!\207" vconcat vector [2] 4 "\n\n(fn NODE)" type-of signal wrong-type-argument avl-tree- 1 0] 10 (#$ . 20856)])
#@253 Apply FUNCTION to all elements in AVL tree TREE,
and combine the results using COMBINATOR.

The FUNCTION is applied and the results are combined in ascending
order, or descending order if REVERSE is non-nil.

(fn FUN COMBINATOR TREE &optional REVERSE)
(defalias 'avl-tree-mapf #[1027 "\301C\302\303\304\305\306\307\n\n#\310\"\311\312%\313!>\204$\314\315\316D\"\210\317H\320H\2031\320\2022\317#\210\211\242\237\207" [cl-struct-avl-tree--tags nil avl-tree--mapc make-byte-code 257 "\302\301\300\303H!\302\242\"\240\207" vconcat vector [2] 6 "\n\n(fn NODE)" type-of signal wrong-type-argument avl-tree- 1 0] 14 (#$ . 21398)])
#@437 Apply FUNCTION to all elements in AVL tree TREE,
and make a list of the results.

The FUNCTION is applied and the list constructed in ascending
order, or descending order if REVERSE is non-nil.

Note that if you don't care about the order in which FUNCTION is
applied, just that the resulting list is in the correct order,
then

  (avl-tree-mapf function \='cons tree (not reverse))

is more efficient.

(fn FUN TREE &optional REVERSE)
(defalias 'avl-tree-mapcar #[770 "\300\301$\237\207" [avl-tree-mapf cons] 8 (#$ . 22042)])
#@71 Return the first element in TREE, or nil if TREE is empty.

(fn TREE)
(defalias 'avl-tree-first #[257 "\301
!>\204\302\303\304D\"\210\211\305H\306H\211\205)\211\306H\203&\211\306H\262
\202\211\307H\207" [cl-struct-avl-tree--tags type-of signal wrong-type-argument avl-tree- 1 0 2] 5 (#$ . 22578)])
#@70 Return the last element in TREE, or nil if TREE is empty.

(fn TREE)
(defalias 'avl-tree-last #[257 "\301
!>\204\302\303\304D\"\210\211\305H\306H\211\205)\211\305H\203&\211\305H\262
\202\211\307H\207" [cl-struct-avl-tree--tags type-of signal wrong-type-argument avl-tree- 1 0 2] 5 (#$ . 22890)])
#@48 Return a copy of the AVL tree TREE.

(fn TREE)
(defalias 'avl-tree-copy #[257 "\301\302!>\204\303\304\305D\"\210
\306H!\302
!>\204#\303\304\305D\"\210\211\307H\211\310\311\302!>\204:\303\304\305D\"\210\307H\310H!I\266\211\207" [cl-struct-avl-tree--tags avl-tree-create type-of signal wrong-type-argument avl-tree- 2 1 0 avl-tree--do-copy] 10 (#$ . 23200)])
#@66 Return a sorted list containing all elements of TREE.

(fn TREE)
(defalias 'avl-tree-flatten #[257 "\301C\302\303\304\305\306\307!\310\"\311\312%\313!>\204 \314\315\316D\"\210\317H\320H\317#\210\211\242\207" [cl-struct-avl-tree--tags nil avl-tree--mapc make-byte-code 257 "\300
\301H\300\242B\240\207" vconcat vector [2] 4 "\n\n(fn NODE)" type-of signal wrong-type-argument avl-tree- 1 0] 9 (#$ . 23579)])
#@51 Return the number of elements in TREE.

(fn TREE)
(defalias 'avl-tree-size #[257 "\301C\302\303\304\305\306\307!\310\"\311\312%\313!>\204 \314\315\316D\"\210\317H\301H\301#\210\211\242\207" [cl-struct-avl-tree--tags 0 avl-tree--mapc make-byte-code 257 "\300\211\242T\240\207" vconcat vector [] 3 "\n\n(fn _)" type-of signal wrong-type-argument avl-tree- 1] 9 (#$ . 23999)])
#@37 Clear the AVL tree TREE.

(fn TREE)
(defalias 'avl-tree-clear #[257 "\301
!>\204\302\303\304D\"\210\211\305H\211\306\307I\207" [cl-struct-avl-tree--tags type-of signal wrong-type-argument avl-tree- 1 0 nil] 5 (#$ . 24387)])
#@786 Return an object that behaves like a sorted stack
of all elements of TREE.

If REVERSE is non-nil, the stack is sorted in reverse order.
(See also `avl-tree-stack-pop').

Note that any modification to TREE *immediately* invalidates all
avl-tree-stacks created before the modification (in particular,
calling `avl-tree-stack-pop' will give unpredictable results).

Operations on these objects are significantly more efficient than
constructing a real stack with `avl-tree-flatten' and using
standard stack functions.  As such, they can be useful in
implementing efficient algorithms of AVL trees.  However, in cases
where mapping functions `avl-tree-mapc', `avl-tree-mapcar' or
`avl-tree-mapf' would be sufficient, it is better to use one of
those instead.

(fn TREE &optional REVERSE)
(defalias 'avl-tree-stack #[513 "\300\"\301
!\210\211\207" [avl-tree--stack-create avl-tree--stack-repopulate] 5 (#$ . 24622)])
#@272 Pop the first element from AVL-TREE-STACK.
(See also `avl-tree-stack').

Returns nil if the stack is empty, or NILFLAG if specified.
(The latter allows an empty stack to be distinguished from
a null element stored in the AVL tree.)

(fn AVL-TREE-STACK &optional NILFLAG)
(defalias 'avl-tree-stack-pop #[513 "\301\211\302!>\204\303\304\305D\"\210\211\306H\211\306AI\210\266\202\242\211\262\204*\202q\307\302!>\204=\303\304\305D\"\210\310H\203G\311\202H\310\"\211\262\203n\302!>\204_\303\304\305D\"\210\211\306\306HBI\266\312!\210
\306H\207" [cl-struct-avl-tree--stack-tags nil type-of signal wrong-type-argument avl-tree--stack 2 avl-tree--node-branch 1 0 avl-tree--stack-repopulate] 10 (#$ . 25544)])
#@280 Return the first element of AVL-TREE-STACK, without removing it
from the stack.

Returns nil if the stack is empty, or NILFLAG if specified.
(The latter allows an empty stack to be distinguished from
a null element stored in the AVL tree.)

(fn AVL-TREE-STACK &optional NILFLAG)
(defalias 'avl-tree-stack-first #[513 "\301!>\204\302\303\304D\"\210
\305H@\206\211\207" [cl-struct-avl-tree--stack-tags type-of signal wrong-type-argument avl-tree--stack 2] 6 (#$ . 26287)])
#@74 Return t if AVL-TREE-STACK is empty, nil otherwise.

(fn AVL-TREE-STACK)
(defalias 'avl-tree-stack-empty-p #[257 "\301
!>\204\302\303\304D\"\210\211\305H?\207" [cl-struct-avl-tree--stack-tags type-of signal wrong-type-argument avl-tree--stack 2] 5 (#$ . 26771)])
#@395 Return an AVL tree iterator object.

Calling `iter-next' on this object will retrieve the next element
from TREE. If REVERSE is non-nil, elements are returned in
reverse order.

Note that any modification to TREE *immediately* invalidates all
iterators created from TREE before the modification (in
particular, calling `iter-next' will give unpredictable results).

(fn TREE &optional REVERSE)
(defalias 'avl-tree-iter #[513 "\300C\300C\300C\300\211C\300C\300C\300C\300C\300C\300C\300C\300C\300\301\302\303\304\305!\306\"\307$\240\210\301\302\310\304\305
$\311\"\312$\240\210\301\302\313\304\305#\314\"\307$\240\210\301\302\315\304\305$\316\"\312$\240\210\301\302\317\304\305$\320\"\321$\240\210\301\302\322\304\305$\320\"\321$\240\210\301\302\323\304\305\f$\320\"\312$\240\210
\301\302\322\304\305$\320\"\321$\240\210\301\302\324\304\305\n%\325\"\312$\262


\240\210\301\326\327\304\305#\330\"\331\332%\211\262
\207" [nil make-byte-code 0 "\301\302\300\242\"\207" vconcat vector [signal iter-end-of-sequence] 3 "\301\304\302\242!?\300\303\242\240\210\240\207" [avl-tree-stack-empty-p] 4 "\300\302\242\240\210\303\304\301\242\"\207" [throw cps--yield] "\301\304\302\242!\300\303\242\240\210\240\207" [avl-tree-stack-pop] "\300\301\242\203\303\242\202
\302\242\240\207" [] 2 "\302\301\242\240\210\300\303\242\240\207" "\301\302\242\300\303\242\240\210\240\207" "\303\305\300\301\"\302\304\242\240\210\240\207" [avl-tree-stack] 514 "
\303\267\2027\300\302\242\240\210\301\304\240\207\301
\240\210\304C\305\306\307\310\311\300\301\302$\312\"\313$\216\31421\300\242 \210\202)0
\315\240\210)\207\316\317\"\207" [#s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (:close 6 :next 15)) nil make-byte-code 0 "\303\242?\205\300\302\242\240\210\301\304\240\207" vconcat vector [nil] 2 cps--yield t error "unknown iterator operation %S"] 12 "\n\n(fn OP VALUE)"] 26 (#$ . 27045)])
(provide 'avl-tree)