;ELC   
;;; Compiled
;;; in Emacs version 26.3
;;; 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 'ztree-util)
#@60 Mark files as different if their permissions are different
(defvar ztree-diff-consider-file-permissions nil (#$ . 430))
#@49 Mark files as different if their size different
(defvar ztree-diff-consider-file-size t (#$ . 556))
#@192 Command-line options for the diff program used as a diff backend. These options are added to default '-q' option.
Should be a list of strings.
Example:
(setq ztree-diff-options '("-w" "-i"))
(defvar ztree-diff-additional-options nil (#$ . 663))
#@75 Function which determines if the node should be excluded from comparison.
(defvar ztree-diff-model-ignore-fun nil (#$ . 914))
(make-variable-buffer-local 'ztree-diff-model-ignore-fun)
#@74 compiler-macro for inlining `ztree-diff-node-p'.

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

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

(fn CL-WHOLE-ARG CL-X)
(defalias 'ztree-diff-node-parent--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ztree-diff-node-parent (or (ztree-diff-node-p cl-x) (signal 'wrong-type-argument (list 'ztree-diff-node cl-x))) (aref cl-x 1)) nil] 9 (#$ . 1762)])
(put 'ztree-diff-node-parent 'compiler-macro 'ztree-diff-node-parent--cmacro)
#@327 Access slot "parent" of `(ztree-diff-node (:constructor) (:constructor ztree-diff-node-create (parent left-path right-path different &aux (short-name (ztree-file-short-name (or left-path right-path))) (right-short-name (if (and left-path right-path) (ztree-file-short-name right-path) short-name)))))' struct CL-X.

(fn CL-X)
(defalias 'ztree-diff-node-parent #[257 "\301!>\204 \302\303\304D\"\210\211\305H\207" [cl-struct-ztree-diff-node-tags type-of signal wrong-type-argument ztree-diff-node 1] 5 (#$ . 2194)])
(byte-code "\300\301\302\303#\300\207" [function-put ztree-diff-node-parent side-effect-free t] 4)
#@82 compiler-macro for inlining `ztree-diff-node-left-path'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'ztree-diff-node-left-path--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ztree-diff-node-left-path (or (ztree-diff-node-p cl-x) (signal 'wrong-type-argument (list 'ztree-diff-node cl-x))) (aref cl-x 2)) nil] 9 (#$ . 2817)])
(put 'ztree-diff-node-left-path 'compiler-macro 'ztree-diff-node-left-path--cmacro)
#@330 Access slot "left-path" of `(ztree-diff-node (:constructor) (:constructor ztree-diff-node-create (parent left-path right-path different &aux (short-name (ztree-file-short-name (or left-path right-path))) (right-short-name (if (and left-path right-path) (ztree-file-short-name right-path) short-name)))))' struct CL-X.

(fn CL-X)
(defalias 'ztree-diff-node-left-path #[257 "\301!>\204 \302\303\304D\"\210\211\305H\207" [cl-struct-ztree-diff-node-tags type-of signal wrong-type-argument ztree-diff-node 2] 5 (#$ . 3264)])
(byte-code "\300\301\302\303#\300\207" [function-put ztree-diff-node-left-path side-effect-free t] 4)
#@83 compiler-macro for inlining `ztree-diff-node-right-path'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'ztree-diff-node-right-path--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ztree-diff-node-right-path (or (ztree-diff-node-p cl-x) (signal 'wrong-type-argument (list 'ztree-diff-node cl-x))) (aref cl-x 3)) nil] 9 (#$ . 3896)])
(put 'ztree-diff-node-right-path 'compiler-macro 'ztree-diff-node-right-path--cmacro)
#@331 Access slot "right-path" of `(ztree-diff-node (:constructor) (:constructor ztree-diff-node-create (parent left-path right-path different &aux (short-name (ztree-file-short-name (or left-path right-path))) (right-short-name (if (and left-path right-path) (ztree-file-short-name right-path) short-name)))))' struct CL-X.

(fn CL-X)
(defalias 'ztree-diff-node-right-path #[257 "\301!>\204 \302\303\304D\"\210\211\305H\207" [cl-struct-ztree-diff-node-tags type-of signal wrong-type-argument ztree-diff-node 3] 5 (#$ . 4348)])
(byte-code "\300\301\302\303#\300\207" [function-put ztree-diff-node-right-path side-effect-free t] 4)
#@83 compiler-macro for inlining `ztree-diff-node-short-name'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'ztree-diff-node-short-name--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ztree-diff-node-short-name (or (ztree-diff-node-p cl-x) (signal 'wrong-type-argument (list 'ztree-diff-node cl-x))) (aref cl-x 4)) nil] 9 (#$ . 4983)])
(put 'ztree-diff-node-short-name 'compiler-macro 'ztree-diff-node-short-name--cmacro)
#@331 Access slot "short-name" of `(ztree-diff-node (:constructor) (:constructor ztree-diff-node-create (parent left-path right-path different &aux (short-name (ztree-file-short-name (or left-path right-path))) (right-short-name (if (and left-path right-path) (ztree-file-short-name right-path) short-name)))))' struct CL-X.

(fn CL-X)
(defalias 'ztree-diff-node-short-name #[257 "\301!>\204 \302\303\304D\"\210\211\305H\207" [cl-struct-ztree-diff-node-tags type-of signal wrong-type-argument ztree-diff-node 4] 5 (#$ . 5435)])
(byte-code "\300\301\302\303#\300\207" [function-put ztree-diff-node-short-name side-effect-free t] 4)
#@89 compiler-macro for inlining `ztree-diff-node-right-short-name'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'ztree-diff-node-right-short-name--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ztree-diff-node-right-short-name (or (ztree-diff-node-p cl-x) (signal 'wrong-type-argument (list 'ztree-diff-node cl-x))) (aref cl-x 5)) nil] 9 (#$ . 6070)])
(put 'ztree-diff-node-right-short-name 'compiler-macro 'ztree-diff-node-right-short-name--cmacro)
#@337 Access slot "right-short-name" of `(ztree-diff-node (:constructor) (:constructor ztree-diff-node-create (parent left-path right-path different &aux (short-name (ztree-file-short-name (or left-path right-path))) (right-short-name (if (and left-path right-path) (ztree-file-short-name right-path) short-name)))))' struct CL-X.

(fn CL-X)
(defalias 'ztree-diff-node-right-short-name #[257 "\301!>\204 \302\303\304D\"\210\211\305H\207" [cl-struct-ztree-diff-node-tags type-of signal wrong-type-argument ztree-diff-node 5] 5 (#$ . 6552)])
(byte-code "\300\301\302\303#\300\207" [function-put ztree-diff-node-right-short-name side-effect-free t] 4)
#@81 compiler-macro for inlining `ztree-diff-node-children'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'ztree-diff-node-children--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ztree-diff-node-children (or (ztree-diff-node-p cl-x) (signal 'wrong-type-argument (list 'ztree-diff-node cl-x))) (aref cl-x 6)) nil] 9 (#$ . 7205)])
(put 'ztree-diff-node-children 'compiler-macro 'ztree-diff-node-children--cmacro)
#@329 Access slot "children" of `(ztree-diff-node (:constructor) (:constructor ztree-diff-node-create (parent left-path right-path different &aux (short-name (ztree-file-short-name (or left-path right-path))) (right-short-name (if (and left-path right-path) (ztree-file-short-name right-path) short-name)))))' struct CL-X.

(fn CL-X)
(defalias 'ztree-diff-node-children #[257 "\301!>\204 \302\303\304D\"\210\211\305H\207" [cl-struct-ztree-diff-node-tags type-of signal wrong-type-argument ztree-diff-node 6] 5 (#$ . 7647)])
(byte-code "\300\301\302\303#\300\207" [function-put ztree-diff-node-children side-effect-free t] 4)
#@82 compiler-macro for inlining `ztree-diff-node-different'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'ztree-diff-node-different--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ztree-diff-node-different (or (ztree-diff-node-p cl-x) (signal 'wrong-type-argument (list 'ztree-diff-node cl-x))) (aref cl-x 7)) nil] 9 (#$ . 8276)])
(put 'ztree-diff-node-different 'compiler-macro 'ztree-diff-node-different--cmacro)
#@330 Access slot "different" of `(ztree-diff-node (:constructor) (:constructor ztree-diff-node-create (parent left-path right-path different &aux (short-name (ztree-file-short-name (or left-path right-path))) (right-short-name (if (and left-path right-path) (ztree-file-short-name right-path) short-name)))))' struct CL-X.

(fn CL-X)
(defalias 'ztree-diff-node-different #[257 "\301!>\204 \302\303\304D\"\210\211\305H\207" [cl-struct-ztree-diff-node-tags type-of signal wrong-type-argument ztree-diff-node 7] 5 (#$ . 8723)])
(byte-code "\300\301\302\303#\304\305\306\"\207" [function-put ztree-diff-node-different side-effect-free t defalias copy-ztree-diff-node copy-sequence] 4)
#@158 compiler-macro for inlining `make-ztree-diff-node'.

(fn CL-WHOLE &cl-quote &key PARENT LEFT-PATH RIGHT-PATH SHORT-NAME RIGHT-SHORT-NAME CHILDREN DIFFERENT)
(defalias 'make-ztree-diff-node--cmacro #[385 "\300\301\"A@\300\302\"A@\300\303\"A@\300\304\"A@\300\305\"A@\300\306\"A@\300\307\"A@\211\203Y \211@\310>\203A \211AA\262\202. \311	>A@\203P \312\262\202. \313\314@\"\210\202. \210\315\316\317\312\f\312\f\f\f\f\f\f\f&\f\207" [plist-member :parent :left-path :right-path :short-name :right-short-name :children :different (:parent :left-path :right-path :short-name :right-short-name :children :different :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:parent :left-path :right-path :short-name :right-short-name :children :different)" cl--defsubst-expand (parent left-path right-path short-name right-short-name children different) (cl-block make-ztree-diff-node (record 'ztree-diff-node parent left-path right-path short-name right-short-name children different))] 22 (#$ . 9410)])
(put 'make-ztree-diff-node 'compiler-macro 'make-ztree-diff-node--cmacro)
#@138 Constructor for objects of type `ztree-diff-node'.

(fn &key PARENT LEFT-PATH RIGHT-PATH SHORT-NAME RIGHT-SHORT-NAME CHILDREN DIFFERENT)
(defalias 'make-ztree-diff-node #[128 "\300\301\"A@\300\302\"A@\300\303\"A@\300\304\"A@\300\305\"A@\300\306\"A@\300\307\"A@\211\203Y \211@\310>\203A \211AA\262\202. \311	>A@\203P \312\262\202. \313\314@\"\210\202. \210\315\316&\207" [plist-member :parent :left-path :right-path :short-name :right-short-name :children :different (:parent :left-path :right-path :short-name :right-short-name :children :different :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:parent :left-path :right-path :short-name :right-short-name :children :different)" record ztree-diff-node] 17 (#$ . 10533)])
(byte-code "\300\301\302\303#\300\207" [function-put make-ztree-diff-node side-effect-free t] 4)
#@96 Constructor for objects of type `ztree-diff-node'.

(fn PARENT LEFT-PATH RIGHT-PATH DIFFERENT)
(defalias 'ztree-diff-node-create #[1028 "\300\206 !\203 \203 \300!\202 \211\301\302\303\n&\207" [ztree-file-short-name record ztree-diff-node nil] 15 (#$ . 11421)])
(byte-code "\300\301\302\303#\304\305\306\307\310\306\311\312\305\303&	\207" [function-put ztree-diff-node-create side-effect-free t cl-struct-define ztree-diff-node nil cl-structure-object record ((cl-tag-slot) (parent) (left-path) (right-path) (short-name) (right-short-name) (children) (different)) cl-struct-ztree-diff-node-tags] 11)
#@78 Determine if the NODE should be excluded from comparison results.

(fn NODE)
(defalias 'ztree-diff-model-ignore-p #[257 "\205 !\207" [ztree-diff-model-ignore-fun] 3 (#$ . 12047)])
#@66 Construct the string with contents of the NODE given.

(fn NODE)
(defalias 'ztree-diff-node-to-string #[257 "\301\302!>\204 \303\304\305D\"\210\306H\307\211\203R \211@\310\302!>\204, \303\304\305D\"\210\311H\312\302!>\204C \303\304\305D\"\210\313H!\260\262A\266\202\202 \210\314\302!>\204d \303\304\305D\"\210\311H\315\316\302	!>\204| \303\304\305D\"\210\317H!\315\320	\302\f!>\204\226 \303\304\305D\"\210\313H!\315\321\f\302!>\204\260 \303\304\305D\"\210\322H!\315\323\302!>\204\312 \303\304\305D\"\210\324H!\315\325\315\260\207" [cl-struct-ztree-diff-node-tags #[257 "\211\203= \211;\203\n \207\211\301=\203 \302\207\211\303=\203 \304\207\211\305=\203\" \306\207\211\307=\203* \310\207\311!>\2049 \312\313\314D\"\210\211\315H\207\316\207" [cl-struct-ztree-diff-node-tags new "new" diff "different" ignore "ignored" same "same" type-of signal wrong-type-argument ztree-diff-node 4 "(empty)"] 5 "\n\n(fn X)"] type-of signal wrong-type-argument ztree-diff-node 6 "" "\n   * " 4 ": " 7 "Node: " "\n" " * Parent: " 1 " * Status: " " * Left path: " 2 " * Right path: " 3 " * Children: "] 22 (#$ . 12237)])
#@121 Return the short name of the NODE given.
If the RIGHT-SIDE is true, take the right leaf

(fn NODE &optional RIGHT-SIDE)
(defalias 'ztree-diff-node-short-name-wrapper #[513 "\211\204 \301!>\204 \302\303\304D\"\210\305H\207\301!>\204& \302\303\304D\"\210\306H\207" [cl-struct-ztree-diff-node-tags type-of signal wrong-type-argument ztree-diff-node 4 5] 6 (#$ . 13414)])
#@51 Determines if the NODE is a directory.

(fn NODE)
(defalias 'ztree-diff-node-is-directory #[257 "\301!>\204 \302\303\304D\"\210\211\305H\301!>\204! \302\303\304D\"\210\306H\203. \307!\2021 \307!\207" [cl-struct-ztree-diff-node-tags type-of signal wrong-type-argument ztree-diff-node 2 3 file-directory-p] 6 (#$ . 13798)])
#@181 Determine the side there the file is present for NODE.
Return BOTH if the file present on both sides;
LEFT if only on the left side and
RIGHT if only on the right side.

(fn NODE)
(defalias 'ztree-diff-node-side #[257 "\301!>\204 \302\303\304D\"\210\211\305H\301!>\204! \302\303\304D\"\210\306H\2030 \211\2030 \307\2029 \2038 \310\2029 \311\207" [cl-struct-ztree-diff-node-tags type-of signal wrong-type-argument ztree-diff-node 2 3 both left right] 6 (#$ . 14138)])
#@60 Determines if NODE1 and NODE2 are equal.

(fn NODE1 NODE2)
(defalias 'ztree-diff-node-equal #[514 "\301!>\204 \302\303\304D\"\210\305H\301!>\204! \302\303\304D\"\210\305H\230\205u \301!>\2047 \302\303\304D\"\210\306H\301!>\204I \302\303\304D\"\210\306H\230\205u \301!>\204_ \302\303\304D\"\210\307H\301!>\204q \302\303\304D\"\210\307H\230\207" [cl-struct-ztree-diff-node-tags type-of signal wrong-type-argument ztree-diff-node 4 2 3] 7 (#$ . 14621)])
#@90 Compare files FILE1 and FILE2 using external diff.
Returns t if equal.

(fn FILE1 FILE2)
(defalias 'ztree-diff-model-files-equal #[514 "\304\"\204 \305\306!\210\307!\307!\203# \310\311!8\310\311!8U\203L 	\2035 \312\311!8\312\311!8\230\203L \313\314\n\315\211\211\316\317\n\nD\"B&\320U\204P \321\202Q \322\207" [ztree-diff-consider-file-size ztree-diff-consider-file-permissions diff-command ztree-diff-additional-options ztree-same-host-p error "Compared files are not on the same host" ztree-untrampify-filename 7 file-attributes 8 apply process-file nil "-q" append 0 diff same] 15 (#$ . 15103)])
#@91 Return the list of full paths of files in a directory DIR.
Filters out . and ..

(fn DIR)
(defalias 'ztree-directory-files #[257 "\300\301\302\303\"\"\207" [ztree-filter #[257 "\300!\211\301\230\206\f \211\302\230?\207" [ztree-file-short-name "." ".."] 4 "\n\n(fn FILE)"] directory-files full] 6 (#$ . 15722)])
#@111 Rescan the NODE.
The node is a either a file or directory with both
left and right parts existing.

(fn NODE)
(defalias 'ztree-diff-model-partial-rescan #[257 "\301!\203 \302!\210\202\277 \303!>\204 \304\305\306D\"\210\211\211\307\310!\204\217 \311\303!>\2046 \304\305\306D\"\210\307H\312\"\204\217 \311\303\211!>\204Q \304\305\306D\"\210\313H!>\204u \304\305\306\303!>\204n \304\305\306\nD\"\210\313HD\"\210\303!>\204\205 \304\305\306D\"\210\313H\307H\312\"\203\223 \312\202\274 \314\303!>\204\244 \304\305\306D\"\210\315H\303!>\204\270 \304\305\306D\"\210\316H\"I\266\317!\207" [cl-struct-ztree-diff-node-tags ztree-diff-node-is-directory ztree-diff-node-recreate-with-progress type-of signal wrong-type-argument ztree-diff-node 7 ztree-diff-model-ignore-p eql ignore 1 ztree-diff-model-files-equal 2 3 ztree-diff-node-update-all-parents-diff] 12 (#$ . 16042)])
#@197 Create a subtree with given PARENT for the given PATH.
Argument SIDE either `left' or `right' side.
Argument DIFF different status to be assigned to all created nodes.

(fn PARENT PATH SIDE DIFF)
(defalias 'ztree-diff-model-subtree #[1028 "\301!\302\211\203p \211@\303!\203O \304\305=\205 \306=\205$ $\307		$\310!>\204> \311\312\313D\"\210\211\314I\266B\262\266\202i \304\305=\205Z \306=\205b $B\262A\266\202\202 \210\207" [cl-struct-ztree-diff-node-tags ztree-directory-files nil file-directory-p ztree-diff-node-create left right ztree-diff-model-subtree type-of signal wrong-type-argument ztree-diff-node 6] 14 (#$ . 16957)])
#@68 Set the diff status for the NODE based on its children.

(fn NODE)
(defalias 'ztree-diff-node-update-diff-from-children #[257 "\301\302!>\204 \303\304\305D\"\210\306H\307\"?\205K \310\311\302!>\204* \303\304\305D\"\210\312H\313\314\315\316&\302!>\204B \303\304\305D\"\210\211\306I\262\262\207" [cl-struct-ztree-diff-node-tags eql type-of signal wrong-type-argument ztree-diff-node 7 ignore cl-reduce ztree-diff-model-update-diff 6 :initial-value same :key ztree-diff-node-different] 8 (#$ . 17634)])
#@69 Recursively update all parents diff status for the NODE.

(fn NODE)
(defalias 'ztree-diff-node-update-all-parents-diff #[257 "\211\301!>\204 \302\303\304D\"\210\211\305H\211\262\205  \306!\210\202 \207" [cl-struct-ztree-diff-node-tags type-of signal wrong-type-argument ztree-diff-node 1 ztree-diff-node-update-diff-from-children] 6 (#$ . 18157)])
#@118 Get the diff status depending if OLD or NEW is not nil.
If the OLD is `ignore', do not change anything

(fn OLD NEW)
(defalias 'ztree-diff-model-update-diff #[514 "\300\301\"\203	 \301\207\300\301\"\203 \207\300\302\"\204  \300\302\"\203\" \302\207\300\303\"\203+ \303\207\207" [eql ignore diff new] 5 (#$ . 18519)])
#@193 Recursively update diff status of all children of NODE.
This function will traverse through all children recursively
setting status from the NODE, unless they have an ignore status

(fn NODE)
(defalias 'ztree-diff-node-update-diff-from-parent #[257 "\301!>\204 \302\303\304D\"\210\211\305H\301!>\204! \302\303\304D\"\210\306H\307\310\311\312\313\314!\315\"\306\316%\"\207" [cl-struct-ztree-diff-node-tags type-of signal wrong-type-argument ztree-diff-node 7 6 mapc make-byte-code 257 "\302\300\303\"\204' \302\300\303\"\206# \302\304!	>\204 \305\306\307D\"\210\310H\303\"?\205@ \304!	>\2046 \305\306\307D\"\210\211\211\310\300I\266\311!\207" vconcat vector [cl-struct-ztree-diff-node-tags eql ignore type-of signal wrong-type-argument ztree-diff-node 7 ztree-diff-node-update-diff-from-parent] "\n\n(fn CHILD)"] 10 (#$ . 18851)])
#@141 Find in LIST of files the file with name SHORTNAME.
If IS-DIR searching for directories; assume files otherwise

(fn LIST SHORTNAME IS-DIR)
(defalias 'ztree-diff-model-find-in-files #[771 "\300\301\302\303\304\305\"\306\"\307\310%\"\207" [ztree-find make-byte-code 257 "\302!\300\230\205 \301\303!=\207" vconcat vector [ztree-file-short-name file-directory-p] 4 "\n\n(fn X)"] 12 (#$ . 19707)])
#@164 Determine if the NODE and its children should be ignored.
If no parent - never ignore;
if in ignore list - ignore
if parent has ignored status - ignore

(fn NODE)
(defalias 'ztree-diff-model-should-ignore #[257 "\301!>\204 \302\303\304D\"\210\211\305H\211\2051 \306\301!>\204& \302\303\304D\"\210\307H\310\"\2061 \311!\207" [cl-struct-ztree-diff-node-tags type-of signal wrong-type-argument ztree-diff-node 1 eql 7 ignore ztree-diff-model-ignore-p] 7 (#$ . 20116)])
#@65 Initiate update of the NODE with a progress printout

(fn NODE)
(defalias 'ztree-diff-node-recreate-with-progress #[257 "\301\302\303!>\204 \304\305\306D\"\210\307H\310\303!>\204% \304\305\306D\"\210\311H\312\260!\313\"\210\314!\207" [cl-struct-ztree-diff-node-tags make-progress-reporter "Comparing " type-of signal wrong-type-argument ztree-diff-node 2 " and " 3 " ..." ztree-diff-node-recreate progress-reporter-done] 9 (#$ . 20597)])
#@146 Traverse 2 paths defined in the NODE updating its children and status.
When REPORTER provided update the progress.

(fn NODE &optional REPORTER)
(defalias 'ztree-diff-node-recreate #[513 "\301\302!>\204 \303\304\305D\"\210\306H!\301\302!>\204% \303\304\305D\"\210\307H!\310!\211\2034 \311\2025 \312\313\203N \313\211\247\203H \211@Y\205L \314\"\266\203k \302!>\204c \303\304\305	D\"\210\211\315\311I\266\211\203C\211@\316!\317!\320#\321\f\n$\310!\203\242 \302!>\204\233 \303\304\305D\"\210\211\211\315\311I\266\203\257 \322\323\324$\262\n\203\352 \204\352 \302!>\204\306 \303\304\305D\"\210\211\211\325\326	\327\302!>\204\337 \303\304\305\nD\"\210\315H$I\266\2024\203(\204(\330\302!>\204\303\304\305D\"\210\315H\311\"\204(\302!>\204\303\304\305D\"\210\211\211\315\331\"I\266\2024\2034\2034\332!\210\211B\262\266A\266\202\202l \210\211\203\264\211@\317!\321\n\313$\310!\203r\302!>\204k\303\304\305D\"\210\211\211\315\311I\266\203\246\302!>\204\205\303\304\305D\"\210\211\211\325\326\333\302!>\204\236\303\304\305\nD\"\210\315H$I\266\211B\262\266A\266\202\202E\210\204\332\302!>\204\312\303\304\305	D\"\210\211\315\334\335\336\337\340\341&I\266\302!>\204\353\303\304\305	D\"\210\211\325I\262\207" [cl-struct-ztree-diff-node-tags ztree-directory-files type-of signal wrong-type-argument ztree-diff-node 2 3 ztree-diff-model-should-ignore ignore new nil progress-reporter-do-update 7 ztree-file-short-name file-directory-p ztree-diff-model-find-in-files ztree-diff-node-create cl-delete :test string-equal 6 ztree-diff-model-subtree left eql ztree-diff-model-files-equal ztree-diff-node-recreate right cl-reduce ztree-diff-model-update-diff :initial-value same :key ztree-diff-node-different] 24 (#$ . 21056)])
#@30 Refresh the NODE.

(fn NODE)
(defalias 'ztree-diff-model-update-node #[257 "\300!\207" [ztree-diff-node-recreate-with-progress] 3 (#$ . 22919)])
#@212 Set the buffer-local ignore function to IGNORE-P.
Ignore function is a function of one argument (ztree-diff-node)
which returns t if the node should be ignored (like files starting
with dot etc).

(fn IGNORE-P)
(defalias 'ztree-diff-model-set-ignore-fun #[257 "\211\211\207" [ztree-diff-model-ignore-fun] 3 (#$ . 23072)])
(provide 'ztree-diff-model)