O=ddZddlmZmZddlmZddlmZddlZ ddl m Z m Z m Z dZd]d Zd Zd Zd Zd ZdZd]dZd]dZd^dZd^dZd^dZd_dZd^dZd^dZdZdZd]dZdZ dZ!d`dZ"dZ#dZ$dZ%d Z&d!Z'd"Z(d#Z)d$Z*d^d%Z+d^d&Z,d`d'Z-dad)Z.d*Z/d+Z0d^d,Z1d^d-Z2d.Z3d/Z4d^d0Z5d1Z6d2Z7d_d3Z8dbd5Z9d6Z:d^d7Z;d8Zd;Z?d<Z@d^d=ZAd^d>ZBd?ZCd@ZDd]dAZEd]dBZFd^dCZGd^dDZHdEZIdFZJdGZKdHZLd^dIZMd^dJZNdKZOdLZPd^dMZQdNZRdOZSdPZTdQZUdRZVd^dSZWd^dTZXdUZYdadVZZdWZ[dXZ\dcdYZ]dZZ^dcd[Z_dcd\Z`dS)dz; Functions that operate on lists. .. versionadded:: 1.0.0 ) bisect_left bisect_right) cmp_to_key)ceilN)base_get iteriterateeparse_iteratee)Jchunkcompactconcat difference difference_bydifference_withdrop drop_rightdrop_right_while drop_while duplicatesfill find_indexfind_last_indexflatten flatten_deep flatten_depth from_pairsheadindex_ofinitial intercalate interleave intersectionintersection_byintersection_with intersperselast last_index_ofmapcatnthpullpull_all pull_all_by pull_all_withpull_atpushremovereverseshiftslice_sort sorted_indexsorted_index_bysorted_index_ofsorted_last_indexsorted_last_index_bysorted_last_index_of sorted_uniqsorted_uniq_bysplicesplit_attailtake take_righttake_right_while take_whileunionunion_by union_withuniquniq_by uniq_withunshiftunzip unzip_withwithoutxorxor_byxor_withzip_ zip_objectzip_object_deepzip_withcttttz }fdt |DS)a Creates a list of elements split into groups the length of `size`. If `array` can't be split evenly, the final chunk will be the remaining elements. Args: array (list): List to chunk. size (int, optional): Chunk size. Defaults to ``1``. Returns: list: New list containing chunks of `array`. Example: >>> chunk([1, 2, 3, 4, 5], 2) [[1, 2], [3, 4], [5]] .. versionadded:: 1.1.0 c6g|]}|z|dzzSr).0iarraysizes 7D:\Sites\api_v1\venv\Lib\site-packages\pydash/arrays.py zchunk..rs/ D D DE!d(a!et^+ , D D D)intrlenfloatrange)r[r\chunkss`` r]r r ^sO&c%jj5;;.// 0 0F D D D D DeFmm D D DDr_cd|DS)a Creates a list with all falsey values of array removed. Args: array (list): List to compact. Returns: list: Compacted list. Example: >>> compact(['', 1, 0, True, False, None]) [1, True] .. versionadded:: 1.0.0 cg|]}||SrXrXrYitems r]r^zcompact..s + + +Td +D + + +r_rXr[s r]r r us" , +U + + ++r_c t|S)a_ Concatenates zero or more lists into one. Args: arrays (list): Lists to concatenate. Returns: list: Concatenated list. Example: >>> concat([1, 2], [3, 4], [[5], [6]]) [1, 2, 3, 4, [5], [6]] .. versionadded:: 2.0.0 .. versionchanged:: 4.0.0 Renamed from ``cat`` to ``concat``. )rarrayss r]r r s( 6??r_ct|g|RS)a6 Creates a list of list elements not present in others. Args: array (list): List to process. others (list): Lists to check. Returns: list: Difference between `others`. Example: >>> difference([1, 2, 3], [1], [2]) [3] .. versionadded:: 1.0.0 )rr[otherss r]rrs$ 5 *6 * * **r_c|dd}|s|Stdg|Ri|\}}|D]$}|stt|||}%|S)a This method is like :func:`difference` except that it accepts an iteratee which is invoked for each element of each array to generate the criterion by which they're compared. The order and references of result values are determined by `array`. The iteratee is invoked with one argument: ``(value)``. Args: array (list): The array to find the difference of. others (list): Lists to check for difference with `array`. Keyword Args: iteratee (mixed, optional): Function to transform the elements of the arrays. Defaults to :func:`.identity`. Returns: list: Difference between `others`. Example: >>> difference_by([1.2, 1.5, 1.7, 2.8], [0.9, 3.2], round) [1.5, 1.7] .. versionadded:: 4.0.0 Niterateerq)r listiterdifferencer[rokwargsrqothers r]rrs2 !!!HE  &jD6DDDVDDHfFF  ^E58DDDEE Lr_c|dd}|s|S|d}|d}|t|s| |}|dd}|D]$}|stt|||}%|S)a This method is like :func:`difference` except that it accepts a comparator which is invoked to compare the elements of all arrays. The order and references of result values are determined by the first array. The comparator is invoked with two arguments: ``(arr_val, oth_val)``. Args: array (list): The array to find the difference of. others (list): Lists to check for difference with `array`. Keyword Args: comparator (callable, optional): Function to compare the elements of the arrays. Defaults to :func:`.is_equal`. Returns: list: Difference between `others`. Example: >>> array = ['apple', 'banana', 'pear'] >>> others = (['avocado', 'pumpkin'], ['peach']) >>> comparator = lambda a, b: a[0] == b[0] >>> difference_with(array, *others, comparator=comparator) ['banana'] .. versionadded:: 4.0.0 N comparatorry)getcallablersrt)r[rorvry last_otherrws r]rrs6 !!!HE  L))JJx 33z7I JJ  ^E5ZHHHII Lr_c*t|fdS)a Creates a slice of `array` with `n` elements dropped from the beginning. Args: array (list): List to process. n (int, optional): Number of elements to drop. Defaults to ``1``. Returns: list: Dropped list. Example: >>> drop([1, 2, 3, 4], 2) [3, 4] .. versionadded:: 1.0.0 .. versionchanged:: 1.1.0 Added ``n`` argument and removed as alias of :func:`rest`. .. versionchanged:: 3.0.0 Made ``n`` default to ``1``. c|kSNrX_indexns r]zdrop..& eair_)rr[rs `r]rr0 e7777 8 88r_cLt|t|fdS)a Creates a slice of `array` with `n` elements dropped from the end. Args: array (list): List to process. n (int, optional): Number of elements to drop. Defaults to ``1``. Returns: list: Dropped list. Example: >>> drop_right([1, 2, 3, 4], 2) [1, 2] .. versionadded:: 1.1.0 .. versionchanged:: 3.0.0 Made ``n`` default to ``1``. c|z kSrrXrrlengthrs r]rzdrop_right..?Ve^4Ir_)rarr[rrs `@r]rr).*ZZF E#I#I#I#I#I J JJr_cxt|}t||dD]\}}}}|r|dz}|d|S)a Creates a slice of `array` excluding elements dropped from the end. Elements are dropped until the `predicate` returns falsey. The `predicate` is invoked with three arguments: ``(value, index, array)``. Args: array (list): List to process. predicate (mixed): Predicate called per iteration Returns: list: Dropped list. Example: >>> drop_right_while([1, 2, 3, 4], lambda x: x >= 3) [1, 2] .. versionadded:: 1.1.0 Tr1rNrar r[ predicateris_truers r]rrBsZ( E A( 4HHHAq   FAA  !9r_cZd}t||D]\}}}}|r|dz }||dS)a Creates a slice of `array` excluding elements dropped from the beginning. Elements are dropped until the `predicate` returns falsey. The `predicate` is invoked with three arguments: ``(value, index, array)``. Args: array (list): List to process. predicate (mixed): Predicate called per iteration Returns: list: Dropped list. Example: >>> drop_while([1, 2, 3, 4], lambda x: x < 3) [3, 4] .. versionadded:: 1.1.0 rrNr rs r]rr`sO( A( ::Aq   FAA  9r_c|r#tj|fdD}n}tfdt|D}|S)a+ Creates a unique list of duplicate values from `array`. If iteratee is passed, each element of array is passed through a iteratee before duplicates are computed. The iteratee is invoked with three arguments: ``(value, index, array)``. If an object path is passed for iteratee, the created iteratee will return the path value of the given element. If an object is passed for iteratee, the created filter style iteratee will return ``True`` for elements that have the properties of the given object, else ``False``. Args: array (list): List to process. iteratee (mixed, optional): Iteratee applied per iteration. Returns: list: List of duplicates. Example: >>> duplicates([0, 1, 3, 2, 3, 1]) [3, 1] .. versionadded:: 3.0.0 c&g|] }|SrXrX)rYrhcbks r]r^zduplicates..s!000$CCII000r_c3.K|]\}}|VdSrrX)rYrZrr[s r] zduplicates..s+==DAquQx======r_)pydrqrGiterduplicates)r[rqcomputedlstrs` @r]rr~sn.l8$$0000%000 ====N8$<$<=== = =C Jr_c|t|}nt|t|}|d||gt|||zz||dz|dd<|S)a Fills elements of array with value from `start` up to, but not including, `end`. Args: array (list): List to fill. value (mixed): Value to fill with. start (int, optional): Index to start filling. Defaults to ``0``. end (int, optional): Index to end filling. Defaults to ``len(array)``. Returns: list: Filled `array`. Example: >>> fill([1, 2, 3, 4, 5], 0) [0, 0, 0, 0, 0] >>> fill([1, 2, 3, 4, 5], 0, 1, 3) [1, 0, 0, 4, 5] >>> fill([1, 2, 3, 4, 5], 0, 0, 100) [0, 0, 0, 0, 0] Warning: `array` is modified in place. .. versionadded:: 3.1.0 N)ramin)r[valuestartends r]rrsq6 {%jj#s5zz""VeV}wU59-=)>)>>>sttLE!!!H Lr_cVdt||D}t|dS)a% This method is similar to :func:`pydash.collections.find`, except that it returns the index of the element that passes the predicate check, instead of the element itself. Args: array (list): List to process. predicate (mixed, optional): Predicate applied per iteration. Returns: int: Index of found item or ``-1`` if not found. Example: >>> find_index([1, 2, 3, 4], lambda x: x >= 3) 2 >>> find_index([1, 2, 3, 4], lambda x: x > 4) -1 .. versionadded:: 1.0.0 c3(K|] \}}}}| |VdSrrXrYrrrZs r]rzfind_index..s0 R R$GQ1' Ra R R R R R Rr_rzr nextr[rsearchs r]rrs2*S R UI(F(F R R RF   r_cZdt||dD}t|dS)a This method is similar to :func:`find_index`, except that it iterates over elements from right to left. Args: array (list): List to process. predicate (mixed, optional): Predicate applied per iteration. Returns: int: Index of found item or ``-1`` if not found. Example: >>> find_last_index([1, 2, 3, 4], lambda x: x >= 3) 3 >>> find_last_index([1, 2, 3, 4], lambda x: x > 4) -1 .. versionadded:: 1.0.0 c3(K|] \}}}}| |VdSrrXrs r]rz"find_last_index..s1 ` `$GQ1X_ `a ` ` ` ` ` `r_Trrzrrs r]rrs7*a ` UIt(T(T(T ` ` `F   r_c$t|dS)a Flattens array a single level deep. Args: array (list): List to flatten. Returns: list: Flattened list. Example: >>> flatten([[1], [2, [3]], [[4]]]) [1, 2, [3], [4]] .. versionadded:: 1.0.0 .. versionchanged:: 2.0.0 Removed `callback` option. Added ``is_deep`` option. Made it shallow by default. .. versionchanged:: 4.0.0 Removed ``is_deep`` option. Use :func:`flatten_deep` instead. rdepthrris r]rrs2 a ( ( ((r_c$t|dS)z Flattens an array recursively. Args: array (list): List to flatten. Returns: list: Flattened list. Example: >>> flatten_deep([[1], [2, [3]], [[4]]]) [1, 2, 3, 4] .. versionadded:: 2.0.0 rzrrris r]rrs" b ) ) ))r_c>tt||S)aI Recursively flatten `array` up to `depth` times. Args: array (list): List to flatten. depth (int, optional): Depth to flatten to. Defaults to ``1``. Returns: list: Flattened list. Example: >>> flatten_depth([[[1], [2, [3]], [[4]]]], 1) [[1], [2, [3]], [[4]]] >>> flatten_depth([[[1], [2, [3]], [[4]]]], 2) [1, 2, [3], [4]] >>> flatten_depth([[[1], [2, [3]], [[4]]]], 3) [1, 2, 3, 4] >>> flatten_depth([[[1], [2, [3]], [[4]]]], 4) [1, 2, 3, 4] .. versionadded:: 4.0.0 r)rs iterflatten)r[rs r]rr)s0  E/// 0 00r_c t|S)a Returns a dict from the given list of pairs. Args: pairs (list): List of key-value pairs. Returns: dict Example: >>> from_pairs([['a', 1], ['b', 2]]) == {'a': 1, 'b': 2} True .. versionadded:: 4.0.0 )dict)pairss r]rrDs" ;;r_c&t|ddS)a. Return the first element of `array`. Args: array (list): List to process. Returns: mixed: First element of list. Example: >>> head([1, 2, 3, 4]) 1 .. versionadded:: 1.0.0 .. versionchanged:: Renamed from ``first`` to ``head``. rNdefaultrris r]rrXs( E1d + + ++r_cR |||S#t$rYdSwxYw)a Gets the index at which the first occurrence of value is found. Args: array (list): List to search. value (mixed): Value to search for. from_index (int, optional): Index to search from. Returns: int: Index of found item or ``-1`` if not found. Example: >>> index_of([1, 2, 3, 4], 2) 1 >>> index_of([2, 1, 2, 3], 2, from_index=1) 2 .. versionadded:: 1.0.0 rz)r ValueError)r[r from_indexs r]rros=*{{5*--- rrs  &&c|ddS)z Return all but the last element of `array`. Args: array (list): List to process. Returns: list: Initial part of `array`. Example: >>> initial([1, 2, 3, 4]) [1, 2, 3] .. versionadded:: 1.0.0 NrzrXris r]rrs" ":r_c<tt||S)am Like :func:`intersperse` for lists of lists but shallowly flattening the result. Args: array (list): List to intercalate. separator (mixed): Element to insert. Returns: list: Intercalated list. Example: >>> intercalate([1, [2], [3], 4], 'x') [1, 'x', 2, 'x', 3, 'x', 4] .. versionadded:: 2.0.0 )rr%r[ separators r]r r s& ;ui00 1 11r_c.tt|S)az Merge multiple lists into a single list by inserting the next element of each list by sequential round-robin into the new list. Args: arrays (list): Lists to interleave. Returns: list: Interleaved list. Example: >>> interleave([1, 2, 3], [4, 5, 6], [7, 8, 9]) [1, 4, 7, 2, 5, 8, 3, 6, 9] .. versionadded:: 2.0.0 )rsiterinterleaverks r]r!r!s$ ' ( ((r_ct|g|RS)a Computes the intersection of all the passed-in arrays. Args: array (list): The array to find the intersection of. others (list): Lists to check for intersection with `array`. Returns: list: Intersection of provided lists. Example: >>> intersection([1, 2, 3], [1, 2, 3, 4, 5], [2, 3]) [2, 3] >>> intersection([1, 2, 3]) [1, 2, 3] .. versionadded:: 1.0.0 .. versionchanged:: 4.0.0 Support finding intersection of unhashable types. )r$rns r]r"r"s0 U ,V , , ,,r_c|dd}|s|Stdg|Ri|\}}t|d}|D]%}tt|||}|sn&|S)a$ This method is like :func:`intersection` except that it accepts an iteratee which is invoked for each element of each array to generate the criterion by which they're compared. The order and references of result values are determined by `array`. The iteratee is invoked with one argument: ``(value)``. Args: array (list): The array to find the intersection of. others (list): Lists to check for intersection with `array`. Keyword Args: iteratee (mixed, optional): Function to transform the elements of the arrays. Defaults to :func:`.identity`. Returns: list: Intersection of provided lists. Example: >>> intersection_by([1.2, 1.5, 1.7, 2.8], [0.9, 3.2], round) [1.2, 2.8] .. versionadded:: 4.0.0 Nrqc t|Srrarws r]rz!intersection_by.. c%jjr_keyrrr sortedrsiterintersectionrus r]r#r#s2 !!!HE  %jD6DDDVDDHfF 8 8 9 9 9F%eUXFFFGG  E  Lr_c|dd}|s|Stdg|Ri|\}}t|d}|D]%}tt|||}|sn&|S)a This method is like :func:`intersection` except that it accepts a comparator which is invoked to compare the elements of all arrays. The order and references of result values are determined by the first array. The comparator is invoked with two arguments: ``(arr_val, oth_val)``. Args: array (list): The array to find the intersection of. others (list): Lists to check for intersection with `array`. Keyword Args: comparator (callable, optional): Function to compare the elements of the arrays. Defaults to :func:`.is_equal`. Returns: list: Intersection of provided lists. Example: >>> array = ['apple', 'banana', 'pear'] >>> others = (['avocado', 'pumpkin'], ['peach']) >>> comparator = lambda a, b: a[0] == b[0] >>> intersection_with(array, *others, comparator=comparator) ['pear'] .. versionadded:: 4.0.0 Nryc t|Srrrs r]rz#intersection_with..2rr_rr{r)r[rorvryrws r]r$r$s6 !!!HE  ' HvHHHHHJF 8 8 9 9 9F%eUzJJJKK  E  Lr_c<tt||S)a\ Insert a separating element between the elements of `array`. Args: array (list): List to intersperse. separator (mixed): Element to insert. Returns: list: Interspersed list. Example: >>> intersperse([1, [2], [3], 4], 'x') [1, 'x', [2], 'x', [3], 'x', 4] .. versionadded:: 2.0.0 )rsiterinterspersers r]r%r%<s$ y11 2 22r_c&t|ddS)z Return the last element of `array`. Args: array (list): List to process. Returns: mixed: Last part of `array`. Example: >>> last([1, 2, 3, 4]) 4 .. versionadded:: 1.0.0 rzNrrris r]r&r&Qs" E2t , , ,,r_c t|x}} t|}|dkrtd||znt||dz }n#tt f$rYnwxYw|r||kr|||kr|S|dz}|dS)a Gets the index at which the last occurrence of value is found. Args: array (list): List to search. value (mixed): Value to search for. from_index (int, optional): Index to search from. Returns: int: Index of found item or ``False`` if not found. Example: >>> last_index_of([1, 2, 2, 4], 2) 2 >>> last_index_of([1, 2, 2, 4], 2, from_index=1) 1 .. versionadded:: 1.0.0 rrrz)rar`maxr TypeErrorr)r[rrr array_lens r]r'r'es*E "EI]__ /91nnAuz)***#jRWZ[R[B\B\ z "      9  u!6!6L    2sAA#"A#c:ttj||S)a Map a iteratee to each element of a list and concatenate the results into a single list using :func:`concat`. Args: array (list): List to map and concatenate. iteratee (mixed): Iteratee to apply to each element. Returns: list: Mapped and concatenated list. Example: >>> mapcat(range(4), lambda x: list(range(x))) [0, 0, 1, 0, 1, 2] .. versionadded:: 2.0.0 )r rmap_r[rqs r]r(r(s& 38E8,, --r_c,tj||S)a Gets the element at index n of array. Args: array (list): List passed in by the user. pos (int): Index of element to return. Returns: mixed: Returns the element at :attr:`pos`. Example: >>> nth([1, 2, 3], 0) 1 >>> nth([3, 4, 5, 6], 2) 5 >>> nth([11, 22, 33], -1) 33 >>> nth([11, 22, 33]) 11 .. versionadded:: 4.0.0 )rr|)r[poss r]r)r)s0 75#  r_rzc,||S)a4 Remove element of array at `index` and return element. Args: array (list): List to pop from. index (int, optional): Index to remove element from. Defaults to ``-1``. Returns: mixed: Value at `index`. Warning: `array` is modified in place. Example: >>> array = [1, 2, 3, 4] >>> item = pop(array) >>> item 4 >>> array [1, 2, 3] >>> item = pop(array, index=0) >>> item 1 >>> array [2, 3] .. versionadded:: 2.2.0 popr[rs r]rrs< 99U  r_c"t||S)a Removes all provided values from the given array. Args: array (list): List to pull from. values (mixed): Values to remove. Returns: list: Modified `array`. Warning: `array` is modified in place. Example: >>> pull([1, 2, 2, 3, 3, 4], 2, 3) [1, 4] .. versionadded:: 1.0.0 .. versionchanged:: 4.0.0 :func:`pull` method now calls :func:`pull_all` method for the desired functionality. )r+r[valuess r]r*r*s2 E6 " ""r_c*t|g|R|dd<|S)a0 Removes all provided values from the given array. Args: array (list): Array to modify. values (list): Values to remove. Returns: list: Modified `array`. Example: >>> pull_all([1, 2, 2, 3, 3, 4], [2, 3]) [1, 4] .. versionadded:: 4.0.0 N)rMrs r]r+r+s&&u&v&&&E!!!H Lr_cbt|t|||}t||S)a This method is like :func:`pull_all` except that it accepts iteratee which is invoked for each element of array and values to generate the criterion by which they're compared. The iteratee is invoked with one argument: ``(value)``. Args: array (list): Array to modify. values (list): Values to remove. iteratee (mixed, optional): Function to transform the elements of the arrays. Defaults to :func:`.identity`. Returns: list: Modified `array`. Example: >>> array = [{'x': 1}, {'x': 2}, {'x': 3}, {'x': 1}] >>> pull_all_by(array, [{'x': 1}, {'x': 3}], 'x') [{'x': 2}] .. versionadded:: 4.0.0 rr)rrr+)r[rrqs r]r,r,s2.}UFXNNN O OF E6 " ""r_cbt|t|||}t||S)a This method is like :func:`pull_all` except that it accepts comparator which is invoked to compare elements of array to values. The comparator is invoked with two arguments: ``(arr_val, oth_val)``. Args: array (list): Array to modify. values (list): Values to remove. comparator (callable, optional): Function to compare the elements of the arrays. Defaults to :func:`.is_equal`. Returns: list: Modified `array`. Example: >>> array = [{'x': 1, 'y': 2}, {'x': 3, 'y': 4}, {'x': 5, 'y': 6}] >>> res = pull_all_with(array, [{'x': 3, 'y': 4}], lambda a, b: a == b) >>> res == [{'x': 1, 'y': 2}, {'x': 5, 'y': 6}] True >>> array = [{'x': 1, 'y': 2}, {'x': 3, 'y': 4}, {'x': 5, 'y': 6}] >>> res = pull_all_with(array, [{'x': 3, 'y': 4}], lambda a, b: a != b) >>> res == [{'x': 3, 'y': 4}] True .. versionadded:: 4.0.0 r{)rrr+)r[rrys r]r-r-+s28ufTTT U UF E6 " ""r_cRt|}t|dD]}||=|S)a Removes elements from `array` corresponding to the specified indexes and returns a list of the removed elements. Indexes may be specified as a list of indexes or as individual arguments. Args: array (list): List to pull from. indexes (int): Indexes to pull. Returns: list: Modified `array`. Warning: `array` is modified in place. Example: >>> pull_at([1, 2, 3, 4], 0, 2) [2, 4] .. versionadded:: 1.1.0 Tr)rr)r[indexesrs r]r.r.Ks;,gG... %LL Lr_c:|D]}|||S)a Push items onto the end of `array` and return modified `array`. Args: array (list): List to push to. items (mixed): Items to append. Returns: list: Modified `array`. Warning: `array` is modified in place. Example: >>> array = [1, 2, 3] >>> push(array, 4, 5, [6]) [1, 2, 3, 4, 5, [6]] .. versionadded:: 2.2.0 .. versionchanged:: 4.0.0 Removed alias ``append``. appendr[itemsrhs r]r/r/hs-2 T Lr_cg}g}t||D]@\}}}}|r|||%|||A||dd<|S)a3 Removes all elements from a list that the predicate returns truthy for and returns an array of removed elements. Args: array (list): List to remove elements from. predicate (mixed, optional): Predicate applied per iteration. Returns: list: Removed elements of `array`. Warning: `array` is modified in place. Example: >>> array = [1, 2, 3, 4] >>> items = remove(array, lambda x: x >= 3) >>> items [3, 4] >>> array [1, 2] .. versionadded:: 1.0.0 N)r r)r[rremovedkeptrrrZs r]r0r0s~4G D( ::""Aq  " NN58 $ $ $ $ KKa ! ! ! !E!!!H Nr_c|dddS)z Return `array` in reverse order. Args: array (list|string): Object to process. Returns: list|string: Reverse of object. Example: >>> reverse([1, 2, 3, 4]) [4, 3, 2, 1] .. versionadded:: 2.2.0 NrzrXris r]r1r1s& 2;r_c"t|dS)a Remove the first element of `array` and return it. Args: array (list): List to shift. Returns: mixed: First element of `array`. Warning: `array` is modified in place. Example: >>> array = [1, 2, 3, 4] >>> item = shift(array) >>> item 1 >>> array [2, 3, 4] .. versionadded:: 2.2.0 rrris r]r2r2s0 ua==r_cZ| |dkr|dznt||zdz}|||S)a Slices `array` from the `start` index up to, but not including, the `end` index. Args: array (list): Array to slice. start (int, optional): Start index. Defaults to ``0``. end (int, optional): End index. Defaults to selecting the value at ``start`` index. Returns: list: Sliced list. Example: >>> slice_([1, 2, 3, 4]) [1] >>> slice_([1, 2, 3, 4], 1) [2] >>> slice_([1, 2, 3, 4], 1, 3) [2, 3] .. versionadded:: 1.1.0 Nrrr)r[rrs r]r3r3s=. {"aZZuqyyc%jj5.@1.D s r_Fc||r|rtd|rt|}||||S)a Sort `array` using optional `comparator`, `key`, and `reverse` options and return sorted `array`. Note: Python 3 removed the option to pass a custom comparator function and instead only allows a key function. Therefore, if a comparator function is passed in, it will be converted to a key function automatically using ``functools.cmp_to_key``. Args: array (list): List to sort. comparator (callable, optional): A custom comparator function used to sort the list. Function should accept two arguments and return a negative, zero, or position number depending on whether the first argument is considered smaller than, equal to, or larger than the second argument. Defaults to ``None``. This argument is mutually exclusive with `key`. key (iteratee, optional): A function of one argument used to extract a a comparator key from each list element. Defaults to ``None``. This argument is mutually exclusive with `comparator`. reverse (bool, optional): Whether to reverse the sort. Defaults to ``False``. Returns: list: Sorted list. Warning: `array` is modified in place. Example: >>> sort([2, 1, 4, 3]) [1, 2, 3, 4] >>> sort([2, 1, 4, 3], reverse=True) [4, 3, 2, 1] >>> results = sort([{'a': 2, 'b': 1}, {'a': 3, 'b': 2}, {'a': 0, 'b': 3}], key=lambda item: item['a']) >>> assert results == [{'a': 0, 'b': 3}, {'a': 2, 'b': 1}, {'a': 3, 'b': 2}] .. versionadded:: 2.2.0 z;The "comparator" and "key" arguments are mutually exclusive)rr1)rrr4)r[ryrr1s r]r4r4sUXXcXVWWW%$$ JJ3J((( Lr_c"t||S)a  Uses a binary search to determine the lowest index at which `value` should be inserted into `array` in order to maintain its sort order. Args: array (list): List to inspect. value (mixed): Value to evaluate. Returns: int: Returns the index at which `value` should be inserted into `array`. Example: >>> sorted_index([1, 2, 2, 3, 4], 2) 1 .. versionadded:: 1.0.0 .. versionchanged:: 4.0.0 Move iteratee support to :func:`sorted_index_by`. )r6r[rs r]r5r53s, 5% ( ((r_cr:tjtfd|D}|}t||S)a This method is like :func:`sorted_index` except that it accepts iteratee which is invoked for `value` and each element of `array` to compute their sort ranking. The iteratee is invoked with one argument: ``(value)``. Args: array (list): List to inspect. value (mixed): Value to evaluate. iteratee (mixed, optional): The iteratee invoked per element. Defaults to :func:`.identity`. Returns: int: Returns the index at which `value` should be inserted into `array`. Example: >>> array = [{'x': 4}, {'x': 5}] >>> sorted_index_by(array, {'x': 4}, lambda o: o['x']) 0 >>> sorted_index_by(array, {'x': 4}, 'x') 0 .. versionadded:: 4.0.0 c3.K|]}|VdSrrXrYrhrqs r]rz"sorted_index_by..g+88$xx~~888888r_)rrqrrr[rrqs `r]r6r6Ls[0 <))8888%88888 ue $ $$r_cht||}|t|kr|||kr|SdS)a Returns the index of the matched `value` from the sorted `array`, else ``-1``. Args: array (list): Array to inspect. value (mixed): Value to search for. Returns: int: Returns the index of the first matched value, else ``-1``. Example: >>> sorted_index_of([3, 5, 7, 10], 3) 0 >>> sorted_index_of([10, 10, 5, 7, 3], 10) -1 .. versionadded:: 4.0.0 rz)r5rar[rrs r]r7r7ms<(  & &E s5zzeEle33 rr_c"t||S)a6 This method is like :func:`sorted_index` except that it returns the highest index at which `value` should be inserted into `array` in order to maintain its sort order. Args: array (list): List to inspect. value (mixed): Value to evaluate. Returns: int: Returns the index at which `value` should be inserted into `array`. Example: >>> sorted_last_index([1, 2, 2, 3, 4], 2) 3 .. versionadded:: 1.1.0 .. versionchanged:: 4.0.0 Move iteratee support to :func:`sorted_last_index_by`. )r9rs r]r8r8s, u - --r_cr:tjtfd|D}|}t||S)a This method is like :func:`sorted_last_index` except that it accepts iteratee which is invoked for `value` and each element of `array` to compute their sort ranking. The iteratee is invoked with one argument: ``(value)``. Args: array (list): List to inspect. value (mixed): Value to evaluate. iteratee (mixed, optional): The iteratee invoked per element. Defaults to :func:`.identity`. Returns: int: Returns the index at which `value` should be inserted into `array`. Example: >>> array = [{'x': 4}, {'x': 5}] >>> sorted_last_index_by(array, {'x': 4}, lambda o: o['x']) 1 >>> sorted_last_index_by(array, {'x': 4}, 'x') 1 c3.K|]}|VdSrrXrs r]rz'sorted_last_index_by..rr_)rrqrrrs `r]r9r9s[, <))8888%88888 u % %%r_cnt||dz }|t|kr|||kr|SdS)a This method is like :func:`last_index_of` except that it performs a binary search on a sorted `array`. Args: array (list): Array to inspect. value (mixed): Value to search for. Returns: int: Returns the index of the matched value, else ``-1``. Example: >>> sorted_last_index_of([4, 5, 5, 5, 6], 5) 3 >>> sorted_last_index_of([6, 5, 5, 5, 4], 6) -1 .. versionadded:: 4.0.0 rrz)r8rars r]r:r:sA* eU + +a /E s5zzeEle33 rr_c:tt|S)aY Return sorted array with unique elements. Args: array (list): List of values to be sorted. Returns: list: List of unique elements in a sorted fashion. Example: >>> sorted_uniq([4, 2, 2, 5]) [2, 4, 5] >>> sorted_uniq([-2, -2, 4, 1]) [-2, 1, 4] .. versionadded:: 4.0.0 )rrGris r]r;r;s& $u++  r_c>tt||S)a This method is like :func:`sorted_uniq` except that it accepts iteratee which is invoked for each element in array to generate the criterion by which uniqueness is computed. The order of result values is determined by the order they occur in the array. The iteratee is invoked with one argument: ``(value)``. Args: array (list): List of values to be sorted. iteratee (mixed, optional): Function to transform the elements of the arrays. Defaults to :func:`.identity`. Returns: list: Unique list. Example: >>> sorted_uniq_by([3, 2, 1, 3, 2, 1], lambda val: val % 2) [2, 3] .. versionadded:: 4.0.0 rr)rrHrs r]r<r<s, '%(333 4 44r_c |t||z }tj|}|rt|}||||z}||||z=t |D]}||||rd|S|S)ac Modify the contents of `array` by inserting elements starting at index `start` and removing `count` number of elements after. Args: array (list|str): List to splice. start (int): Start to splice at. count (int, optional): Number of items to remove starting at `start`. If ``None`` then all items after `start` are removed. Defaults to ``None``. items (mixed): Elements to insert starting at `start`. Each item is inserted in the order given. Returns: list|str: The removed elements of `array` or the spliced string. Warning: `array` is modified in place if ``list``. Example: >>> array = [1, 2, 3, 4] >>> splice(array, 1) [2, 3, 4] >>> array [1] >>> array = [1, 2, 3, 4] >>> splice(array, 1, 2) [2, 3] >>> array [1, 4] >>> array = [1, 2, 3, 4] >>> splice(array, 1, 2, 0, 0) [2, 3] >>> array [1, 0, 0, 4] .. versionadded:: 2.2.0 .. versionchanged:: 3.0.0 Support string splicing. N)rar is_stringrsr1insertjoin)r[rcountrr rrhs r]r=r= sT }E U" e$$IU EEEM)*G eeem#$"" UD!!!!wwu~~r_c*|d|||dgS)a= Returns a list of two lists composed of the split of `array` at `index`. Args: array (list): List to split. index (int): Index to split at. Returns: list: Split list. Example: >>> split_at([1, 2, 3, 4], 2) [[1, 2], [3, 4]] .. versionadded:: 2.0.0 NrXrs r]r>r>Ks$ &5&M5= ))r_c|ddS)a= Return all but the first element of `array`. Args: array (list): List to process. Returns: list: Rest of the list. Example: >>> tail([1, 2, 3, 4]) [2, 3, 4] .. versionadded:: 1.0.0 .. versionchanged:: 4.0.0 Renamed from ``rest`` to ``tail``. rNrXris r]r?r?`s( 9r_c*t|fdS)a Creates a slice of `array` with `n` elements taken from the beginning. Args: array (list): List to process. n (int, optional): Number of elements to take. Defaults to ``1``. Returns: list: Taken list. Example: >>> take([1, 2, 3, 4], 2) [1, 2] .. versionadded:: 1.0.0 .. versionchanged:: 1.1.0 Added ``n`` argument and removed as alias of :func:`first`. .. versionchanged:: 3.0.0 Made ``n`` default to ``1``. c|kSrrXrs r]rztake..rr_)rCrs `r]r@r@wrr_cLt|t|fdS)a Creates a slice of `array` with `n` elements taken from the end. Args: array (list): List to process. n (int, optional): Number of elements to take. Defaults to ``1``. Returns: list: Taken list. Example: >>> take_right([1, 2, 3, 4], 2) [3, 4] .. versionadded:: 1.1.0 .. versionchanged:: 3.0.0 Made ``n`` default to ``1``. c|z kSrrXrs r]rztake_right..rr_)rarBrs `@r]rArArr_cxt|}t||dD]\}}}}|r|dz}||dS)a Creates a slice of `array` with elements taken from the end. Elements are taken until the `predicate` returns falsey. The `predicate` is invoked with three arguments: ``(value, index, array)``. Args: array (list): List to process. predicate (mixed): Predicate called per iteration Returns: list: Dropped list. Example: >>> take_right_while([1, 2, 3, 4], lambda x: x >= 3) [3, 4] .. versionadded:: 1.1.0 TrrNrrs r]rBrBsZ( E A( 4HHHAq   FAA  9r_cZd}t||D]\}}}}|r|dz }|d|S)a Creates a slice of `array` with elements taken from the beginning. Elements are taken until the `predicate` returns falsey. The `predicate` is invoked with three arguments: ``(value, index, array)``. Args: array (list): List to process. predicate (mixed): Predicate called per iteration Returns: list: Taken list. Example: >>> take_while([1, 2, 3, 4], lambda x: x < 3) [1, 2] .. versionadded:: 1.1.0 rrNrrs r]rCrCsO( A( ::Aq   FAA  !9r_ct|s |ddStt|gt|zS)aD Computes the union of the passed-in arrays. Args: array (list): List to union with. others (list): Lists to unionize with `array`. Returns: list: Unionized list. Example: >>> union([1, 2, 3], [2, 3, 4], [3, 4, 5]) [1, 2, 3, 4, 5] .. versionadded:: 1.0.0 N)rGrrsrns r]rDrDs<$ QQQx $v,,.// 0 00r_c|s |ddStdg|Ri|\}}tt|gt|z|S)a This method is similar to :func:`union` except that it accepts iteratee which is invoked for each element of each arrays to generate the criterion by which uniqueness is computed. Args: array (list): List to unionize with. others (list): Lists to unionize with `array`. Keyword Args: iteratee (callable): Function to invoke on each element. Returns: list: Unionized list. Example: >>> union_by([1, 2, 3], [2, 3, 4], iteratee=lambda x: x % 2) [1, 2] >>> union_by([1, 2, 3], [2, 3, 4], iteratee=lambda x: x % 9) [1, 2, 3, 4] .. versionadded:: 4.0.0 Nrqrr)r rHrrs)r[rorvrqs r]rErEsc0 QQQx%jD6DDDVDDHf 7E7T&\\122X F F FFr_c|s |ddStdg|Ri|\}}tt|gt|z|S)a This method is like :func:`union` except that it accepts comparator which is invoked to compare elements of arrays. Result values are chosen from the first array in which the value occurs. Args: array (list): List to unionize with. others (list): Lists to unionize with `array`. Keyword Args: comparator (callable, optional): Function to compare the elements of the arrays. Defaults to :func:`.is_equal`. Returns: list: Unionized list. Example: >>> comparator = lambda a, b: (a % 2) == (b % 2) >>> union_with([1, 2, 3], [2, 3, 4], comparator=comparator) [1, 2] >>> union_with([1, 2, 3], [2, 3, 4]) [1, 2, 3, 4] .. versionadded:: 4.0.0 Nryr{)r rIrrs)r[rorvrys r]rFrFsc4 QQQx' HvHHHHHJ WeWtF||344 L L LLr_c t|S)aU Creates a duplicate-value-free version of the array. If iteratee is passed, each element of array is passed through a iteratee before uniqueness is computed. The iteratee is invoked with three arguments: ``(value, index, array)``. If an object path is passed for iteratee, the created iteratee will return the path value of the given element. If an object is passed for iteratee, the created filter style iteratee will return ``True`` for elements that have the properties of the given object, else ``False``. Args: array (list): List to process. Returns: list: Unique list. Example: >>> uniq([1, 2, 3, 1, 2, 3]) [1, 2, 3] .. versionadded:: 1.0.0 .. versionchanged:: 4.0.0 - Moved `iteratee` argument to :func:`uniq_by`. - Removed alias ``unique``. )rHris r]rGrGAs6 5>>r_c>tt||S)a This method is like :func:`uniq` except that it accepts iteratee which is invoked for each element in array to generate the criterion by which uniqueness is computed. The order of result values is determined by the order they occur in the array. The iteratee is invoked with one argument: ``(value)``. Args: array (list): List to process. iteratee (mixed, optional): Function to transform the elements of the arrays. Defaults to :func:`.identity`. Returns: list: Unique list. Example: >>> uniq_by([1, 2, 3, 1, 2, 3], lambda val: val % 2) [1, 2] .. versionadded:: 4.0.0 rrrs iteruniquers r]rHrH_s,  58444 5 55r_c>tt||S)au This method is like :func:`uniq` except that it accepts comparator which is invoked to compare elements of array. The order of result values is determined by the order they occur in the array.The comparator is invoked with two arguments: ``(value, other)``. Args: array (list): List to process. comparator (callable, optional): Function to compare the elements of the arrays. Defaults to :func:`.is_equal`. Returns: list: Unique list. Example: >>> uniq_with([1, 2, 3, 4, 5], lambda a, b: (a % 2) == (b % 2)) [1, 2] .. versionadded:: 4.0.0 r{r)r[rys r]rIrIxs*  5Z888 9 99r_cVt|D]}|d||S)a Insert the given elements at the beginning of `array` and return the modified list. Args: array (list): List to modify. items (mixed): Items to insert. Returns: list: Modified list. Warning: `array` is modified in place. Example: >>> array = [1, 2, 3, 4] >>> unshift(array, -1, -2) [-1, -2, 1, 2, 3, 4] >>> array [-1, -2, 1, 2, 3, 4] .. versionadded:: 2.2.0 r)r1r rs r]rJrJs50 Q Lr_ct|S)a The inverse of :func:`zip_`, this method splits groups of elements into lists composed of elements from each group at their corresponding indexes. Args: array (list): List to process. Returns: list: Unzipped list. Example: >>> unzip([[1, 4, 7], [2, 5, 8], [3, 6, 9]]) [[1, 2, 3], [4, 5, 6], [7, 8, 9]] .. versionadded:: 1.0.0 )rQris r]rKrKs$ <r_cf|sgSt|}|Sfd}tj||S)a& This method is like :func:`unzip` except that it accepts a iteratee to specify how regrouped values should be combined. The iteratee is invoked with four arguments: ``(accumulator, value, index, group)``. Args: array (list): List to process. iteratee (callable, optional): Function to combine regrouped values. Returns: list: Unzipped list. Example: >>> from pydash import add >>> unzip_with([[1, 10, 100], [2, 20, 200]], add) [3, 30, 300] .. versionadded:: 3.3.0 Nc.tj|Sr)rreduce_)grouprqs r]rzunzip_with..cbks{5(+++r_)rKrr)r[rqresultrs ` r]rLrLsU*  5\\F ,,,,, 8FC  r_c fd|DS)a< Creates an array with all occurrences of the passed values removed. Args: array (list): List to filter. values (mixed): Values to remove. Returns: list: Filtered list. Example: >>> without([1, 2, 3, 2, 4, 4], 2, 4) [1, 3] .. versionadded:: 1.0.0 cg|]}|v| SrXrX)rYrhrs r]r^zwithout..s# 9 9 9Td&&8&8D&8&8&8r_rXrs `r]rMrMs$ : 9 9 9U 9 9 99r_ct|g|RS)a7 Creates a list that is the symmetric difference of the provided lists. Args: array (list): List to process. *lists (list): Lists to xor with. Returns: list: XOR'd list. Example: >>> xor([1, 3, 4], [1, 2, 4], [2]) [3] .. versionadded:: 1.0.0 )rO)r[listss r]rNrNs$ % %  r_c |s |ddStdg|Ri|\}}ttt||dzt ||d||g|ddRS)a" This method is like :func:`xor` except that it accepts iteratee which is invoked for each element of each arrays to generate the criterion by which by which they're compared. The order of result values is determined by the order they occur in the arrays. The iteratee is invoked with one argument: ``(value)``. Args: array (list): List to process. *lists (list): Lists to xor with. Keyword Args: iteratee (mixed, optional): Function to transform the elements of the arrays. Defaults to :func:`.identity`. Returns: list: XOR'd list. Example: >>> xor_by([2.1, 1.2], [2.3, 3.4], round) [1.2, 3.4] >>> xor_by([{'x': 1}], [{'x': 2}, {'x': 1}], 'x') [{'x': 2}] .. versionadded:: 4.0.0 Nrqrrrr)r rNrGrr#)r[r'rvrqs r]rOrOs6 QQQx$ZB%BBB6BBOHe  a uQx(CCC!       qrr    r_c |s |ddStdg|Ri|\}}ttt||dzt ||d||g|ddRS)ae This method is like :func:`xor` except that it accepts comparator which is invoked to compare elements of arrays. The order of result values is determined by the order they occur in the arrays. The comparator is invoked with two arguments: ``(arr_val, oth_val)``. Args: array (list): List to process. *lists (list): Lists to xor with. Keyword Args: comparator (callable, optional): Function to compare the elements of the arrays. Defaults to :func:`.is_equal`. Returns: list: XOR'd list. Example: >>> objects = [{'x': 1, 'y': 2}, {'x': 2, 'y': 1}] >>> others = [{'x': 1, 'y': 1}, {'x': 1, 'y': 2}] >>> expected = [{'y': 1, 'x': 2}, {'y': 1, 'x': 1}] >>> xor_with(objects, others, lambda a, b: a == b) == expected True .. versionadded:: 4.0.0 Nryrr{r)r rPrGrr$)r[r'rvcomps r]rPrP<s6 QQQx @@@@@@KD%  a !%qdCCC       qrr    r_c(dt|DS)a Groups the elements of each array at their corresponding indexes. Useful for separate data sources that are coordinated through matching array indexes. Args: arrays (list): Lists to process. Returns: list: Zipped list. Example: >>> zip_([1, 2, 3], [4, 5, 6], [7, 8, 9]) [[1, 4, 7], [2, 5, 8], [3, 6, 9]] .. versionadded:: 1.0.0 c,g|]}t|SrX)rsrgs r]r^zzip_..{s 0 0 04DJJ 0 0 0r_)ziprks r]rQrQhs& 1 03< 0 0 00r_cd|t|\}}tt||S)aK Creates a dict composed from lists of keys and values. Pass either a single two dimensional list, i.e. ``[[key1, value1], [key2, value2]]``, or two lists, one of keys and one of corresponding values. Args: keys (list): Either a list of keys or a list of ``[key, value]`` pairs. values (list, optional): List of values to zip. Returns: dict: Zipped dict. Example: >>> zip_object([1, 2, 3], [4, 5, 6]) {1: 4, 2: 5, 3: 6} .. versionadded:: 1.0.0 .. versionchanged:: 4.0.0 Removed alias ``object_``. )rKrr-)keysrs r]rRrR~s00~T{{ f D&!! " ""r_c |t|\}}i}t|D].\}}tj||tj||}/|S)a This method is like :func:`zip_object` except that it supports property paths. Args: keys (list): Either a list of keys or a list of ``[key, value]`` pairs. values (list, optional): List of values to zip. Returns: dict: Zipped dict. Example: >>> expected = {'a': {'b': {'c': 1, 'd': 2}}} >>> zip_object_deep(['a.b.c', 'a.b.d'], [1, 2]) == expected True .. versionadded:: 4.0.0 )rK enumeraterset_r|)r/robjidxrs r]rSrSs\&~T{{ f CdOO77ShsC!5!566 Jr_cd|vr |d}n(t|dkr|d}|dd}nd}t||S)a This method is like :func:`zip` except that it accepts a iteratee to specify how grouped values should be combined. The iteratee is invoked with four arguments: ``(accumulator, value, index, group)``. Args: *arrays (list): Lists to process. Keyword Args: iteratee (callable): Function to combine grouped values. Returns: list: Zipped list of grouped elements. Example: >>> from pydash import add >>> zip_with([1, 2], [10, 20], [100, 200], add) [111, 222] >>> zip_with([1, 2], [10, 20], [100, 200], iteratee=add) [111, 222] .. versionadded:: 3.3.0 rqrrzN)rarL)rlrvrqs r]rTrTsW2V*% Vq": fh ' ''r_c#K|D]C}t|ttfr!|dkrt||dz D]}|V?|VDdS)z/Iteratively flatten a list shallowly or deeply.rrN) isinstancerstupler)r[rrhsubitems r]rrsw dT5M * * uzz&tUQY77    JJJJ r_c'Kd|D}|rDg}|D]9} t|V||*#t$rY6wxYw|}|BdSdS)zInterleave multiple lists.c,g|]}t|SrX)iter)rYarrs r]r^z"iterinterleave..s ) ) )3T#YY ) ) )r_N)rr StopIteration)rliters nextitersitrs r]rrs ) )& ) ) )E     C 3ii  %%%%           s&? A  A c#dKt|}t|V|D] }|V|V dS)z!Iteratively intersperse iterable.N)r<r)iterablerrhs r]rrsPH~~H x.. r_c#K|sdS|tj|}t}g}|D]}||}n ||}|L ||vr|V||3#t$r ||vr|V||Y\wxYwd}|D]}|||rd}n|r|V||dS)z Yield each unique item in array.NTF)rrqsetaddrr) r[ryrq seen_hashableseen_unhashablerhcmp_itemunseen seen_items r]rr sC <))EEMO11  HHx~~H   5=00JJJ!%%h/// 5 5 5?22JJJ#**8444 5 F,   :h 22"FE 1 &&x000/11sA""'B  B c#xKg}t|D]%\}}||vr||fV||&dS)z!Yield duplictes found in `array`.N)r1r)r[seenrZrhs r]rr* s] DU##4 4<<T'MMMM KK     r_c#.K|r|sdS| tj}tj|}g}|D]e}||}||vr||g}|D]9}||} | |vr|| ||| r|Vn:fdS)zlYield intersecting values between `array` and `other` using `comparator` to determine if they intersect.N)ris_equalrqr) r[rwryrqrMrhrI seen_othersr cmp_values r]rr4 s \ |H%%H D8D>> t    H   E IK''   y ) ) )z(I..   #r_c#K|rsdS tjtjfd}g}g}|D]}||vs |||r|VdS)zsYield different values in `array` as compared to `other` using `comparator` to determine if they are different.Ncd}||vr>D]$}||rd}n%|r|||S)NTFr)rhrMis_diffrryrqrws r] is_differentz$iterdifference..is_differentb sv t    :hhtnnhhuoo>>#GE " D!!!r_)rrOrq)r[rwryrqrUrMnot_seenrhs ``` r]rtrtW s \ |H%%H        DH 8  ||D$77 JJJr_rWr)rN)r)rz)NNF)NN)a__doc__bisectrr functoolsrmathrpydashrhelpersrr r __all__r r r rrrrrrrrrrrrrrrrrrr r!r"r#r$r%r&r'r(r)rr*r+r,r-r.r/r0r1r2r3r4r5r6r7r8r9r:r;r<r=r>r?r@rArBrCrDrErFrGrHrIrJrKrLrMrNrOrPrQrRrSrTrrrrrrrtrXr_r]r^s8 -,,,,,,, ;;;;;;;;;;K \EEEE.,,,(.+++*&&&R---`99996KKKK2<:,55552;;;;|****.99996KKKK2<<1110GGG@MMMD<66662::::0<* ! ! ! !F:::*!!!*)))X)))X111,####<:!(!(!(R    "1"1"1"1J    Fr_