L iUdZddlZddlZddlZddlZddlZddlZddlZddlZddl Z ddl m Z m Z m Z mZddlmZmZmZmZddlmZddlmZmZmZmZmZmZmZmZmZm Z m!Z!m"Z"ddl#m$Z$m%Z%m&Z&ddl'm(Z)gd Z*e!d Z+e!d Z,e!d Z-e!d Z.dZ/dZ0Gdde Z1GddejdZ3eZ4eZ5ee5ge6e7ee4ffZ8eeee4ge5fZ9eZ:ee4ge:fZ;ee:ge4fZee=gee6ee4e=ffZ?e6e1dfZ@ee5ge6e7e6e1efeffZAGdde%ZBejZDiZEeFeGeeBfeHd<Gdde%ZIiZJeFeGeeIfeHd<iZKeFe=eGefeHd<e)dZL ejjdZOe)eOZOeOeLkrdxZPZQnd xZPZQ dZSgZTe7eeHd"<ddddd#d$eGed%e8d&e9d'ee=d(ee;d)ee<d*eeAd+dfd,ZUdddd-d$eGed.ee7e=d/ee7e=d'ee=d+df d0ZVeWZXeWeGeHd1<d$eGed+dfd2ZYd$eGed+eZfd3Z[ejd 4Gd5d6Z]d7dd+eZfd8Z^d7dd+efd9Z_d$eGed'e=d+dfd:Z`e$d;ea< dddddd#d$eGed%e8d&e9d=ee>d>ee?d'ee=d(ee;d)ee<d*eeAd+dfd?Zbd$eGed+dfd@Zcddddd#d$eGed%e8d&e9d'ee=d(ee;d)ee<d*eeAd+dfdAZdejd 4GdBdCee+Zee!dDeEZfejd 4GdFdGeefe+fZgejd 4GdHdIZhdJe"eieGfd+eZfdKZjd$eGd+eZfdLZkdJeid+eZfdMZle!dNd OZmGdPdQe6emdfZndJe"eieGfd+eZfdRZodSZpeqeHdT<d$eGd+eZfdUZrdJeid+eZfdVZsdWe6e+dfd+e6e7e+e4ffdXZtdWe6e+dfd+e6e7e6e1e+fe4ffdYZudZee+d[e4d+e6e+dffd\ZvdWe7e+d+e6e7e+e4ffd]ZwdWe7e+d+e6e7e6e1e+fe4ffd^ZxdZee+d[e4d+e7e+fd_ZydWeFee+fd+e6e7e+e4ffd`ZzdWeFee+fd+e6e7e6e1e+fe4ffdaZ{dZee+d[e4d+eFee+ffdbZ|dWe%d+e6e7ee4ffdcZ}dWe%d+e6e7e6e1efe4ffddZ~dZee+d[e4d+e%fdeZd[e4d+e:fdfZdge:d+e4fdhZdWeee+fd+e6e7e+e4ffdiZdWeee+fd+e6e7e6e1e+fe4ffdjZdZee+d[e4d+eee+ffdkZeZeZdWe ee+fd+e6e7e+e4ffdlZdWe ee+fd+e6e7e6e1e+fe4ffdmZdZee+d[e4d+e ee+ffdnZd[e4d+e:fdoZdge:d+e4fdpZdWe e+d+e6e7e+e4ffdqZdWe e+d+e6e7e6e1e+fe4ffdrZdZee+d[e4d+e e+fdsZede6etevdteuuede7eweydvexuedeFeze|dwe{uede e}edxeee~#edeeedyeuede eedzeee#ede eed{eueeFee hZeeGeHd|<ee6e7eFe ee e hZeeGeHd}<e$d~ea<ded+eZfdZded+efdZ dde5deee5geZfd+eZfdZe$dea<dde5deee5geZfd+eZfdZejd d d dGddZejd d ddGddeZeZ dde5deee5geZfd+e6e7eeffdZdeeded+e5fdZ dde5deee5geZfd+eefdZ dde5deee5geZfd+e7efdZ dde5deee5geZfd+efdZdddedefde5de5deee5geZfd+e5f dZdddedefde5de5deee5geZfd+e5f dZe6eGe+eGe,fZe6eGe+eGe,eGe-fZejDdk\re"eGee6eGedfejFfZne"eGee6eGedffZee"e+e,fge.fZee"e+e,e-fge.fZee+ge.fZeege.fZee+geegeffZedeGe+d+eee+effdZedee+e,fd+eee+e,effdZedee+e,e-fd+eee+e,e-effdZeded+eeefdZedeegeZfd+eeefdZde"eeegeZffd+eeefdZe ddee+efde5deee5geZfdeGe+d+e5f dZe ddee+e,efde5deee5geZfdee+e,fd+e5f dZe ddee+e,e-efde5deee5geZfdee+e,e-fd+e5f dZe ddeede5deee5geZfded+e5f dZe ddeede5deee5geZfdeegeZfd+e5f dZ ddeede5deee5geZfde"eeegeZffd+e5f dZe ddee+efde5deee5geZfdeGe+d+e5f dZe ddee+e,efde5deee5geZfdee+e,fd+e5f dZe ddee+e,e-efde5deee5geZfdee+e,e-fd+e5f dZe ddeede5deee5geZfded+e5f dZe ddeede5deee5geZfdeegeZfd+e5f dZ ddeede5deee5geZfde"eeegeZffd+e5f dZ ddeegeZfde5deee5geZfd+eZfdZ ddeegeZfde5deee5geZfd+eZfdZe ddee+eZfde5deee5geZfdeGe+d+eZf dZe ddee+e,eZfde5deee5geZfdee+e,fd+eZf dZe ddee+e,e-eZfde5deee5geZfdee+e,e-fd+eZf dZ ddeeZde5deee5geZfded+eZf dZe ddee+eZfde5deee5geZfdeGe+d+eZf dZe ddee+e,eZfde5deee5geZfdee+e,fd+eZf dZe ddee+e,e-eZfde5deee5geZfdee+e,e-fd+eZf dZ ddeeZde5deee5geZfded+eZf dZ dde5dedeee5geZfd+ee7efdZejGddZGdde%ZiZeFeqefeHd<ded+efdZdJeFe=efd+e"eeFe=efffdZde:d+efdZeeeed<ddedeeqd+e=fdZejrde=d+efdÄZGdĄdūZded+e=fdƄZe$dea<ded+e=fdȄZe$dea<de=d+efd˄Zde5de5d+e7efd΄Z dde5deee5geZfd+e6e7e6e@efeffdτZ dde5deee5geZfd+e7e6e@effdЄZ dde@de5deee5geZfd+ee6e@effd҄Zdddedefde5de5deee5geZfd+e5f dӄZde@d+e=fdՄZdJede@d+efdքZy#ejj$rdxZPZQe)d!ZOY wxYw)a Contains utility functions for working with nested python data structures. A *pytree* is Python nested data structure. It is a tree in the sense that nodes are Python collections (e.g., list, tuple, dict) and the leaves are Python values. Furthermore, a pytree should not contain reference cycles. pytrees are useful for working with nested collections of Tensors. For example, one can use `tree_map` to map a function over all Tensors inside some nested collection of Tensors and `tree_leaves` to get a flat list of all Tensors inside some nested collection. pytrees are helpful for implementing nested collection support for PyTorch APIs. This pytree implementation is not very performant due to Python overhead To improve the performance we can move parts of the implementation to C++. N) defaultdictdeque namedtuple OrderedDict)HashableIterableMappingSequence)Enum) AnyCallablecastClassVarFinalGenericNoReturnOptionaloverloadProtocolTypeVarUnion) deprecated NamedTupleSelf) TorchVersion)&PyTreeContext FlattenFunc UnflattenFuncDumpableContextToDumpableContextFnFromDumpableContextFnTreeSpecLeafSpeckeystrkey_getregister_pytree_node tree_is_leaf tree_flattentree_flatten_with_pathtree_unflatten tree_iter tree_leavestree_leaves_with_pathtree_structuretree_maptree_map_with_path tree_map_ tree_map_onlytree_map_only_tree_alltree_any tree_all_only tree_any_onlytreespec_dumpstreespec_loadstreespec_pprint is_namedtupleis_namedtuple_classis_namedtuple_instance is_structseqis_structseq_classis_structseq_instanceTSURNO_SERIALIZED_TYPE_NAME_FOUNDcDeZdZdefdZdedefdZdefdZ de de fdZ y) KeyEntryreturncyNselfs Y/mnt/ssd/data/python-lab/Trading/venv/lib/python3.12/site-packages/torch/utils/_pytree.py__hash__zKeyEntry.__hash__fothercyrLrMrOrTs rP__eq__zKeyEntry.__eq__hrRrScyrLrMrNs rP__str__zKeyEntry.__str__jrRrSparentcyrLrM)rOrZs rPgetz KeyEntry.getlrRrSN) __name__ __module__ __qualname__intrQobjectboolrWstrrYr r\rMrSrPrIrIes,"#"0F0t0!!*#*#*rSrIc<eZdZdedeeeeeffffd ZxZ S) EnumEncoderobjrJct|tr=d|jjd|jj|j dSt tt|%|S)NT:)__enum__fqnname) isinstancer __class__r^r_rkrrcsuperdefault)rOrfrms rProzEnumEncoder.defaultps] c4  --2231S]]5O5O4PQ  C-..rS) r]r^r_rarrcdictr ro __classcell__)rms@rPrereos-/6/eCc3h,?&@//rSrer#.cBeZdZUeeed<eed<eed<ee ed<y)NodeDeftype flatten_fn unflatten_fnflatten_with_keys_fnN) r]r^r_rtr __annotations__rrrFlattenWithKeysFuncrMrSrPrsrss# s)O"#677rSrsSUPPORTED_NODEScHeZdZUeeed<eed<eeed<ee ed<y)_SerializeNodeDeftypserialized_type_nameto_dumpable_contextfrom_dumpable_contextN) r]r^r_rtr rxrcrr!r"rMrSrPr|r|s) cN!"566#$9::rSr|SUPPORTED_SERIALIZED_TYPESSERIALIZED_TYPE_TO_PYTHON_TYPEz0.13.0optreeFTz0.0.0a0_cxx_pytree_pending_importsr~rrrwclsrurvr~rrrwrJc &t5|tvrt|d dddt|||||||tsyt rddlm}|j||||||y|||f}|||d} tj|| fy#1swYixYw)a Register a container-like type as pytree node. Note: :func:`register_dataclass` is a simpler way of registering a container-like type as a pytree node. Args: cls: the type to register flatten_fn: A callable that takes a pytree and returns a flattened representation of the pytree and additional context to represent the flattened pytree. unflatten_fn: A callable that takes a flattened version of the pytree, additional context, and returns an unflattened pytree. serialized_type_name: A keyword argument used to specify the fully qualified name used when serializing the tree spec. to_dumpable_context: An optional keyword argument to custom specify how to convert the context of the pytree to a custom json dumpable representation. This is used for json serialization, which is being used in torch.export right now. from_dumpable_context: An optional keyword argument to custom specify how to convert the custom json dumpable representation of the context back to the original context. This is used for json deserialization, which is being used in torch.export right now. flatten_with_keys_fn: An optional keyword argument to specify how to access each pytree leaf's keypath when flattening and tree-mapping. Like ``flatten_fn``, but in place of a List[leaf], it should return a List[(keypath, leaf)]. z& is already registered as pytree node.NrrF) _cxx_pytree)r~rr) _NODE_REGISTRY_LOCKrz ValueError_private_register_pytree_node_cxx_pytree_exists_cxx_pytree_importedrrappend) rrurvr~rrrwcxxargskwargss rPr'r'sL M / !u$JKL L "M" 1/31 ( ))   !5 3"7 * Z.$8#6%:  $**D&>:GMMs BB) field_namesdrop_field_namesr~rrc |xsg}tjstdd;tjDcgc]}|js|j c}ntjDchc]}|js|j }}|j ||tk7r?d}|tz x}r |d|dz }t|z x}r |d|dz }t|d td ttttfffd d ttd td tffd } d td ttttff fd } t | || ycc}wcc}w)a Registers a type that has the semantics of a ``dataclasses.dataclass`` type as a pytree node. This is a simpler API than :func:`register_pytree_node` for registering a dataclass or a custom class with the semantics of a dataclass. Args: cls: The python type to register. The class must have the semantics of a dataclass; in particular, it must be constructed by passing the fields in. field_names (Optional[List[str]]): A list of field names that correspond to the **non-constant data** in this class. This list must contain all the fields that are used to initialize the class. This argument is optional if ``cls`` is a dataclass, in which case the fields will be taken from ``dataclasses.fields()``. drop_field_names (Optional[List[str]]): A list of field names that should not be included in the pytree. serialized_type_name: A keyword argument used to specify the fully qualified name used when serializing the tree spec. This is only needed for serializing the treespec in torch.export. Example: >>> from torch import Tensor >>> from dataclasses import dataclass >>> import torch.utils._pytree as pytree >>> >>> @dataclass >>> class Point: >>> x: Tensor >>> y: Tensor >>> >>> pytree.register_dataclass(Point) >>> >>> point = Point(torch.tensor(0), torch.tensor(1)) >>> point = pytree.tree_map(lambda x: x + 1, point) >>> assert torch.allclose(point.x, torch.tensor(1)) >>> assert torch.allclose(point.y, torch.tensor(2)) NzKfield_names must be specified with a list of all fields used to initialize z, as it is not a dataclass.z3field_names does not include all dataclass fields. z!Missing fields in `field_names`: z. If you want to include these fields in the pytree, please add them to `field_names`, otherwise please add them to `drop_field_names`. z$Unexpected fields in `field_names`: zA. Please remove these fields, or add them to `drop_field_names`. rfrJcg}g}g}D]D}t||}|#|j||j|4|j|F|||gfSrL)getattrr)rf flattened flat_names none_namesrkvalrs rP _flatten_fnz'register_dataclass.._flatten_fnbsn    (D#t$C  %!!$'!!$'  (:z222rSvaluescontextc n|\}}ditt||tj|S)NrM)rpzipfromkeys)rrrrrs rP _unflatten_fnz)register_dataclass.._unflatten_fnos5!( JPT#j&12PdmmJ6OPPrSc|\}\}}t||Dcgc]\}}t||fc}}|fScc}}wrL)r GetAttrKey)rfrr _none_nameskvrs rP_flatten_fn_with_keysz1register_dataclass.._flatten_fn_with_keysssD/:3/?, ,J /2:y/IJtq!A"JJVVJs<r~rw) dataclasses is_dataclassrfieldsinitrkdifference_updatesetr tuplelistrrr) rrrr~fdataclass_init_fields error_msgmissing unexpectedrrrs `` @rPregister_dataclassrs`(-2  # #C (  !U"=?   '2'9'9#'>I!!&&qvvI 1<1C1CC1H SAAFF S S//0@A C $4 4NI/#k2BBBwB7yA,, !-0EEEzE::,GWW Y' ' 3 3tCy''9!: 3QhsmQgQ#QW3W5cG1C+DW" 12 [J Ss FFFFCONSTANT_NODESc|jtjur td|j tdd}d}d}t5t ||||t j|dddy#1swYyxYw)aRegisters a type as a pytree node with no leaves. In a :func:`torch.compile` region, if instances of these types get passed to :func:`torch._dynamo.nonstrict_trace`-ed function, they treated as a constant (sometimes referred to as "static"): 1. if the instance object existed before the :func:`torch.compile` region, we _assume_ no mutation will happen to it inside the :func:`torch.compile` region, require that it has non-default `__eq__` and `__hash__` methods, and we guard on the instance based on its `__eq__` method, i.e., if a new instance fails to match any instances from the previous compilations, :func:`torch.compile` will recompile the function using the new instance. 2. else if the instance object is created inside the :func:`torch.compile` region, we currently don't support using it in a :func:`torch._dynamo.nonstrict_trace`-ed function. In general, if your class holds Tensors or dynamic int/float/bool (values that may change from run-to-run of a function being compiled), then you probably do not want to register it as a constant. Otherwise if you want to pass instance of a class to a :func:`torch._dynamo.nonstrict_trace`-ed function, but you either can't use :func:`register_pytree_node` on the class, or the class is "constant" enough that you don't want to bother using :func:`register_pytree_node`, you should consider using this function. Args: cls: the type to register as a constant. This type must be hashable. Example: >>> from dataclasses import dataclass >>> import torch.utils._pytree as pytree >>> >>> @dataclass(frozen=True) >>> class Config: >>> norm: str >>> >>> pytree.register_constant(Config) >>> >>> config = Config("l2") >>> values, spec = pytree.tree_flatten(config) >>> assert len(values) == 0 zSregister_constant(cls) expects `cls` to have a non-default `__eq__` implementation.NzUregister_constant(cls) expects `cls` to have a non-default `__hash__` implementation.cgt|fSrL ConstantNodexs rP_flattenz#register_constant.._flatten<?""rSc|jSrL)value)_rs rP _unflattenz%register_constant.._unflattens }}rScgt|fSrLrrs rP_flatten_with_keysz-register_constant.._flatten_with_keysrrS)rw)rWra TypeErrorrQrrradd)rrrrs rPregister_constantrs^ zzV]]" a   || c  ##  %   !3  3   s %A<<Bc6t|txr|tvSrL)rlrtrrs rPis_constant_classrs c4 :SN%::rS)frozenceZdZUeed<y)rrN)r]r^r_r rxrMrSrPrrs JrSrspecc6t|jtS)zEChecks if the spec is from a pytree registered with register_constant)rlrrrs rP_is_constant_holderrs dllL 11rSc4t|sJtg|S)zTGiven a spec from a pytree registered with register_constant, retrieves the constant)rr+rs rP_retrieve_constantrs t $$ $ "d ##rSc Pt|tt|ttt y)a Registers a namedtuple as a valid pytree node. By default namedtuples are valid pytree nodes, but they are not serializable. This API provides the argument `serialized_type_name` which allows these namedtuples to be serialized. Args: cls: the dataclass type to register serialized_type_name: The serialized name for the dataclass. This is required if you want to serialize the pytree TreeSpec containing this namedtuple. rN)r_namedtuple_flatten_namedtuple_unflatten_namedtuple_serialize_namedtuple_deserialize_namedtuple_flatten_with_keys)rr~s rP_register_namedtuplers!"" 115:rSzy`torch.utils._pytree._register_pytree_node` is deprecated. Please use `torch.utils._pytree.register_pytree_node` instead.)category to_str_fnmaybe_from_str_fnc h||tjdtdt|||||||y)aRegister a container-like type as pytree node for the Python pytree only. Args: cls: the type to register flatten_fn: A callable that takes a pytree and returns a flattened representation of the pytree and additional context to represent the flattened pytree. unflatten_fn: A callable that takes a flattened version of the pytree, additional context, and returns an unflattened pytree. serialized_type_name: A keyword argument used to specify the fully qualified name used when serializing the tree spec. to_dumpable_context: An optional keyword argument to custom specify how to convert the context of the pytree to a custom json dumpable representation. This is used for json serialization, which is being used in torch.export right now. from_dumpable_context: An optional keyword argument to custom specify how to convert the custom json dumpable representation of the context back to the original context. This is used for json deserialization, which is being used in torch.export right now. flatten_with_keys_fn: An optional keyword argument to specify how to access each pytree leaf's keypath when flattening and tree-mapping. Like ``flatten_fn``, but in place of a List[leaf], it should return a List[(keypath, leaf)]. Nzx`to_str_fn` and `maybe_from_str_fn` is deprecated. Please use `to_dumpable_context` and `from_dumpable_context` instead.) stacklevelr)warningswarn FutureWarningr) rrurvrrr~rrrws rP_register_pytree_nodersHR 1 =  T   " 1/31rSct5t|=t|}t|j=t|=t j |dddy#1swYyxYw)zThis is an internal function that is used to deregister a pytree node type for the Python pytree only. This should be only used inside PyTorch. N)rrzrrr~rdiscard)rnode_defs rP_deregister_pytree_noder=sR $ C -c2 *8+H+H I &s +s# $$$s >AAc(t5|tvrtj|dt ||||}|t|<|du|duz rt d|d|t }t||||}|t|<|t|<dddy#1swYyxYw)zThis is an internal function that is used to register a pytree node type for the Python pytree only. End-users should use :func:`register_pytree_node` instead. zM is already registered as pytree node. Overwriting the previous registration.Nz7Both to_dumpable_context and from_dumpable_context for z must be None or registered.) rrzrrrsrrGr|rr) rrurvr~rrrwrserialize_node_defs rPrrKs C / ! MM%99  3 L:NO' 4 ',AT,I JI#O))  '#@ .   !   +="3'?B&';<7CCCs A8BBc:eZdZUeed<defdZdeedefdZ y) SequenceKeyidxrJc"d|jdSN[]rrNs rPrYzSequenceKey.__str__{488,a  rSsequencec ||jSrLr)rOrs rPr\zSequenceKey.get~s!!rSN) r]r^r_r`rxrcrYr rBr\rMrSrPrrws* H!!"HQK"A"rSrK)boundc>eZdZUeed<defdZdeeefdefdZ y) MappingKeykeyrJc"d|jdSrrrNs rPrYzMappingKey.__str__rrSmappingc ||jSrLr)rOrs rPr\zMappingKey.getstxx  rSN) r]r^r_rrxrcrYr rBr\rMrSrPrrs. F!!!71a4=!Q!rSrc4eZdZUeed<defdZdedefdZy)rrkrJc d|jS)N.)rkrNs rPrYzGetAttrKey.__str__s499+rSrfc.t||jSrL)rrk)rOrfs rPr\zGetAttrKey.getssDII&&rSN)r]r^r_rcrxrYr r\rMrSrPrrs& I's's'rSrrfcRt|tr|n t|}t|S)zSReturn whether the object is an instance of namedtuple or a subclass of namedtuple.)rlrtr=rfrs rPr<r<s!C&#DIC s ##rSct|txr{t|txritt |ddtxrLt d|j Dxr.tt |ddxrtt |ddS)z5Return whether the class is a subclass of namedtuple._fieldsNc3>K|]}t|tuywrL)rtrc).0fields rP z&is_namedtuple_class..sr>s tCy ))rS_T_co) covariantc eZdZUdZdZeeded<ee ed<ee ed<ee ed<de fdZ dd e e d eed eeefde fd Zy ) structseqz D  : ws$6=s C  :S]]%889 9 rSc*tt|S)z=Return whether the object is an instance of PyStructSequence.)r@rtrs rPrArAs d3i ((rSdct|dfSrLrr's rP_tuple_flattenr+s 7D=rSct|\}}t|Dcgc]\}}t||fc}}|fScc}}wrL)r+ enumeraterr'rrirs rP_tuple_flatten_with_keysr0=%Q'OFG,5f,= >DAq[^Q  > GG >:rrct|SrL)rrrs rP_tuple_unflattenr5s =rSc |dfSrLrMr*s rP _list_flattenr7s d7NrSct|\}}t|Dcgc]\}}t||fc}}|fScc}}wrL)r7r-rr.s rP_list_flatten_with_keysr9s;#A&OFG,5f,= >DAq[^Q  > GG >r2ct|SrLr)r4s rP_list_unflattenr;s <rScft|jt|jfSrLrrkeysr*s rP _dict_flattenr? "  T!&&(^ ++rSct|\}}t||Dcgc]\}}t||fc}}|fScc}}wrL)r?rrr'rrrrs rP_dict_flatten_with_keysrCs?$A&OFG+.w+? @41aZ]A  @' II @;c,tt||SrL)rprr4s rP_dict_unflattenrFs GV$ %%rSc.t|t|fSrL)rrtr*s rPrrs 7DG rSct|\}}t|j|Dcgc]\}}t||fc}}|fScc}}wrL)rrrr)r'rrr rs rPrrsI*!,OFG03GOOV0LMHE1*U Q M MsAc(tt||SrL)rrr4s rPrr(s  GV, --rSc|tvrtd|dt|}|j}|tk(rtd|d|S)Nz-Can't serialize TreeSpec of namedtuple class zc because we didn't register a serializated_type_name. Please register using `_register_namedtuple`.za because we couldn't find a serializated_type_name. Please register using `_register_namedtuple`.)rrr~rG)rrr~s rPrr,ss00!;G9E& &  4G<-BB<<!;G9E& &  rSdumpable_contextcF|tvrtd|dt|}|S)Nz/Can't deserialize TreeSpec of namedtuple class z. because we couldn't find a serializated name.)rr)rKr}s rPrr@s>==!=>N=OP< <  ))9 :C JrScft|jt|jfSrLr=r*s rP_ordereddict_flattenrNKr@rSct|\}}t||Dcgc]\}}t||fc}}|fScc}}wrL)rNrrrBs rP_ordereddict_flatten_with_keysrPOs?+1-OFG+.w+? @41aZ]A  @' II @rDc:tdt||DS)Nc3*K|] \}}||f ywrLrM)r rrs rPr z)_ordereddict_unflatten..ZsK UU|Ks)rrr4s rP_ordereddict_unflattenrSVs Kc'66JK KKrSc>t|\}}||j|gfSrL)r?default_factory)r'r dict_contexts rP_defaultdict_flattenrWas'(+FL A%%|4 44rSct|\}}|\}}t||Dcgc]\}}t||fc}}|fScc}}wrL)rWrr)r'rrrrVrrs rP_defaultdict_flatten_with_keysrYfsH+1-OFGOA|+.|V+D E41aZ]A  Ew NN EsAc8|\}}t|t||SrL)rrF)rrrUrVs rP_defaultdict_unflattenr[ns"%,!O\  (M NNrScD|\}}|j|j|d}|S)N)default_factory_moduledefault_factory_namerV)r^r_)rrUrVjson_defaultdicts rP_defaultdict_serializer`vs1$+!O\"1"<"< / < <$ rSct|tsJt|hdk(sJ|d}|d}t|tsJt|tsJt j |}t ||}|d}||gS)N>rVr^r]r]r^rV)rlrprrc importlib import_moduler)rKr]r^modulerUrVs rP_defaultdict_deserializeres & -- -  %   ..FG+,BC ,c 22 2 *C 00 0  $ $%; )rps rP_is_namedtuple_instancerrs "$ ''rSc>t|}t|rtS|SrL)rtr=r)rp node_types rP_get_node_typerus!T I 9% rSis_leafc:| ||ryt|tvS)aWCheck if a pytree is a leaf. >>> tree_is_leaf(1) True >>> tree_is_leaf(None) True >>> tree_is_leaf([1, 2, 3]) False >>> tree_is_leaf((1, 2, 3), is_leaf=lambda x: isinstance(x, tuple)) True >>> tree_is_leaf({"a": 1, "b": 2, "c": 3}) False >>> tree_is_leaf({"a": 1, "b": 2, "c": None}) False T)rurzrprvs rPr(r(s#&wt} $  66rSztorch.utils._pytree._is_leaf is private and will be removed in a future release. Please use torch.utils._pytree.tree_is_leaf instead.ct||SNrv)r(rxs rP_is_leafr|s g ..rS)rreqreprc0eZdZUeed<eed<eded<ejdZ e ed<ejdZ e ed<ejdZ e ed<dd Z dd e d efd Zded efdZd efdZded eefdZdeed efdZd e fdZy )r#rtrchildren_specsF)r num_nodes num_leaves num_childrenrJNc,td|jDd}td|jD}t|j}tj |d|tj |d|tj |d|y)Nc34K|]}|jywrL)rr rs rPr z)TreeSpec.__post_init__..-sHDHrF)startc34K|]}|jywrL)rrs rPr z)TreeSpec.__post_init__...sITIrrrr)sumrlenra __setattr__)rOrrrs rP __post_init__zTreeSpec.__post_init__,swHD4G4GHPQR IT5H5HII 4../ 4i84z:4>rSindentc d|jjd|jd}d}|jdkDr|dz }||jdj |z }||jdkDrdndz }|dj |jddDcgc]}d d |zz|j |zc}z }|d }||zScc}w) Nz TreeSpec(z, z, [rrrrF,  z]))rtr]rrr__repr__join)rOr repr_prefixchildren_specs_strchild repr_suffixs rPrzTreeSpec.__repr__4s&tyy'9'9&:"T\\N#N "$   q aKF $"5"5a"8"A"A&"I I  ):):Q)>#B F  #(("&!4!4QR!83<'%..*@@#   114 [(( s!C rTc ||ury|j|jurat|jt|jk7ry|j|jk7ry|j|jk7ryyt S)NTF)rmrcrtrrNotImplementedrVs rPrWzTreeSpec.__eq__Dsj 5= __ .499~UZZ0||u}},$$(<(<<rScB|jdk(xr|jdk(S)NrF)rrrNs rPrvzTreeSpec.is_leafQs~~";t!';;rSrpcbdtdtdttddffd g}||||S)NtreespecrpsubtreesrJc P|jr|j|yt|}|jtvr||jk7rt d|jd|dt |j}||\}}t||jk7r%t d|jdt|d||jk7rt d|jd|jtvxr|tv}|s+||jk7rt d|jd|dt||jk7r%t d|jdt|d|r|jtur |jn|jd}|} t|} t| } | | k7rG| j| } | j| } d}| r|d | z }| r|d | z }t d |d| Dcgc]}|| }}n^t |j}||\}}|tur8||jk7r)t d |jd |jd|dt!||j"D]\}}|||ycc}w)NzType mismatch; expected z , but got rzNode arity mismatch; expected z+Node context mismatch for custom node type zNode type mismatch; expected rFrz; missing key(s): z; extra key(s): zNode keys mismatchz$Node context mismatch for node type z ; expected )rvrrurtrorrzrurrrrnrr differencerrr)rrprrtruchildrenrboth_standard_dictrV expected_keys got_key_setexpected_key_set missing_keys extra_keysmessagersubtreesubspechelpers rPrz&TreeSpec.flatten_up_to..helperUs!%&t,I}}M1 -$$$,MM#4Jym1N-Y7BB $.t$4!'x=H$9$99$$$,$9$9#:*S]OSTVh...$EhmmEVVWXMM%889!%88#*i8==.H$$$,MM#4Jym1Nt9 5 55$$$,$9$9#:*SYKqR &$== ;!((&--a0 ! %1M"%d)K'*='9$"&66'7'B'B;'O %0%;%;'JJG%#)9*'FFG(+=gYa)HII5BCcS CHC"1!;!F!FJ(24(8%Hg!.!X%5%55(B8==BST((0(8(8';:g[PQS %((2I2I$J 3 w2 3 Ds J#)r#rr)rOrprrs @rP flatten_up_tozTreeSpec.flatten_up_toTsGL 3XL 3VL 3tF|L 3PTL 3\"$tT8$rSleavesc t|ttfs t|}t||jk7r(t dt|d|jd|d|j r|dSt|jj}d}d}g}|jD]6}||jz }|j|j||||}8|||jS)Nz0treespec.unflatten(leaves): `leaves` has length z, but the spec refers to a pytree that holds z items (z).r)rlrrrrrrvrzrtrvrr unflattenr)rOrrvrend child_pytrees child_specs rPrzTreeSpec.unflattens&4-0&\F v;$// )B3v;-P>>Boo=NOr#  <<>!9 &tyy1>>  -- J :(( (C  !5!5fU36G!H IE  M4<<88rSc|j}|tur|j\}}|t|f}nn|tt fvrt|j}nJ||t vr |j}n3t|jtr|jj}nd}t||t|jfSrL) rtrrrrprrorlrrhashr)rOrtrUrVhashable_contexts rPrQzTreeSpec.__hash__sII  #,0LL )O\ /|1DE  4- -$T\\2   )}"<#||   l 3#||11  $ Y 0%8K8K2LMNNrSrJNr)r]r^r_r rxrrrr rr`rrrrcrrrbrWrvrrrrQrMrSrPr#r#"s I $$&[&&E2Is2'k''U3J3) ))u5L#5?)s)3) F t <<Q&QT&\Qf9 9&92O#OrSceZdZUejddZeed<ejddZe ed<eje dZ e ded<d d Z dd e d efd Zy)r$NF)rorrtr)rUrr#rrJctj|ddtj|ddtj|ddy)NrrFrrr)rarrNs rPrzLeafSpec.__post_init__s84a04q143rSrcyN*rM)rOrs rPrzLeafSpec.__repr__rSrr)r]r^r_rr rtr rxrrrrrr`rcrrMrSrPr$r$so! !!$U;D#;({((EBGWB'8{'8'85(ND$4 s3rSr$cddtdttdtffd g}||}||fS)zkFlattens a pytree into a list of values and a TreeSpec that can be used to reconstruct the pytree. noderrJct| r|j|tSt|}t|j }||\}}|Dcgc] }|| }}t |||Scc}wrz)r(r _LEAF_SPECrurzrur#) rrrtrurrrsubspecsrrvs rPrztree_flatten..helpersz g . MM$  "4( $Y/:: &t,'8@@eF5&)@@ 7H55AsA2)rrr r#)rprvrrrs ` @rPr)r)s? 6V 6T#Y 68 6FdF#H 8 rSrrctt|tstdt|d|j |S)zqGiven a list of values and a TreeSpec, builds a pytree. This is the inverse operation of `tree_flatten`. zftree_unflatten(leaves, treespec): Expected `treespec` to be instance of TreeSpec but got item of type r)rlr#rrtr)rrs rPr+r+ sE h )99=h8H K     f %%rSc#Kt||r|yt|}t|j}||\}}|D]}t ||Ed{y7w)z,Get an iterator over the leaves of a pytree.r{N)r(rurzrur,)rprvrtrurrrs rPr,r,sd D'* "4( $Y/:: %d+ q# 9E 8 8 8 9 8sAAAAc.tt||S)z!Get a list of leaves of a pytree.r{)rr,rxs rPr-r-'s  $0 11rSc"t||dS)zGet the TreeSpec for a pytree.r{rF)r)rxs rPr/r//s g .q 11rSr{funcrestsct||\}}|g|Dcgc]}|j|c}z}|jt|g|Scc}w)aMap a multi-input function over pytree args to produce a new pytree. See also :func:`tree_map_`. >>> tree_map(lambda x: x + 1, {"x": 7, "y": (42, 64)}) {'x': 8, 'y': (43, 65)} >>> tree_map(lambda x: x is None, {"x": 7, "y": (42, 64), "z": None}) {'x': False, 'y': (False, False), 'z': True} If multiple inputs are given, the structure of the tree is taken from the first input; subsequent inputs need only have ``tree`` as a prefix: >>> tree_map(lambda x, y: [x] + y, [5, 6], [[7, 9], [1, 2]]) [[5, 7, 9], [6, 1, 2]] Args: func (callable): A function that takes ``1 + len(rests)`` arguments, to be applied at the corresponding leaves of the pytrees. tree (pytree): A pytree to be mapped over, with each leaf providing the first positional argument to function ``func``. rests (tuple of pytree): A tuple of pytrees, each of which has the same structure as ``tree`` or has ``tree`` as a prefix. is_leaf (callable, optional): An extra leaf predicate function that will be called at each flattening step. The function should have a single argument with signature ``is_leaf(node) -> bool``. If it returns :data:`True`, the whole subtree being treated as a leaf. Otherwise, the default pytree registry will be used to determine a node is a leaf or not. If the function is not specified, the default pytree registry will be used. Returns: A new pytree with the same structure as ``tree`` but with the value at each leaf given by ``func(x, *xs)`` where ``x`` is the value at the corresponding leaf in ``tree`` and ``xs`` is the tuple of values at corresponding nodes in ``rests``. r{)r)rrmaprrprvrrrr flat_argss rPr0r07sYN$D':FHuE!H2215EEI   c$33 44FsAct||\}}|g|Dcgc]}|j|c}z}tt|g|d|Scc}w)aTLike :func:`tree_map`, but do an inplace call on each leaf and return the original tree. See also :func:`tree_map`. Args: func (callable): A function that takes ``1 + len(rests)`` arguments, to be applied at the corresponding leaves of the pytrees. tree (pytree): A pytree to be mapped over, with each leaf providing the first positional argument to function ``func``. rests (tuple of pytree): A tuple of pytrees, each of which has the same structure as ``tree`` or has ``tree`` as a prefix. is_leaf (callable, optional): An extra leaf predicate function that will be called at each flattening step. The function should have a single argument with signature ``is_leaf(node) -> bool``. If it returns :data:`True`, the whole subtree being treated as a leaf. Otherwise, the default pytree registry will be used to determine a node is a leaf or not. If the function is not specified, the default pytree registry will be used. Returns: The original ``tree`` with the value at each leaf is given by the side-effect of function ``func(x, *xs)`` (not the return value) where ``x`` is the value at the corresponding leaf in ``tree`` and ``xs`` is the tuple of values at values at corresponding nodes in ``rests``. r{rrl)r)rrrrs rPr2r2csV8$D':FHuE!H2215EEI #d Y * KFsA  type_or_types_or_predcyrLrMrs rPmap_onlyrJMrScyrLrMrs rPrrsRUrScyrLrMrs rPrrs$'rScyrLrMrs rPrrrrScyrLrMrs rPrrs rScDtttfs-tjdk\r-tt j rdtdtffd ntrn tddttgtfdttgtfffd }|S)a Suppose you are writing a tree_map over tensors, leaving everything else unchanged. Ordinarily you would have to write: def go(t): if isinstance(t, Tensor): return ... else: return t With this function, you only need to write: @map_only(Tensor) def go(t): return ... You can also directly use 'tree_map_only' rrrJct|SrLrl)rrs rPpredzmap_only..predsa!67 7rSz9Argument must be a type, a tuple of types, or a callable.rc`tjdtdtffd }|S)NrrJc(|r|S|SrLrM)rrrs rPwrappedz*map_only..wrapper..wrappedsAwAwHrS) functoolswrapsrBr )rrrs` rPwrapperzmap_only..wrappers3   q S    rS) rlrtrsys version_infotypes UnionTyper rbrrr rB)rrrs` @rPrrs*'$7 G# ,eoo > 8C 8D 8 ' ($STThsCx(XseSj-A NrScyrLrMrrrprvs rPr3r3rScyrLrMrs rPr3r3rrScyrLrMrs rPr3r3rrScyrLrMrs rPr3r3rrScyrLrMrs rPr3r3rrSc<tt||||Srz)r0rrs rPr3r3s! 3H23D94 QQrScyrLrMrs rPr4r4rrScyrLrMrs rPr4r4#rrScyrLrMrs rPr4r4-rrScyrLrMrs rPr4r47rrScyrLrMrs rPr4r4ArrSc<tt||||Srz)r2rrs rPr4r4Ks! 4X34T:D' RRrSrcFt||}tt||Srz)r,rrrrprvrs rPr5r5U" $0I s4# $$rScFt||}tt||Srz)r,anyrrs rPr6r6^rrS type_or_typescyrLrMrrrprvs rPr7r7g rScyrLrMrs rPr7r7qrrScyrLrMrs rPr7r7{rrScJt||}tfd|DS)Nr{c3HK|]}t|s|ywrLrr rrrs rPr z tree_all_only..J1Z=-ItAwJ" ")r,rrrrprvrs`` rPr7r7"$0I J J JJrScyrLrMrs rPr8r8rrScyrLrMrs rPr8r8rrScyrLrMrs rPr8r8rrScJt||}tfd|DS)Nr{c3HK|]}t|s|ywrLrrs rPr z tree_any_only..rr)r,rrs`` rPr8r8rrSct|tsJt||r|g|jzS|j ryt |}||j k7ryt|j}||\}}t||jk7s||jk7ryg}t||jD]\}} t|| |} | || z }y|Srz)rlr#r(rrvrurtrzrurrrrr_broadcast_to_and_flatten) rprrvrtrurctxresultrrflats rPrrs h )) )D'*v++++t$IHMM! +66J#D)M3 =X222cX=M=M6MF 0G0GHz( GL   dNF  MrSc<eZdZUdZeeed<eed<eded<y)_TreeSpecSchemaa _TreeSpecSchema is the schema used to serialize the TreeSpec It contains the following fields: - type: A string name of the type. null for the case of a LeafSpec. - context: Any format which is json dumpable - children_spec: A list of children serialized specs. rtr children_specN) r]r^r_r rrcrxr rrMrSrPrrs% 3- )**rSrc:eZdZUeegefed<eegefed<y) _ProtocolFntreespec_to_jsonjson_to_treespecN)r]r^r_r r#r rxrMrSrPrrs'z?:;;0(:;;rSr_SUPPORTED_PROTOCOLScR|jr tddgS|jtvrt d|jdt|j}|j }|t k(rt d|jd|j' tj|jt}n|j|j}|jDcgc] }t|}}t|||S#t$r}td|d}~wwxYwcc}w)Nz Serializing  in pytree is not registered.z%No registered serialization name for zZ found. Please update your _register_pytree_node call with a `serialized_type_name` kwarg.rzUnable to serialize context. Please make the context json dump-able, or register a custom serializer using _register_pytree_node.)rvrrtrrr~rGrjsondumpsrrerr_treespec_to_json)rrr~serialized_contexter child_schemass rPrrs5tT2..}}66!8==/)F G  4HMMB-BB<<!3HMM?Ca a  --5 !%H,<,<+!N 0CCHDTDTU;C;R;RS%&u-SMS /1C] SS A   Ts%D&D$ D! DD!cd|vrp|djd\}}}tj|}|}|jdD]}t ||}t t t|}||dS|S)Nrirjrhrrk) partitionrbrcsplitrrrtr )rfmodnamer classnamemodenum_clsattrs rPenum_object_hookr+sS #E 4 4S 9I%%g.OOC( /Dx.H /T H-F $$ JrS json_schemac|d|dt|ddk(rtS|dtvrtd|ddt|d}t|}|j t j|dt}n|j |d}|dDcgc] }t|}}t|||S#t$r}td|d}~wwxYwcc}w) NrtrrrzDeserializing r) object_hookzUnable to deserialize context. Please make the context json load-able, or register a custom serializer using _register_pytree_node.) rrrrrrrloadsr+r_json_to_treespecr#)r,r}rrex child_stringrs rPr0r0*sF#  " *  O, - 26"@@![011N O   )V)< =C3C8//7 jjY!7EUVG%::;y;QR=Hrrrasdictre)rr3 json_specstr_specs rPr9r9Ps h )--1(^,)r;r3r,s rPr:r:fsh JJz2Hk''#H->>{KK  H:& $%9%>%>%@ AB D rSceZdZdefdZy) _DummyLeafrJcyrrMrNs rPrz_DummyLeaf.__repr__srrSN)r]r^r_rcrrMrSrPr>r>rs#rSr>ctt|jDcgc] }tc}|}t |Scc}wrL)r+rangerr>r~)rr dummy_trees rPr;r;ws<$X%8%89:!:J   ;sAzC`pytree_to_str` is deprecated. Please use `treespec_dumps` instead.ct|SrL)r9)rs rP pytree_to_strrDs ( ##rSzC`str_to_pytree` is deprecated. Please use `treespec_loads` instead.rct|SrL)r:)rs rP str_to_pytreerFs $ rSrrcg}|D]}|jt||jD]}|jt||S)zpGet a flat list of arguments to this function A slightly faster version of tree_leaves((args, kwargs)) )extendr,r)rrras rParg_tree_leavesrJsR F $ il#$ ]]_$ il#$ MrScPt||\}}ttd|||fS)aFlattens a pytree like :func:`tree_flatten`, but also returns each leaf's key path. Args: tree: a pytree to flatten. If it contains a custom type, that type must be registered with an appropriate `tree_flatten_with_path_fn` when registered with :func:`register_pytree_node`. is_leaf: An extra leaf predicate function that will be called at each flattening step. The function should have a single argument with signature ``is_leaf(node) -> bool``. If it returns :data:`True`, the whole subtree being treated as a leaf. Otherwise, the default pytree registry will be used to determine a node is a leaf or not. If the function is not specified, the default pytree registry will be used. Returns: A tuple where the first element is a list of (key path, leaf) pairs, and the second element is a :class:`TreeSpec` representing the structure of the flattened tree. rM)r)r_generate_key_paths)rprvrrs rPr*r*s.(tW-KAx #Bg6 7 AArSc.ttd||S)a8Gets the leaves of a pytree like ``tree_leaves`` and returns each leaf's key path. Args: tree: a pytree. If it contains a custom type, that type must be registered with an appropriate `tree_flatten_with_path_fn` when registered with :func:`register_pytree_node`. is_leaf: An extra leaf predicate function that will be called at each flattening step. The function should have a single argument with signature ``is_leaf(node) -> bool``. If it returns :data:`True`, the whole subtree being treated as a leaf. Otherwise, the default pytree registry will be used to determine a node is a leaf or not. If the function is not specified, the default pytree registry will be used. Returns: A list of (key path, leaf) pairs. rM)rrLrxs rPr.r.s$ #Bg6 77rSkey_pathc#K|r||r||fyt|}tj|}|s||fy|j}|r0||\}}|D]\}} t g||| |Ed{!yt d|d7w)Nz.Did not find a flatten_with_keys_fn for type: zF. Please pass a flatten_with_keys_fn argument to register_pytree_node.)rurzr\rwrLr) rNrprvrthandlerflatten_with_keys key_childrenrrcs rPrLrLs 74=nt$I!!),G n44+D1 a  GDAq*>X>q>1gF F F G bool``. If it returns :data:`True`, the whole subtree being treated as a leaf. Otherwise, the default pytree registry will be used to determine a node is a leaf or not. If the function is not specified, the default pytree registry will be used. Returns A new pytree with the same structure as ``tree`` but with the value at each leaf given by ``func(keypath, x, *xs)`` where ``keypath`` is the key path at the corresponding leaf in ``tree``, ``x`` is the value at that leaf, and ``xs`` is the tuple of values at corresponding nodes in ``rests``. c3(K|] }| ywrLrM)r xsrs rPr z%tree_map_with_path..sKBdBiKs)r*rrrr)rrprvrkeypath_leavesrrall_keypath_leavess` rPr1r1si: 6dGDNH#~./N'e*T8+A+A!+D*TT   K#7I2JK KK+UsA$kpc\dj|Dcgc] }t|c}Scc}w)z9Given a key path, return a pretty-printed representation.r)rrc)rYrs rPr%r% s# 77B'qCF' (('s)c6|D]}|j|}|S)zAGiven an object and a key path, return the value at the key path.)r\)rfrYrs rPr&r&s# eeCj JrS)NNrL)r rrrbimportlib.metadatarr threadingrr collectionsrrrrcollections.abcrrr r enumr typingr r rrrrrrrrrrtyping_extensionsrrrtorch.torch_versionr _TorchVersion__all__rBrCrDrEr7rGrI JSONEncoderrerrrrrrr r!r"rc ToStrFuncMaybeFromStrFuncKeyPathryrsRLockrrzrprtrxr|rr_optree_minimum_versionmetadataversion_optree_version_cxx_pytree_dynamo_traceablerPackageNotFoundErrorrrr'rrrrrbr dataclassrrrrrrrrrrrrrar<r=r>rrr?r"r`r@rAr+r0r5r7r9r;r?rCrFrrrrrrNrPrS_odict_flatten_odict_unflattenrWrYr[r`rerhrjrm frozensetrnrorrrur(r|r#r$rr)r+r,r-r/r0r2Type2Type3rrTypeAnyFn2Fn3FnFnAny MapOnlyFnrr3r4r5r6r7r8rrrrrr+r0r9 lru_cacher:r>r;rDrFrJr*r.rLr1r%r&rMrSrPr~s"  CCAA    ;:=' T CL CL CL CL+,' ?+x+/$""/  xtCy''9!::; (3-169: y/9: /!2G!;< j$s),c1 2 SE8E#w2C,D#EEF # xtE(C-4H/I3/N)OOP8j8&ioo',.d3i().; ;BDDc,=!=>C79S$s)^ 49 (1A((00:O $O4O00 =BA$'9<@@$'9)+T#Y++/9==A:>I; cI;I; I; #3- I; ""56 I;$$9:I;##67I; I;^(,,0*. l cl$s)$ltCy) l #3- l  l^ ED !K 49K K \;49;;d#$2j2T2 $Z$C$  c 8 E &*48 4+/9==A:>4 c44 4 " 4  01 4#3-4""564$$9:4##674 4  4n $ c $  $&+/9==A:>)C c)C)C )C #3- )C ""56 )C$$9:)C##67)C )CXd#"'!*"$" Cx d#!A!$!d#''$'$uVT\*$t$ T d **4* 4("eSj!",#eFDL)#d##S" D T  )v)$) eAsFmd1gw.>(?H QV}H 4hk" #W ,-HXa[7uQV}T!WtAw'7!8HtAwH5eHaK6H1I71R+SH HQK'd1g,T#q&\,eDGW,<&=,J CF|J 4hk" #W ,-J&HQK&'&d36l&:%S 70B*C 4hm$ %w ./.(1+..J. 7  (o',KQ/,E$q'7:J4K,J36J 4hk" #W ,-JL QKL LaL&)5KQ/5E$q'7:J4K5 O36O 4hk" #W ,-OO QKO OaOG++7+&eAh5a')9#:H QxH 4hk" #W ,-H)Xa[)7)uQx) )1 (0 (0 1-1627 2.27 ,1 (1$ [1Q'RYt_R!*     " y  E  (#($(  (377 7 hx~. /7 70 ;  /6/HXvhn-E$F/RV/  /D$UCoOoODoOlD%eDxE&Z 37  hx~. / 49h 4 &8C= &H & &379 9 hx~. /9c]9&372 2 hx~. /2 #Y2372 2 hx~. /2237 )5 38 )5 )5 )5hx~. / )5  )5`37  38   hx~. /   D d1gtAw d1gtAwQ'(wDIuT#Y^4eooEFGDIuT#Y^445Gad }a aAg"# qc1f# aS(C5#:.. /  MDGM9R3Z3HM M UE!Q$KUyQ3Y7PU U ' Aq>'s1aC< !' '  MGM9U3Z3HM M  #SE4K0 uSz   + (C5$;*?!?@+uSz+\ 37  QV*   hx~. / 7    37  aCi.   hx~. /  A;    37  aAsl    hx~. /  Aq>    37  *   hx~. / "    37  *   hx~. / #SE4K0   37 R *R  R hx~. / R (C5$;*?!?@R  R 37  QV*   hx~. / 7    37  aCi.   hx~. /  A;    37  aAsl    hx~. /  Aq>    37  *   hx~. / "    37  *   hx~. / #SE4K0   37 S *S  S hx~. / S (C5$;*?!?@S  S37% C5$; % %hx~. /% %37% C5$; % %hx~. /% % 37  QW+   hx~. / 7    37  aDj/   hx~. / A;    37  aAtm    hx~. / Aq>   37 K +K  K hx~. / KK  K 37  QW+   hx~. / 7    37  aDj/   hx~. / A;    37  aAtm    hx~. / Aq>   37 K +K  K hx~. / KK  K,37 hx~. /d3i D  + + +<*< 02d3 +,1!T!T_!TH $sCx. U4c3h3G-H  2? 2x 2F&&79JKQX##, sx h3 I $H$$ $  I      6 V S 37B B hx~. /B 4gsl# $h ./B4378 8 hx~. /8 % 8037   hx~. / eGSL!"  B37 L 38  L  L  Lhx~. / L  LF)w)3) 'c}:../8== #5#I.O/su%u*)u*