�
1�3\c@@su
dZd
dl
mZ
d
dlZd
dlZd
dlZddlmZ
ddlm	Z	
ddl
mZmZ
dd	l
mZ
dd
lmZmZ
dZdef
d��YZddd
�Zdd�
Zddd
d�Zdd�
Zdd�
Zd�Zejdede�def
d��Y�
Zd�Zd�Z d�Z!d�Z"d�Z#def
d��YZ$dS(s4Helper class to compute deltas stored inside revlogsi(
tabsolute_importNi(
tnullrev(
t
_i
(tREVIDX_ISCENSOREDtREVIDX_RAWTEXT_CHANGING_FLAGS(
tattr(terrortmdifft_testrevlogcB@sAeZ
dZd
dd�Zd�Zd�Zd�Zd�ZRS(s)minimalist fake revlog to use in doctestsg�?icC@s|
|_||_
||_d
S(s.data is an list of revision payload boundariesN(t_datat_srdensitythresholdt
_srmingapsize(tselftdatatdensitytmingap((sB/usr/lib64/python2.7/site-packages/mercurial/revlogutils/deltas.pyt__init__*s	
	
cC@s|
d
krd
S|j|
dS(Nii
(
R	(Rtrev((sB/usr/lib64/python2.7/site-packages/mercurial/revlogutils/deltas.pytstart0s


cC@s|j|
S(
N(
R	(RR((sB/usr/lib64/python2.7/site-packages/mercurial/revlogutils/deltas.pytend5s
cC@s|j|
�
|j
|
�
S(
N(RR(RR((sB/usr/lib64/python2.7/site-packages/mercurial/revlogutils/deltas.pytlength8s
c

C@s
t|j
�
S(
N(tlenR	(
R((sB/usr/lib64/python2.7/site-packages/mercurial/revlogutils/deltas.pyt__len__;s
(t__name__t
__module__t__doc__RRRRR(((sB/usr/lib64/python2.7/site-packages/mercurial/revlogutils/deltas.pyR's
			cc@s�|dk	r!t
||j�}n|dkp6|dksQd
}tj|�
�
nxHt||
||j|j�D](}xt|||�D]}|V
q�WqpWdS(s�slice revs to reduce the amount of unrelated data to be read from disk.

    ``revs`` is sliced into groups that should be read in one time.
    Assume that revs are sorted.

    The initial chunk is sliced until the overall density (payload/chunks-span
    ratio) is above `revlog._srdensitythreshold`. No gap smaller than
    `revlog._srmingapsize` is skipped.

    If `targetsize` is set, no chunk larger than `targetsize` will be yield.
    For consistency with other slicing choice, this limit won't go lower than
    `revlog._srmingapsize`.

    If individual revisions chunk are larger than this limit, they will still
    be raised individually.

    >>> revlog = _testrevlog([
    ...  5,  #00 (5)
    ...  10, #01 (5)
    ...  12, #02 (2)
    ...  12, #03 (empty)
    ...  27, #04 (15)
    ...  31, #05 (4)
    ...  31, #06 (empty)
    ...  42, #07 (11)
    ...  47, #08 (5)
    ...  47, #09 (empty)
    ...  48, #10 (1)
    ...  51, #11 (3)
    ...  74, #12 (23)
    ...  85, #13 (11)
    ...  86, #14 (1)
    ...  91, #15 (5)
    ... ])

    >>> list(slicechunk(revlog, list(range(16))))
    [[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]]
    >>> list(slicechunk(revlog, [0, 15]))
    [[0], [15]]
    >>> list(slicechunk(revlog, [0, 11, 15]))
    [[0], [11], [15]]
    >>> list(slicechunk(revlog, [0, 11, 13, 15]))
    [[0], [11, 13, 15]]
    >>> list(slicechunk(revlog, [1, 2, 3, 5, 8, 10, 11, 14]))
    [[1, 2], [5, 8, 10, 11], [14]]

    Slicing with a maximum chunk size
    >>> list(slicechunk(revlog, [0, 11, 13, 15], targetsize=15))
    [[0], [11], [13], [15]]
    >>> list(slicechunk(revlog, [0, 11, 13, 15], targetsize=20))
    [[0], [11], [13, 15]]
    s*cannot use `targetsize` with a `deltainfo`N(tNonetmaxRRtProgrammingErrort_slicechunktodensityR
t_slicechunktosize(trevlogtrevst	deltainfot
targetsizetmsgtchunktsubchunk((sB/usr/lib64/python2.7/site-packages/mercurial/revlogutils/deltas.pyt
slicechunk>s5








cc@s�|d
ks!t
||
�|k
r*|
V
d
Sd}|j|
d�
}d}t|
�
}t|�

x~|D]v\}}|j|�
|}	|	|k
r�|}qft||
||d�}
|
r�|
V
n|}|j|�
}|}qfWt||
|�V
d
S(s�slice revs to match the target size

    This is intended to be used on chunk that density slicing selected by that
    are still too large compared to the read garantee of revlog. This might
    happens when "minimal gap size" interrupted the slicing or when chain are
    built in a way that create large blocks next to each other.

    >>> revlog = _testrevlog([
    ...  3,  #0 (3)
    ...  5,  #1 (2)
    ...  6,  #2 (1)
    ...  8,  #3 (2)
    ...  8,  #4 (empty)
    ...  11, #5 (3)
    ...  12, #6 (1)
    ...  13, #7 (1)
    ...  14, #8 (1)
    ... ])

    Cases where chunk is already small enough
    >>> list(_slicechunktosize(revlog, [0], 3))
    [[0]]
    >>> list(_slicechunktosize(revlog, [6, 7], 3))
    [[6, 7]]
    >>> list(_slicechunktosize(revlog, [0], None))
    [[0]]
    >>> list(_slicechunktosize(revlog, [6, 7], None))
    [[6, 7]]

    cases where we need actual slicing
    >>> list(_slicechunktosize(revlog, [0, 1], 3))
    [[0], [1]]
    >>> list(_slicechunktosize(revlog, [1, 3], 3))
    [[1], [3]]
    >>> list(_slicechunktosize(revlog, [1, 2, 3], 3))
    [[1, 2], [3]]
    >>> list(_slicechunktosize(revlog, [3, 5], 3))
    [[3], [5]]
    >>> list(_slicechunktosize(revlog, [3, 4, 5], 3))
    [[3], [5]]
    >>> list(_slicechunktosize(revlog, [5, 6, 7, 8], 3))
    [[5], [6, 7, 8]]
    >>> list(_slicechunktosize(revlog, [0, 1, 2, 3, 4, 5, 6, 7, 8], 3))
    [[0], [1, 2], [3], [5], [6, 7, 8]]

    Case with too large individual chunk (must return valid chunk)
    >>> list(_slicechunktosize(revlog, [0, 1], 2))
    [[0], [1]]
    >>> list(_slicechunktosize(revlog, [1, 3], 1))
    [[1], [3]]
    >>> list(_slicechunktosize(revlog, [3, 4, 5], 2))
    [[3], [5]]
    Nii
(RtsegmentspanRt	enumeratetnextRt
_trimchunk(RR R"tstartrevidxt	startdatat	endrevidxtiterrevstidxt
rtspanR$((sB/usr/lib64/python2.7/site-packages/mercurial/revlogutils/deltas.pyR�s&7!










	






g�?c#@s�|j}|j
�t|
�
d
k
r-|
V
dSt|�
}|j|d
�
}|dkr�t||
�}t�f
d�|
D�
�
}	n|j}|j}	||kr�|
V
dS|}
|r�|	t	|�
}nd}||kr�|
V
dS|dk	r
|j
r
t|
�
}
|
j|�

ng}t
j|�

d}
x�t|
�
D]�\}}||krq
||�
}�|�
}n|}|j
}|dkr�
q>
n|
dk	r�
||
}||kr�
t
j|||f�
q�
n||}
q>
Wg}t
j|�

xk|r_||kr_t
j|�
\}}t
j||�
|
|8}
|
dkrV|	t	|
�
}q�
d}q�
Wd}xB|r�t
j|�
}t||
||�}|r�|V
n|}qiWt||
|�}|r�|V
ndS(sslice revs to reduce the amount of unrelated data to be read from disk.

    ``revs`` is sliced into groups that should be read in one time.
    Assume that revs are sorted.

    ``deltainfo`` is a _deltainfo instance of a revision that we would append
    to the top of the revlog.

    The initial chunk is sliced until the overall density (payload/chunks-span
    ratio) is above `targetdensity`. No gap smaller than `mingapsize` is
    skipped.

    >>> revlog = _testrevlog([
    ...  5,  #00 (5)
    ...  10, #01 (5)
    ...  12, #02 (2)
    ...  12, #03 (empty)
    ...  27, #04 (15)
    ...  31, #05 (4)
    ...  31, #06 (empty)
    ...  42, #07 (11)
    ...  47, #08 (5)
    ...  47, #09 (empty)
    ...  48, #10 (1)
    ...  51, #11 (3)
    ...  74, #12 (23)
    ...  85, #13 (11)
    ...  86, #14 (1)
    ...  91, #15 (5)
    ... ])

    >>> list(_slicechunktodensity(revlog, list(range(16))))
    [[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]]
    >>> list(_slicechunktodensity(revlog, [0, 15]))
    [[0], [15]]
    >>> list(_slicechunktodensity(revlog, [0, 11, 15]))
    [[0], [11], [15]]
    >>> list(_slicechunktodensity(revlog, [0, 11, 13, 15]))
    [[0], [11, 13, 15]]
    >>> list(_slicechunktodensity(revlog, [1, 2, 3, 5, 8, 10, 11, 14]))
    [[1, 2], [5, 8, 10, 11], [14]]
    >>> list(_slicechunktodensity(revlog, [1, 2, 3, 5, 8, 10, 11, 14],
    ...                           mingapsize=20))
    [[1, 2, 3, 5, 8, 10, 11], [14]]
    >>> list(_slicechunktodensity(revlog, [1, 2, 3, 5, 8, 10, 11, 14],
    ...                           targetdensity=0.95))
    [[1, 2], [5], [8, 10, 11], [14]]
    >>> list(_slicechunktodensity(revlog, [1, 2, 3, 5, 8, 10, 11, 14],
    ...                           targetdensity=0.95, mingapsize=12))
    [[1, 2], [5, 8, 10, 11], [14]]
    i
Nc
3@s|]}
�|
�
V
qdS(
N((t.0R0(
R(sB/usr/lib64/python2.7/site-packages/mercurial/revlogutils/deltas.pys	<genexpr>
sg�?i(RRRRRR'tsumtdistancetcompresseddeltalentfloattdeltalentlisttappendtheapqtheapifyR(theappushtheappopR*(RR R!t
targetdensityt
mingapsizeRtnextrevt
nextoffsettdeltachainspantchainpayloadtreaddataRtgapsheaptprevendt
iRtrevstarttrevlentgapsizetindicesheapt
oppgapsizetgapidxtprevidxR/R$((
RsB/usr/lib64/python2.7/site-packages/mercurial/revlogutils/deltas.pyR�sx5	
	




	
	














	











	





cC@s�|j}|dkr$t|
�
}n|
|d
t|�
kr�xC|d
kr�||kr�||
|d
�
dkr�|d
8}qAWn|
||!S(s�returns revs[startidx:endidx] without empty trailing revs

    Doctest Setup
    >>> revlog = _testrevlog([
    ...  5,  #0
    ...  10, #1
    ...  12, #2
    ...  12, #3 (empty)
    ...  17, #4
    ...  21, #5
    ...  21, #6 (empty)
    ... ])

    Contiguous cases:
    >>> _trimchunk(revlog, [0, 1, 2, 3, 4, 5, 6], 0)
    [0, 1, 2, 3, 4, 5]
    >>> _trimchunk(revlog, [0, 1, 2, 3, 4, 5, 6], 0, 5)
    [0, 1, 2, 3, 4]
    >>> _trimchunk(revlog, [0, 1, 2, 3, 4, 5, 6], 0, 4)
    [0, 1, 2]
    >>> _trimchunk(revlog, [0, 1, 2, 3, 4, 5, 6], 2, 4)
    [2]
    >>> _trimchunk(revlog, [0, 1, 2, 3, 4, 5, 6], 3)
    [3, 4, 5]
    >>> _trimchunk(revlog, [0, 1, 2, 3, 4, 5, 6], 3, 5)
    [3, 4]

    Discontiguous cases:
    >>> _trimchunk(revlog, [1, 3, 5, 6], 0)
    [1, 3, 5]
    >>> _trimchunk(revlog, [1, 3, 5, 6], 0, 2)
    [1]
    >>> _trimchunk(revlog, [1, 3, 5, 6], 1, 3)
    [3, 5]
    >>> _trimchunk(revlog, [1, 3, 5, 6], 1)
    [3, 5]
    i
iN(RRR(RR tstartidxtendidxR((sB/usr/lib64/python2.7/site-packages/mercurial/revlogutils/deltas.pyR*_
s&	



cC@s�|
s
d
S|dk	rnt
|�
|
dk
rnt
|
�
dkrE|jS|jt
|�
d�
}|j|}n|j|
d�
}||j|
d
�
S(s�
Get the byte span of a segment of revisions

    revs is a sorted array of revision numbers

    >>> revlog = _testrevlog([
    ...  5,  #0
    ...  10, #1
    ...  12, #2
    ...  12, #3 (empty)
    ...  17, #4
    ... ])

    >>> segmentspan(revlog, [0, 1, 2, 3, 4])
    17
    >>> segmentspan(revlog, [0, 4])
    17
    >>> segmentspan(revlog, [3, 4])
    5
    >>> segmentspan(revlog, [1, 2, 3,])
    7
    >>> segmentspan(revlog, [1, 3])
    7
    ii����i
N(RRR7RR(RR R!toffsetR((sB/usr/lib64/python2.7/site-packages/mercurial/revlogutils/deltas.pyR'�
s

"




c
C@s
tj
d
�
}|| tj|
j|�
t|�
|�krK||}	n-|
j|d|dt�
}
tj|
|�}	yv|
j	|	|ddt
�
}|\}	}|r�|
j|	|d|d|�
n|t@r�t
jtd�
|�
�
nWn$t
jk
r



|t@s
�q
n
X|	S(s<build full text from a (base, delta) pair and other metadatas>lllt_dftrawtreadtp1tp2snode %s is not censored(tstructtcalcsizeRtreplacediffheadertrawsizeRtrevisiontFalsetpatcht
_processflagstTruet	checkhashRRtStorageErrorRtCensoredNodeError(
tfhRtbaserevtdeltaRURVtflagstexpectednodethlentfulltexttbasetexttrestvalidatehash((sB/usr/lib64/python2.7/site-packages/mercurial/revlogutils/deltas.pyt_textfromdelta�
s$

















tslotstfrozent
_deltainfoc
B@sheZ
ej�Zej�Zej�Zej�Zej�Zej�Z	ej�Z
ej�ZRS((RRRtibR4R7R
tbaset	chainbasetchainlenR5t
snapshotdepth(((sB/usr/lib64/python2.7/site-packages/mercurial/revlogutils/deltas.pyRp�
s






cC@s�
|
dkrt
S|jr�|
j}|tkrD|j|�
d
}ng}x-t|�
D]\}}|j|�
sWPqWqWW||}t|||
�}g|D]}t	|||
�^q�}	t
|	�
}
n	|
j}
|j}|d}|j
}
|
s�|
}
nt
|
|�}
|jr1
|
|jkr1
|j}
n|
|
krA
t
S||
jkrT
t
S|t|
jkrk
t
S|jr�
|j|
jkr�
t
S|
jdk	r�
||
j?|
jkr�
t
S|
jr�
|j|
j�
|
jkr�
t
StS(s�Returns True if the given delta is good. Good means that it is within
    the disk span, disk size, and chain length bounds that we know to be
    performant.iiN(RR\t
_sparserevlogRrR
t_deltachainR(t
issnapshotR&R'RR4ttextlent_maxdeltachainspanRR7tLIMIT_DELTA2TEXTR5t_maxchainlenRtRuRR_(RR!trevinfoRrt
deltachainR/R0tchunksR tall_spanR4Ryt
defaultmaxtmaxdist((sB/usr/lib64/python2.7/site-packages/mercurial/revlogutils/deltas.pytisgooddeltainfo�
sP
		







"
		


	

	




	



	

cc@s�
t|�
o|j
sd
V
d
S|j}|j}d
}|
t}ttg
�
}	t||||�}
x
t	r|
|
j
|�
}|d
kr�Png}x�|D]�}
xK|jr�|
tkp�|
|	kp�||
�
r�|	j|
�

||
�
}
q�W|
|	kr�q�n|	j|
�

||j|
�
kr'
q�n|
tkr9
q�n|j
|
�
t@rR
q�n|j|
�

q�W|rgt|�
V}qgqgWd
V
d
S(s�Provides group of revision to be tested as delta base

    This top level function focus on emitting groups with unique and worthwhile
    content. See _raw_candidate_groups for details about the group order.
    N(Rt_storedeltachainsRRtdeltaparentR{tsetR
t_refinedgroupsR_tsendt
_generaldeltataddRfRR9ttuple(RRyRURVt
cachedeltatdeltalengthR�tgoodtdeltas_limitttestedt
candidatest
temptativetgroupR((sB/usr/lib64/python2.7/site-packages/mercurial/revlogutils/deltas.pyt_candidategroups:sD

	
	



	





















cC@sV|j}|j
}x=|j|�
D],}||�
r"|
||�
j|�

q"q"Wd
S(s#find snapshot from start_rev to tipN(R�RxR R9(Rtcachet	start_revR�RxR((sB/usr/lib64/python2.7/site-packages/mercurial/revlogutils/deltas.pyt_findsnapshotsps
	
	


c
c@sw
d}|rD|j
rD|jrD|d
f
V}|dk	rDdV
dSnx4t||
||�D]}|V}|dk	rZPqZqZW|js�dV
dS|dk	rn
||
|fkrn
|j|�
rn
d}x?||kr

|}|j|�
}|tkr�Pn|f
V}q�Wtj	t
�
}t|||d�
d}x@||krj
|}tt
d�||D�
�
�
}	|	V}q.
WndV
dS(Nii
c
s@s|]}
|
V
qdS(
N((R2t
c((sB/usr/lib64/python2.7/site-packages/mercurial/revlogutils/deltas.pys	<genexpr>�s(RR�t_lazydeltabaset
_rawgroupsRvRxR�R
tcollectionstdefaultdictR8R�R�tsorted(
RRURVR�R�R�tpreviousRrt	snapshotstchildren((sB/usr/lib64/python2.7/site-packages/mercurial/revlogutils/deltas.pyR�xs:







	

-










 
c#@sX�j}�j
}t��
}|d
}�f
d�}|r�g|
|fD]}	|	tkrJ|	^qJ}
�jr�t|
�
dkr�|
j�
|
d
f
V
|
df
V
q�t|
�
dkr�|
V
q�n|rC|
rCtjt�
}tjt	�
}g|
D]}	||	�
^q�}
xO|
D]G}x>t
|�
D]0\}}�j|�
sH
Pn||j|�

q)
Wq
Wt
|d�
d
}t�||�
t	�}x|
D]}|j|�

q�
Wd}x0�j||�D]}||kr�
|}Pq�
q�
W|dk	rut|j��
}||�
}xct
|�
D]R\}}||kr:qn||krJPn�j|�
s]Pn||j|�

qWnd}x�t|j�dt�

D]�\}}t	�}x|D]}|j||�

q�W|dk	r�g|D]}||kr�|^q�}ntt|�
�
V
tt|�
�
V
t
|�
}q�Wt|t�
V
n|sT|f
V
ndS(s�Provides group of revision to be tested as delta base

    This lower level function focus on emitting delta theorically interresting
    without looking it any practical details.

    The group order aims at providing fast or small candidates first.
    i
c

@s�j|�
d
S(Ni(
Rw(
R(
R(sB/usr/lib64/python2.7/site-packages/mercurial/revlogutils/deltas.pyt<lambda>�tiitreverseN(R�RvRR
t_deltabothparentstsortR�R�R8R�R(RxR�tminR�tupdateRR RtkeysR�titemsR_R�(RRURVR�tgdeltatsparsetcurrtprevR~t
ptparentsR�t
parents_snapstcandidate_chainstchainR/t
st	snapfloortall_revstotherR0t	max_depthtfloortsnapstsiblings((
RsB/usr/lib64/python2.7/site-packages/mercurial/revlogutils/deltas.pyR��sp	
	



+












		


















%
	



(

	t
deltacomputerc
B@s>eZ
d�Zd
�Zd�Zd�Zd�Zd�ZRS(cC@s
|
|_dS(
N(
R(RR((sB/usr/lib64/python2.7/site-packages/mercurial/revlogutils/deltas.pyR!s
c		C@s�|
j}|d
dk	r!|d
S|j}|
j}|d
}|d}t|||||
j|
j|
j|
j�}|d
<|S(s�Builds a fulltext version of a revision

        revinfo: _revisioninfo instance that contains all needed info
        fh:      file handle to either the .i or the .d revlog file,
                 depending on whether it is inlined or not
        ii
N(	tbtextRRR�RmRURVRftnode(	RR}RcR�RR�RdReRi((sB/usr/lib64/python2.7/site-packages/mercurial/revlogutils/deltas.pyt	buildtext$s	

	
	






c	C@s�|j}|j
||�}|j|
�
rXtj|j|
�
t|�
�}||}n-|j|
d
|dt�
}tj	||�}|S(NRRRS(
RR�t
iscensoredRRYRZRR[R_ttextdiff(	RRrR}RcRt
ttheaderRetptext((sB/usr/lib64/python2.7/site-packages/mercurial/revlogutils/deltas.pyt_builddeltadiff9s
	

!


c	C@s*d}|
j
r�|
j
\}}|}xF|tkrl||krl|jj|�
d
krl|jj|�
}q'W||kr�|
j
d}q�n|dkr�|j||
|�}n|j}|j|�
\}	}
t|	�
t|
�
}|j	|�
}|j
t|�
d�
}
||
|j|�
}|jr5
|}n|}|j
|�
\}}|d7}||7}|j}d}|tkr�
d
}n}|jr|j|�
r|j|
j�
|j|
j�
}}|||fkr|j|�
rt|j|�
d
�
}qnt|||	|
f|||||�S(Nii
(RR�R
RRR�R�tcompressRRsRRR�t
_chaininfoRvRxRRURVRwRp(RR}RrRcRet	cachebaset	cachedifftcurrentbaseRR�R
R7RsRQtdistt	deltabaseRtR5RuRURV((sB/usr/lib64/python2.7/site-packages/mercurial/revlogutils/deltas.pyt_builddeltainfoGsF
	









	





	
	




	


	
%
!

	
c
	C@s�t|j
�
}|j||
�}|j
j|�
}t|d
�
t|d�
}}}|}	}
d}d
}t||||	|
|||�S(Ni
i(RRR�R�Rp(
RRcR}R�trawtextR
R5R7R�R�RsRuRt((sB/usr/lib64/python2.7/site-packages/mercurial/revlogutils/deltas.pyt_fullsnapshotinfoss



&




	
cC@s�
|
js|j
||
�S|
jt@r6|j
||
�S|
j}|
j}|
j}|j}d}|j	|�
|j	|�
}}	t
|j|
j||	|�}
t|
�
}x�|dk	rs
g}|dk	r�|j|�

nxH|D]@}
|j
|
|
|�}t|j||
�r�|j|�

q�q�W|rC
t|d
d��

}n|dk	rd
|
j|j�
}q�t|
�
}q�W|dkr�
|j
||
�}n|S(s�
Find an acceptable delta against a candidate revision

        revinfo: information about the revision (instance of _revisioninfo)
        fh:      file handle to either the .i or the .d revlog file,
                 depending on whether it is inlined or not

        Returns the first acceptable candidate revision, as ordered by
        _candidategroups

        If no suitable deltabase is found, we return delta info for a full
        snapshot.
        tkeyc


S@s|jS(
N(
R7(
t
x((sB/usr/lib64/python2.7/site-packages/mercurial/revlogutils/deltas.pyR��R�N(RyR�RfRR�RURVRRRR�R)R9R�R�R�R�Rr(RR}RcR�RURVRR!tp1rtp2rtgroupst
candidaterevstnominateddeltastcandidaterevtcandidatedelta((sB/usr/lib64/python2.7/site-packages/mercurial/revlogutils/deltas.pyt
finddeltainfo�s:
	


	
	
	
	

















(RRRR�R�R�R�R�(((sB/usr/lib64/python2.7/site-packages/mercurial/revlogutils/deltas.pyR� s
				,	
(%Rt
__future__RR�R:RWR�R
ti18nRt	constantsRRt
thirdpartyRR�RRR{tobjectRRR&RRR*R'RmR�R_RpR�R�R�R�R�R�(((sB/usr/lib64/python2.7/site-packages/mercurial/revlogutils/deltas.pyt<module>s4

DM
�5#	

	[	6		3	u