VĻ`w%ATddlZddlZddlmZddlmZddlmZm Z m Z m Z ddl m Z ddlmZmZe j$dZd Zd Zd Zd(d Zd(d ZdZdZdZdZdZdZdZdZ dZ!dZ"dZ#dZ$dZ%dZ&d)dZ'dZ(dZ)d(dZ*dZ+dZ,d Z-Gd!d"Z.d#Z/d$Z0d%Z1d&Z2d'Z3y)*N)_)nullrev)matchpathutilpolicyutil) stringutil)flagutilsidedata copy_tracingcxt|jD]\}}||k(r||=||vr||=||vs||= y)z)filters out invalid copies after chainingN)listitems)srcdsttkvs 4usr/lib/python3.12/site-packages/mercurial/copies.py_filterr"sF,QWWY1 6! c\! c\! c|j}|jD]\}}|j||||<|S)z.chain two sets of copies 'prefix' and 'suffix')copyrget)prefixsuffixresultkeyvalues r_chainr!Cs: [[]Flln Ujj.s % Mrc|jD]c}|j}|j|d|jk(r|cS|s=|j|d|jk(sa|cSy)a return file context that is the ancestor of fctx present in ancestor manifest am Note: we used to try and stop after a given limit, however checking if that limit is reached turned out to be very expensive. we are better off disabling that feature.N) ancestorspathrfilenode)fctxambasemffr$s r _tracefiler*Ks^^^ vvx 66$  -K fjjt, <K rc|j}|jj}t|D],}|j |j r |s!||r*||=.|SN)dirstatecopiesrr get_entrytracked)repordscrs r_dirstatecopiesr4[sT B A !W||A&&5q! Hrch|j}|j}|j||S)zComputes which files are in b but not a. This is its own function so extensions can easily wrap this call to see what files _forwardcopies is about to process. r)manifest filesnotin)abrmambs r_computeforwardmissingr=ds- B B ==5= ))rcf|jdk(ry|jjdd}d}||vS)z9Checks if we should use changeset-centric copy algorithmschangeset-sidedataT experimentalscopies.read-from)schangeset-onlys compatibility)filecopiesmodeuiconfig)r1readfromchangesetsources rusechangesetcentricalgorFns9 33ww~~o/BCH;O  &&rc|j}t|r t|||S|jjxr|jj dd}|jj }|r |d||fz|j}|dn|j}i} |} |j|k(r^|jjtk(r9tj|j} tj|| } |jj ddr1t!|j#|} |r9|dt%| zn$t'||| } |r|dt%| z|jj(j+|jgd } t-| D]u}|r |d |z||}| |_|rt1j2}t5|||}|r|r |d |z|| |<|sV|d t1j2z zw| S)z@Like _forwardcopies(), but b.rev() cannot be None (working copy)devel debug.copiess3debug.copies: looking into rename from %s to %s Nscopy-tracing.trace-all-filess+debug.copies: searching all files: %d r6s/debug.copies: missing files to search: %d T inclusives&debug.copies: tracing file: %s s%debug.copies: rename of: %s s(debug.copies: time: %f seconds )_reporF_changesetforwardcopiesrB debugflag configbooldebugr7p1p2revrmatchmodexactfilesintersectmatchersrwalklenr= changelogr#sorted_ancestrycontextr timerr*)r9r:baserr1rPdbgr'r(cmforwardmissingmatch filesmatchermissingancestrycontextr)r&startopaths r_committedforwardcopiesrgws 77Dt$&q!U33 GG   O$''"4"4X"OE ''--C  Cq!f LM B\Tt}}F B ttv{qttvzz|w.~~aggi0 &88 M ww($CDqvve}%  ?#g,N O(A5HI  Cg,  gg''111557)t1LO G_  :Q> ?t / JJLE4V, =EFBqE  <::<%') $ Irc|j}|j|jtj|j t fd}|Sfd}|S)zreturns a function that returns the following data given a " * p1: revision number of first parent * p2: revision number of first parent * changes: a ChangingFiles object c|\}}|zr0|jjtj}nd}|||fSr,) _sidedatar sidedatamodSD_FILES)rSrQrRraw HASCOPIESINFOchangelogrevisionflagsparentss rrevinfoz _revinfo_getter..revinfosNS\FBSzM)',66::;;O;OPC= rcd|\}}|zr|j}nd}|||fSr,)changes)rSrQrRrtrnrorprqs rrrz _revinfo_getter..revinfos>S\FBSzM)+C088G$ $r)rZ parentrevsrpr REVIDX_HASCOPIESINFOrorustmod)r1rclrrrnrorprqs @@@@r_revinfo_getterrysU BmmG HHE11M,, !$ N % Nrcifd}|S)z&return a cached version of is_ancestorcj||kDry||k(ry||f}j|}|||x}|<|S)NFT)r)ancdescrretcache is_ancestors r _is_ancestorz(cached_is_ancestor.._is_ancestorsL : D[Dkiin ;*35 5C%* r)rrrs` @rcached_is_ancestorrs E  rc d|jt|jfvriS|jj}|j}|j }|j }ttf}|j|jgd}|j|jg|jg} t} d} |jjdd} | D]U} || }||k(rd} |\}}|tk7r||vr| j||tk7s@||vsE| j|W| siS| r[t| } t| }|jg}|j||| d}t|}| D cgc] } | |vs|  } } |j dk(rt#d | D}| D]9} |j%| D]#}|tk(r d || <||vs||xxd z cc<%;t'||}|jj)5t+| ||j|||| cdddSt#d | D}| D]@} |j%| D]*}|tk(r g|| <||vs||j-| ,B| j/}||jk(sJ| j1| | j3t5|}t7| ||j|||Scc} w#1swYyxYw) NTrJ)commonheadsFrHscopy-tracing.multi-thread) includepathr?c3$K|]}|df yw)rNr.0rs r z*_changesetforwardcopies..5s4eq!ferrc3$K|]}|gf ywr,rrs rrz*_changesetforwardcopies..Ks/ABr)rSrr1 unfilteredrZ isancestorrev_uncheckedparentrevsr#findmissingrevssetrBrOaddrminreachablerootsrAdictruryreading_combine_changeset_copiesappendpopextendsort_revinfo_getter_extra_combine_changeset_copies_extra)r9r:rr1rx isancestorrq graph_rootsr#revsrootshas_graph_roots multi_threadrpsrQrRmh roots_to_headchildren_countprrchildrenxs rrMrMsuuw7AEEG$$ 668   D B!!J%%GG$K aeegY$ 7I  aeegYquuwi  @D EEO77%%h0LML QZ  "OFBW}y " W}y "   U  J UUWI))!Q4)H M* 64a1 #546 334e44A]]1%<$%q!&"1%*% &"$. ^^ # # %,& %///A]]1%<  =QK&&q) & HHJAEEG|| E '-. (AEEGWeZ  a7*& %s L!'L!2L&&L/c "|j}t$tjt|||||}nt |}i} |D]g} || \} } } d}d| fd| ffD]E\}}|t k(r|j |}|%|dz}|||<|r| j |d}n| j|d}|ix}}n|r|j}n|}| i}|dk(r | j}n|dk(r | j}|rR|j}|jD])\}}|j |}| |d|d}| |f||<+||usJ| jr1| jD]"}||vs||ur|j}| df||<$||}0|dk(sJt|||| | }H|| | <ji}| |}|J|jD]\}\}}| |||<|s*t|jD]}||r ||=|S)acombine the copies information for each item of iterrevs revs: sorted iterable of revision to visit children_count: a {parent: } mapping. targetrev: the final copies destination revision (not in iterrevs) revinfo(rev): a function that return (p1, p2, p1copies, p2copies, removed) match: a matcher It returns the aggregated copies information for `targetrev`. Nr)alwaysrwcombine_changeset_copiesrrrrrrcopied_from_p1copied_from_p2rremoved_merge_copies_dictkeys)rr targetrevrrrrr alwaysmatch final_copies all_copies current_revrQrRrtcurrent_copiesparent parent_revremaining_childrenr. newcopies childcopiesdestsourceprevr)targetrev_itemsttfilenames rrr^s,,.K77 J 7L ( 3  K%k2OBG!N)*2wB&8" (%3%7%7 %C"%-"a'"-?z*%'^^J=F'^^J=F>)++I' & I &I&"$K{&-&<&< 1&-&<&< "$*KKM ,7,=,=,?LD&#)::f#5D#/DG4G)-a/:F.CIdO -@ )666!(A I~#,#617 I0;T/B ! "1")%.N"Q;&;%7!&"# &Nu'9B'5J{ #M R $Y/***"1"7"7"9 D,2v!%+ T"#: \..01H? *2 rrc|jD]`\}}|j|}||||<t|||||\}} | r|tk(r ||df||<G||df||<R|tk(s\|||<b|S)amerge two copies-mapping together, minor and major In case of conflict, value from "major" will be picked. - `isancestors(low_rev, high_rev)`: callable return True if `low_rev` is an ancestors of `high_rev`, - `ismerged(path)`: callable return True if `path` have been merged in the current revision, return the resulting dict (in practice, the "minor" object, updated) r)rr_compare_values PICK_MAJOR) minormajorrrt current_mergerr otherpick overwrites rrrs{{} e $ =E$K-T5%OD):%#0%(";E$K#0%(";E$K##d % Lrc|\}}|\}}||k(r||k(sJtdfS|||||jvrtdfS|||||jvrtdfS|||r |||jvrtdfStdfS|||r |||jvrtdfStdfS|tdfS|tdfStdfS)zcompare two value within a _merge_copies_dict loop iteration return (pick, overwrite). - pick is one of PICK_MINOR, PICK_MAJOR or PICK_EITHER - overwrite is True if pick is a return of an ambiguity that needs resolution. FT) PICK_EITHERsalvaged PICK_MINORrmerged) rtrrrrmajor_tt major_valueminor_tt minor_values rrrs("Hk!Hk8k)))E!!  #   G$$ $4  #   G$$ $4 Hh '  47>>#9t# #u$ $ Hh '  47>>#9t# #u$ $  4  44rcTj}|jfdfd}|S)aWreturn a function that return multiple data given a "i * p1: revision number of first parent * p2: revision number of first parent * p1copies: mapping of copies from p1 * p2copies: mapping of copies from p2 * removed: a list of removed files * ismerged: a callback to know if file was merged in that revision c |fd}|S)Nc|jvry|}|jj|j}d}|D]}|jk7s|dz }|dk\S)NFrrr)rV_filelogrq _filenodenullid)r$r&rq nb_parentsnctxr1s rismergedz=_revinfo_getter_extra..get_ismerged..ismerged>se399;&t9Dmm++DNN;GJ #!OJ? "rr)rSrrr1s @r get_ismergedz+_revinfo_getter_extra..get_ismerged;s3i #rc~|\}} |}|j\}}|j}||||||fSr,)_copies filesremoved) rSrQrRrp1copiesp2copiesrrrqr1s rrrz&_revinfo_getter_extra..revinfoKsMB3i [[(""$2x7L4EEEr)rZru)r1rxrrrrqs` @@rrr.s) BmmG F Nrc i}|j}|D]A}|j|d} | i} t||D]\} } || \} } }}}}|| k(rd}|}n || k(sJd}|}|s,|jDcic]\}}||s||}}}| }|rR| j }|jD])\}}| j |}| |d|d}| |f||<+|| usJ|D]"}||vs|| ur| j }| df||<$|j | }|||| <|dk(rt ||||t ||||||| <Di}||jD]\}\}}| |||<|Scc}}w)zyversion of `_combine_changeset_copies` that works with the Google specific "extra" based storage for copy informationNrr)rr enumeraterrr_merge_copies_dict_extra)rrrrrrrrrrr.ir3rQrRrrrrrrrrrrrrr) othercopiesrrs rrrUs J,,.K 4( >Fhqk*DAq->-@-@cE#JCH-@I"KKM $/$5$5$7LD&!::f-D'DG,?!%a'(&kIdO %8 !... > F*%+KKM $%t9IaL%..+K" ) 1 Q;,#Y H-!; H%.JqMc+ pL(399;lr6  !'L < [s =F F c|jD]P\}}|j|}||||<|d}|d}|d|dk(r5||k(s|||r ||sL|||<Ry)zrversion of `_merge_copies_dict` that works with the Google specific "extra" based storage for copy informationNrr)rr) rrrrrr rnew_ttother_tts rrrs|{{} e $ =E$K1XFQxHQx58#("!&(3D>#d !%rc||}|jj|}|j>t||j ||}t |t |j|}|St||||}|S)zgiven copies to context 'dst', finds renames from that context)r[r)r.rrrrrs rrrsH Av||~&1 q  8 ! ' Hrc|j}|jjxr|jjdd}|r |jj d||fz||k(s|r|siS|j <||j k(r)|r|jj dt||S|j|}||k(r,|r|jj dt|||}n||k(r,|r|jj dt|||}n|r|jj d d}|j tk7r|}t||}t||||} t|t| z} | D],} |j| | j| k(s'|| =| | =.t|||} t| | }t!||||S) z5find {dst@y: src@x} copy mapping for directed comparerHrIs-debug.copies: searching copies from %s to %s Ns$debug.copies: search mode: dirstate s#debug.copies: search mode: forward r6s$debug.copies: search mode: backward s$debug.copies: search mode: combined )rLrBrNrOrPrSrQr4ancestorrrrrrrr!r) ryrr1rPr9r.r^x_copiesy_copies same_keysrx_backward_renamess r pathcopiesrs 77D GG   O$''"4"4X"OE   =A F  AvQa uuw1;  GGMMB CtU++ 1 AAv  GGMMA B1E2 a  GGMMB C!!Qe4  GGMMB C 557g D!!Q'!!QE:MCM1 A||A(,,q/1QKQK.h5A    Aq& Mrcj|r|r||k(rttifS|jj}|jK|j|jj k(r tt ||tifS|jjdd}tj|durttifSt|rt||||S|dk(r)t|||rt||||St||||St||||S)a Finds moves and copies between context c1 and c2 that are relevant for merging. 'base' will be used as the merge base. Copytracing is used in commands like rebase, merge, unshelve, etc to merge files that were moved/ copied in one merge parent and modified in another. For example: o ---> 4 another commit | | o ---> 3 commit that modifies a.txt | / o / ---> 2 commit that moves a.txt to b.txt |/ o ---> 1 merge base If we try to rebase revision 3 on revision 4, since there is no a.txt in revision 4, and if user have copytrace disabled, we prints the following message: ```other changed which local deleted``` Returns a tuple where: "branch_copies" an instance of branch_copies. "diverge" is a mapping of source name -> list of destination names for divergent renames. This function calls different copytracing algorithms based on config. r@rFs heuristics) branch_copiesr1rnoder-rQr4rBrCr parseboolrF_fullcopytracing_isfullcopytraceable_heuristicscopytracing)r1c1c2r^r copytracings r mergecopiesr  sB R28 33'')'')K wwyRWWY$--*:*:*<< /$ < = O   ''..,?KK(E1 33t$b"d33 m# b$ /#D"b$7 7%dBD99b"d33rc6|j|j}|jri|jrY|jj dd}t |j d|j|j}||kSy)aChecks that if base, source and destination are all no-public branches, if yes let's use the full copytrace algorithm for increased capabilities since it will be fast enough. `experimental.copytrace.sourcecommitlimit` can be used to set a limit for number of changesets from c1 to base such that if number of changesets are more than the limit, full copytracing algorithm won't be used. r@scopytrace.sourcecommitlimit%d::%dF)rSrQmutablerB configintrYr)r1r r^sourcecommitlimitcommitss rrrQs{ vvx UUW zz|  GG-- ; dii 488:rvvx@A*** rc ||vr ||vr|||<yy||vry||||k7rt||||sy||||k7s#|j||j|k7r |D]} ||| < yyr,)_relatedrp) rdsts1m1m2r<r r^r renamedeleters r_checksinglesidecopiesres "} b= %L   B CBsG HRWd3i$@ CBsG rxx} =CDI >rc eZdZdZ ddZdZy)ra Information about copies made on one side of a merge/graft. "copy" is a mapping from destination name -> source name, where source is in c1 and destination is in c2 or vice-versa. "movewithdir" is a mapping from source name -> destination name, where the file at source present in one context but not the other needs to be moved to destination by the merge process, because the other context moved the directory it is in. "renamedelete" is a mapping of source name -> list of destination names for files deleted in c1 that were renamed in c2 or vice-versa. "dirmove" is a mapping of detected source dir -> destination dir renames. This is needed for handling changes to new files previously grafted into renamed directories. Nch|in||_|in||_|in||_|i|_y||_yr,rrdirmove movewithdir)selfrrrrs r__init__zbranch_copies.__init__sA,BD "."6BL$_r' !,!42+rc pd|jd|jd|jd|jd S)Nzr)rs r__repr__zbranch_copies.__repr__s, II    LL      r)NNNN)__name__ __module__ __qualname____doc__r r"rrrrrzs&GKF rrc $%&'(|j&|j'|j(t||}t||}|s|sttifSi}i}|jD]&\}} |j | gj |(|jD]&\}} |j | gj |(i} i} i} i} i}t |t |z}|D]} |j| }|j| }|r|r| &vrF| 'vrBt |}t |}||zr||zD] }| | |<| | |<at||z| | <s| &vsx| 'vs}t |}t |}||zD] }| | |<| | |<|rt| |&'(||| | |st| |'&(||| | g%%&'(fd$$fd}$fd}jjr|}|}d}|r2jjd|dzdj|fz|r2jjd|dzdj|fzt }t }| jD]}|j|| jD]}|j||jD]}|j|jjd d|fd |ffD]{\}}|s jjd |zt|D]G}d }|| vs|| vr|d z }||vr|dz }||vr|dz }jjd||||fzI}~~jjdt!|| ||\}}t!|| ||\} }!t| | ||!}"t| || |}#|"|#| fS)a'The full copytracing algorithm which finds all the new files that were added from merge base up to the top commit and for each file it checks if this file was copied from another file. This is pretty slow when a lot of changesets are involved but will track all the copies. csoj j}j j}t||z }t||z }j||f|Sr,)r8rr[r) idx addedinm1 addedinm2u1u2rrrr<r1s r_get_addedfilesz)_fullcopytracing.._get_addedfilessp b$*:*:*<=I b$*:*:*<=I I-.B I-.B LL"b "SzrcdS)Nrrr.srz"_fullcopytracing.. ?1%rcdS)Nrrr0srr1z"_fullcopytracing..r2rs unmatched files in %ss %s: %s slocals sothersK all copies found (* = to merge, ! = divergent, % = renamed and deleted): sremotes on %s side: r*!%s src: '%s' -> dst: '%s' %s s! checking for directory renames )r7rrr setdefaultrrrr[rrBrNrPjoinvaluesupdate _dir_renames))r1r r r^copies1copies2inversecopies1inversecopies2rrcopy1copy2diverge renamedelete1 renamedelete2 allsourcesrdsts2u1fnu2fnr,r-headerrenamedeleteset divergesetdstssider.r)notedirmove1 movewithdir2dirmove2 movewithdir1branch_copies1branch_copies2r.rrrr<s)` @@@@@rrrs7 B B Br"Gr"G w 33NNMMOS!!#r*11#6$MMOS!!#r*11#6$ E EGMM^$s>'::J""3'""3' U"}BE E  5=$u}%(c %(c  -$*%%-#8GCLsbyE E  5=C!$E#J!$E#J)  "UBBD%  "UBBD% GP E &D %D ww V V+ GGMM6H#4hmmB6G"HH   GGMM6H#4hmmB6G"HH %U NN$D   d #%!((*D  " "4 (+!((*D  " "4 (+   + '09g2FGLD& GGMM-4 5F^:eDLD ?DLD'DLD 6&)Q9MM$ H  GGMM78)$E7DIHl)$E7DIHl"5-<PN"5-<PN >7 22rc*t}i}|jD]\}}tj|tj|} } | |vr5|j | r#|j | r|j | i| |vr|| | k7r|j | | || <|D] } | |vs|| = ~|siifS|jD cic]\} } | dz| dz}} } |D]%}|j jd|||fz't|d}i}|D]^}||vs|D]R}|j|s|||t|dz}||vr%|||<|j jd||fz^`||fScc} } w)aFinds moved directories and files that should move with them. ctx: the context for one of the sides copy: files copied on the same side (as ctx) fullcopy: files copied on the same side (as ctx), including those that merge.manifestmerge() won't care about addedfilesfn: function returning added files on the other side (compared to ctx) /s) discovered dir src: '%s' -> dst: '%s' T)reverseNs' pending file src: '%s' -> dst: '%s' ) rrrdirnamehasdirrrBrPr[ startswithrY)r1rrfullcopy addedfilesfninvalidrrrdsrcddstrrrddirmove_children_firstrr)dfs rr;r;*seGGNN$S%%c*H,<,odaq4xT!oG>   9Q O K $GT:K ^ H +<<? aAk1B~)+ A G "g&, K ;?sFc|j|j}jjt}|j|j djjs)|j j dt||S}|k7rzt|jdk(r)|j j dt||S|j|j|j}|k7rzi}t}|jD]\}} | vs | ||<fd} |D cgc] } | | s | } } i} | rtjt }tjt }j#jD]h} t$j&j)| }t$j&j+| }||j-| ||j-| j| D]} t$j&j)| }t$j&j+| }||}||}||z}j/| }|j j1dd}t||kDr3|j j3t5d| t|fz|D]%}|j/|}t7||s!| | |<'t9| t9|ifScc} w) a}Fast copytracing using filename heuristics Assumes that moves or renames are of following two types: 1) Inside a directory only (same directory name but different filenames) 2) Move from one directory to another (same filenames but different directory names) Works only when there are no merge commits in the "source branch". Source branch is commits from base up to c2 not including base. If merge is involved it fallbacks to _fullcopytracing(). Can be used by setting the following config: [experimental] copytrace = heuristics In some cases the copy/move candidates found by heuristics can be very large in number and that will make the algorithm slow. The number of possible candidates to check can be limited by using the config `experimental.copytrace.movecandidateslimit` which defaults to 100. rs?switching to full copytracing as base is not an ancestor of c2 rs0switching to full copytracing because of merges c$|vxr |vxr|vSr,r)r)r^r rs rr1z(_heuristicscopytracing..sQb[:Q$Y:17:rr@scopytrace.movecandidateslimitsBskipping copytracing for '%s', more candidates than the limit: %d )rSrQrr7rrBrPrrYrqr:rVrr collections defaultdictrr8osr$basenamerXrfilectxrstatusrrr)r1r r r^ changedfilesrr=cprrfiltr) missingfilesr<basenametofilenamedirnametofilenamerhrX samebasename samedirnamemovecandidatesf2 maxcandidates candidatef1rs `` @rrrqs2 vvx UUW vvx UUW5L B 99Y BFFH 5   #  b"d33 C + s{{}  " GGMMN O#D"b$7 7CIIK(ffh +G b !BHHJS "9GCL ;D+7|!tAwA|L7G(44T:'33D9t}}/Aww''*Hggooa(G x ( / / 2 g & - -a 0 0 Aww''*Hggooa(G-h7L+G4K)K7NAB!GG--!AM>"]2;#n-. /+ ZZ *B#*+GI& ,3B  !=#92 ==]8s 2 M M ct||k(ry|j|j}} |j|j}}| t|}| t|} |j|j}}||kDr t|}n||kDr t|}n||k(SH#t$rYywxYw)aFreturn True if f1 and f2 filectx have a common ancestor Walk back to common ancestor to see if the two files originate from the same file. Since workingfilectx's rev() is None it messes up the integer comparison logic, hence the pre-step check for None (f1 and f2 can only be workingfilectx's initially). TF)r#linkrevnext StopIteration)rwrtg1g2f1rf2rs rrrs Rx \\^R\\^B::<S ;bB ;bBzz|RZZ\CSy"Xs"XRx sBB+*B++ B76B7ct||}|j}t|||t|j D] \}}||vs ||=|j D]\}}||j |y)a reproduce copies between base and ctx in the wctx Unlike mergecopies(), this function will only consider copies between base and ctx; it will ignore copies between base and wctx. Also unlike mergecopies(), this function will apply copies to the working copy (instead of just returning information about the copies). That makes it cheaper (especially in the common case of base==ctx.p1()) and useful also when experimental.copytrace=off. merge.update() will have already marked most copies, but it will only mark copies if it thinks the source files are related (see merge._related()). It will also not mark copies if the file wasn't modified on the local side. This function adds the copies that were "missed" by merge.update(). N)rrQrrr markcopied) wctxrr^ new_copiesrr__rrs r graftcopiesrs D#&J WWYF FD*% ))+,b 6>4 -$$&S S S!'rr,)NN)4rergi18nrrrrrTrrr utilsr revlogutilsr r rk importrustrwrr!r*r4r=rFrgryrrMrrrrrrrrrrrrrr rrrrr;rrrrrrrs  &  N +B   *'@F#L$i Xnd   >7 t$NCL$,  .  +\C4L(*! ! HI3XD Nj>ZB"r