ijmUdZddlmZddlZddlZddlZddlZddlZddlm Z m Z m Z m Z ddl mZmZddlmZddlmZmZmZmZmZmZmZmZddlmZddlmZmZm Z m!Z!m"Z"m#Z#dd l$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+dd l,m-Z-m.Z.m/Z/er)ddl0Z0dd l1m2Z2m3Z3m4Z4dd l$m5Z5m6Z6m7Z7m8Z8m9Z9ed e:e7Z;gdZej~dKddddde>Gddee)Z@[>GddZAeAZBdeCd<eZDdeCd<[Aer8ddlEmFZFeFdZGedZHeFdZIed ZJGd!d"eeGeHeIeJfZK dLd#ZLed$d% dMd&ZMe dNd$d% dOd'ZM dNd$d% dPd(ZMeLeMed) dQd*ZN[M[Le dNddd+ dRd,ZOe dSd-ZO dNddd+ dTd.ZOdUd/ZPejdVd0ZRdWd1ZSdXd2ZTdYd3ZUdZd4ZVd[d5ZWd\d6ZXd]d7ZYd^d8ZZd_d9Z[ d^d:Z\d_d;Z] d`d<Z^dad=Z_ dbd>Z` dcd?Za dbd@Zb dcdAZcdddBZddedCZedfdDZfdgdEZgdhdFZh didGZie:de@e:deTeUe!e'jHeke@ekeVeWe"e'jHeme@emeXeYe"e'jHeoe@eoeZe[ee'jHe e@e efege e'jHe e@e e^e_ee'jHe e@e e`eaee'jHe e@e edeee"e'jHe(e@e(eheie#e'jHi ZvdIeCdJ<e@eoe\e]ee'jHZwe@e ebecee'jHZxy)jz&Registry for custom pytree node types.) annotationsN) OrderedDict defaultdictdeque namedtuple) itemgetter methodcaller)Lock) TYPE_CHECKINGAnyCallableClassVarGeneric NamedTupleTypeVaroverload) AutoEntry MappingEntryNamedTupleEntry PyTreeEntry SequenceEntryStructSequenceEntry)ChildrenMetaData PyTreeKindStructSequenceTis_namedtuple_classis_structseq_class)safe_ziptotal_order_sortedunzip2) Collection GeneratorIterable)KTVTCustomTreeNode FlattenFunc UnflattenFuncCustomTreeNodeType)bound)register_pytree_noderegister_pytree_node_classunregister_pytree_nodedict_insertion_ordered slotsT)initrepreqfrozenceZdZUdZded<ded<ded<ej dk\rd ed <eZd ed <e jZ d ed<dZ ded<y)PyTreeNodeRegistryEntryz>A dataclass that stores the information of a pytree node type.zbuiltins.type[Collection[T]]typeFlattenFunc[T] flatten_funcUnflattenFunc[T]unflatten_funcr1zdataclasses.KW_ONLY_zbuiltins.type[PyTreeEntry]path_entry_typerkindstr namespaceN) __name__ __module__ __qualname____doc____annotations__sys version_inforrArCUSTOMrBrEd/var/www/html/emotional.easysim.app/public_html/venv/lib/python3.12/site-packages/optree/registry.pyr:r:IsPH &&  $$ 7" 2;O/;!((D*(IsrOr:c$eZdZUdZded<ddZy)GlobalNamespacerNzClassVar[tuple[()]] __slots__cy)NzrNselfs rP__repr__zGlobalNamespace.__repr__`s#rON)returnrD)rFrGrHrSrJrWrNrOrPrRrR]s%'I"'$rOrRrD__GLOBAL_NAMESPACEr __REGISTRY_LOCK) ParamSpec_P_T_GetP_GetTceZdZddZddZy)_CallableWithGetctNNotImplementedErrorrVargskwargss rP__call__z_CallableWithGet.__call__r% %rOctrcrdrfs rPgetz_CallableWithGet.getvrjrON)rgz_P.argsrhz _P.kwargsrXr])rgz _GetP.argsrhz _GetP.kwargsrXr_)rFrGrHrirlrNrOrPraraqs  & &rOracdfd }|S)Nc|_|Src)rl)funcrls rP decoratorz_add_get..decorators rO)rozCallable[_P, _T]rXz&_CallableWithGet[_P, _T, _GetP, _GetT]rN)rlrps` rP_add_getrqzs rOrC)rEcyrcrNclsrEs rPpytree_node_registry_getrus &)rOcyrcrNrss rPrurus +.rOcJ|turd}|,|tur$tj|st d|dt |t st d|d|t|dh}t5tjDcic]}|j|vr |j|}}dddtj|rtt <t"|t$<S|dk7rtj'||f}||Stj|r|t urtS|t$urt"Stj'|}||St)|rtj't*St-|rtj'tSycc}w#1swYxYw)aLook up the pytree node registry. >>> register_pytree_node.get() # doctest: +IGNORE_WHITESPACE,ELLIPSIS { : PyTreeNodeRegistryEntry( type=, flatten_func=, unflatten_func=, path_entry_type=, kind=, namespace='' ), : PyTreeNodeRegistryEntry( type=, flatten_func=, unflatten_func=, path_entry_type=, kind=, namespace='' ), : PyTreeNodeRegistryEntry( type=, flatten_func=, unflatten_func=, path_entry_type=, kind=, namespace='' ), ... } >>> register_pytree_node.get(defaultdict) # doctest: +IGNORE_WHITESPACE,ELLIPSIS PyTreeNodeRegistryEntry( type=, flatten_func=, unflatten_func=, path_entry_type=, kind=, namespace='' ) >>> register_pytree_node.get(frozenset) # frozenset is considered as a leaf node None Args: cls (type or None, optional): The class of the pytree node to retrieve. If not provided, all the registered pytree nodes in the namespace are returned. namespace (str, optional): The namespace of the registry to retrieve. If not provided, the global namespace is used. Returns: If the ``cls`` is not provided, a dictionary of all the registered pytree nodes in the namespace is returned. If the ``cls`` is provided, the corresponding registry entry is returned if the ``cls`` is registered as a pytree node. Otherwise, :data:`None` is returned, i.e., the ``cls`` is represented as a leaf node. rCNzExpected a class or None, got .$The namespace must be a string, got )rYrinspectisclass TypeError isinstancerD frozensetrZ_NODETYPE_REGISTRYvaluesrEr;_Cis_dict_insertion_ordered&_DICT_INSERTION_ORDERED_REGISTRY_ENTRYdict-_DEFAULTDICT_INSERTION_ORDERED_REGISTRY_ENTRYrrlrrr)rtrE namespaceshandlerregistrys rPrurusx&&   z !$8qABB i %29-q A   { 2/   288:$$ 2 g%H   ' ' 2CHTN$QH[ !B$(()S)9:  N ##I. $;9 9 + @ @ $$S)G#!%%n553!%%j11 9  s-F"F&FFF")rActj|std|dtj|rt|tstd|d|t urt |tstd|d|dk(r td|t ur|}d}n||f}t5tj|||||t|||||t|<ddd|S#1swY|SxYw) a3Extend the set of types that are considered internal nodes in pytrees. See also :func:`register_pytree_node_class` and :func:`unregister_pytree_node`. The ``namespace`` argument is used to avoid collisions that occur when different libraries register the same Python type with different behaviors. It is recommended to add a unique prefix to the namespace to avoid conflicts with other libraries. Namespaces can also be used to specify the same class in different namespaces for different use cases. .. warning:: For safety reasons, a ``namespace`` must be specified while registering a custom type. It is used to isolate the behavior of flattening and unflattening a pytree node type. This is to prevent accidental collisions between different libraries that may register the same type. Args: cls (type): A Python type to treat as an internal pytree node. flatten_func (callable): A function to be used during flattening, taking an instance of ``cls`` and returning a triple or optionally a pair, with (1) an iterable for the children to be flattened recursively, and (2) some hashable metadata to be stored in the treespec and to be passed to the ``unflatten_func``, and (3) (optional) an iterable for the tree path entries to the corresponding children. If the entries are not provided or given by :data:`None`, then `range(len(children))` will be used. unflatten_func (callable): A function taking two arguments: the metadata that was returned by ``flatten_func`` and stored in the treespec, and the unflattened children. The function should return an instance of ``cls``. path_entry_type (type, optional): The type of the path entry to be used in the treespec. (default: :class:`AutoEntry`) namespace (str): A non-empty string that uniquely identifies the namespace of the type registry. This is used to isolate the registry from other modules that might register a different custom behavior for the same type. Returns: The same type as the input ``cls``. Raises: TypeError: If the input type is not a class. TypeError: If the path entry class is not a subclass of :class:`PyTreeEntry`. TypeError: If the namespace is not a string. ValueError: If the namespace is an empty string. ValueError: If the type is already registered in the registry. .. versionadded:: 0.12.0 The ``path_entry_type`` argument to specify the path entry type used in :meth:`PyTreeSpec.accessors` and :func:`tree_flatten_with_accessor`. If not provided, :class:`AutoEntry` will be used. Examples: >>> # Register a Python type with lambda functions >>> register_pytree_node( ... set, ... lambda s: (sorted(s), None, None), ... lambda _, children: set(children), ... namespace='set', ... ) >>> # Register a custom type into a namespace with accessor support >>> import types >>> # This can be whatever your container type is. >>> class MyContainer(types.SimpleNamespace): ... pass >>> # (Optional) Define a custom path entry type for accessor support. >>> # Here we showcase how to define one. In practice, you can use the built-in ``GetAttrEntry``. >>> class MyContainerEntry(PyTreeEntry): ... def __call__(self, obj): ... return getattr(obj, self.entry) ... def codify(self, node=''): ... return f'{node}.{self.entry}' >>> register_pytree_node( # doctest: +ELLIPSIS ... MyContainer, ... flatten_func=lambda ct: ( ... list(vars(ct).values()), ... list(vars(ct).keys()), ... list(vars(ct).keys()), ... ), ... unflatten_func=lambda keys, values: MyContainer(**dict(zip(keys, values))), ... path_entry_type=MyContainerEntry, ... namespace='mycontainer', ... ) >>> tree = {'config': MyContainer(lr=0.01, momentum=0.9), 'steps': 1000} >>> # Flatten without specifying the namespace >>> tree_flatten(tree) # `MyContainer`s are leaf nodes ([MyContainer(lr=0.01, momentum=0.9), 1000], PyTreeSpec({'config': *, 'steps': *})) >>> # Flatten with the namespace >>> leaves, treespec = tree_flatten(tree, namespace='mycontainer') >>> leaves, treespec ([0.01, 0.9, 1000], PyTreeSpec({'config': CustomTreeNode(MyContainer[['lr', 'momentum']], [*, *]), 'steps': *}, namespace='mycontainer')) >>> # Custom ``entries`` are defined as attribute names >>> tree_paths(tree, namespace='mycontainer') [('config', 'lr'), ('config', 'momentum'), ('steps',)] >>> # Custom path entry type defines the pytree access behavior >>> accessors = tree_accessors(tree, namespace='mycontainer') >>> accessors[0].codify() "*['config'].lr" >>> accessors[0](tree) 0.01 >>> # Unflatten back to a copy of the original object >>> tree_unflatten(treespec, leaves) {'config': MyContainer(lr=0.01, momentum=0.9), 'steps': 1000} Expected a class, got rx(Expected a subclass of PyTreeEntry, got ryrC(The namespace cannot be an empty string.rArEN)rzr{r| issubclassrrYr}rD ValueErrorrZr register_noder:r)rtr=r?rArEregistration_keys rPr-r-sj ??3 0q9:: OOO ,O[1YB?BUUVWXX**:i3M>ym1MNNBCDD&& %s+          0G   + 0 +,  J  Js '1C""C,rcyrcrNrtrArEs rPr.r.s:=rOcyrcrNrs rPr.r.srOctusttr" tddk(r tddc tdturttst ddk(r td dfd }|St j st dd td tt j rttst d d tfd d DstfddDst dtjj dd}ttjtj dj  dd}|_|_t't)dj$S)aExtend the set of types that are considered internal nodes in pytrees. See also :func:`register_pytree_node` and :func:`unregister_pytree_node`. The ``namespace`` argument is used to avoid collisions that occur when different libraries register the same Python type with different behaviors. It is recommended to add a unique prefix to the namespace to avoid conflicts with other libraries. Namespaces can also be used to specify the same class in different namespaces for different use cases. .. warning:: For safety reasons, a ``namespace`` must be specified while registering a custom type. It is used to isolate the behavior of flattening and unflattening a pytree node type. This is to prevent accidental collisions between different libraries that may register the same type. Args: cls (type, optional): A Python type to treat as an internal pytree node. path_entry_type (type, optional): The type of the path entry to be used in the treespec. (default: :class:`AutoEntry`) namespace (str, optional): A non-empty string that uniquely identifies the namespace of the type registry. This is used to isolate the registry from other modules that might register a different custom behavior for the same type. Returns: The same type as the input ``cls`` if the argument presents. Otherwise, return a decorator function that registers the class as a pytree node. Raises: TypeError: If the path entry class is not a subclass of :class:`PyTreeEntry`. TypeError: If the namespace is not a string. TypeError: If the class does not define the required method pairs. ValueError: If the namespace is an empty string. ValueError: If the type is already registered in the registry. .. versionadded:: 0.12.0 The ``TREE_PATH_ENTRY_TYPE`` class variable to specify the path entry type used in :meth:`PyTreeSpec.accessors` and :func:`tree_flatten_with_accessor`. If not provided, :class:`AutoEntry` will be used. .. versionadded:: 0.18.0 Previously, this function looked for methods named ``tree_flatten`` and ``tree_unflatten`` for the given class. Since version 0.18.0, it prefers methods named ``__tree_flatten__`` and ``__tree_unflatten__`` instead. The old method names are still supported for backward compatibility, but it is recommended to use the new method names. The method resolution follows this priority: 1. If both ``__tree_flatten__`` and ``__tree_unflatten__`` are defined, use them directly. 2. If both ``tree_flatten`` and ``tree_unflatten`` are defined, wrap them as dunder methods. 3. If neither complete pair is available, raise a :exc:`TypeError` suggesting the new method names. This function is a thin wrapper around :func:`register_pytree_node`, and provides a class-oriented interface: .. code-block:: python @register_pytree_node_class(namespace='foo') class Special: TREE_PATH_ENTRY_TYPE = GetAttrEntry def __init__(self, x, y): self.x = x self.y = y def __tree_flatten__(self): return ((self.x, self.y), None, ('x', 'y')) @classmethod def __tree_unflatten__(cls, metadata, children): return cls(*children) @register_pytree_node_class('mylist') class MyList(UserList): TREE_PATH_ENTRY_TYPE = SequenceEntry def __tree_flatten__(self): return self.data, None, None @classmethod def __tree_unflatten__(cls, metadata, children): return cls(*children) # Legacy style (still supported but not recommended) @register_pytree_node_class(namespace='legacy') class LegacyStyleMyList(UserList): def tree_flatten(self): # Implementation automatically wrapped as __tree_flatten__ return self.data, None, None @classmethod def tree_unflatten(cls, metadata, children): # Implementation automatically wrapped as __tree_unflatten__ return cls(*children) Nz?Cannot specify `namespace` when the first argument is a string.rCrz.decorator's- /# rOrrxTREE_PATH_ENTRY_TYPErc3JK|]}tt|dywrccallablegetattr.0methodrts rP z-register_pytree_node_class..8s'  fd+, #)__tree_flatten____tree_unflatten__c3JK|]}tt|dywrcrrs rPrz-register_pytree_node_class..=s$ 5;HWS&$/ 0 r) tree_flattentree_unflattenzh must define both `__tree_flatten__` and `__tree_unflatten__` methods for registration as a pytree node.c"|jSrc)rrUs rPrz4register_pytree_node_class..__tree_flatten__Hs $$& &rO__func__c&|j||Src)r)rtmetadatachildrens rPrz6register_pytree_node_class..__tree_unflatten__Os%%h9 9rOrr)rtr+rXr+)rVCustomTreeNode[T]rXzQtuple[Children[T], MetaData] | tuple[Children[T], MetaData, Iterable[Any] | None])rtztype[CustomTreeNode[T]]rrrz Children[T]rXr)rYr}rDrr|rzr{rrrrall functoolswrapsr classmethodrrrr-r )rtrArErprrs``` rPr.r.s#D   JsC$8  ^_ _ "9GH HsYWXX**:i3M>ymLMMBCDD {  ??3 0q9::!#'=yI OOO ,O[1YB?BUUVWXX @   ?a  '55  )) * '# '_ ' + '  !3!3ZASAST U :( : :" :   : V  : 0!3 '( '  JrOchtj|std|d|turt |t std|d|dk(r t d|tur|}d}n||f}t5tj||tj|cdddS#1swYyxYw)aRemove a type from the pytree node registry. See also :func:`register_pytree_node` and :func:`register_pytree_node_class`. This function is the inverse operation of function :func:`register_pytree_node`. Args: cls (type): A Python type to remove from the pytree node registry. namespace (str): The namespace of the pytree node registry to remove the type from. Returns: The removed registry entry. Raises: TypeError: If the input type is not a class. TypeError: If the namespace is not a string. ValueError: If the namespace is an empty string. ValueError: If the type is a built-in type that cannot be unregistered. ValueError: If the type is not found in the registry. Examples: >>> # Register a Python type with lambda functions >>> register_pytree_node( ... set, ... lambda s: (sorted(s), None, None), ... lambda _, children: set(children), ... namespace='temp', ... ) >>> # Unregister the Python type >>> unregister_pytree_node(set, namespace='temp') rrxryrCrN) rzr{r|rYr}rDrrZrunregister_noderpop)rtrErs rPr/r/hsD ??3 0q9::**:i3M>ym1MNNBCDD&& %s+ 8 3 *!%%&67888s 3+B((B1c#K|turt|tstd|d|dk(r t d|turd}t 5t j|d}t jt||ddd dt 5t j|dddy#1swY4xYw#1swYyxYw#t 5t j|dddw#1swYwxYwxYww)aContext manager to temporarily set the dictionary sorting mode. This context manager is used to temporarily set the dictionary sorting mode for a specific namespace. The dictionary sorting mode is used to determine whether the keys of a dictionary should be sorted or keep the insertion order when flattening a pytree. >>> tree = {'b': (2, [3, 4]), 'a': 1, 'c': None, 'd': 5} >>> tree_flatten(tree) # doctest: +IGNORE_WHITESPACE ( [1, 2, 3, 4, 5], PyTreeSpec({'a': *, 'b': (*, [*, *]), 'c': None, 'd': *}) ) >>> with dict_insertion_ordered(True, namespace='some-namespace'): # doctest: +IGNORE_WHITESPACE ... tree_flatten(tree, namespace='some-namespace') ( [2, 3, 4, 1, 5], PyTreeSpec({'b': (*, [*, *]), 'a': *, 'c': None, 'd': *}, namespace='some-namespace') ) .. warning:: The dictionary sorting mode is a global setting and is **not thread-safe**. It is recommended to use this context manager in a single-threaded environment. Args: mode (bool): The dictionary sorting mode to set. namespace (str): The namespace to set the dictionary sorting mode for. ryrxrCrF)inherit_global_namespaceN) rYr}rDr|rrZrrset_dict_insertion_orderedbool)moderEprevs rPr0r0s:**:i3M>ym1MNNBCDD&& =++IPUV %%d4j)<=;  ;  ) )$ : ; ;== ; ;_ ;  ) )$ : ; ; ;sfAD 7B4D C DC+ D4B=9DC D C?C3* C?3C< 8C??Dc.t|tdS)Nr)key)r!r)itemss rP _sorted_itemsrs eA 77rOcy)N)rNNrN)r@s rP _none_flattenrs rOc\t}tt|||ur tdy)NzExpected no children.)objectnextiterr)r@rsentinels rP_none_unflattenrs-xH DNH%X50116rOc |dfSrcrNtups rP_tuple_flattenr 9rOct|Src)tupler@rs rP_tuple_unflattenrs ?rOc |dfSrcrN)lsts rP _list_flattenrrrOct|Src)listrs rP_list_unflattenrs >rOchtt|j\}}|t||fSrc)r"rrrdctkeysrs rP _dict_flattenrs,- 45LD& 4:t ##rOc,tt||Srcrr rrs rP_dict_unflattenr v& ''rOcVt|j\}}|t||fSrcr"rrrs rP_dict_insertion_ordered_flattenr)#))+&LD& 4:t ##rOc,tt||Srcrrs rP!_dict_insertion_ordered_unflattenrrrOcVt|j\}}|t||fSrcrrs rP_ordereddict_flattenrrrOc,tt||Src)rr rs rP_ordereddict_unflattenrs xf- ..rOcBt|\}}}||j|f|fSrc)rdefault_factoryrr dict_metadataentriess rP_defaultdict_flattenrs-&33%7"FM7 C''7 @@rOc8|\}}t|t||Src)rrrrrrs rP_defaultdict_unflattenrs" &."O]  v(N OOrOcBt|\}}}||j|f|fSrc)rrrs rP&_defaultdict_insertion_ordered_flattenr(s.&ES%I"FM7 C''7 @@rOc8|\}}t|t||Src)rrrs rP(_defaultdict_insertion_ordered_unflattenr4s$ &."O] (I-Y_(` aarOc||jfSrcmaxlen)deqs rP_deque_flattenr=s  ?rOct||S)Nr)r)rrs rP_deque_unflattenrAs & ))rOc|t|fSrcr;rs rP_namedtuple_flattenrE S >rOc ||SrcrNrtrs rP_namedtuple_unflattenrJs >rOc|t|fSrcr)seqs rP_structseq_flattenrNrrOc||SrcrNrs rP_structseq_unflattenrRs x=rO)rArBz6dict[type | tuple[str, type], PyTreeNodeRegistryEntry]rrN)rlzCallable[_GetP, _GetT]rXzDCallable[[Callable[_P, _T]], _CallableWithGet[_P, _T, _GetP, _GetT]])rtr;rErDrXzPyTreeNodeRegistryEntry | Nonerc)rtNonerErDrXz#dict[type, PyTreeNodeRegistryEntry])rtz type | NonerErDrXzDdict[type, PyTreeNodeRegistryEntry] | PyTreeNodeRegistryEntry | None) r=r<r?r>rttype[Collection[T]]rAztype[PyTreeEntry]rErDrXr )rt str | NonerAtype[PyTreeEntry] | NonerEr rXz2Callable[[CustomTreeNodeType], CustomTreeNodeType])rtr+rAr rErDrXr+)rtzCustomTreeNodeType | str | NonerAr rEr rXzGCustomTreeNodeType | Callable[[CustomTreeNodeType], CustomTreeNodeType])rtr;rErDrXr:)rrrErDrXzGenerator[None])rzIterable[tuple[KT, VT]]rXzlist[tuple[KT, VT]])r@rrXztuple[tuple[()], None])r@rrz Iterable[Any]rXr)r tuple[T, ...]rXztuple[tuple[T, ...], None])r@rr Iterable[T]rXr )rlist[T]rXztuple[list[T], None])r@rrr rXr)r dict[KT, VT]rX/tuple[tuple[VT, ...], list[KT], tuple[KT, ...]])rlist[KT]r Iterable[VT]rXr)rOrderedDict[KT, VT]rXr)rrrrrXr)rdefaultdict[KT, VT]rXzOtuple[tuple[VT, ...], tuple[Callable[[], VT] | None, list[KT]], tuple[KT, ...]])rz!tuple[Callable[[], VT], list[KT]]rrrXr)rdeque[T]rXztuple[deque[T], int | None])rz int | Nonerr rXr)r NamedTuple[T]rXz)tuple[tuple[T, ...], type[NamedTuple[T]]])rtztype[NamedTuple[T]]rr rXr)rStructSequence[T]rXz-tuple[tuple[T, ...], type[StructSequence[T]]])rtztype[StructSequence[T]]rr rXr)yrI __future__r contextlib dataclassesrrzrK collectionsrrrroperatorrr threadingr typingr r r rrrrr optree._Croptree.accessorsrrrrrr optree.typingrrrrrrr optree.utilsr r!r"builtinscollections.abcr#r$r%r&r'r(r)r*r;r+__all__rLSLOTS dataclassr:rRrYrJrZtyping_extensionsr[r\r]r^r_rarqrur-r.r/contextmanagerr0rrrrrrrrrrrrrrrrrrrrrrrNONErTUPLErLISTrDICT NAMEDTUPLE ORDEREDDICT DEFAULTDICTDEQUESTRUCTSEQUENCErrrrNrOrPr3s -# CC-aaa>=??PP!!5T.=QR ++w6$BKDtTKUK gaj L  $$*+C++ 4B B g E G E&72r5%#78&      ) ) ) $ ) ) . . . . ) . .h h h h J hV "#*3 S!S% S S ' SSS$Slh =15 = =. =  = 8 = =  .      ,0p15 p (p. p  p M pf28j +;+;\82 $ ( $  $ $( $  $ $/ A  A AP/P P P A  A Ab/b b b*    J' T # __  " %      ! % __   ! $ __  ''  " " ($  # # ($  # #  " %     ++  & & s@NJ@F*A#%  *&1H*,    1-rO