pyGoEdge-UserPanel/.venv/Lib/site-packages/dns/__pycache__/btree.cpython-312.pyc

<EFBFBD>
g<>
i%x<00>
<00><>
<00>dZd
dl
mZmZ
d
dlmZmZmZmZm	Z	m
Z
mZ
dZe
d<05>
Z
Gd<06>dee
<00>Ze
de<0E>	<09>Zd
edefd<0C>Zd
edefd
<0A>ZGd<0E>d<0F>ZGd<10>dee
ef<00>ZGd<12>dee
ef<00>ZGd<14>de<16>ZGd<16>dee
ef<00>Ze
d<18>
ZGd<19>deee
ef<00>ZGd<1B>dee
efee
ee
effee
ef<00>ZGd<1D>deee
<00>ZGd<1F>d eee
ee
<00>Zy!)"z<>
A BTree in the style of Cormen, Leiserson, and Rivest's "Algorithms" book, with
copy-on-write node updates, cursors, and optional space optimization for mostly-in-order
insertion.
<EFBFBD>)<02>MutableMapping<6E>
MutableSet)<07>Any<6E>Callable<6C>Generic<69>Optional<61>Tuple<6C>TypeVar<61>cast<73><00>KTc<00><00>eZ
dZd
Zdefd<03>Zy)<05>Elementz+All items stored in the BTree are Elements.<2E>returnc

<00><00>t<00>
)
zFThe key for this element; the returned type must implement comparison.)
<01>NotImplementedError<6F>
<01>selfs
 <20>8E:\Project\pygoedge\.venv\Lib\site-packages\dns/btree.py<70>keyzElement.keys<00><00>!<21>!<21>N)<06>__name__<5F>
__module__<EFBFBD>__qualname__<5F>__doc__r
r<00>rrrrs<00><00>5<>"<22>R<EFBFBD>"rr<00>ET)
<01>bound<6E>
trc
<00><00>|d
z
S)z[The minimum number of keys in a non-root node for a BTree with the specified
    ``t``
    <20>
r<00>
rs
 r<00>_MINr#s
<00><00>
<0A>q<EFBFBD>5<EFBFBD>Lrc
<00><00>d
|zdz
S)zGThe maximum number of keys in node for a BTree with the specified ``t``<60>r!rr"s
 r<00>_MAXr&#s<00><00><0C>q<EFBFBD>5<EFBFBD>1<EFBFBD>9<EFBFBD>rc
<00><00>eZ
dZd
Zd<02>Zy)<04>_Creatorz<72>A _Creator class instance is used as a unique id for the BTree which created
    a node.

    We use a dedicated creator rather than just a BTree reference to avoid circularity
    that would complicate GC.
    c
<00><00>t
|<00>
d
<01>S)N<>
x)
<01>idrs
 r<00>__str__z_Creator.__str__0s<00><00><14>T<EFBFBD>(<28>1<EFBFBD><1C>rN)rrrrr,rrrr(r((s<00><00><08>
rr(c	<00><>
<00>eZ
dZd
Zgd<02>
Zdededefd<06>Zdefd<08>Z	defd	<09>Z
d
edeeeffd<0B>Z
dedd
fd<0E>Zd
edeed
effd<0F>Zd
ededzfd<11>Zdeddfd<12>Zdedededzfd<15>Zded
ed
ffd<16>Zdd
dedefd<18>Zdd
dedefd<19>Zdd
dedd
ddfd<1D>Zdd
deddfd<1E>Zdefd<1F>Zdefd <20>Zdd
deddfd!<21>Zd
eded
d"edzdedzfd#<23>Zd$eeg
dfddfd%<25>Z d$ed
g
dfddfd&<26>Z!deded
fd'<27>Z"dedd
fd(<28>Z#d)<29>Z$y)*<2A>_NodezFA Node in the BTree.

    A Node (leaf or internal) of the BTree.
    <20>r<00>creator<6F>is_leaf<61>elts<74>childrenrr0r1c<00>X<00>|
d
k\sJ<00>
|
|_||_
||_g|_g|_y)N<>r/)rrr0r1s    r<00>__init__z_Node.__init__<s0<00><00><10>A<EFBFBD>v<EFBFBD>
<0A>v<EFBFBD><12><04><06><1E><04><0C><1E><04><0C> <20><04>	<09>-/<2F><04>
rrc
<00><><00>t
|j<00>
t|j<00>
ksJ<00>
t
|j<00>
t|j<00>
k(S)
z/Does this node have the maximal number of keys?)<04>lenr2r&rrs
 r<00>
is_maximalz_Node.is_maximalD<00>;<00><00><12>4<EFBFBD>9<EFBFBD>9<EFBFBD>~<7E><14>d<EFBFBD>f<EFBFBD>f<EFBFBD><1C>-<2D>-<2D>-<2D><12>4<EFBFBD>9<EFBFBD>9<EFBFBD>~<7E><14>d<EFBFBD>f<EFBFBD>f<EFBFBD><1C>-<2D>-rc
<00><><00>t
|j<00>
t|j<00>
k\sJ<00>
t
|j<00>
t|j<00>
k(S)
z/Does this node have the minimal number of keys?)r8r2r#rrs
 r<00>
is_minimalz_Node.is_minimalIr:rrc<00>h
<00>t
|j<00>
}|d
kDr'|
|j|dz
j<00>kDr|dfSd
}t
|j<00>
}|dz
}d}||krK||zdz}|j|j<00>}|
|k(r	|}d}	||fS|
|kr|}|dz
}n|dz}||kr
<01>K||fS)z<>Get the index of the ``Element`` matching ``key`` or the index of its
        least successor.

        Returns a tuple of the index and an ``equal`` boolean that is ``True`` iff.
        the key was found.
        rr!Fr%T)r8r2r)rr<00>
l<>
i<>
r<>equal<61>
m<>
ks        r<00>search_in_nodez_Node.search_in_nodeNs<><00><00>
<10><04>	<09>	<09>N<EFBFBD>
<01><0C>q<EFBFBD>5<EFBFBD>S<EFBFBD>4<EFBFBD>9<EFBFBD>9<EFBFBD>Q<EFBFBD><11>U<EFBFBD>+<2B>/<2F>/<2F>1<>1<><14>e<EFBFBD>8<EFBFBD>O<EFBFBD>
<0A>
<01><0F><04>	<09>	<09>N<EFBFBD>
<01>
<0A>
<01>E<EFBFBD>
<01><15><05><0F>1<EFBFBD>f<EFBFBD><12>Q<EFBFBD><15>1<EFBFBD><0C>A<EFBFBD><14>	<09>	<09>!<21><0C> <20> <20>"<22>A<EFBFBD><12>a<EFBFBD>x<EFBFBD><15>
<01><1C><05><15><11>%<25>x<EFBFBD><0F><15>q<EFBFBD><17><15>
<01><15>
<01>E<EFBFBD>
<01><15>
<01>E<EFBFBD>
<01><10>1<EFBFBD>f<EFBFBD><11>%<25>x<EFBFBD>r<00>indexz
_Node[KT, ET]c<00><><00>|jrJ<00>
|j|
}|j|j<00>
}|r||j|
<|S|S<00>
N)r1r3<00>	maybe_cowr0)rrE<00>child<6C>cloneds    r<00>maybe_cow_childz_Node.maybe_cow_childksJ<00><00><17><<3C><<3C><1F><1F><14>
<0A>
<0A>e<EFBFBD>$<24><05><16><1F><1F><14><1C><1C>.<2E><06><11>#)<29>D<EFBFBD>M<EFBFBD>M<EFBFBD>%<25> <20><19>M<EFBFBD><18>Lrc<00><><00>|j
|
<01>
\}}|r||fS|jr
y
|j|<02>
}|j|
<01>
S)z<>Get the node associated with key and its index, doing
        copy-on-write if we have to descend.

        Returns a tuple of the node and the index, or the tuple ``(None, 0)``
        if the key was not found.
        <20>Nr)rDr1rK<00>	_get_node)rrr?rArIs     rrNz_Node._get_nodeusN<00><00><18>&<26>&<26>s<EFBFBD>+<2B><08>
<01>5<EFBFBD><10><18>!<21>9<EFBFBD><1C>
<11>\<5C>\<5C><1C><18>(<28>(<28><11>+<2B>E<EFBFBD><18>?<3F>?<3F>3<EFBFBD>'<27>'rNc<00><><00>|j
|
<01>
\}}|r|j|S|jr
y
|j|j	|
<01>
S)z8Get the element associated with *key* or return ``None``N)rDr2r1r3<00>get)rrr?rAs    rrPz	_Node.get<65>sK<00><00><17>&<26>&<26>s<EFBFBD>+<2B><08>
<01>5<EFBFBD><10><17>9<EFBFBD>9<EFBFBD>Q<EFBFBD><<3C><1F>
<11>\<5C>\<5C><17><17>=<3D>=<3D><11>#<23>'<27>'<27><03>,<2C>,rc<00><>
<00>|
d
k(r
y|j|
dz
}t|j<00>
t|j<00>
k(r
y|j|
dz
<00>
}t|j<00>
t|j<00>
krC|j
||
dz
<00>s
yt|j<00>
t|j<00>
kr
<01>Byy)a-
Try to minimize the number of Nodes in a BTree where the insertion
        is done in-order or close to it, by stealing as much as we can from our
        right sibling.

        If we don't do this, then an in-order insertion will produce a BTree
        where most of the nodes are minimal.
        rNr!)r3r8r2r&rrK<00>try_right_steal)rrE<00>lefts   r<00>optimize_in_order_insertionz!_Node.optimize_in_order_insertion<6F>s<><00><00><11>A<EFBFBD>:<3A><12><13>}<7D>}<7D>U<EFBFBD>Q<EFBFBD>Y<EFBFBD>'<27><04><0E>t<EFBFBD>y<EFBFBD>y<EFBFBD>><3E>T<EFBFBD>$<24>&<26>&<26>\<5C>)<29><12><13>#<23>#<23>E<EFBFBD>A<EFBFBD>I<EFBFBD>.<2E><04><11>$<24>)<29>)<29>n<EFBFBD>t<EFBFBD>D<EFBFBD>F<EFBFBD>F<EFBFBD>|<7C>+<2B><17>'<27>'<27><04>e<EFBFBD>a<EFBFBD>i<EFBFBD>8<><15><12>$<24>)<29>)<29>n<EFBFBD>t<EFBFBD>D<EFBFBD>F<EFBFBD>F<EFBFBD>|<7C>+r<00>element<6E>in_orderc<00><>
<00>|j
<00>rJ<00>
	|
j<00>}|j|<03>
\}}|r |j|}|
|j|<|S|jr|jj||
<01>
y|j
|<04>
}|j
<00>r|j|j<00><00>
<00><>|j|
|<02>}|r|j|<04>

|SrG)r9rrDr2r1<00>insertrK<00>adopt<70>split<69>insert_nonfullrT)	rrUrVrr?rA<00>oldrI<00>oelts	         rr[z_Node.insert_nonfull<6C>s<><00><00><17>?<3F>?<3F>$<24>$<24>$<24><12><19>+<2B>+<2B>-<2D>C<EFBFBD><1B>*<2A>*<2A>3<EFBFBD>/<2F>H<EFBFBD>A<EFBFBD>u<EFBFBD><14><1A>i<EFBFBD>i<EFBFBD>
<01>l<EFBFBD><03>&<26><04>	<09>	<09>!<21><0C><1A>
<EFBFBD><15><1C><1C><14>	<09>	<09> <20> <20><11>G<EFBFBD>,<2C><1B><1C>,<2C>,<2C>Q<EFBFBD>/<2F><05><18>#<23>#<23>%<25><1E>D<EFBFBD>J<EFBFBD>J<EFBFBD><05><0B><0B>
<0A>.<2E><1D><1C>+<2B>+<2B>G<EFBFBD>X<EFBFBD>><3E><04><1B><18>4<>4<>Q<EFBFBD>7<><1B>rc
<00><><00>|j
<00>sJ<00>
|j|j|j|j<00>}
t|jt|j<00>
d
zd<00>
|
_|jt|j<00>
}t|jdt|j<00>
<00>
|_|jsft|jt|j<00>
d
zd<00>
|
_t|jdt|j<00>
d
z<00>
|_|||
fS)zASplit a maximal node into two minimal ones and a central element.r!N)	r9<00>	__class__rr0r1<00>listr2r#r3)r<00>right<68>middles   rrZz_Node.split<69>s<><00><00><13><EFBFBD><EFBFBD> <20> <20> <20><14><0E><0E>t<EFBFBD>v<EFBFBD>v<EFBFBD>t<EFBFBD>|<7C>|<7C>T<EFBFBD>\<5C>\<5C>B<><05><19>$<24>)<29>)<29>D<EFBFBD><14><16><16>L<EFBFBD>1<EFBFBD>$4<>$6<>7<>8<><05>
<EFBFBD><15><19><19>4<EFBFBD><04><06><06><<3C>(<28><06><18><14><19><19>><3E>T<EFBFBD>$<24>&<26>&<26>\<5C>2<>3<><04>	<09><13>|<7C>|<7C>!<21>$<24>-<2D>-<2D><04>T<EFBFBD>V<EFBFBD>V<EFBFBD><0C>q<EFBFBD>0@<40>0B<30>"C<>D<>E<EFBFBD>N<EFBFBD> <20><14><1D><1D>/A<><14>d<EFBFBD>f<EFBFBD>f<EFBFBD><1C>
<01>1A<31>!B<>C<>D<EFBFBD>M<EFBFBD><13>V<EFBFBD>U<EFBFBD>"<22>"r<00>parentc<00><>
<00>|d
k7r<>|
j|dz
}|j<00>s<>|
j|dz
<00>
}|
j|dz
}|jj	<00>|
j|dz
<|jjd
|<04>
|jsD|jrJ<00>
|jj	<00>}|jjd
|<05>
yy)z<>Try to steal from this Node's left sibling for balancing purposes.

        Returns ``True`` if the theft was successful, or ``False`` if not.
        rr!TF)r3r<rKr2<00>poprXr1)rrcrErS<00>eltrIs      r<00>try_left_stealz_Node.try_left_steal<61>s<><00><00>
<11>A<EFBFBD>:<3A><19>?<3F>?<3F>5<EFBFBD>1<EFBFBD>9<EFBFBD>-<2D>D<EFBFBD><17>?<3F>?<3F>$<24><1D>-<2D>-<2D>e<EFBFBD>a<EFBFBD>i<EFBFBD>8<><04><1C>k<EFBFBD>k<EFBFBD>%<25>!<21>)<29>,<2C><03>)-<2D><19><19><1D><1D><1F><06><0B><0B>E<EFBFBD>A<EFBFBD>I<EFBFBD>&<26><14>	<09>	<09> <20> <20><11>C<EFBFBD>(<28><1B>|<7C>|<7C>#<23>|<7C>|<7C>+<2B>+<2B> <20>M<EFBFBD>M<EFBFBD>-<2D>-<2D>/<2F>E<EFBFBD><18>M<EFBFBD>M<EFBFBD>(<28>(<28><11>E<EFBFBD>2<><1B>rc<00><>
<00>|d
zt
|
j<00>
kr<>|
j|d
z}|j<00>s<>|
j|d
z<00>
}|
j|}|jjd<02>
|
j|<|jj
|<04>

|jsD|jrJ<00>
|jjd<02>
}|jj
|<05>

yy)z<>Try to steal from this Node's right sibling for balancing purposes.

        Returns ``True`` if the theft was successful, or ``False`` if not.
        r!rTF)r8r3r<rKr2re<00>appendr1)rrcrErarfrIs      rrRz_Node.try_right_steal<61>s<><00><00>
<11>1<EFBFBD>9<EFBFBD>s<EFBFBD>6<EFBFBD>?<3F>?<3F>+<2B>+<2B><1A>O<EFBFBD>O<EFBFBD>E<EFBFBD>A<EFBFBD>I<EFBFBD>.<2E>E<EFBFBD><18>#<23>#<23>%<25><1E>.<2E>.<2E>u<EFBFBD>q<EFBFBD>y<EFBFBD>9<><05><1C>k<EFBFBD>k<EFBFBD>%<25>(<28><03>%*<2A>Z<EFBFBD>Z<EFBFBD>^<5E>^<5E>A<EFBFBD>%6<><06><0B><0B>E<EFBFBD>"<22><14>	<09>	<09> <20> <20><13>%<25><1C>}<7D>}<7D>#<23>|<7C>|<7C>+<2B>+<2B>!<21>N<EFBFBD>N<EFBFBD>.<2E>.<2E>q<EFBFBD>1<>E<EFBFBD><18>M<EFBFBD>M<EFBFBD>(<28>(<28><15>/<2F><1B>rrSrbrac<00>v
<00>|j
<00>rJ<00>
|jrJ<00>
|j<00>}|j|<04>
\}}|rJ<00>
|jj||<02>
t
|j<00>
d
k(r
|
|g|_y|j||
k(sJ<00>
|jj|dz|<03>
y)z<>Adopt left, middle, and right into our Node (which must not be maximal,
        and which must not be a leaf).  In the case were we are not the new root,
        then the left child must already be in the Node.rr!N)r9r1rrDr2rXr8r3)rrSrbrarr?rAs       rrYz_Node.adopt<70>s<><00><00><18>?<3F>?<3F>$<24>$<24>$<24><17><<3C><<3C><1F><1F><14>j<EFBFBD>j<EFBFBD>l<EFBFBD><03><17>&<26>&<26>s<EFBFBD>+<2B><08>
<01>5<EFBFBD><18><18>y<EFBFBD><0C>	<09>	<09><18><18><11>F<EFBFBD>#<23><0E>t<EFBFBD>}<7D>}<7D><1D><11>"<22>!<21>5<EFBFBD>M<EFBFBD>D<EFBFBD>M<EFBFBD><17>=<3D>=<3D><11>#<23>t<EFBFBD>+<2B>+<2B>+<2B><10>M<EFBFBD>M<EFBFBD> <20> <20><11>Q<EFBFBD><15><05>.rc<00>V
<00>|
jj|d
z<00>
}|jj|
jj|<02>
<00>

|jj	|j<00>

|j
s&|jj	|j<00>

yy)z>Merge this node's parent and its right sibling into this node.r!N)r3rer2ri<00>extendr1)rrcrEras    r<00>mergez_Node.merge<67>sq<00><00><16><0F><0F>#<23>#<23>E<EFBFBD>A<EFBFBD>I<EFBFBD>.<2E><05><0C>	<09>	<09><18><18><16><1B><1B><1F><1F><15>/<2F>0<><0C>	<09>	<09><18><18><15><1A><1A>$<24><13>|<7C>|<7C><10>M<EFBFBD>M<EFBFBD> <20> <20><15><1E><1E>0<>rc
<00>r<00>|jr|jd
S|jd
j<00>S)z"The least element in this subtree.r)r1r2r3<00>minimumrs
 rroz
_Node.minimum
s/<00><00><0F><<3C><<3C><17>9<EFBFBD>9<EFBFBD>Q<EFBFBD><<3C><1F><17>=<3D>=<3D><11>#<23>+<2B>+<2B>-<2D>-rc
<00>r<00>|jr|jd
S|jd
j<00>S)z%The greatest element in this subtree.<2E><><EFBFBD><EFBFBD><EFBFBD>)r1r2r3<00>maximumrs
 rrrz
_Node.maximum
s/<00><00><0F><<3C><<3C><17>9<EFBFBD>9<EFBFBD>R<EFBFBD>=<3D> <20><17>=<3D>=<3D><12>$<24>,<2C>,<2C>.<2E>.rc<00><><00>|
jrJ<00>
|j|
|<02>r
y
|j|
|<02>r
y
|dk(r|j|
|<02>
y
|
j	|dz
<00>
}|j|
|dz
<00>
y
)z<>This Node is minimal, and we want to make it non-minimal so we can delete.
        We try to steal from our siblings, and if that doesn't work we will merge
        with one of them.Nrr!)r1rgrRrmrK)rrcrErSs    r<00>balancez
_Node.balance
st<00><00><1A>><3E>><3E>!<21>!<21><0F><1E><1E>v<EFBFBD>u<EFBFBD>-<2D><12><0F><1F><1F><06><05>.<2E><12><10>A<EFBFBD>:<3A><10>J<EFBFBD>J<EFBFBD>v<EFBFBD>u<EFBFBD>%<25><1A>)<29>)<29>%<25>!<21>)<29>4<>D<EFBFBD><10>J<EFBFBD>J<EFBFBD>v<EFBFBD>u<EFBFBD>q<EFBFBD>y<EFBFBD>)r<00>exactc<00><00>|<02>|j
<00>rJ<00>
|j|
<01>
\}}d
}|r~|<03>|j||u
rtd<02>
<00>
|jr|jj|<04>
Sd
}|
}|j|dzj<00>}|j<00>}
|dz}|jr|<03>td<04>
<00>
y
|j|<04>
}|j
<00>rK|j||<04>
|j|
<01>
\}}|rJ<00>
|j|}|j
<00>rJ<00>
|j|
||<03>}	|<06><|j|<06>
\}
}|
<EFBFBD>J<00>
|	<09>J<00>
|
j|}|	|
j|<|}	|	S)z<>Delete an element matching *key* if it exists.  If *exact* is not ``None``
        then it must be an exact match with that element.  The Node must not be
        minimal unless it is the root.Nz'exact delete did not match existing eltr!zexact delete had no match)
r<rDr2<00>
ValueErrorr1rer3rorrKrt<00>deleterN)rrrcrur?rA<00>original_key<65>least_successorrIrf<00>noder]s            rrxz_Node.delete&
s<>
<00><00><16>~<7E>T<EFBFBD>_<EFBFBD>_<EFBFBD>%6<>6<>6<><17>&<26>&<26>s<EFBFBD>+<2B><08>
<01>5<EFBFBD><1B><0C><10><14> <20>T<EFBFBD>Y<EFBFBD>Y<EFBFBD>q<EFBFBD>\<5C><15>%><3E> <20>!J<>K<>K<><13>|<7C>|<7C><1B>y<EFBFBD>y<EFBFBD>}<7D>}<7D>Q<EFBFBD>'<27>'<27><19>E<EFBFBD><1E>L<EFBFBD>"<22>m<EFBFBD>m<EFBFBD>A<EFBFBD>
<01>E<EFBFBD>2<>:<3A>:<3A><<3C>O<EFBFBD>!<21>%<25>%<25>'<27>C<EFBFBD><11>A<EFBFBD><05>A<EFBFBD><0F><<3C><<3C><14> <20> <20>!<<3C>=<3D>=<3D><17><14>$<24>$<24>Q<EFBFBD>'<27><05><10><1B><1B><1D><11>M<EFBFBD>M<EFBFBD>$<24>
<01>"<22><1B>*<2A>*<2A>3<EFBFBD>/<2F>H<EFBFBD>A<EFBFBD>u<EFBFBD><1C><1C>9<EFBFBD><18>M<EFBFBD>M<EFBFBD>!<21>$<24>E<EFBFBD><1C>'<27>'<27>)<29>)<29>)<29><13>l<EFBFBD>l<EFBFBD>3<EFBFBD><04>e<EFBFBD>,<2C><03><17>#<23><1A>n<EFBFBD>n<EFBFBD>\<5C>2<>G<EFBFBD>D<EFBFBD>!<21><17>#<23>#<23>#<23><16>?<3F>"<22>?<3F><17>9<EFBFBD>9<EFBFBD>Q<EFBFBD><<3C>D<EFBFBD><1E>D<EFBFBD>I<EFBFBD>I<EFBFBD>a<EFBFBD>L<EFBFBD><16>C<EFBFBD><12>
r<00>visitc<00><><00>t
|j<00>
D]7\}}|js|j|j	|
<01>

|
|<03>

<00>9|js|jd
j	|
<01>

yy)z-Call *visit* on all of the elements in order.rqN)<05>	enumerater2r1r3<00>visit_in_order)rr|r?rfs    rrz_Node.visit_in_orderU
sc<00><00><1F><04>	<09>	<09>*<2A>F<EFBFBD>A<EFBFBD>s<EFBFBD><17><<3C><<3C><14>
<0A>
<0A>a<EFBFBD> <20>/<2F>/<2F><05>6<><11>#<23>J<EFBFBD>+<2B><14>|<7C>|<7C><10>M<EFBFBD>M<EFBFBD>"<22><1D>,<2C>,<2C>U<EFBFBD>3<>rc<00>r<00>|
|<00>

|js#|jD]}|j|
<01>

<00>y
y
)z?Visit nodes in preorder.  This method is only used for testing.N)r1r3<00>_visit_preorder_by_node)rr|rIs   rr<>z_Node._visit_preorder_by_node^
s1<00><00>
<0A>d<EFBFBD><0B><13>|<7C>|<7C><1D><1D><1D><05><15>-<2D>-<2D>e<EFBFBD>4<>'<27>rc<00>B<00>|j|
u
r|j|
<01>
Sy
)z<>Return a clone of this Node if it was not created by *creator*, or ``None``
        otherwise (i.e. copy for copy-on-write if we haven't already copied it).N)r0<00>clone)rr0s  rrHz_Node.maybe_cowe
s"<00><00><10><<3C><<3C>w<EFBFBD>&<26><17>:<3A>:<3A>g<EFBFBD>&<26>&<26>rc<00>
<00>|j
|j|
|j<00>}|jj	|j<00>

|js%|j
j	|j
<00>

|S)
z+Make a shallow-copy duplicate of this node.)r_rr1r2rlr3)rr0rJs   rr<>z_Node.clonem
sT<00><00><15><1E><1E><04><06><06><07><14><1C><1C>><3E><06><0E><0B><0B><1A><1A>4<EFBFBD>9<EFBFBD>9<EFBFBD>%<25><13>|<7C>|<7C><12>O<EFBFBD>O<EFBFBD>"<22>"<22>4<EFBFBD>=<3D>=<3D>1<><15>
rc
	<00><><00>|js8d
d
j|jD<00>
cgc]}
t|
<01>
d<02><04><02>c}
<01>
z}nd}t|<00>
d<02>d
|j<00>d
|j
<00>|<02><00>Sc
c}
w)N<>
 r*<00>)r1<00>joinr3r+r0r2)r<00>
cr3s   rr,z
_Node.__str__u
sm<00><00><13>|<7C>|<7C><1A>S<EFBFBD>X<EFBFBD>X<EFBFBD>T<EFBFBD>]<5D>]<5D>&K<>]<5D>
<01>"<22>Q<EFBFBD>%<25>
<01><19>|<7C>]<5D>&K<>L<>L<>H<EFBFBD><19>H<EFBFBD><14>T<EFBFBD>(<28>1<EFBFBD><1C>Q<EFBFBD>t<EFBFBD>|<7C>|<7C>n<EFBFBD>A<EFBFBD>d<EFBFBD>i<EFBFBD>i<EFBFBD>[<5B><18>
<EFBFBD>C<>C<><43>'L
s<00>A1
)%rrrr<00>	__slots__<5F>intr(<00>boolr6r9r<r
<00>tuplerDrKr	rrNrrPrTr[rZrgrRrYrmrorrrtrxrrr<>rHr<>r,rrrr.r.4s7<00><00><08>
@
<01>I<EFBFBD>0<>#<23>0<><08>0<>4<EFBFBD>0<>.<2E>D<EFBFBD>.<2E>
.<2E>D<EFBFBD>.<2E>
<18>"<22><18><15>s<EFBFBD>D<EFBFBD>y<EFBFBD>)9<><18>:<19>S<EFBFBD><19>_<EFBFBD><19>(<28>R<EFBFBD>(<28>E<EFBFBD>(<28>?<3F>*C<>S<EFBFBD>*H<>$I<>(<28> -<2D>r<EFBFBD>-<2D>b<EFBFBD>4<EFBFBD>i<EFBFBD>-<2D><16><13><16><14><16>$<1C>b<EFBFBD><1C>D<EFBFBD><1C>R<EFBFBD>$<24>Y<EFBFBD><1C>2
#<23>u<EFBFBD>_<EFBFBD>b<EFBFBD>/<2F>A<>B<>
#<23><15>_<EFBFBD><15>S<EFBFBD><15>T<EFBFBD><15>&<15>o<EFBFBD><15>c<EFBFBD><15>d<EFBFBD><15>&/<2F>/<2F>/<2F>2<EFBFBD>/<2F>o<EFBFBD>/<2F>RV<52>/<2F>"1<>O<EFBFBD>1<>C<EFBFBD>1<>D<EFBFBD>1<>.<2E><12>.<2E>/<2F><12>/<2F>*<2A>o<EFBFBD>*<2A>c<EFBFBD>*<2A>d<EFBFBD>*<2A>&-<13><15>-<13>'<27><0F>8<>-<13>AC<41>d<EFBFBD><19>-<13>	<0B>d<EFBFBD><19>-<13>^
4<>H<EFBFBD>b<EFBFBD>T<EFBFBD>4<EFBFBD>Z<EFBFBD>$8<>4<>T<EFBFBD>4<>5<>X<EFBFBD><EFBFBD>6G<36><14>6M<36>-N<>5<>SW<53>5<><18><18><18>h<EFBFBD><EFBFBD>.G<><18><16>X<EFBFBD><16>/<2F><16>D
rr.c<00><><00>eZ
dZd
Zdd<02>Zdd<05>Zdd<06>Zd<07>Zd<08>Zde	dzfd	<09>Z
de	dzfd
<EFBFBD>Zdede
ddfd
<0A>Zddededdfd<0F>Zdd<10>Zdd<11>Zd<12>Zd<13>Zy)<17>Cursorz<72>A seekable cursor for a BTree.

    If you are going to use a cursor on a mutable BTree, you should use it
    in a ``with`` block so that any mutations of the BTree automatically park
    the cursor.
    c<00><><00>|
|_d|_
d
|_d|_d|_g|_d|_d|_d|_y)NrFT)	<09>btree<65>current_node<64>
current_index<65>recurse<73>
increasing<EFBFBD>parents<74>parked<65>parking_key<65>parking_key_read)rr<>s  rr6zCursor.__init__<5F>
sG<00><00><1A><04>
<EFBFBD>*.<2E><04><19>#$<24><04><1A><1C><04><0C><1E><04><0F>02<30><04><0C><1B><04><0B>&*<2A><04><18> %<25><04>rrNc
<00>X
<00>|j<00>J<00>
|jjs<>|jj|j|jf<02>

|jj
|j|_|j<00>J<00>
d
|_|jjs
<01><>yyrM)r<>r1r<>rir<>r3rs
 r<00>_seek_leastzCursor._seek_least<73>
s<><00><00><14> <20> <20>,<2C>,<2C>,<2C><16>#<23>#<23>+<2B>+<2B><10>L<EFBFBD>L<EFBFBD><1F><1F><14>!2<>!2<>D<EFBFBD>4F<34>4F<34> G<>H<> $<24> 1<> 1<> :<3A> :<3A>4<EFBFBD>;M<>;M<> N<>D<EFBFBD><1D><17>$<24>$<24>0<>0<>0<>!"<22>D<EFBFBD><1E>	<17>#<23>#<23>+<2B>+rc
<00><>
<00>|j<00>J<00>
|jjs<>|jj|j|jf<02>

|jj
|j|_|j<00>J<00>
t
|jj<00>
|_|jjs
<01><>yyrG)r<>r1r<>rir<>r3r8r2rs
 r<00>_seek_greatestzCursor._seek_greatest<73>
s<><00><00><14> <20> <20>,<2C>,<2C>,<2C><16>#<23>#<23>+<2B>+<2B><10>L<EFBFBD>L<EFBFBD><1F><1F><14>!2<>!2<>D<EFBFBD>4F<34>4F<34> G<>H<> $<24> 1<> 1<> :<3A> :<3A>4<EFBFBD>;M<>;M<> N<>D<EFBFBD><1D><17>$<24>$<24>0<>0<>0<>!$<24>T<EFBFBD>%6<>%6<>%;<3B>%;<3B>!<<3C>D<EFBFBD><1E>	<17>#<23>#<23>+<2B>+rc
<00>,<00>|jsd
|_yy)a<>
Park the cursor.

        A cursor must be "parked" before mutating the BTree to avoid undefined behavior.
        Cursors created in a ``with`` block register with their BTree and will park
        automatically.  Note that a parked cursor may not observe some changes made when
        it is parked; for example a cursor being iterated with next() will not see items
        inserted before its current position.
        TN)
r<>rs
 r<00>parkzCursor.park<72>
s<00><00><14>{<7B>{<7B><1E>D<EFBFBD>K<EFBFBD>rc
<00><><00>|jrp|j<00>U|j}
|jr|j}n|j}|j	|j|<02>
|
|_d
|_d|_
yy<00>NF)r<>r<>r<>r<><00>seek)rr<><00>befores   r<00>
_maybe_unparkzCursor._maybe_unpark<72>
so<00><00><0F>;<3B>;<3B><13><1F><1F>+<2B>!<21>_<EFBFBD>_<EFBFBD>
<EFBFBD><17>(<28>(<28>"&<26><1F><1F>0<>F<EFBFBD>
"<22>_<EFBFBD>_<EFBFBD>F<EFBFBD><14>	<09>	<09>$<24>*<2A>*<2A>F<EFBFBD>3<>",<2C><04><0F><1F>D<EFBFBD>K<EFBFBD>#<23>D<EFBFBD><1C>!rc
<00>P<00>|j
<00>
d
|_
|j<00>z|jdk(r
y
|jdk(sJ<00>
|jj
|_t
|jj
j<00>
|_|j<00>
	|jr#|js|j<00>
d|_	d|_
|x
jdzc_|jdk\r^|jj|j}
|jjsd|_	|
j<00>|_
d|_
|
St
|j<00>
dkDr(|jj<00>\|_|_nd
|_d|_y
<01>
<01>	)zAGet the previous element, or return None if on the left boundary.Nrr!TF)r<>r<>r<>r<>r<><00>rootr8r2r<>r<>r<>r1rr<>r<>re<00>rrfs  r<00>prevzCursor.prev<65>
s_
<00><00><0C><1A><1A><1C><1F><04><18><0F><1C><1C>$<24><13>!<21>!<21>Q<EFBFBD>&<26><1B><1B>)<29>)<29>Q<EFBFBD>.<2E>.<2E>.<2E>%)<29>J<EFBFBD>J<EFBFBD>O<EFBFBD>O<EFBFBD><04>!<21>%(<28><14><1A><1A><1F><1F>)=<3D>)=<3D>%><3E><04>"<22><14>#<23>#<23>%<25><12><13>|<7C>|<7C><1B><EFBFBD><EFBFBD><19>'<27>'<27>)<29>$<24><04><0C>#<23>D<EFBFBD>O<EFBFBD><10><1E><1E>!<21>#<23><1E><13>!<21>!<21>Q<EFBFBD>&<26><1A>'<27>'<27>,<2C>,<2C>T<EFBFBD>-?<3F>-?<3F>@<40><03><1B>(<28>(<28>0<>0<>#'<27>D<EFBFBD>L<EFBFBD>#&<26>7<EFBFBD>7<EFBFBD>9<EFBFBD><04> <20>(,<2C><04>%<25><1A>
<EFBFBD><16>t<EFBFBD>|<7C>|<7C>$<24>q<EFBFBD>(<28><@<40>L<EFBFBD>L<EFBFBD><L<><L<><N<>9<>D<EFBFBD>%<25>t<EFBFBD>'9<>(,<2C>D<EFBFBD>%<25>)*<2A>D<EFBFBD>&<26><1F>-rc
<00><<00>|j
<00>
d
|_
|j<00>S|jdk(r
y
|jdk(sJ<00>
|jj
|_d|_|j
<00>
	|jr#|jr|j
<00>
d|_d|_|jt|jj<00>
krs|jj|j}
|x
jdz
c_|jjsd|_|
j<00>|_
d|_
|
St|j<00>
dkDr(|jj<00>\|_|_nd
|_d|_y
<01>
<01>&)z>Get the next element, or return None if on the right boundary.Nr!rTF)r<>r<>r<>r<>r<>r<>r<>r<>r<>r8r2r1rr<>r<>rer<>s  r<00>nextzCursor.next<78>
s]
<00><00><0C><1A><1A><1C><1F><04><18><0F><1C><1C>$<24><13>!<21>!<21>Q<EFBFBD>&<26><1B><1B>)<29>)<29>Q<EFBFBD>.<2E>.<2E>.<2E>%)<29>J<EFBFBD>J<EFBFBD>O<EFBFBD>O<EFBFBD><04>!<21>%&<26><04>"<22><14> <20> <20>"<22><12><13>|<7C>|<7C><17>?<3F>?<3F><19>$<24>$<24>&<26>$<24><04><0C>"<22>D<EFBFBD>O<EFBFBD><13>!<21>!<21>C<EFBFBD><04>(9<>(9<>(><3E>(><3E>$?<3F>?<3F><1A>'<27>'<27>,<2C>,<2C>T<EFBFBD>-?<3F>-?<3F>@<40><03><14>"<22>"<22>a<EFBFBD>'<27>"<22><1B>(<28>(<28>0<>0<>#'<27>D<EFBFBD>L<EFBFBD>#&<26>7<EFBFBD>7<EFBFBD>9<EFBFBD><04> <20>(,<2C><04>%<25><1A>
<EFBFBD><16>t<EFBFBD>|<7C>|<7C>$<24>q<EFBFBD>(<28><@<40>L<EFBFBD>L<EFBFBD><L<><L<><N<>9<>D<EFBFBD>%<25>t<EFBFBD>'9<>(,<2C>D<EFBFBD>%<25>)*<2A>D<EFBFBD>&<26><1F>-rr<>r?c<00>,<00>|
r||_y|d
z|_y)Nr!)
r<>)rr<>r?s   r<00>_adjust_for_beforezCursor._adjust_for_befores<00><00><11>!"<22>D<EFBFBD><1E>!"<22>Q<EFBFBD><15>D<EFBFBD>rrc<00><><00>|jj|_|j<00>J<00>
d|_g|_||_d|_|
|_d|_|jjs<>|jj|
<01>
\}}|r6|j||<03>
|r|j<00>
y
|j<00>
y
|jj|j|f<02>

|jj||_|j<00>J<00>
|jjs
<01><>|jj|
<01>
\}}|r|j||<03>
y
||_y
)a<>
Seek to the specified key.

        If *before* is ``True`` (the default) then the cursor is positioned just
        before *key* if it exists, or before its least successor if it doesn't.  A
        subsequent next() will retrieve this value.  If *before* is ``False``, then
        the cursor is positioned just after *key* if it exists, or its greatest
        precessessor if it doesn't.  A subsequent prev() will return this value.
        NF)r<>r<>r<>r<>r<>r<>r<>r<>r<>r1rDr<>r<>r<>rir3r<>)rrr<>r?rAs     rr<>zCursor.seeksC
<00><00>!<21>J<EFBFBD>J<EFBFBD>O<EFBFBD>O<EFBFBD><04><19><13> <20> <20>,<2C>,<2C>,<2C><1C><04><0C><19><04><0C> <20><04><0F><1B><04><0B><1E><04><18> %<25><04><1D><16>#<23>#<23>+<2B>+<2B><1B>(<28>(<28>7<>7<><03><<3C>H<EFBFBD>A<EFBFBD>u<EFBFBD><14><14>'<27>'<27><06>
<01>2<><19><18>'<27>'<27>)<29><17><19>$<24>$<24>&<26><16><10>L<EFBFBD>L<EFBFBD><1F><1F><14>!2<>!2<>A<EFBFBD> 6<>7<> $<24> 1<> 1<> :<3A> :<3A>1<EFBFBD> =<3D>D<EFBFBD><1D><17>$<24>$<24>0<>0<>0<><17>#<23>#<23>+<2B>+<2B><18>$<24>$<24>3<>3<>C<EFBFBD>8<><08>
<01>5<EFBFBD><10><10>#<23>#<23>F<EFBFBD>A<EFBFBD>.<2E>!"<22>D<EFBFBD>rc
<00>f<00>d
|_d|_
d|_d|_g|_d|_d
|_y
)z<>Seek to the left boundary (i.e. just before the least element).

        A subsequent next() will return the least element if the BTree isn't empty.NrFT<46>r<>r<>r<>r<>r<>r<>r<>rs
 r<00>
seek_firstzCursor.seek_first?s8<00><00>!<21><04><19><1E><04><1A><1C><04><0C><1E><04><0F><19><04><0C><1B><04><0B><1F><04>rc
<00>f<00>d
|_d|_
d|_d|_g|_d|_d
|_y
)z<>Seek to the right boundary (i.e. just after the greatest element).

        A subsequent prev() will return the greatest element if the BTree isn't empty.
        Nr!Fr<46>rs
 r<00>	seek_lastzCursor.seek_lastKs8<00><00>
!<21><04><19><1E><04><1A><1C><04><0C><1F><04><0F><19><04><0C><1B><04><0B><1F><04>rc
<00><<00>|jj|<00>

|SrG)r<><00>register_cursorrs
 r<00>	__enter__zCursor.__enter__Xs<00><00><0C>
<EFBFBD>
<EFBFBD>"<22>"<22>4<EFBFBD>(<28><13>rc<00>:<00>|jj|<00>

y
r<>)r<><00>deregister_cursor)r<00>exc_type<70>	exc_value<75>	tracebacks    r<00>__exit__zCursor.__exit__\s<00><00><0C>
<EFBFBD>
<EFBFBD>$<24>$<24>T<EFBFBD>*<2A>r)r<>z
BTree[KT, ET]<5D>rN)
T)rrrrr6r<>r<>r<>r<>rr<>r<>r<>r<>r<>r
r<>r<>r<>r<>r<>rrrr<>r<>}
s<><00><00><08>&<26>#<23>=<3D>
<1F>$<24>&& <20>b<EFBFBD>4<EFBFBD>i<EFBFBD>& <20>P
& <20>b<EFBFBD>4<EFBFBD>i<EFBFBD>& <20>P
'<27><14>'<27>#<23>'<27>$<24>'<27>!#<23><02>!#<23>D<EFBFBD>!#<23>D<EFBFBD>!#<23>F

 <20> <20><14>rr<>c
<00><00>eZ
dZd
Zy)<03>	ImmutablezThe BTree is immutable.N)rrrrrrrr<>r<>as<00><00>!rr<>c<00>:
<00>eZ
dZd
Zedd<03>dededfd<06>Zd<07>Zdd	<09>Z	dd
e
dede
dzfd<0C>Zd
e
de
dzfd<0E>Zd
e
de
dzde
dzfd<10>Zd
e
de
dzfd<11>Zde
de
dzfd<13>Zd<14>Zdee
g
dfddfd<16>Zdeeg
dfddfd<17>Zdee
e
ffd<18>Zdeddfd<1A>Zdeddfd<1B>Zd<1C>Zd<1D>Zy) <20>BTreez2An in-memory BTree with copy-on-write and cursors.N<>r<00>originalrr<>c
<00>|
<00>t
<00>|_
d
|_|
|
|
t<00>|_|<02>K|jstd<03>
<00>
|j|_|j|_|j|_y|
dkrtd<05>
<00>
|
|_t|j|jd<06>|_d|_y)z<>Create a BTree.

        If *original* is not ``None``, then the BTree is shallow-cloned from
        *original* using copy-on-write.  Otherwise a new BTree with the specified
        *t* value is created.

        The BTree is not thread-safe.
        FNzoriginal BTree is not immutabler5zt must be >= 3Tr)
r(r0<00>
_immutable<EFBFBD>set<65>cursorsrwrr<><00>sizer.)rrr<>s   rr6zBTree.__init__hs<><00><00> <20>z<EFBFBD><04><0C><1F><04><0F><0C><0C><0C>$'<27>E<EFBFBD><04><0C><13><1F><1B>&<26>&<26> <20>!B<>C<>C<><1D>Z<EFBFBD>Z<EFBFBD>D<EFBFBD>F<EFBFBD> <20>
<0A>
<0A>D<EFBFBD>I<EFBFBD> <20>
<0A>
<0A>D<EFBFBD>I<EFBFBD><10>1<EFBFBD>u<EFBFBD> <20>!1<>2<>2<><16>D<EFBFBD>F<EFBFBD><1D>d<EFBFBD>f<EFBFBD>f<EFBFBD>d<EFBFBD>l<EFBFBD>l<EFBFBD>D<EFBFBD>9<>D<EFBFBD>I<EFBFBD><19>D<EFBFBD>Irc
<00>,<00>|jsd
|_yy)z<>Make the BTree immutable.

        Attempts to alter the BTree after making it immutable will raise an
        Immutable exception.  This operation cannot be undone.
        TN)
r<>rs
 r<00>make_immutablezBTree.make_immutable<6C>s<00><00><14><EFBFBD><EFBFBD>"<22>D<EFBFBD>O<EFBFBD>rrc
<00>j<00>|jrt<00>
|jD]}
|
j<00>
<00>yrG)r<>r<>r<>r<><00>r<00>cursors  r<00>_check_mutable_and_parkzBTree._check_mutable_and_park<72>s%<00><00><0F>?<3F>?<3F><1B>O<EFBFBD><1A>l<EFBFBD>l<EFBFBD>F<EFBFBD><12>K<EFBFBD>K<EFBFBD>M<EFBFBD>#rrfrVc<00><>
<00>|j
<00>
|jj|j<00>
}|r||_
|jj	<00>rY|j}t|j|jd
<01>|_
|jj|j<00><00>
|jj|
|<02>}|<05>|x
jdz
c_
|S)aE
Insert the element into the BTree.

        If *in_order* is ``True``, then extra work will be done to make left siblings
        full, which optimizes storage space when the the elements are inserted in-order
        or close to it.

        Returns the previously existing element at the element's key or ``None``.
        Fr!)r<>r<>rHr0r9r.rrYrZr[r<>)rrfrVrJ<00>old_rootr]s      r<00>insert_elementzBTree.insert_element<6E>s<><00><00>	
<0A>$<24>$<24>&<26><15><19><19>$<24>$<24>T<EFBFBD>\<5C>\<5C>2<><06><11><1E>D<EFBFBD>I<EFBFBD><0F>9<EFBFBD>9<EFBFBD><1F><1F>!<21><1B>y<EFBFBD>y<EFBFBD>H<EFBFBD><1D>d<EFBFBD>f<EFBFBD>f<EFBFBD>d<EFBFBD>l<EFBFBD>l<EFBFBD>E<EFBFBD>:<3A>D<EFBFBD>I<EFBFBD><1B>D<EFBFBD>I<EFBFBD>I<EFBFBD>O<EFBFBD>O<EFBFBD>X<EFBFBD>^<5E>^<5E>-<2D>.<2E><13>y<EFBFBD>y<EFBFBD>'<27>'<27><03>X<EFBFBD>6<><04><0F><<3C><10>I<EFBFBD>I<EFBFBD><11>N<EFBFBD>I<EFBFBD><13>rrc<00>8<00>|jj|
<01>
S)
zhGet the element matching *key* from the BTree, or return ``None`` if it
        does not exist.
        )r<>rP<00>rrs  r<00>get_elementzBTree.get_element<6E>s<00><00><14>y<EFBFBD>y<EFBFBD>}<7D>}<7D>S<EFBFBD>!<21>!rruc<00><>
<00>|j
<00>
|jj|j<00>
}|r||_
|jj	|
d|<02>}|<04><>|x
j
d
zc_t
|jj<00>
dk(rX|jjsBt
|jj<00>
d
k(sJ<00>
|jjd|_
|S)Nr!r)
r<EFBFBD>r<>rHr0rxr<>r8r2r1r3)rrrurJrfs     r<00>_deletez
BTree._delete<74>s<><00><00><0C>$<24>$<24>&<26><15><19><19>$<24>$<24>T<EFBFBD>\<5C>\<5C>2<><06><11><1E>D<EFBFBD>I<EFBFBD><12>i<EFBFBD>i<EFBFBD><1E><1E>s<EFBFBD>D<EFBFBD>%<25>0<><03><0E>?<3F><10>I<EFBFBD>I<EFBFBD><11>N<EFBFBD>I<EFBFBD><12>4<EFBFBD>9<EFBFBD>9<EFBFBD>><3E>><3E>"<22>a<EFBFBD>'<27><1C>y<EFBFBD>y<EFBFBD>(<28>(<28><1E>t<EFBFBD>y<EFBFBD>y<EFBFBD>1<>1<>2<>a<EFBFBD>7<>7<>7<> $<24>	<09>	<09> 2<> 2<>1<EFBFBD> 5<>D<EFBFBD>I<EFBFBD><12>
rc<00>&<00>|j
|
d
<01>S)z<>Delete the element matching *key* from the BTree.

        Returns the matching element or ``None`` if it does not exist.
        N)
r<>r<>s  r<00>
delete_keyzBTree.delete_key<65>s<00><00>
<14>|<7C>|<7C>C<EFBFBD><14>&<26>&rrUc<00>R<00>|j
|
j<00>|
<01>}||
usJ<00>
|S)
zwDelete *element* from the BTree.

        Returns the matching element or ``None`` if it was not in the BTree.
        )r<>r)rrU<00>delts   r<00>delete_exactzBTree.delete_exact<63>s+<00><00>
<14>|<7C>|<7C>G<EFBFBD>K<EFBFBD>K<EFBFBD>M<EFBFBD>7<EFBFBD>3<><04><13>w<EFBFBD><EFBFBD><1E><EFBFBD><13>rc

<00><00>|jSrG)
r<>rs
 r<00>__len__z
BTree.__len__<5F><00><00><00><13>y<EFBFBD>y<EFBFBD>rr|c<00>:<00>|jj|
<01>

y
)zBCall *visit*(element) on all elements in the tree in sorted order.N)r<>r<00>rr|s  rrzBTree.visit_in_order<65>s<00><00><0C>	<09>	<09> <20> <20><15>'rc<00>:<00>|jj|
<01>

yrG)r<>r<>r<>s  rr<>zBTree._visit_preorder_by_node<64>s<00><00><0C>	<09>	<09>)<29>)<29>%<25>0rc
<00><00>t
|<00>
S)
zCreate a cursor.)
r<>rs
 rr<>zBTree.cursor<6F>s<00><00><15>d<EFBFBD>|<7C>rr<>c<00>:<00>|jj|
<01>

y
)z4Register a cursor for the automatic parking service.N)r<><00>addr<64>s  rr<>zBTree.register_cursor<6F>s<00><00><0C><0C><0C><18><18><16> rc<00>:<00>|jj|
<01>

y
)z7Deregister a cursor from the automatic parking service.N)r<><00>discardr<64>s  rr<>zBTree.deregister_cursor<6F>s<00><00><0C><0C><0C><1C><1C>V<EFBFBD>$rc
<00>&<00>|j
|<00>
<01>
S)N)
r<><00>
r_rs
 r<00>__copy__zBTree.__copy__<5F>s<00><00><13>~<7E>~<7E>t<EFBFBD>~<7E>,<2C>,rc
#<00><>K
<00>|j
<00>5}
	|
j<00>}|<02>
n|j<00><00><02>

<00>&	ddd<00>
y#1s
w
Y

yxYw
<01>w
rG)r<>r<>r)rr<>rfs   r<00>__iter__zBTree.__iter__<5F>sE<00><00><><00>
<11>[<5B>[<5B>]<5D>f<EFBFBD><16><1C>k<EFBFBD>k<EFBFBD>m<EFBFBD><03><16>;<3B><19><19>g<EFBFBD>g<EFBFBD>i<EFBFBD><0F>	<17><1A>	<1B>]<5D>]<5D>s<00>A
<01>(A<03>	A
<01>A<07>
A
r<>)
F)rrrr<00>	DEFAULT_Tr<54>rr6r<>r<>rr<>r<>r
r<>r<>r<>r<>r<>rrr.r<>r<>r<>r<>r<>r<>r<>rrrr<>r<>es6
<00><00><<3C>#,<2C>D<EFBFBD><1A>S<EFBFBD><1A><08><17>8I<38><1A><#<23><1A><14>"<22><14><04><14><12>d<EFBFBD><19><14>."<22>r<EFBFBD>"<22>b<EFBFBD>4<EFBFBD>i<EFBFBD>"<22><13>2<EFBFBD><13>b<EFBFBD>4<EFBFBD>i<EFBFBD><13>B<EFBFBD><14>I<EFBFBD><13>"'<27>b<EFBFBD>'<27>R<EFBFBD>$<24>Y<EFBFBD>'<27><14>B<EFBFBD><14>2<EFBFBD><04>9<EFBFBD><14>
<19>(<28>H<EFBFBD>b<EFBFBD>T<EFBFBD>4<EFBFBD>Z<EFBFBD>$8<>(<28>T<EFBFBD>(<28>
1<>X<EFBFBD>u<EFBFBD>g<EFBFBD>t<EFBFBD>m<EFBFBD>-D<>
1<><14>
1<><1C><06>r<EFBFBD>2<EFBFBD>v<EFBFBD><0E><1C>!<21>f<EFBFBD>!<21><14>!<21>%<25><06>%<25>4<EFBFBD>%<25>
-<2D> rr<><00>VTc<00>D<00>eZ
dZd
Zdedefd<04>Zdefd<06>Zdefd<07>Zd<08>Z	d	<09>Z
y
)<0B>KVz/The BTree element type used in a ``BTreeDict``.r<00>valuec<00> <00>|
|_||_
yrG<00><02>_key<65>_value)rrr<>s   rr6zKV.__init__<5F>s<00><00><17><04>	<09><1B><04>rrc

<00><00>|jSrG<00>
r<>rs
 rrzKV.keyr<>rc

<00><00>|jSrG)
r<>rs
 rr<>zKV.values<00><00><13>{<7B>{<7B>rc
<00><<00>d
|j<00>d|j<00>d<03>S<00>NzKV(z, <20>
)r<>rs
 rr,z
KV.__str__	<00><00><00><14>T<EFBFBD>Y<EFBFBD>Y<EFBFBD>K<EFBFBD>r<EFBFBD>$<24>+<2B>+<2B><1D>a<EFBFBD>0<>0rc
<00><<00>d
|j<00>d|j<00>d<03>Sr<>r<>rs
 r<00>__repr__zKV.__repr__r<>rN)rrrrr
r<>r6rr<>r,r<>rrrr<>r<><00>s:<00><00>9<><1C>B<EFBFBD><1C>r<EFBFBD><1C>
<19>R<EFBFBD>
<19>
<1B>r<EFBFBD>
<1B>
1<>
1rr<>c<00>t<00><00>eZ
dZd
Zeddd<04>dededzdef<06>f
d<08>Zd	e	d
e
fd<0B>Zd	e	de
d
dfd
<0A>Zd	e	d
dfd<0E>Z
<0A>x
ZS)<0F>	BTreeDictzA MutableMapping implemented with a BTree.

    Unlike a normal Python dict, the BTreeDict may be mutated while iterating.
    NF<4E>rr<>rVrr<>rVc
<00>6<00>
<01>t<00>|<00>|
|<02>
<01>
||_y<00>Nr<4E><00><03>superr6rV<00>rrr<>rVr_s    <20>rr6zBTreeDict.__init__<00><00><><00>	<0E><07><18>1<EFBFBD>x<EFBFBD><18>0<> <20><04>
rrrc<00>p<00>|j
|
<01>
}|<02>t<00>
tt|<02>j	<00>SrG)r<><00>KeyErrorrr<>r<>)rrrfs   r<00>__getitem__zBTreeDict.__getitem__ s1<00><00><12><1E><1E>s<EFBFBD>#<23><03><0E>;<3B><1A>N<EFBFBD><17><02>C<EFBFBD>=<3D>&<26>&<26>(<28>(rr<>c<00>T<00>t
|
|<02>}|j||j<00>
yrG)r<>r<>rV)rrr<>rfs    r<00>__setitem__zBTreeDict.__setitem__'s!<00><00><10><13>e<EFBFBD>n<EFBFBD><03><0C><1B><1B>C<EFBFBD><14><1D><1D>/rc<00>2<00>|j
|
<01>
<00>t<00>
yrG)r<>r
r<>s  r<00>__delitem__zBTreeDict.__delitem__+s<00><00><0F>?<3F>?<3F>3<EFBFBD><1F>'<27><1A>N<EFBFBD>(r)rrrrr<>r<>r<>r<>r6r
r<>r
r

r
<00>
__classcell__r<5F>s
@rr<>r<>sz<00><><00><08><1B>!%<25><1E>!<21><0F>!<21><18>$<24>,<2C>	!<21>
<17>!<21>)<29>r<EFBFBD>)<29>b<EFBFBD>)<29>0<>r<EFBFBD>0<>"<22>0<><14>0<><1B>r<EFBFBD><1B>d<EFBFBD>rr<>c<00>(<00>eZ
dZd
Zdefd<03>Zdefd<05>Zy)<07>Memberz.The BTree element type used in a ``BTreeSet``.rc<00><00>|
|_yrGr<>r<>s  rr6zMember.__init__3s	<00><00><17><04>	rrc

<00><00>|jSrGr<>rs
 rrz
Member.key6r<>rN)rrrrr
r6rrrrr
r
0s<00><00>8<>
<18>B<EFBFBD>
<18>
<19>R<EFBFBD>
rr
c<00>p<00><00>eZ
dZd
Zeddd<04>dededzdef<06>f
d<08>Zd	e	d
efd<0B>Z
ded
dfd
<0A>Zded
dfd<0E>Z
<0A>x
ZS)<0F>BTreeSetzyA MutableSet implemented with a BTree.

    Unlike a normal Python set, the BTreeSet may be mutated while iterating.
    NFr<46>rr<>rVc
<00>6<00>
<01>t<00>|<00>|
|<02>
<01>
||_yr

r
r
s    <20>rr6zBTreeSet.__init__@r
rrrc<00>(<00>|j
|
<01>
du
SrG)
r<>r<>s  r<00>__contains__zBTreeSet.__contains__Js<00><00><13><1F><1F><03>$<24>D<EFBFBD>0<>0rr<>c<00>R<00>t
|
<01>
}|j||j<00>
yrG)r
r<>rV)rr<>rfs   rr<>zBTreeSet.addMs<00><00><14>U<EFBFBD>m<EFBFBD><03><0C><1B><1B>C<EFBFBD><14><1D><1D>/rc<00>&<00>|j
|
<01>

yrG)
r<>)rr<>s  rr<>zBTreeSet.discardQs<00><00><0C><0F><0F><05>r)rrrrr<>r<>r<>r<>r6rr
r
r<>r<>r

r<>s
@rr
r
:ss<00><><00><08><1B>!%<25><1E>!<21><0F>!<21><18>$<24>,<2C>	!<21>
<17>!<21>
1<><03>
1<><04>
1<>0<><12>0<><04>0<>
<1F>R<EFBFBD>
<1F>D<EFBFBD>
rr
N)r<00>collections.abcrr<00>typingrrrrr	r
rr<>r
rrr<>r#r&r(r.r<><00>	Exceptionr<6E>r<>r<>r<>r<>r
r
rrr<00><module>r

sE
<00>


<01>
<04>
7<>I<>I<>I<><0F>	<09><0C>T<EFBFBD>]<5D><02>
"<22>g<EFBFBD>b<EFBFBD>k<EFBFBD>
"<22>
<0A>T<EFBFBD><17>!<21><02>
<11>C<EFBFBD>
<11>C<EFBFBD>
<11>
<15>C<EFBFBD>
<15>C<EFBFBD>
<15>
	
<1F>	
<1F>F
D
<01>G<EFBFBD>B<EFBFBD><02>F<EFBFBD>O<EFBFBD>F
D
<01>R
a
<15>W<EFBFBD>R<EFBFBD><12>V<EFBFBD>_<EFBFBD>a
<15>H

"<22>	<09>

"<22>Q
 <20>G<EFBFBD>B<EFBFBD><02>F<EFBFBD>O<EFBFBD>Q
 <20>h
<0A>T<EFBFBD>]<5D><02>
1<><17>'<27>"<22>b<EFBFBD>&<26>/<2F>
1<>(
<1B><07><02>B<EFBFBD><06><0F><15>r<EFBFBD>2<EFBFBD>b<EFBFBD>"<22>f<EFBFBD>:<3A>~<7E>!6<><0E>r<EFBFBD>2<EFBFBD>v<EFBFBD>8N<38>
<1B>@

<19>W<EFBFBD>g<EFBFBD>b<EFBFBD>k<EFBFBD>
<19>
<1F>u<EFBFBD>g<EFBFBD>b<EFBFBD>k<EFBFBD>:<3A>b<EFBFBD>><3E>
r