Vpf}^ dZddlmZdgZddlZddlmZmZddlZddl m Z ddl Z ddl Z ddl mZddlmZdd lmZdd lmZdd lmZdd lmZdd lmZddlmZddlmZddlmZddlm Z ddlm!Z!ddlm"Z"ddl#m$Z$ddl%m&Z&m'Z'm(Z(m)Z)m*Z*ddl+m,Z,m-Z-e-e.cZ.Z/e,e0cZ0Z1ddd!Z2dd"dd&Z3dd(Z4dd+Z5dd,Z6 ddd1Z7dd4Z8dd8Z9d9d:dd=Z:dddAZ;dBZe?e j@e jAe&fZBeCeDeEeFfZGddCZHdDZIdddGZJddIZKddKZLejMefZNeNe jAfzZOdLZP dddddMddSZQejRee jSdTUdd[ZTe jSdd]ZUd^ZVd_ZWGd`daZXGdbdcZYiddeWdeeIdeKdfeLdge!jZdhe!j[dieHdje!j\dkeHdle!j]dmeHdne!j^doeHdpe!j_dqeHdre!j`dseHdte!jadue!jbdveHdwe!jcdxeHdwe!jcdyzd{eHd|e!jdd}eHd|e!jddyzid~eHde!jedeHde!jedyzdeHde!jfdeHde!jfdyzdeHde!jgdeHde!jgdyzdeHde!jhdeHde!jhdyzdeHde!jideHde!jidyzdeHde!jjdeHde!jjdyzdeHde!jkdeHde!jkdyzdeHdejldeHdejldyzdeHde!jmeHde!jmdyzeHde!jneHde!jndyzeHde!joeHde!jodyze!jpeHde!jqeHde!jreHde!jqdyzeHde!jrdyzeJd Zside jtde judejvdejwdejxdejyde2dejzde7de!j{de!j|deQdej}de j~de jdejdejidejde5d0e jde jd.e jdejde jde jdejdejde:dejdejdejdejde jde jejeje3eje8e je;ejeTd ZeVeUdZetAw+G+GDD t $ $D  Q % %%r'newshapeDimSize | Shaperc} tn #gYnxYwtjdtD}t |dkrt d||r'|\}gd||dzdR}t dgtj|RDrtj tj |zdkrft dtjdtj d |d tj |d tj  tj tj|}|gd|||dzdRSnt d gtjRDr|tj tj krRt dtjdtj d |dtj d tfdDS)z)Fixes a -1 value in newshape, if present.cPg|]#\}}t|tu|dk!|$S))typer/).0ids r% z%_compute_newshape..}s/ K K KAQ31771777r'rNz>can only specify one unknown axis size with a `-1` value, got Nc3@K|]}t|tVdSN isinstancer/rYr[s r% z$_compute_newshape..s, E E1Jq#   E E E E E Er'rzcannot reshape array of shape z (size z ) into shape z. because the product of specified axis sizes (z) does not evenly divide c3@K|]}t|tVdSr^r_ras r%rbz$_compute_newshape..s, B B1Jq#   B B B B B Br')c3K|]C}tj|dr(tjtj n|VDdS)rWN)r definitely_equaldivide_shape_sizesr3shape)rYr[r8rSs r%rbz$_compute_newshape..snII:;$'2..6' X>>>>45IIIIIIr')iterr canonicalize_shape enumeraterOr@allr3rhr4mathprodcancel_divide_tracerstuple)r8rS orig_newshapeneg1srZ other_sizesszs`` r%_compute_newshaperuus-NNNNzHHH  $X . .( K K8,, K K K%ZZ!^^ +(++ , ,, R BA2HRaRL28AaCDD>22K E E(D"(1++(D (D(D E E EEE9  TY{+++q00 8rx{{8827ST::88$188/3y/E/E88,.71::88 9 99  #BHQKK = =B ~ 1x| 1R 1(1Q344. 1 11 B B(A"(1++(A(A(A B B BBBR  di)))) Qrx{{QQ27ST::QQ$1QQ:>)H:M:MQQQ R RR IIIII?GIII I IIsC)orderrwstrcd}t|t|dkr|dn|}|dkrtj||dS|dkrNt t |jddd}tj||ddd|jS|dkrtd td |d ) z|Returns an array containing the same data with a new shape. Refer to :func:`jax.numpy.reshape` for full documentation. TrNrrvNFrWAz&np.reshape order=A is not implemented.z'Unexpected value for 'order' argument: .) rurOrreshapelistrangendimTr, ValueError)r8rwrB__tracebackhide__rSdimss r%_reshapers  qSYY!^^$q'' F F( c\\ ;q(D ) )) || af ddd# $ $D ;q(44R4.$ / / 11 || F G GG GuGGG H HHr'DTypeLike | NonerXNonecP|tdtjd|tj|}t j|dt j|}|jdkrY|j j |j krtdttj|d|S|jd|j j z|j zdkrtd|j |kr|S|j t"kr#t|d |Stj|j t(jrg|jdd|jdd zR}tj|j j }tj||jd ddd f|jjd d dd f|j}t||S|t"kr2t|t(jt"Stj|t(jrXt|tj|j |}|d ddd fd |d d dd fzzS|j j |j krU|j |j j z}|jg|jdd|jd|z|R}tj||S|j j |j krJtj||}|jg|jdd|jd|jdzRStj||S)aReturn a bitwise copy of the array, viewed as a new dtype. This is fuller-featured wrapper around :func:`jax.lax.bitcast_convert_type`. If the source and target dtype have the same bitwidth, the result has the same shape as the input array. If the bitwidth of the target dtype is different from the source, the size of the last axis of the result is adjusted accordingly. >>> jnp.zeros([1,2,3], dtype=jnp.int16).view(jnp.int8).shape (1, 2, 6) >>> jnp.zeros([1,2,4], dtype=jnp.int8).view(jnp.int16).shape (1, 2, 2) Conversions involving booleans are not well-defined in all situations. With regards to the shape of result as explained above, booleans are treated as having a bitwidth of 8. However, when converting to a boolean array, the input should only contain 0 or 1 bytes. Otherwise, results may be unpredictable or may change depending on how the result is used. This conversion is guaranteed and safe: >>> jnp.array([1, 0, 1], dtype=jnp.int8).view(jnp.bool_) Array([ True, False, True], dtype=bool) However, there are no guarantees about the results of any expression involving a view such as this: `jnp.array([1, 2, 3], dtype=jnp.int8).view(jnp.bool_)`. In particular, the results may change between JAX releases and depending on the platform. To safely convert such an array to a boolean array, compare it with `0`: >>> jnp.array([1, 2, 0], dtype=jnp.int8) != 0 Array([ True, True, False], dtype=bool) Nz1`type` argument of array.view() is not supported.viewrzDview() of a 0d array is only supported if the itemsize is unchanged.)rrWzuWhen changing to a larger dtype, its size must be a divisor of the total size in bytes of the last axis of the array.uint8.rNy?)r,rcheck_arraylikerr=r check_user_dtype_supportedcanonicalize_dtyperrr5r_viewr expand_dimssqueezerhrr$r>r3complexfloatingfinfozerosatsetrealimagrr}bitcast_convert_type)rrrX new_shape new_dtypeoutfactors r%rrsaD  Q R RRvs######E6222  #E * *%X]] yU^++ ] ^ ^^ d++U 3 3 ; ; = == imci((EN:a?? Q R RR Y% J Y$ G$$e , ,,#)R%7884#)CRC.4#)B-!"344I **0I ?9i 0 0add CMMadd CMM e   d]] bh   & &t , ,,%!3440 Y_U++1 2 2 9 9% @ @C sADqDy>BS!$Q$Y/ // Y%.(( ^sy1 1F #+ Gsy"~ Gsy}'> G G G GC  #C / //Y%.(( "3 . .C 3; F #2# F "  " (E F F FF !#u - --r'c td)z8Not implemented: Use :meth:`~jax.Array.flatten` instead.zRJAX Arrays do not implement the arr.flat property: consider arr.flatten() instead.r,selfs r%_notimplemented_flatrs> ? ??r'cfd}|S)Nc ^t|dr|}r||fn||f}t|tr|St |t vrHt ddt |djdt |djtS)N __jax_array__z unsupported operand type(s) for z: rz and rN) hasattrrr`_accepted_binop_typesrX_rejected_binop_typesr@__name__NotImplemented)rotherrB binary_opopcharswaps r%deferring_binary_opz7_defer_to_unrecognized_arg..deferring_binary_op suo&&$!!##e 3E4==tUmD%.// Y  E{{+++ SSSd1g/SS8.3s-<<A+ , ,<<<<< > >>r')rNr)static_argnums start_indicestuple[tuple[int, ...]] limit_indices removed_dims list[Array]cg}t|||D]H\}}}tj|||}|rtj||}||I|S)zExtracts multiple slices from `arr`. This is used to shard Array arguments to pmap. It's implemented as a Array method here to avoid circular imports. )ziprslicerappend) rrrrresultsstartslimitsremovedsliceds r% _multi_slicerCsq'!$]Mg|]}tj|dS)F)keepdims)r index_in_dim)rYrZrs r%r\z_unstack..Zs+ L L LQ# 1a% 0 0 0 L L Lr'r)rrh)rs`r%_unstackrXs+ L L L L% :K:K L L LLr'c#K||jdkr|VdStj|jd|\}}t|D]}t j|||z|V|rt j|||z|VdSdS)Nr)rhrdivmodrrdynamic_slice_in_dim)rr4 num_chunkstailrZs r% _chunk_iterr\s AGAJ GGGGG}QWQZ66J :  88  $QD$ 7 77777 A  $Q T(94 @ @@@@@@AAr'c,tj||Sr^)r_rewriting_take)rrAs r%_getitemrfs  "4 . ..r'c(eZdZdZdZdZdZdZdS)_IndexUpdateHelpera!Helper property for index update functionality. The ``at`` property provides a functionally pure equivalent of in-place array modifications. In particular: ============================== ================================ Alternate syntax Equivalent In-place expression ============================== ================================ ``x = x.at[idx].set(y)`` ``x[idx] = y`` ``x = x.at[idx].add(y)`` ``x[idx] += y`` ``x = x.at[idx].multiply(y)`` ``x[idx] *= y`` ``x = x.at[idx].divide(y)`` ``x[idx] /= y`` ``x = x.at[idx].power(y)`` ``x[idx] **= y`` ``x = x.at[idx].min(y)`` ``x[idx] = minimum(x[idx], y)`` ``x = x.at[idx].max(y)`` ``x[idx] = maximum(x[idx], y)`` ``x = x.at[idx].apply(ufunc)`` ``ufunc.at(x, idx)`` ``x = x.at[idx].get()`` ``x = x[idx]`` ============================== ================================ None of the ``x.at`` expressions modify the original ``x``; instead they return a modified copy of ``x``. However, inside a :py:func:`~jax.jit` compiled function, expressions like :code:`x = x.at[idx].set(y)` are guaranteed to be applied in-place. Unlike NumPy in-place operations such as :code:`x[idx] += y`, if multiple indices refer to the same location, all updates will be applied (NumPy would only apply the last update, rather than applying all updates.) The order in which conflicting updates are applied is implementation-defined and may be nondeterministic (e.g., due to concurrency on some hardware platforms). By default, JAX assumes that all indices are in-bounds. Alternative out-of-bound index semantics can be specified via the ``mode`` parameter (see below). Arguments --------- mode : str Specify out-of-bound indexing mode. Options are: - ``"promise_in_bounds"``: (default) The user promises that indices are in bounds. No additional checking will be performed. In practice, this means that out-of-bounds indices in ``get()`` will be clipped, and out-of-bounds indices in ``set()``, ``add()``, etc. will be dropped. - ``"clip"``: clamp out of bounds indices into valid range. - ``"drop"``: ignore out-of-bound indices. - ``"fill"``: alias for ``"drop"``. For `get()`, the optional ``fill_value`` argument specifies the value that will be returned. See :class:`jax.lax.GatherScatterMode` for more details. indices_are_sorted : bool If True, the implementation will assume that the indices passed to ``at[]`` are sorted in ascending order, which can lead to more efficient execution on some backends. unique_indices : bool If True, the implementation will assume that the indices passed to ``at[]`` are unique, which can result in more efficient execution on some backends. fill_value : Any Only applies to the ``get()`` method: the fill value to return for out-of-bounds slices when `mode` is ``'fill'``. Ignored otherwise. Defaults to ``NaN`` for inexact types, the largest negative value for signed types, the largest positive value for unsigned types, and ``True`` for booleans. Examples -------- >>> x = jnp.arange(5.0) >>> x Array([0., 1., 2., 3., 4.], dtype=float32) >>> x.at[2].add(10) Array([ 0., 1., 12., 3., 4.], dtype=float32) >>> x.at[10].add(10) # out-of-bounds indices are ignored Array([0., 1., 2., 3., 4.], dtype=float32) >>> x.at[20].add(10, mode='clip') Array([ 0., 1., 2., 3., 14.], dtype=float32) >>> x.at[2].get() Array(2., dtype=float32) >>> x.at[20].get() # out-of-bounds indices clipped Array(4., dtype=float32) >>> x.at[20].get(mode='fill') # out-of-bounds indices filled with NaN Array(nan, dtype=float32) >>> x.at[20].get(mode='fill', fill_value=-1) # custom fill value Array(-1., dtype=float32) arrayc||_dSr^r)rrs r%__init__z_IndexUpdateHelper.__init__s DJJJr'c,t|j|Sr^)_IndexUpdateRefr)rindexs r% __getitem__z_IndexUpdateHelper.__getitem__s 4:u - --r'cd|jdS)Nz_IndexUpdateHelper(rdrrs r%__repr__z_IndexUpdateHelper.__repr__s 0 0 0 00r'N)r __module__ __qualname____doc__ __slots__rrrrr'r%rrjsURRf)...11111r'rceZdZdZdZdZdZddddddZdddd d Zdddd d Z dddd d Z dddd d Z e Z dddd dZ dddd dZdddd dZdddd dZdS)raHelper object to call indexed update functions for an (advanced) index. This object references a source array and a specific indexer into that array. Methods on this object return copies of the source array that have been modified at the positions specified by the indexer. rrc"||_||_dSr^r)rrrs r%rz_IndexUpdateRef.__init__sDJDJJJr'c(d|jd|jdS)Nz_IndexUpdateRef(z, rdrrs r%rz_IndexUpdateRef.__repr__s =dj = =dj = = ==r'FNindices_are_sortedunique_indicesmodercJtj|j|j||||S)alEquivalent to ``x[idx]``. Returns the value of ``x`` that would result from the NumPy-style :mod:indexing ` ``x[idx]``. This function differs from the usual array indexing syntax in that it allows additional keyword arguments ``indices_are_sorted`` and ``unique_indices`` to be passed. See :mod:`jax.ops` for details. r)rrrr)rrrrrs r%getz_IndexUpdateRef.gets1  $TZ8J4B0: < < <` ``x[idx] = y``. See :mod:`jax.ops` for details. r )r_scatter_updaterrrrvaluesrrrs r%rz_IndexUpdateRef.sets8  "4:tz63;6H2@t M M MMr'c fd}tj|j|jt j|jj||||S)a2Pure equivalent of ``func.at(x, idx)`` for a unary ufunc ``func``. Returns the value of ``x`` that would result from applying the unary function ``func`` to ``x`` at the given indices. This is similar to ``x.at[idx].set(func(x[idx]))``, but differs in the case of repeated indices: in ``x.at[idx].apply(func)``, repeated indices result in the function being applied multiple times. Note that in the current implementation, ``scatter_apply`` is not compatible with automatic differentiation. See :mod:`jax.ops` for details. c<tj|||fd|ji|S)N update_shape)r scatter_applyrh)rindicesyrkwargsfuncs r%_scatter_applyz-_IndexUpdateRef.apply.._scatter_applys)  q'4 V VAG Vv V VVr'r )rr rr lax_internal_zeror)rrrrrrs ` r%applyz_IndexUpdateRef.applyseWWWWW  "4:tz#/#5dj6F#G#G#16H2@t  M M MMr'c `tj|j|j|tj|||S)zPure equivalent of ``x[idx] += y``. Returns the value of ``x`` that would result from the NumPy-style :mod:indexed assignment ` ``x[idx] += y``. See :mod:`jax.ops` for details. r )rr rrr scatter_addrs r%addz_IndexUpdateRef.adds9  "4:tz6#&?6H2@t M M MMr'c `tj|j|j|tj|||S)zPure equivalent of ``x[idx] *= y``. Returns the value of ``x`` that would result from the NumPy-style :mod:indexed assignment ` ``x[idx] *= y``. See :mod:`jax.ops` for details. r )rr rrr scatter_mulrs r%multiplyz_IndexUpdateRef.multiplys6  "4:tz6#&?6H2@(,  . . ..r'c tj|jtjt j|j|j|tj |||S)zPure equivalent of ``x[idx] /= y``. Returns the value of ``x`` that would result from the NumPy-style :mod:indexed assignment ` ``x[idx] /= y``. See :mod:`jax.ops` for details. r ) rdividerrr r ones_likerrr rs r%r#z_IndexUpdateRef.divide-sZ = j i1$*==tz6!o1C-;$HHH I IIr'c tj|jtjt j|j|j|tj |||S)zPure equivalent of ``x[idx] **= y``. Returns the value of ``x`` that would result from the NumPy-style :mod:indexed assignment ` ``x[idx] **= y``. See :mod:`jax.ops` for details. r ) rpowerrrr rr$rrr rs r%r&z_IndexUpdateRef.power=sZ < j i1$*==tz6!o1C-;$HHH I IIr'c `tj|j|j|tj|||S)zPure equivalent of ``x[idx] = minimum(x[idx], y)``. Returns the value of ``x`` that would result from the NumPy-style :mod:indexed assignment ` ``x[idx] = minimum(x[idx], y)``. See :mod:`jax.ops` for details. r )rr rrr scatter_minrs r%rGz_IndexUpdateRef.minM9  "4:tz6#&?6H2@t M M MMr'c `tj|j|j|tj|||S)zPure equivalent of ``x[idx] = maximum(x[idx], y)``. Returns the value of ``x`` that would result from the NumPy-style :mod:indexed assignment ` ``x[idx] = maximum(x[idx], y)``. See :mod:`jax.ops` for details. r )rr rrr scatter_maxrs r%rIz_IndexUpdateRef.max\r)r')rrrrrrrr rrrr!mulr#r&rGrIrr'r%rrs !)>>>',E<<<<< /4E M M M M M/4EMMMMM./4E M M M M M49 . . . . . #16uIIIII 16eIIIII /4E M M M M M/4E M M M M M M Mr'rgetitemsetitemdeepcopynegposeqz==nez!=lt<lez<=gt>gez>=absr+raddT)rsub-rsubr,*rmuldiv/rdivtruedivrtruedivfloordivz// rfloordivrrdivmodmod%rmodpowz**rpowmatmul@rmatmuland&|^z<>) randorrorxorrxorinvertlshiftrshiftrlshiftrrshiftrrlanyargmaxargmin argpartitionargsortr$chooserKconj conjugatercumprodcumsumdiagonaldotflattenrAmeannonzerornptpravelrepeatr}r searchsortedsortrstdsum) swapaxestake to_devicetracerPvarr_splitr)rr)flatrmTrrnbytesr5rctD]&\}}t|d|t|'tD](\}}t||t j|)tD](\}}t||t j|)t|dttdS)N_ _array_module) _array_operatorsitemssetattr staticmethod_array_methodsr aval_method_array_properties aval_propertyr) shaped_array operator_namefunction method_namemethod prop_nameprops r%_set_shaped_array_attributesrs "2!7!7!9!9GGmX L-m--|H/E/EFFFF+1133AAk6 L+t'7'?'?@@@@*0022??oi L)T%7%=%=>>>> ,6F)G)GHHHHHr'cfd}|S)NcBt|jd|g|RS)Nr)getattraval)rrBnames r%opz%_forward_operator_to_aval..ops- )749j$jj ) )$ 6 6 6 66r'r)rrs` r%_forward_operator_to_avalrs!77777 )r'cfd}|S)NcPd}t|jj|g|Ri|S)NT)rrfun)rrBrrrs r%methz%_forward_method_to_aval..meths8 '749d # # ' >t > > >v > >>r'r)rrs` r%_forward_method_to_avalrs#????? +r'c,tfd}|S)NcTt|j|Sr^)rrfget)rrs r%rz'_forward_property_to_aval..props# 49d # # ( ( . ..r')property)rrs` r%_forward_property_to_avalrs+ //// 8/ +r'rctD](}||vr"t|d|dt|)tD]$}||vrt||t |%t D]$}||vrt||t |%dSN__)rrrrrrr)tracerexcluderrrs r%_set_tracer_aval_forwardingrs'XXmG## f,=,,,.G .V.VWWW#IIk'!! fk#:;#G#GHHH$GGi fi!:9!E!EFFFGGr'cfd}tD]\}}|d|d|tD]\}}|||tD]\}} ||t | t D]\} } t | | dS)NcJ|vrdSr|vrt||dSdSr^)r) attr_nametarget device_arrayrincludes r% maybe_setattrz1_set_array_base_attributes..maybe_setattrsJyG33 f /i7** lIv.....+*r'r)rrrrr_impl_only_array_methodsr) rrrrrrrrrrrrs ``` r%_set_array_base_attributesrs/////// "2!7!7!9!944mXM(}((((3333+1133''k6M+v&&&&*0022--oiM)Xd^^,,,,,2244&&jdD L$%%%%&&r'c2t|dtdS)Nr)rr)rs r%_set_array_attributesrs ,*,<=====r'c`tjt|fd}|S)Nc(td)NzCannot call abstract method r)rBrrs r%rz%_make_abstract_method..methods CTCC D DDr')abcabstractmethodr)rrrs` r%_make_abstract_methodrsD;;EEEE;E -r'c tD],\}}t|d|dtd|d|-tD]$\}}t||t||%t D]1\}}t||t t||2dSr)rrrrrrr) basearrayrrrrrrs r%_set_array_abstract_methodsr"s !1!7!7!9!9EEmX I-M--- !"8}"8"8"8( C CEEEE+113388k6 I{ !+v 6 68888*0022>>oi Iy *9d;; < <>>>>>>r'c0ttjttjt t dht tjhtdtt ttdS)z9Call this function once to register methods of JAX arraysr)rrN) rr ShapedArray DShapedArrayrrrTracerrrrrrr'r%rr-s|t/000t0111Y@@@@dk3T5M3Tt3TUUUU """e$$$$$r')FN) rrrrrrr r!r"r)rrr r)r(r*)rrr"r/)r8rr"r9)NN)rFrrGrHrIrHr"r)r8rrBrr"r)r8rrSrTr"r)r8rrBrrwrxr"r)rrrrrXrr"r)Fr^)rFrrrr"r)rrr"r)rrrrr"r)r8rrrrQrrrr4rrrr"r) rrrrrrrrr"r)rrr"r)r)r __future__r__all__r functoolsrrrmtypingrrr3rr jax.shardingr jax._srcr r r jax._src.api_utilr jax._src.arrayr jax._src.laxr jax._src.librxcjax._src.numpyrrrr jax._src.opsrjax._src.typingrrrrr jax._src.utilrrmap unsafe_mapr unsafe_zipr&r.r7rCrErLrRrurrrr/floatcomplexgenericndarrayrr~rprdictrrrrrrr_JAX_ARRAY_TYPESrrrstash_axis_envjitrrrrrrnegativepositiveequal not_equalless less_equalgreater greater_equalr:rsubtractr!r# true_divide floor_dividerrJr&rO bitwise_and bitwise_or bitwise_xor bitwise_not left_shift right_shiftrrlr`rarbrcrdrerfrgrrhrirjrkrprIrmrGrnrnrorqrrrrsrrtrurvrwryrzsplitrrrPmatrix_transposerrrrrrrrrrrrrrr'r%rs} " #""""" ' ( $$$$$$$$  !!!!!!111111$$$$$$,,,,,,))))))$$$$$$%%%%%%!!!!!! GGGGGGGGGGGGGG,,,,,,,,CZCZ@@@@@+/%%%%%%FFFF 7777 AE22222 & & & &IIIIB14IIIIII$V.V.V.V.V.r??? eWbj"*eLuc40 ***55555 K+'2:-7)->=A(,a>>>>>>)))*)&MMM MAAA///^1^1^1^1^1^1^1^1B^M^M^M^M^M^M^M^M@. X. #. %. i .  .  .""466.""4)9::.""3 44.""4):;;.""377.""4)=>>.. # #C 4 4. $ $S&*4 @ @ @.  # #C 9 9!." $ $S&/ E E E#..$ # #C 9 9%.& $ $S&/ E E E'.( # #C 7 7).* $ $S&-d C C C+., ' 'V-? @ @-.. ((f.@tLLL/.0 ((v/BCC1.2))$0C$OOO3.4 & &x ? ?5.6 ' '&-d K K K7.8 # #C 4 49.: $ $S&*4 @ @ @;.< # #D&, 7 7=.> $ $T6 ? ? & &tV-? @ @ ' 'f.?d K K K ' 'f.@t L L L [...`... I . I  . )( .  Y  . G. I . %. &+.v. . ).. Z . J .  i !."#..$ Y_%.& %'.().* */+.,-.. Y /.0 */1.23.4 9?5.6 I 7.8 X9.: 9?;.<)(=.> ).?.@ Y A.BC.DE..F . ?   O[...b " + +    I I I     G G G G&&&&&>>> > > > % % % % %r'