sh߂SrSSKrSSKJr \R"SS5rSrSrSr\R"S S 5r \R"S S 5r S r Sr Sr g)z Timsort implementation. Mostly adapted from CPython's listobject.c. For more information, see listsort.txt in CPython's source tree. N)typesTimsortImplementation)compile count_run binarysort gallop_left gallop_right merge_init merge_append merge_popmerge_compute_minrunmerge_lomerge_himerge_atmerge_force_collapsemerge_collapse run_timsortrun_timsort_with_valuesU MergeState) min_gallopkeysvaluespendingnMergeRun)startsizec^^^^^^^ ^ ^ ^ ^ ^^^^^^^^^^^^^^^U"T5m[Rm T "S5mUS5m UU UU4Sj5mUU UU4Sj5mUS5m US5mUU U4Sj5mUU 4Sj5m US 5mUUU 4S j5mUU4S j5mUU4S j5mUU4S j5m US5mUU 4Sj5mUU 4Sj5mSmUUUUU U U UU4Sj5mUUUUU U U UUU4 Sj5mUUU UUU4Sj5mUU4Sj5mUU4Sj5mUU 4Sj5mUUUU UUUUU4Sj5mUUU4Sj5nUUU4Sj5n[UTTTT TT TTTTTTTX#5$)NrcXL$N)rrs f/Users/tiagomarins/Projetos/claudeai/copy_bank/venv/lib/python3.13/site-packages/numba/misc/timsort.py has_values%make_timsort_impl..has_values?s !!c>[[U5S-S-[5nT"X5nUn[TT5/[-n[ T"[ 5X#UT5$)z/ Initialize a MergeState for a non-keyed sort. minlenMERGESTATE_TEMP_SIZErMAX_MERGE_PENDINGr MIN_GALLOP)r temp_size temp_keys temp_valuesrintpmake_temp_areazeros r%r %make_timsort_impl..merge_initCsY D Q*,@A "43  D$'(+<<$z*IGTRRr(c>[[U5S-S-[5nT"X5nT"X5n[TT5/[-n[ T"[ 5X4UT5$)z+ Initialize a MergeState for a keyed sort. r*r+r,) rrr2r3r4rr5r6r7s r%merge_init_with_values1make_timsort_impl..merge_init_with_valuesNs^ D Q*,@A "43 $V7 D$'(+<<$z*IGTRRr(cURnU[:deXRU'[URUR UR URUS-5$)z" Append a run on the merge stack. r+)rr0rrrrr)msrunrs r%r 'make_timsort_impl..merge_appendYsN DD$$$$ 1 "--"))RZZQOOr(c[URURURURUR S- 5$)z' Pop the top run from the merge stack. r+)rrrrrr)r=s r%r $make_timsort_impl..merge_popcs0 "--"))RZZPQRRr(cL>[UR5nX::aU$X!:a US-nX!:aM T"URU5nT"URUR5(aT"URU5nOUn[URX4UR UR 5$)z: Ensure enough temp memory for 'need' items is available. r+)r.rrrrrr)r=needallocedr3r4r&r6s r% merge_getmem'make_timsort_impl..merge_getmemjs bgg, ?InlGn#277G4 bggryy ) )(G[T"U5URURURUR5$)z% Modify the MergeState's min_gallop. )rrrrr)r= new_gallopr5s r%merge_adjust_gallop.make_timsort_impl..merge_adjust_gallop~s- $z*BGGRYY BDDQQr(c X:$)zo Trivial comparison function between two keys. This is factored out to make it clear where comparisons occur. r$)abs r%LTmake_timsort_impl..LTs u r(ch>X$::aXC::deT "X5nX$:XaUS- nXC:aXnUnUnXx:a)XxU- S- -n T "X`U 5(aU nOU S-nXx:aM)[XGS5H n X S- X 'M X`U'U(a$Xn [XGS5H n XS- X'M XU'US- nXC:aMgg)af binarysort is the best method for sorting small arrays: it does few compares, but can do data movement quadratic in the number of elements. [lo, hi) is a contiguous slice of a list, and is sorted via binary insertion. This sort is stable. On entry, must have lo <= start <= hi, and that [lo, start) is already sorted (pass start == lo if you don't know!). r+Nrange) rrlohir _has_valuespivotlrp pivot_valrNr&s r%r%make_timsort_impl..binarysorts{u{** . ; QJEjKEAA %a%A&e!W%%A!A %5R(1u+)G"M u,A &1u FI-%q QJEAjr(c4>X:deUS-U:XagT"XS-X5(a9[US-U5H nT"XXS- 5(aMX1- S4s $ X!- S4$[US-U5H nT"XXS- 5(dMX1- S4s $ X!- S4$)a~ Return the length of the run beginning at lo, in the slice [lo, hi). lo < hi is required on entry. "A run" is the longest ascending sequence, with lo[0] <= lo[1] <= lo[2] <= ... or the longest descending sequence, with lo[0] > lo[1] > lo[2] > ... A tuple (length, descending) is returned, where boolean *descending* is set to 0 in the former case, or to 1 in the latter. For its intended use in a stable mergesort, the strictness of the defn of "descending" is needed so that the caller can safely reverse a descending sequence without violating stability (strict > ensures there are no equal elements to get out of order). r+)r+Fr*TFrR)rrTrUkrNs r%r$make_timsort_impl..count_runs&ww 6R< d6lDH % %262&$'4A;//64<''7D= 262&dgtE{++65=('7E> !r(c >X2:deXB:aXC:deX2- nSnSnT "XU5(aGX4- nXx:a.T "XU-U5(aUnUS-S-nUS::aUnOOXx:aM.Xx:aUnXd- nXt- nOGXB- S-nXx:a-T "XU- U5(aOUnUS-S-nUS::aUnXx:aM-Xx:aUnXG- XF- pvUS- U::a Xg:aXs::deUS- nXg:a)XgU- S- -n T "XU5(aU S-nOU nXg:aM)U$)aK Locate the proper position of key in a sorted vector; if the vector contains an element equal to key, return the position immediately to the left of the leftmost equal element. [gallop_right() does the same except returns the position to the right of the rightmost equal element (if any).] "a" is a sorted vector with stop elements, starting at a[start]. stop must be > start. "hint" is an index at which to begin the search, start <= hint < stop. The closer hint is to the final result, the faster this runs. The return value is the int k in start..stop such that a[k-1] < key <= a[k] pretending that a[start-1] is minus infinity and a[stop] is plus infinity. IOW, key belongs at index k; or, IOW, the first k elements of a should precede key, and the last stop-start-k should follow key. See listsort.txt for info on the method. rr+r$ keyrLrstophintrlastofsofsmaxofsmrNs r%r&make_timsort_impl..gallop_leftss0||},, L ags  [F,as mS))!G!8q.Cax$,| OG KC\A%F,as mS))"G!8q.Cax$,|:t~SqyG# #+EE 1 m'Ma/0A!$}}a%m r(c>X2:deXB:aXC:deX2- nSnSnT "XU5(aHXB- S-nXx:a-T "XXG- 5(aUnUS-S-nUS::aUnOOXx:aM-Xx:aUnXG- XF- pvODX4- nXx:a,T "XXG-5(aOUnUS-S-nUS::aUnXx:aM,Xx:aUnXd- nXt- nUS- U::a Xg:aXs::deUS- nXg:a)XgU- S- -n T "XU 5(aU nOU S-nXg:aM)U$)a Exactly like gallop_left(), except that if key already exists in a[start:stop], finds the position immediately to the right of the rightmost equal value. The return value is the int k in start..stop such that a[k-1] <= key < a[k] The code duplication is massive, but this is enough different given that we're sticking to "<" comparisons that it's much harder to follow if written as one routine with yet another "left or right?" flag. rr+r$ras r%r 'make_timsort_impl..gallop_right;so||},, L cT7  \A%F,cTZ=))!G!8q.Cax$,|:t~S[F,cTZ=))"G!8q.Cax$,| OG KCqyG# #+EE 1 m'Ma/0A#t}}a%m r(cRSnUS:deUS:aXS--nUS-nUS:aMX-$)a} Compute a good value for the minimum run length; natural runs shorter than this are boosted artificially via binary insertion. If n < 64, return n (it's too small to bother with fancy stuff). Else if n is an exact power of 2, return 32. Else return an int k, 32 <= k <= 64, such that n/k is close to, but strictly less than, an exact power of 2. See listsort.txt for more info. r@r+r$)rrYs r%r /make_timsort_impl..merge_compute_minrunsA Av v2g QJA !GA2gu r(c>US:deUS:de[U5HnX5U-XU-'M T"X45(a[U5HnXEU-XU-'M gg)z Upwards memcpy(). rNrR dest_keys dest_values dest_startsrc_keys src_values src_startnitemsir&s r%sortslice_copy)make_timsort_impl..sortslice_copyoA~~QvA(0Q(?I1n % h + +6].8Q.G N+# ,r(c>US:deUS:de[U5HnX5U- XU- 'M T"X45(a[U5HnXEU- XU- 'M gg)z Downwards memcpy(). rNrRrps r%sortslice_copy_down.make_timsort_impl..sortslice_copy_downr{r(r+c >US:a US:aXF::deXSU-:XdeT"X5nT"URURSXUU5 URnURnUn Un Un SnT"Xx5n URn US:GaUS:GaSnSnT"XXs5(a7XX'U (aXX+'U S- n US- nUS-nUS:XaOFUS- nSnX:aO9O6XsX'U (aXX+'U S- n US- nUS-nUS:XaOUS- nSnX:aOMT(GaUS:GaUS:Ga U S- n U[:d U[:aXS:-n T"XXsX4-U5nUU-nUnUS:a"T"XU XxUU5 U U- n UU- nUU-nUS:XaOXX'U (aXX+'U S- n US- nUS-nUS:XaOT"XsXXV-U5nUU-nUnUS:a"T"XU XUU5 U U- n UU- nUU-nUS:XaOAXsX'U (aXX+'U S- n US- nUS-nUS:XaOU[:aMU[:aMU S- n US:a US:aGMUS:Xa T"XU XxUU5 OUS:XdeX:XdeT"X 5$)a Merge the na elements starting at ssa with the nb elements starting at ssb = ssa + na in a stable way, in-place. na and nb must be > 0, and should have na <= nb. See listsort.txt for more info. An updated MergeState is returned (with possibly a different min_gallop or larger temp arrays). NOTE: compared to CPython's timsort, the requirement that "Must also have that keys[ssa + na - 1] belongs at the end of the merge" is removed. This makes the code a bit simpler and easier to reason about. rr+rrrr1)r=rrssanassbnba_keysa_valuesb_keysb_valuesdestrVracountbcountr^ DO_GALLOPrNrr r&rIrErys r%r#make_timsort_impl..merge_losTAv"q&RX--Bh " !rww 1S 99 2 ]] 1faFFfk6;//!'DJ"'/} AID1HC!GBQwaKFF+,"(DJ"'/} AID1HC!GBQwaKFF+9DR!VQa  *f .Bq.0J%V[&sxMAHAF1u&tT'-'(* qa7!!'DJ"'/} AID1HC!GBQw$FKchLAHAF1u'tT'-'(* qa7!!'DJ"'/} AID1HC!GBQww *f .B|a S1faX 7 4!S 7N7; ;#222r(c 2> US:a US:aXF:deXSU-:XdeT"X5nT"URURSXUU5 UnUnURn URn XV-S- n US- nX4-S- nT"X5n URn US:GaUS:GaSnSnT"XXs5(a7XsX'U (aXX+'U S-n US-nUS-nUS:XaOFUS- nSnX:aO9O6XX'U (aXX+'U S-n US-nUS-nUS:XaOUS- nSnX:aOMT(Ga/US:Ga(US:Ga!U S- n U[:d U[:GaXS:-n T"XXsU- S-US-U5nUS-U- nUnUS:a"T"XU XxUU5 U U-n UU-nUU-nUS:XaOXX'U (aXX+'U S-n US-nUS-nUS:XaOT"XsXU- S-US-U5nUS-U- nUnUS:a"T"XU XUU5 U U-n UU-nUU-nUS:XaOBXsX'U (aXX+'U S-n US-nUS-nUS:XaOU[:aMU[:aGMU S- n US:a US:aGMUS:XaT"XX- S-XXV- S-U5 OUS:XdeX:XdeT"X 5$)a Merge the na elements starting at ssa with the nb elements starting at ssb = ssa + na in a stable way, in-place. na and nb must be > 0, and should have na >= nb. See listsort.txt for more info. An updated MergeState is returned (with possibly a different min_gallop or larger temp arrays). NOTE: compared to CPython's timsort, the requirement that "Must also have that keys[ssa + na - 1] belongs at the end of the merge" is removed. This makes the code a bit simpler and easier to reason about. rr+r)r=rrrrrrrrrrrrVrrrr^rrNrr r&rIrEryr}s r%r#make_timsort_impl..merge_hiYsAv"q&RX--Bh " !rww 1S 99x!|1fhl 2 ]] 1faFFfk6;//!'DJ"'/} AID1HC!GBQwaKFF+,"(DJ"'/} AID1HC!GBQwaKFF+;FR!VQa  *f .Bq.0J%V[&(Q,aQTUAa! AF1u,D$,2c,-/ qa7!!'DJ"'/} AID1HC!GBQw$FKrAsQwPSTAa! AF1u+D$,2c,-/ qa7!!'DJ"'/} AID1HC!GBQww *f .B|a U1faZ 7 4Q!SX\ 7N7; ;#222r(c &>URnUS:deUS:deX4S- :Xd X4S- :XdeURUupVURUS-upxUS:aUS:deXV-U:Xde[XVU-5URU'X4S- :Xa"URUS-URUS-'T"U5nT "XXXV-U5n XiU- -nU nUS:XaU$T "XU-S- XXx-Xx-S- 5n X- nXh::a T "XX%XgU5$T "XX%XgU5$)zT Merge the two runs at stack indices i and i+1. An updated MergeState is returned. r*rr+)rrr)r=rrrxrrrrrr^rr rrr s r%r#make_timsort_impl..merge_atsO DDAv vAv vEzQa%Z''**Q-**QU#Av"q&  x3 !2g. 1 A: " 1q5 1BJJq1u  r] Dsx = #g  7I 2X\*DsxA N W 8Bf2B? ?Bf2B? ?r(c,>URS:GaURnURS- nUS:a3X4S- RX4RX4S-R-::d9US:afX4S- RX4S- RX4R-::a3X4S- RX4S-R:aUS-nT"XX$5nO.X4RX4S-R:a T"XX$5nOU$URS:aGMU$)z Examine the stack of runs waiting to be merged, merging adjacent runs until the stack invariants are re-established: 1. len[-3] > len[-2] + len[-1] 2. len[-2] > len[-1] An updated MergeState is returned. See listsort.txt for more info. r+r*rrrr r=rrrrrs r%r)make_timsort_impl..merge_collapse'sddQhjjGqAQ7Q3<,, 'A#,BSBS0SSQ7Q3<,,! 0A0AGJOO0SSq5>&&Q)<)<<FAb27q5>#6#66b2 ddQh r(c>URS:aeURnURS- nUS:a)X4S- RX4S-R:aUS-nT"XX$5nURS:aMeU$)z Regardless of invariants, merge all runs on the stack until only one remains. This is used at the end of the mergesort. An updated MergeState is returned. r+r*rrrs r%r/make_timsort_impl..merge_force_collapseCsvddQhjjGqA1uq5>&&Q)<)<<FA"F.BddQh r(c>UnUS- nXE:aXXsX'X'US- nUS-nXE:aMT"X5(a,UnUS- nXE:aXXsX'X'US- nUS-nXE:aMggg)z Reverse a slice, in-place. r+Nr$)rrrrcrxjr&s r% reverse_slice(make_timsort_impl..reverse_sliceVs  1He#w DGTW FA FAe d # #AqA%'-y&)$ 69QQ% $r(c>[U5nUS:agT "U5nTnUS:alT "XXS-5upgU(a T"XXUU-5 Xd:a[XC5nT "XXUU-XV-5 UnT "U[XV55nT "XU5nXV- nX6-nUS:aMlT"XU5nURS:XdeURSS[U54:Xdeg)z" Run timsort with the mergestate. r*Nrr+)r.r-rrr)r=rr nremainingminrunrTrdescforcerrr rr rrr7s r%run_timsort_with_mergestate6make_timsort_impl..run_timsort_with_mergestatejs Y > &j1 1n"/:GAdBQ7zF/4%Z@b(2/2B&1B GB OJ1n$""F 3ttqyyzz!}CI...r(c(>UnT"T"U5X5 g)z" Run timsort over the given keys. Nr$)rrr rs r%r&make_timsort_impl..run_timsorts #Jt$4dCr(c$>T"T"X5X5 g)z- Run timsort over the given keys and values. Nr$)rrr:rs r%r2make_timsort_impl..run_timsort_with_valuess $$:4$H$( 2r()rr5r)wrapr6rrrrNrrrr r&r5rIr rrr rrErr r:rr rrryr}r7s ` @@@@@@@@@@@@@@@@@@@@@@@@@r%make_timsort_implr9ss.)N ::D 7D " " S S S S P P S S  S S& R R   . .b !" !"H R Rj H HV  (  H  H  H  H I W3W3 W3t Z3Z3 Z3z ,@,@ ,@^  6  $  & !/!/ !/H D D 2 2 ! :{LL)h(n  ..r(c[S/UQ76$)NcU$r#r$)fs r%!make_py_timsort..sr()r)argss r%make_py_timsortrs k 2T 22r(c0^SSKJm [U4Sj/UQ76$)Nr)jitc>T"SS9"U5$)NT)nopythonr$)rrs r%r"make_jit_timsort..sT(:1(=r()numbarr)rrs @r%make_jit_timsortrs = %# %%r()__doc__ collections numba.corer namedtuplerr0r1r/rrrrrr$r(r%rs$..  *  # #BD   ! !*.? @m .`3%r(