U f @s^dZddlmZddlZddlZddlmZmZm Z m Z m Z ddl m Z ddl mZddl mZdd l mZzddlZejZWn$ek rGd d d eZYnXzdd lmZWn$ek rd ejkrЂdZYnXdddddddddddddg ZdZeefZdZdZdZdZ d Z!d!Z"e d"Z#e d#Z$e ed$ee#d$fe$fZ%ze%e e$fZ&Wn0e'k re ed%ee d%fe$fZ&YnXd&d'Z(d(d)Z)d*d+Z*d,d-Z+d.dZ,d/dZ-Gd0d1d1eZ.e.Z/dHd3dZ0d4d5Z1d6dZ2d7dZ3d8dZ4dId:d;Z5dd?Z7dKd@dZ8dLdAdZ9dBdZ:dCdZ;dDdZdNdFdGZ?dS)Oz2Functions for working with nested data structures.)abcN)MappingSequenceTextTypeVarUnion) _is_attrs)_is_namedtuple)_sequence_like)_sortedc@seZdZdZdS) ObjectProxyz$Stub-class for `wrapt.ObjectProxy``.N)__name__ __module__ __qualname____doc__rr4/tmp/pip-target-lpfmz8o1/lib/python/tree/__init__.pyr !sr )_treeZsphinx is_nestedassert_same_structure unflatten_asflatten flatten_up_toflatten_with_pathflatten_with_path_up_to map_structuremap_structure_up_tomap_structure_with_pathmap_structure_with_path_up_totraverse MAP_TO_NONEz0.1.8zThe shallow_tree's keys are not a subset of the input_tree's keys. The shallow_tree has the following keys that are not in the input_tree: {}.zThe two structures don't have the same sequence type. Input structure has type {input_type}, while shallow structure has type {shallow_type}.zThe two structures don't have the same sequence length. Input structure has length {input_length}, while shallow structure has length {shallow_length}.zThe input_tree has fewer elements than the shallow_tree. Input structure has length {input_size}, while shallow structure has length {shallow_size}.zVIf shallow structure is a sequence, input must also be a sequence. Input has type: {}.zpIf shallow structure is a sequence, input must also be a sequence. Input at path: {path} has type: {input_type}.KVzStructureKV[K, V]z Structure[V]csfddjjDS)zReturns a list of (name, value) pairs from an attrs instance. The list will be sorted by name. Args: obj: an object. Returns: A list of (attr_name, attr_value) pairs. csg|]}|jt|jfqSr)namegetattr).0attrobjrr sz$_get_attrs_items..) __class____attrs_attrs__r(rr(r_get_attrs_itemsts r-ccst|D]\}}|VqdSN)_yield_sorted_items)iterable_vrrr _yield_valuesr3ccst|tjr*t|D]}|||fVqnXt|rHt|D] }|Vq:n:t|rn|jD]}|t||fVqVnt |D] }|VqvdS)aYield (key, value) pairs for `iterable` in a deterministic order. For Sequences, the key will be an int, the array index of a value. For Mappings, the key will be the dictionary key. For objects (e.g. namedtuples), the key will be the attribute name. In all cases, the keys will be iterated in sorted order. Args: iterable: an iterable. Yields: The iterable's (key, value) pairs, in order of sorted keys. N) isinstancecollections_abcrr r r-r _fieldsr% enumerate)r0keyitemfieldrrrr/s      r/cCs$t|rtt|jdSt|SdS)Nr,)r lenr%r+ structurerrr _num_elementssr>cCs t|S)a$Checks if a given structure is nested. >>> tree.is_nested(42) False >>> tree.is_nested({"foo": 42}) True Args: structure: A structure to check. Returns: `True` if a given structure is nested, i.e. is a sequence, a mapping, or a namedtuple, and `False` otherwise. )rZ is_sequencer<rrrrscCs t|S)aFlattens a possibly nested structure into a list. >>> tree.flatten([[1, 2, 3], [4, [5], [[6]]]]) [1, 2, 3, 4, 5, 6] If `structure` is not nested, the result is a single-element list. >>> tree.flatten(None) [None] >>> tree.flatten(1) [1] In the case of dict instances, the sequence consists of the values, sorted by key to ensure deterministic behavior. This is true also for :class:`~collections.OrderedDict` instances: their sequence order is ignored, the sorting order of keys is used instead. The same convention is followed in :func:`~tree.unflatten`. This correctly unflattens dicts and ``OrderedDict``\ s after they have been flattened, and also allows flattening an ``OrderedDict`` and then unflattening it back using a corresponding plain dict, or vice-versa. Dictionaries with non-sortable keys cannot be flattened. >>> tree.flatten({100: 'world!', 6: 'Hello'}) ['Hello', 'world!'] Args: structure: An arbitrarily nested structure. Returns: A list, the flattened version of the input `structure`. Raises: TypeError: If `structure` is or contains a mapping with non-sortable keys. )rrr<rrrrs$c@seZdZddZddZdS) _DotStringcCsdSN.rselfrrr__str__sz_DotString.__str__cCsdSr@rrBrrr__repr__sz_DotString.__repr__N)rrrrDrErrrrr?sr?Tc Csxzt|||Wn`ttfk rr}z>ttdd|}ttdd|}t|d|||fW5d}~XYnXdS)aAsserts that two structures are nested in the same way. >>> tree.assert_same_structure([(0, 1)], [(2, 3)]) Note that namedtuples with identical name and fields are always considered to have the same shallow structure (even with `check_types=True`). >>> Foo = collections.namedtuple('Foo', ['a', 'b']) >>> AlsoFoo = collections.namedtuple('Foo', ['a', 'b']) >>> tree.assert_same_structure(Foo(0, 1), AlsoFoo(2, 3)) Named tuples with different names are considered to have different shallow structures: >>> Bar = collections.namedtuple('Bar', ['a', 'b']) >>> tree.assert_same_structure(Foo(0, 1), Bar(2, 3)) Traceback (most recent call last): ... TypeError: The two structures don't have the same nested structure. ... Args: a: an arbitrarily nested structure. b: an arbitrarily nested structure. check_types: if `True` (default) types of sequences are checked as well, including the keys of dictionaries. If set to `False`, for example a list and a tuple of objects will look the same if they have the same size. Note that namedtuples with identical name and fields are always considered to have the same shallow structure. Raises: ValueError: If the two structures do not have the same number of elements or if the two structures are not nested in the same way. TypeError: If the two structures differ in the type of sequence in any of their substructures. Only possible if `check_types` is `True`. cSstSr._DOTr1rrrz'assert_same_structure..cSstSr.rFrHrrrrIrJz9%s Entire first structure: %s Entire second structure: %sN)rr ValueError TypeErrorstrrtype)ab check_typeseZstr1Zstr2rrrrs%cCs^g}t|D]H}t|r>t|||\}}|t|||}q ||||d7}q ||fS)aHelper function for ``unflatten_as``. Args: structure: Substructure (list / tuple / dict) to mimic. flat: Flattened values to output substructure for. index: Index at which to start reading from flat. Returns: The tuple (new_index, child), where: * new_index - the updated index into `flat` having processed `structure`. * packed - the subset of `flat` corresponding to `structure`, having started at `index`, and packed into the same nested format. Raises: ValueError: if `structure` contains more elements than `flat` (assuming indexing starts from `index`). r)r3r_packed_nest_with_indicesappendr )r=ZflatindexpackedsZ new_indexchildrrrrS&s  rScCst|stdt||t|sHt|dkr@tdt||dSt|}t|t|kr|tdt|t|||ft||d\}}t||S)aFUnflattens a sequence into a given structure. >>> tree.unflatten_as([[1, 2], [[3], [4]]], [5, 6, 7, 8]) [[5, 6], [[7], [8]]] If `structure` is a scalar, `flat_sequence` must be a single-element list; in this case the return value is ``flat_sequence[0]``. >>> tree.unflatten_as(None, [1]) 1 If `structure` is or contains a dict instance, the keys will be sorted to pack the flat sequence in deterministic order. This is true also for :class:`~collections.OrderedDict` instances: their sequence order is ignored, the sorting order of keys is used instead. The same convention is followed in :func:`~tree.flatten`. This correctly unflattens dicts and ``OrderedDict``\ s after they have been flattened, and also allows flattening an ``OrderedDict`` and then unflattening it back using a corresponding plain dict, or vice-versa. Dictionaries with non-sortable keys cannot be unflattened. >>> tree.unflatten_as({1: None, 2: None}, ['Hello', 'world!']) {1: 'Hello', 2: 'world!'} Args: structure: Arbitrarily nested structure. flat_sequence: Sequence to unflatten. Returns: `flat_sequence` unflattened into `structure`. Raises: ValueError: If `flat_sequence` and `structure` have different element counts. TypeError: If `structure` is or contains a mapping with non-sortable keys. z-flat_sequence must be a sequence not a {}: {}rz6Structure is a scalar but len(flat_sequence) == %d > 1rzyCould not pack sequence. Structure had %d elements, but flat_sequence had %d elements. Structure: %s, flat_sequence: %s.) rrLformatrNr;rKrrSr )r=Z flat_sequenceZflat_structurer1rVrrrrEs(& cststd|s td|dd}|rFtdd||ddD]}t|d ||d qRt|d fd d tt t |DS) aMaps `func` through given structures. >>> structure = [[1], [2], [3]] >>> tree.map_structure(lambda v: v**2, structure) [[1], [4], [9]] >>> tree.map_structure(lambda x, y: x * y, structure, structure) [[1], [4], [9]] >>> Foo = collections.namedtuple('Foo', ['a', 'b']) >>> structure = Foo(a=1, b=2) >>> tree.map_structure(lambda v: v * 2, structure) Foo(a=2, b=4) Args: func: A callable that accepts as many arguments as there are structures. *structures: Arbitrarily nested structures of the same layout. **kwargs: The only valid keyword argument is `check_types`. If `True` (default) the types of components within the structures have to be match, e.g. ``tree.map_structure(func, [1], (1,))`` will raise a `TypeError`, otherwise this is not enforced. Note that namedtuples with identical name and fields are considered to be the same type. Returns: A new structure with the same layout as the given ones. If the `structures` have components of varying types, the resulting structure will use the same types as ``structures[0]``. Raises: TypeError: If `func` is not callable. ValueError: If the two structures do not have the same number of elements or if the two structures are not nested in the same way. TypeError: If `check_types` is `True` and any two `structures` differ in the types of their components. ValueError: If no structures were given or if a keyword argument other than `check_types` is provided. zfunc must be callable, got: %sz#Must provide at least one structurerQTz8Only valid keyword arguments are `check_types` not: `%s`z`, `rNrrQcsg|] }|qSrr)r&argsfuncrrr*sz!map_structure..) callablerLrKpopjoinkeysrrzipmapr)r] structureskwargsrQotherrr\rrs $   cOst|d|f||S)aMaps `func` through given structures. This is a variant of :func:`~tree.map_structure` which accumulates a *path* while mapping through the structures. A path is a tuple of indices and/or keys which uniquely identifies the positions of the arguments passed to `func`. >>> tree.map_structure_with_path( ... lambda path, v: (path, v**2), ... [{"foo": 42}]) [{'foo': ((0, 'foo'), 1764)}] Args: func: A callable that accepts a path and as many arguments as there are structures. *structures: Arbitrarily nested structures of the same layout. **kwargs: The only valid keyword argument is `check_types`. If `True` (default) the types of components within the structures have to be match, e.g. ``tree.map_structure_with_path(func, [1], (1,))`` will raise a `TypeError`, otherwise this is not enforced. Note that namedtuples with identical name and fields are considered to be the same type. Returns: A new structure with the same layout as the given ones. If the `structures` have components of varying types, the resulting structure will use the same types as ``structures[0]``. Raises: TypeError: If `func` is not callable or if the `structures` do not have the same layout. TypeError: If `check_types` is `True` and any two `structures` differ in the types of their components. ValueError: If no structures were given or if a keyword argument other than `check_types` is provided. rr)r]rdrerrrrs$rc cst|ts,t|tjtjfs8t|s8t|s8||fVnRtt|}t|D]<\}}||f}||}t |||dD]\}}||fVqtqLdS)aYields (path, value) pairs of input_tree flattened up to shallow_tree. Args: shallow_tree: Nested structure. Traverse no further than its leaf nodes. input_tree: Nested structure. Return the paths and values from this tree. Must have the same upper structure as shallow_tree. path: Tuple. Optional argument, only used when recursing. The path from the root of the original shallow_tree, down to the root of the shallow_tree arg of this recursive call. Yields: Pairs of (path, value), where path the tuple path of a leaf node in shallow_tree, and value is the value of the corresponding node in input_tree. )pathN) r4_TEXT_OR_BYTESr5rrr r dictr/_yield_flat_up_to) shallow_tree input_treerh shallow_keyZshallow_subtreesubpathZ input_subtreeZ leaf_pathZ leaf_valuerrrrks&    rkc 'stfdd|D}z,|D]"}t|\}}|dd|VqWnRtk r}z4tdd}td|jdd |dd |W5d}~XYnXdS) z.Nrpaths)rzCould not find key 'rz' in some `input_trees`. Please ensure the structure of all `input_trees` are compatible with `shallow_tree`. The last valid path yielded was rA)rbKeyErrorlocalsgetrKr[)rlZ input_treesZzipped_iteratorsZpaths_and_valuesrqvaluesrRrrpr_multiyield_flat_up_tos  rvc st|rt|sH|dk r6ttjt|t|dnttt|t|tr^t|j }nt|}|rt||st |d}t |d}|r|rt ||stt jt||dn.t|tjrt|tjstt jt||dt|t|krttjt|t|dn,t|t|kr>> shallow_tree = {"a": "A", "b": "B"} >>> input_tree = {"a": 1, "c": 2} >>> _assert_shallow_structure(shallow_tree, input_tree) Traceback (most recent call last): ... ValueError: The shallow_tree's keys are not a subset of the input_tree's ... The following code will raise an exception: >>> shallow_tree = ["a", "b"] >>> input_tree = ["c", ["d", "e"], "f"] >>> _assert_shallow_structure(shallow_tree, input_tree) Traceback (most recent call last): ... ValueError: The two structures don't have the same sequence length. ... By setting check_types=False, we drop the requirement that corresponding nodes in shallow_tree and input_tree have to be the same type. Sequences are treated equivalently to Mappables that map integer keys (indices) to values. The following code will therefore not raise an exception: >>> _assert_shallow_structure({0: "foo"}, ["foo"], check_types=False) Args: shallow_tree: an arbitrarily nested structure. input_tree: an arbitrarily nested structure. path: if not `None`, a tuple containing the current path in the nested structure. This is only used for more informative errror messages. check_types: if `True` (default) the sequence types of `shallow_tree` and `input_tree` have to be the same. Raises: TypeError: If `shallow_tree` is a sequence but `input_tree` is not. TypeError: If the sequence types of `shallow_tree` are different from `input_tree`. Only raised if `check_types` is `True`. ValueError: If the sequence lengths of `shallow_tree` are different from `input_tree`. N)rh input_typeF)rw shallow_type)Z input_lengthZshallow_length)Z input_sizeZ shallow_sizecs2D]\}}||kr|Sqtt|gdSr.)rK_SHALLOW_TREE_HAS_INVALID_KEYSrY)rnZ input_key input_branchZ input_iterrrget_matching_input_branchrs  z<_assert_shallow_structure..get_matching_input_branchrZ)rrL._IF_SHALLOW_IS_SEQ_INPUT_MUST_BE_SEQ_WITH_PATHrYlistrN$_IF_SHALLOW_IS_SEQ_INPUT_MUST_BE_SEQr4r __wrapped__r rZsame_namedtuples"_STRUCTURES_HAVE_MISMATCHING_TYPESr5rr>rK$_STRUCTURES_HAVE_MISMATCHING_LENGTHS%_INPUT_TREE_SMALLER_THAN_SHALLOW_TREEr/_assert_shallow_structure) rlrmrhrQrxZshallow_is_namedtupleZinput_is_namedtupleZ shallow_iterr|rnZshallow_branchrzrr{rrst3           rcCs$t||d|dddt||DS)aFlattens `input_structure` up to `shallow_structure`. All further nested components in `input_structure` are retained as-is. >>> structure = [[1, 1], [2, 2]] >>> tree.flatten_up_to([None, None], structure) [[1, 1], [2, 2]] >>> tree.flatten_up_to([None, [None, None]], structure) [[1, 1], 2, 2] If `shallow_structure` and `input_structure` are not nested, the result is a single-element list: >>> tree.flatten_up_to(42, 1) [1] >>> tree.flatten_up_to(42, [1, 2, 3]) [[1, 2, 3]] Args: shallow_structure: A structure with the same (but possibly more shallow) layout as `input_structure`. input_structure: An arbitrarily nested structure. check_types: If `True`, check that each node in shallow_tree has the same type as the corresponding node in `input_structure`. Returns: A list, the partially flattened version of `input_structure` wrt `shallow_structure`. Raises: TypeError: If the layout of `shallow_structure` does not match that of `input_structure`. TypeError: If `check_types` is `True` and `shallow_structure` and `input_structure` differ in the types of their components. NrhrQcSsg|] \}}|qSrr)r&r1r2rrrr*sz!flatten_up_to..)rrkshallow_structureZinput_structurerQrrrrs$cCst||d|dtt||S)aFlattens `input_structure` up to `shallow_structure`. This is a combination of :func:`~tree.flatten_up_to` and :func:`~tree.flatten_with_path` Args: shallow_structure: A structure with the same (but possibly more shallow) layout as `input_structure`. input_structure: An arbitrarily nested structure. check_types: If `True`, check that each node in shallow_tree has the same type as the corresponding node in `input_structure`. Returns: A list of ``(path, item)`` pairs corresponding to the partially flattened version of `input_structure` wrt `shallow_structure`. Raises: TypeError: If the layout of `shallow_structure` does not match that of `input_structure`. TypeError: If `input_structure` is or contains a mapping with non-sortable keys. TypeError: If `check_types` is `True` and `shallow_structure` and `input_structure` differ in the types of their components. rr)rr~rkrrrrrscst|fddf||S)aMaps `func` through given structures up to `shallow_structure`. This is a variant of :func:`~tree.map_structure` which only maps the given structures up to `shallow_structure`. All further nested components are retained as-is. >>> structure = [[1, 1], [2, 2]] >>> tree.map_structure_up_to([None, None], len, structure) [2, 2] >>> tree.map_structure_up_to([None, [None, None]], str, structure) ['[1, 1]', ['2', '2']] Args: shallow_structure: A structure with layout common to all `structures`. func: A callable that accepts as many arguments as there are structures. *structures: Arbitrarily nested structures of the same layout. **kwargs: No valid keyword arguments. Raises: ValueError: If `func` is not callable or if `structures` have different layout or if the layout of `shallow_structure` does not match that of `structures` or if no structures were given. Returns: A new structure with the same layout as `shallow_structure`. cs|Sr.r)r1r[r\rrrIrJz%map_structure_up_to..rg)rr]rdrerr\rrs cOsDd|krtd~g}t|f|D]}|||q&t||S)a Maps `func` through given structures up to `shallow_structure`. This is a combination of :func:`~tree.map_structure_up_to` and :func:`~tree.map_structure_with_path` Args: shallow_structure: A structure with layout common to all `structures`. func: A callable that accepts a path and as many arguments as there are structures. *structures: Arbitrarily nested structures of the same layout. **kwargs: No valid keyword arguments. Raises: ValueError: If `func` is not callable or if `structures` have different layout or if the layout of `shallow_structure` does not match that of `structures` or if no structures were given. Returns: Result of repeatedly applying `func`. Has the same structure layout as `shallow_tree`. rQzDThe use of `check_types` is deprecated and does not have any effect.)loggingwarningrvrTr)rr]rdreresultsZpath_and_valuesrrrrs cCstt||S)a\Flattens a possibly nested structure into a list. This is a variant of :func:`~tree.flattens` which produces a list of pairs: ``(path, item)``. A path is a tuple of indices and/or keys which uniquely identifies the position of the corresponding ``item``. >>> tree.flatten_with_path([{"foo": 42}]) [((0, 'foo'), 42)] Args: structure: An arbitrarily nested structure. Returns: A list of ``(path, item)`` pairs corresponding to the flattened version of the input `structure`. Raises: TypeError: If ``structure`` is or contains a mapping with non-sortable keys. )r~rkr<rrrrscstfdd||dS)aETraverses the given nested structure, applying the given function. The traversal is depth-first. If ``top_down`` is True (default), parents are returned before their children (giving the option to avoid traversing into a sub-tree). >>> visited = [] >>> tree.traverse(visited.append, [(1, 2), [3], {"a": 4}], top_down=True) [(1, 2), [3], {'a': 4}] >>> visited [[(1, 2), [3], {'a': 4}], (1, 2), 1, 2, [3], 3, {'a': 4}, 4] >>> visited = [] >>> tree.traverse(visited.append, [(1, 2), [3], {"a": 4}], top_down=False) [(1, 2), [3], {'a': 4}] >>> visited [1, 2, (1, 2), 3, [3], 4, {'a': 4}, [(1, 2), [3], {'a': 4}]] Args: fn: The function to be applied to each sub-nest of the structure. When traversing top-down: If ``fn(subtree) is None`` the traversal continues into the sub-tree. If ``fn(subtree) is not None`` the traversal does not continue into the sub-tree. The sub-tree will be replaced by ``fn(subtree)`` in the returned structure (to replace the sub-tree with None, use the special value :data:`MAP_TO_NONE`). When traversing bottom-up: If ``fn(subtree) is None`` the traversed sub-tree is returned unaltered. If ``fn(subtree) is not None`` the sub-tree will be replaced by ``fn(subtree)`` in the returned structure (to replace the sub-tree with None, use the special value :data:`MAP_TO_NONE`). structure: The structure to traverse. top_down: If True, parent structures will be visited before their children. Returns: The structured output from the traversal. cs|Sr.r)r1xfnrrrISrJztraverse..)top_down)traverse_with_pathrr=rrrrr *s)csfddd|S)a.Traverses the given nested structure, applying the given function. The traversal is depth-first. If ``top_down`` is True (default), parents are returned before their children (giving the option to avoid traversing into a sub-tree). >>> visited = [] >>> tree.traverse_with_path( ... lambda path, subtree: visited.append((path, subtree)), ... [(1, 2), [3], {"a": 4}], ... top_down=True) [(1, 2), [3], {'a': 4}] >>> visited == [ ... ((), [(1, 2), [3], {'a': 4}]), ... ((0,), (1, 2)), ... ((0, 0), 1), ... ((0, 1), 2), ... ((1,), [3]), ... ((1, 0), 3), ... ((2,), {'a': 4}), ... ((2, 'a'), 4)] True >>> visited = [] >>> tree.traverse_with_path( ... lambda path, subtree: visited.append((path, subtree)), ... [(1, 2), [3], {"a": 4}], ... top_down=False) [(1, 2), [3], {'a': 4}] >>> visited == [ ... ((0, 0), 1), ... ((0, 1), 2), ... ((0,), (1, 2)), ... ((1, 0), 3), ... ((1,), [3]), ... ((2, 'a'), 4), ... ((2,), {'a': 4}), ... ((), [(1, 2), [3], {'a': 4}])] True Args: fn: The function to be applied to the path to each sub-nest of the structure and the sub-nest value. When traversing top-down: If ``fn(path, subtree) is None`` the traversal continues into the sub-tree. If ``fn(path, subtree) is not None`` the traversal does not continue into the sub-tree. The sub-tree will be replaced by ``fn(path, subtree)`` in the returned structure (to replace the sub-tree with None, use the special value :data:`MAP_TO_NONE`). When traversing bottom-up: If ``fn(path, subtree) is None`` the traversed sub-tree is returned unaltered. If ``fn(path, subtree) is not None`` the sub-tree will be replaced by ``fn(path, subtree)`` in the returned structure (to replace the sub-tree with None, use the special value :data:`MAP_TO_NONE`). structure: The structure to traverse. top_down: If True, parent structures will be visited before their children. Returns: The structured output from the traversal. cszfddfdd}rJ}|dkr8|S|tkrDdS|Sn,|}|}|dkrf|S|tkrrdS|SdS)z#Recursive traversal implementation.cs|\}}|f|Sr.r)r9Z subtree_pathZsubtree)rh traverse_implrr subtree_fnsz=traverse_with_path..traverse_impl..subtree_fncs$trtttSSdSr.)rr rcr/r)r=rrrtraverse_subtreess  zDtraverse_with_path..traverse_impl..traverse_subtreesN)r!)rhr=rretZtraversed_structurerrr)rhr=rrrs   z)traverse_with_path..traverse_implrrrrrrrVs> r)T)r)NT)T)T)T)T)@r collectionsrr5rsystypingrrrrrsequencer r r r Zwraptr ImportErrorobjecttreermodules__all__ __version__rMbytesriryrrrrr}r"r#Z StructureKVZ StructurerLr-r3r/r>rrr?rGrrSrrrrkrvrrrrrrr!r rrrrrs          "'  0;6( ! s , !! ,