ukixpddlZddlZddlmZmZmZddlZddlm Z ddlm Z ddlm Z ddl m Z ddlmZddlmZdd lmZdd lmZdd lmZdd lmZmZdd lmZmZmZm Z ddl!m"Z"m#Z#e#dZ$dddddeezde dzdedejPezdzdeezdzdef d Z.e$ d>ddddeezde dzdedejPezdzdeezdzdef d!Z/e$ d>ddd"eezde dzdedejPezdzdef d#Z0e$ d>dddeezdede dzdedejPezdzdef d$Z1e d?ddd'ed(ed)e2d*e3d+ed&de dzd,e2dejPezdzdefd-Z4e d@ddd'ed(ed)e2d*e3d+ed%de dzd,e2dejPezdzde5eeffd.Z4e dAdddd/d'ed(ed)e2d*e3d+ed%de dzd,e2dejPezdzde5eeffd0Z4e d?ddd'ed(ed)e2d*e3d+e3de dzd,e2dejPezdzdee5eefzfd1Z4e$ d?ddd'ed(ed)e2d*e3d+e3de dzd,e2dejPezdzdee5eefzfd2Z4e jld34 d?ddd'ed(ed)e2d*e3d+e3de dzd,e2dejPezdzdee5eefzfd5Z7e$ dBd'ed(ed)e2d*e3d6ede dzd,e2defd7Z8e jld84 dBd'ed(ed)e2d*e3d6ede dzd,e2defd9Z9e$ dCd'ed(ed)e2d*e3de dzd,e2defd:Z:e jld84 dCd'ed(ed)e2d*e3de dzd,e2defd;Z;y)DN)AnyLiteraloverload)api)core)dtypes)lax) xla_client)asarray)ufuncs)util)Sharding) NamedSharding PartitionSpec)Array ArrayLikeDuckTypedArray DTypeLike)canonicalize_axis set_modulez jax.numpyshapecontextreturnct|ttfs?t|dddk(st j |dk(rt j|f|St j||S)Nndimr) isinstancetuplelistgetattrnprrcanonicalize_shape)rrs X/home/cdr/jupyterlab/.venv/lib/python3.12/site-packages/jax/_src/numpy/array_creation.pyr!r!(sX UUDM *ufd#q(BGGENa,?  " "E8W 55  " "5' 22device out_shardingdtyper%r&c2t|tjr tdt d||x}r t|t j |tn|d}t|}tj||d}tj|d||S)aCreate an array full of zeros. JAX implementation of :func:`numpy.zeros`. Args: shape: int or sequence of ints specifying the shape of the created array. dtype: optional dtype for the created array; defaults to float32 or float64 depending on the X64 configuration (see :ref:`default-dtypes`). device: (optional) :class:`~jax.Device` or :class:`~jax.sharding.Sharding` to which the created array will be committed. This argument exists for compatibility with the :ref:`python-array-api`. out_sharding: (optional) :class:`~jax.sharding.PartitionSpec` or :class:`~jax.NamedSharding` representing the sharding of the created array (see `explicit sharding`_ for more details). This argument exists for consistency with other array creation routines across JAX. Specifying both ``out_sharding`` and ``device`` will result in an error. Returns: Array of the specified shape and dtype, with the given device/sharding if specified. See also: - :func:`jax.numpy.zeros_like` - :func:`jax.numpy.empty` - :func:`jax.numpy.ones` - :func:`jax.numpy.full` Examples: >>> jnp.zeros(4) Array([0., 0., 0., 0.], dtype=float32) >>> jnp.zeros((2, 3), dtype=bool) Array([[False, False, False], [False, False, False]], dtype=bool) .. _explicit sharding: https://docs.jax.dev/en/latest/notebooks/explicit-sharding.html :expected sequence object with len >= 0 or a single integerzerosz jnp.zerosrsharding) rtypes GeneratorType TypeError_check_forgot_shape_tupler!check_and_canonicalize_user_dtypefloatr!r choose_device_or_out_shardingr fullrr'r%r&mr,s r"r*r*0sLu**+ P QQ $WeU ;;a;IaL>P  2 2}e% 2% U #%  / / lK)( %EH 55r#c2t|tjr tdt d||x}r t|t |}t j|tn|d}tj||d}tj|d||S)aCreate an array full of ones. JAX implementation of :func:`numpy.ones`. Args: shape: int or sequence of ints specifying the shape of the created array. dtype: optional dtype for the created array; defaults to float32 or float64 depending on the X64 configuration (see :ref:`default-dtypes`). device: (optional) :class:`~jax.Device` or :class:`~jax.sharding.Sharding` to which the created array will be committed. This argument exists for compatibility with the :ref:`python-array-api`. out_sharding: (optional) :class:`~jax.sharding.PartitionSpec` or :class:`~jax.NamedSharding` representing the sharding of the created array (see `explicit sharding`_ for more details). This argument exists for consistency with other array creation routines across JAX. Specifying both ``out_sharding`` and ``device`` will result in an error. Returns: Array of the specified shape and dtype, with the given device/sharding if specified. See also: - :func:`jax.numpy.ones_like` - :func:`jax.numpy.empty` - :func:`jax.numpy.zeros` - :func:`jax.numpy.full` Examples: >>> jnp.ones(4) Array([1., 1., 1., 1.], dtype=float32) >>> jnp.ones((2, 3), dtype=bool) Array([[ True, True, True], [ True, True, True]], dtype=bool) .. _explicit sharding: https://docs.jax.dev/en/latest/notebooks/explicit-sharding.html r)oneszjnp.onesr+) rr-r.r/r0r!rr1r2r r3r r4r5s r"r8r8asLu**+ P QQ $VUE ::a:9Q<=O U #%  2 2}e% 1%  / / lJ(( %EH 55r#ctd||x}r t|tj|tn|d}t ||||S)aCreate an empty array. JAX implementation of :func:`numpy.empty`. Because XLA cannot create an un-initialized array, :func:`jax.numpy.empty` will always return an array full of zeros. Args: shape: int or sequence of ints specifying the shape of the created array. dtype: optional dtype for the created array; defaults to float32 or float64 depending on the X64 configuration (see :ref:`default-dtypes`). device: (optional) :class:`~jax.Device` or :class:`~jax.sharding.Sharding` to which the created array will be committed. This argument exists for compatibility with the :ref:`python-array-api`. out_sharding: (optional) :class:`~jax.sharding.PartitionSpec` or :class:`~jax.NamedSharding` representing the sharding of the created array (see `explicit sharding`_ for more details). This argument exists for consistency with other array creation routines across JAX. Specifying both ``out_sharding`` and ``device`` will result in an error. Returns: Array of the specified shape and dtype, with the given device/sharding if specified. See also: - :func:`jax.numpy.empty_like` - :func:`jax.numpy.zeros` - :func:`jax.numpy.ones` - :func:`jax.numpy.full` Examples: >>> jnp.empty(4) Array([0., 0., 0., 0.], dtype=float32) >>> jnp.empty((2, 3), dtype=bool) Array([[False, False, False], [False, False, False]], dtype=bool) .. _explicit sharding: https://docs.jax.dev/en/latest/notebooks/explicit-sharding.html emptyr$)r0r/rr1r2r*)rr'r%r&r6s r"r;r;sNP %WeU ;;a;IaL>P  2 2}e% 2% ueF FFr#cvt|tr)t|trd|d|d|d|d|d|d|dSyy)NzCannot interpret 'z9' as a data type. Did you accidentally write `jax.numpy.(z, z)` when you meant `jax.numpy.z((z5))`, i.e. with a single tuple argument for the shape?)rint)namerr's r"r0r0s`s 5# 6 (qr%1))-br%A: :;!7r#r% fill_valuecf|tj|d}tjd|t j |dk(r7t |}tj|||tj|Stjtjt||||S)aTCreate an array full of a specified value. JAX implementation of :func:`numpy.full`. Args: shape: int or sequence of ints specifying the shape of the created array. fill_value: scalar or array with which to fill the created array. dtype: optional dtype for the created array; defaults to the dtype of the fill value. device: (optional) :class:`~jax.Device` or :class:`~jax.sharding.Sharding` to which the created array will be committed. Returns: Array of the specified shape and dtype, on the specified device if specified. See also: - :func:`jax.numpy.full_like` - :func:`jax.numpy.empty` - :func:`jax.numpy.zeros` - :func:`jax.numpy.ones` Examples: >>> jnp.full(4, 2, dtype=float) Array([2., 2., 2., 2.], dtype=float32) >>> jnp.full((2, 3), 0, dtype=bool) Array([[False, False, False], [False, False, False]], dtype=bool) `fill_value` may also be an array that is broadcast to the specified shape: >>> jnp.full((2, 3), fill_value=jnp.arange(3)) Array([[0, 1, 2], [0, 1, 2]], dtype=int32) r4rr+r')rr1r check_arrayliker rr!r r4canonicalize_device_to_shardingr device_put _broadcast_tor )rrAr'r%s r"r4r4sL   4 4UF CEvz*WWZA u %E 88E:u!AA&I KK >> 7:U;UCV MMr#acBt|dr t|ds2t|dr|j}tjd||t j |d}| t |}tj||d}tj|d|||S)aCreate an array full of zeros with the same shape and dtype as an array. JAX implementation of :func:`numpy.zeros_like`. Args: a: Array-like object with ``shape`` and ``dtype`` attributes. shape: optionally override the shape of the created array. dtype: optionally override the dtype of the created array. device: (optional) :class:`~jax.Device` or :class:`~jax.sharding.Sharding` to which the created array will be committed. Returns: Array of the specified shape and dtype, on the specified device if specified. See also: - :func:`jax.numpy.zeros` - :func:`jax.numpy.empty_like` - :func:`jax.numpy.ones_like` - :func:`jax.numpy.full_like` Examples: >>> x = jnp.arange(4) >>> jnp.zeros_like(x) Array([0, 0, 0, 0], dtype=int32) >>> jnp.zeros_like(x, dtype=bool) Array([False, False, False, False], dtype=bool) >>> jnp.zeros_like(x, shape=(2, 3)) Array([[0, 0, 0], [0, 0, 0]], dtype=int32) r'r __jax_array__ zeros_likezjnp.zeros_likerr+ hasattrrJr rDrr1r!r3r full_likerHr'rr%r&r,s r"rKrKsH !W '!W"5q/" // aq)   4 4UL IE  u %E  / / l,.( q!UEH ==r#cBt|dr t|ds2t|dr|j}tjd||t j |d}| t |}tj||d}tj|d|||S)aCreate an array of ones with the same shape and dtype as an array. JAX implementation of :func:`numpy.ones_like`. Args: a: Array-like object with ``shape`` and ``dtype`` attributes. shape: optionally override the shape of the created array. dtype: optionally override the dtype of the created array. device: (optional) :class:`~jax.Device` or :class:`~jax.sharding.Sharding` to which the created array will be committed. Returns: Array of the specified shape and dtype, on the specified device if specified. See also: - :func:`jax.numpy.empty` - :func:`jax.numpy.zeros_like` - :func:`jax.numpy.ones_like` - :func:`jax.numpy.full_like` Examples: >>> x = jnp.arange(4) >>> jnp.ones_like(x) Array([1, 1, 1, 1], dtype=int32) >>> jnp.ones_like(x, dtype=bool) Array([ True, True, True, True], dtype=bool) >>> jnp.ones_like(x, shape=(2, 3)) Array([[1, 1, 1], [1, 1, 1]], dtype=int32) r'rrJ ones_likez jnp.ones_liker9r+rLrOs r"rQrQ,sH !W '!W"5q/" // aa(   4 4UK HE  u %E  / / lO-( q!UEH ==r# prototypec :t|dr t|ds2t|dr|j}tjd||t j |d}| t |}tj|d||tj|S)aNCreate an empty array with the same shape and dtype as an array. JAX implementation of :func:`numpy.empty_like`. Because XLA cannot create an un-initialized array, :func:`jax.numpy.empty` will always return an array full of zeros. Args: a: Array-like object with ``shape`` and ``dtype`` attributes. shape: optionally override the shape of the created array. dtype: optionally override the dtype of the created array. device: (optional) :class:`~jax.Device` or :class:`~jax.sharding.Sharding` to which the created array will be committed. Returns: Array of the specified shape and dtype, on the specified device if specified. See also: - :func:`jax.numpy.empty` - :func:`jax.numpy.zeros_like` - :func:`jax.numpy.ones_like` - :func:`jax.numpy.full_like` Examples: >>> x = jnp.arange(4) >>> jnp.empty_like(x) Array([0, 0, 0, 0], dtype=int32) >>> jnp.empty_like(x, dtype=bool) Array([False, False, False, False], dtype=bool) >>> jnp.empty_like(x, shape=(2, 3)) Array([[0, 0, 0], [0, 0, 0]], dtype=int32) r'rrJrQrr+) rMrJr rDrr1r!r rNrE)rRr'rr%s r" empty_likerT]sJ )W %')W*Ey/*))+ii0   4 4UK HE  u %E y!UE $ D DV L NNr#c jt|dr$t|drtjdd|n3tjd||t|dr|j}|t j |d}| t |}tj|dk(r-tj||||tj|S|tj|n|}|t j|n|}tjtj t#||||S)aCreate an array full of a specified value with the same shape and dtype as an array. JAX implementation of :func:`numpy.full_like`. Args: a: Array-like object with ``shape`` and ``dtype`` attributes. fill_value: scalar or array with which to fill the created array. shape: optionally override the shape of the created array. dtype: optionally override the dtype of the created array. device: (optional) :class:`~jax.Device` or :class:`~jax.sharding.Sharding` to which the created array will be committed. Returns: Array of the specified shape and dtype, on the specified device if specified. See also: - :func:`jax.numpy.full` - :func:`jax.numpy.empty_like` - :func:`jax.numpy.zeros_like` - :func:`jax.numpy.ones_like` Examples: >>> x = jnp.arange(4.0) >>> jnp.full_like(x, 2) Array([2., 2., 2., 2.], dtype=float32) >>> jnp.full_like(x, 0, shape=(2, 3)) Array([[0., 0., 0.], [0., 0., 0.]], dtype=float32) `fill_value` may also be an array that is broadcast to the specified shape: >>> x = jnp.arange(6).reshape(2, 3) >>> jnp.full_like(x, fill_value=jnp.array([[1], [2]])) Array([[1, 1, 1], [2, 2, 2]], dtype=int32) r'rrNrrJr+rC)rMr rDrJrr1r!r rr rNrEr result_typerrFrGr )rHrAr'rr%s r"rNrNs R QWQ0a4a4q/" // a   4 4UK HE  u %EWWZA ==Ju"&"F"Fv"N PP!=BHHQKeE%*]F  q !E >> 7:U;UCV MMr#TFstartstopnumendpointretstepaxiscyNrWrXrYrZr[r'r\r%s r"linspaceras GJr#cyr^r_r`s r"raras UXr#)r'r\r%cyr^r_r`s r"raras RUr#cyr^r_r`s r"raras ]`r#c tj|d}tjtj|d}t ||||||||S)a;Return evenly-spaced numbers within an interval. JAX implementation of :func:`numpy.linspace`. Args: start: scalar or array of starting values. stop: scalar or array of stop values. num: number of values to generate. Default: 50. endpoint: if True (default) then include the ``stop`` value in the result. If False, then exclude the ``stop`` value. retstep: If True, then return a ``(result, step)`` tuple, where ``step`` is the interval between adjacent values in ``result``. axis: integer axis along which to generate the linspace. Defaults to zero. device: optional :class:`~jax.Device` or :class:`~jax.sharding.Sharding` to which the created array will be committed. Returns: An array ``values``, or a tuple ``(values, step)`` if ``retstep`` is True, where: - ``values`` is an array of evenly-spaced values from ``start`` to ``stop`` - ``step`` is the interval between adjacent values. See also: - :func:`jax.numpy.arange`: Generate ``N`` evenly-spaced values given a starting point and a step - :func:`jax.numpy.logspace`: Generate logarithmically-spaced values. - :func:`jax.numpy.geomspace`: Generate geometrically-spaced values. Examples: List of 5 values between 0 and 10: >>> jnp.linspace(0, 10, 5) Array([ 0. , 2.5, 5. , 7.5, 10. ], dtype=float32) List of 8 values between 0 and 10, excluding the endpoint: >>> jnp.linspace(0, 10, 8, endpoint=False) Array([0. , 1.25, 2.5 , 3.75, 5. , 6.25, 7.5 , 8.75], dtype=float32) List of values and the step size between them >>> vals, step = jnp.linspace(0, 10, 9, retstep=True) >>> vals Array([ 0. , 1.25, 2.5 , 3.75, 5. , 6.25, 7.5 , 8.75, 10. ], dtype=float32) >>> step Array(1.25, dtype=float32) Multi-dimensional linspace: >>> start = jnp.array([0, 5]) >>> stop = jnp.array([5, 10]) >>> jnp.linspace(start, stop, 5) Array([[ 0. , 5. ], [ 1.25, 6.25], [ 2.5 , 7.5 ], [ 3.75, 8.75], [ 5. , 10. ]], dtype=float32) z'num' argument of jnp.linspacez'axis' argument of jnp.linspacer@)rconcrete_dim_or_errorconcrete_or_erroroperatorindex _linspacer`s r"rarasJ@ ""3(HI#  6W X$ 5$XwtF SSr#)rYrZr[r'r\r%)static_argnamescd|dkrtd|dtjd||\}}|*tjtj ||}ntj |d}tj|}|j|}|j|}ttjtj|tj|} tj|| } tj|| } |dkrt| |zdzn|}| j|d|r|dz n|} |dkDr tj ||z |t#| |z } dgt| z}| ||<tj$|j&}tj(|| j+|t#| |z }|j|}| j+| d|z z| j+| |zz}|rtj,|tj.| |fgt1||j2}n|dk(r4t#|rtj4n||z |} | j+| }n~ttjtj|tj|}|j|dt7dtj4|} t9||}tj:|tj<rCtj:|j&tj<stj>|}tj@|}tjB|||}|r|| fS|S) zAImplementation of linspace differentiable in start and stop args.rzNumber of samples, z, must be non-negative.rar9rCr_r+)" ValueErrorr ensure_arraylikerto_inexact_dtyperVr1astyperr broadcast_shapesr rrGleninsertconvert_element_typer finfor'iotareshape concatenate expand_dimsrrnanr4r; issubdtypeintegerfloorrE_convert_element_type)rWrXrYrZr[r'r\r%computation_dtype bounds_shapebroadcast_startbroadcast_stopdivdelta iota_shape real_dtypestepout empty_shaper,results r"rjrj&s 1W *3%/FG HH%%j%>+% ]  # #F$6$6ud$C DE  4 4UJ GE--e4 ,,( )% & '$c**288E?BHHTNKL,&&ul;/%%dL9.)-\ T !A %t$dAq3#1W++D5L:KLwWZbsOttEL))JJt/066J 88J $ , ,Z 873 ;S SD ;;( )D  " "< 0AH =\*T1 2C OOS#//.4'"JK-dCHH= ?c ax hBFFD5L@Q RE  ! !, /Cs++BHHUORXXd^LMKtQ RVV. /E  U #C ubjj)&2C2CCIIrzz2Z ))C.C  1 1& 9(  $ $S%( C&#&%//r#basec tjtj|d}tjtj|d}t |||||||S)aGenerate logarithmically-spaced values. JAX implementation of :func:`numpy.logspace`. Args: start: scalar or array. Used to specify the start value. The start value is ``base ** start``. stop: scalar or array. Used to specify the stop value. The end value is ``base ** stop``. num: int, optional, default=50. Number of values to generate. endpoint: bool, optional, default=True. If True, then include the ``stop`` value in the result. If False, then exclude the ``stop`` value. base: scalar or array, optional, default=10. Specifies the base of the logarithm. dtype: optional. Specifies the dtype of the output. axis: int, optional, default=0. Axis along which to generate the logspace. Returns: An array of logarithm. See also: - :func:`jax.numpy.arange`: Generate ``N`` evenly-spaced values given a starting point and a step value. - :func:`jax.numpy.linspace`: Generate evenly-spaced values. - :func:`jax.numpy.geomspace`: Generate geometrically-spaced values. Examples: List 5 logarithmically spaced values between 1 (``10 ** 0``) and 100 (``10 ** 2``): >>> with jnp.printoptions(precision=3, suppress=True): ... jnp.logspace(0, 2, 5) Array([ 1. , 3.162, 10. , 31.623, 100. ], dtype=float32) List 5 logarithmically-spaced values between 1(``10 ** 0``) and 100 (``10 ** 2``), excluding endpoint: >>> with jnp.printoptions(precision=3, suppress=True): ... jnp.logspace(0, 2, 5, endpoint=False) Array([ 1. , 2.512, 6.31 , 15.849, 39.811], dtype=float32) List 7 logarithmically-spaced values between 1 (``2 ** 0``) and 4 (``2 ** 2``) with base 2: >>> with jnp.printoptions(precision=3, suppress=True): ... jnp.logspace(0, 2, 7, base=2) Array([1. , 1.26 , 1.587, 2. , 2.52 , 3.175, 4. ], dtype=float32) Multi-dimensional logspace: >>> start = jnp.array([0, 5]) >>> stop = jnp.array([5, 0]) >>> base = jnp.array([2, 3]) >>> with jnp.printoptions(precision=3, suppress=True): ... jnp.logspace(start, stop, 5, base=base) Array([[ 1. , 243. ], [ 2.378, 61.547], [ 5.657, 15.588], [ 13.454, 3.948], [ 32. , 1. ]], dtype=float32) z'num' argument of jnp.logspacez'axis' argument of jnp.logspace)rrgrhri _logspace)rWrXrYrZrr'r\s r"logspacer`sN@ x~~s4TU#  6W X$ 5$XtUD AAr#)rYrZr'r\c |*tjtj||}ntj|d}tj|}t j d||\}}|j |}|j |}t||||dd|}tjtj|||S)zAImplementation of logspace differentiable in start and stop args.NrF)rZr[r'r\) rrorVr1r rnrprar rtr power) rWrXrYrZrr'r\rlins r"rrs  ]  # #F$6$6ud$C DE  4 4UJ GE--e4%%j%>+% ,,( )% & '$c"ED J# ! !&,,tS"95 AAr#ctjtj|d}tjtj|d}t ||||||S)aGenerate geometrically-spaced values. JAX implementation of :func:`numpy.geomspace`. Args: start: scalar or array. Specifies the starting values. stop: scalar or array. Specifies the stop values. num: int, optional, default=50. Number of values to generate. endpoint: bool, optional, default=True. If True, then include the ``stop`` value in the result. If False, then exclude the ``stop`` value. dtype: optional. Specifies the dtype of the output. axis: int, optional, default=0. Axis along which to generate the geomspace. Returns: An array containing the geometrically-spaced values. See also: - :func:`jax.numpy.arange`: Generate ``N`` evenly-spaced values given a starting point and a step value. - :func:`jax.numpy.linspace`: Generate evenly-spaced values. - :func:`jax.numpy.logspace`: Generate logarithmically-spaced values. Examples: List 5 geometrically-spaced values between 1 and 16: >>> with jnp.printoptions(precision=3, suppress=True): ... jnp.geomspace(1, 16, 5) Array([ 1., 2., 4., 8., 16.], dtype=float32) List 4 geomtrically-spaced values between 1 and 16, with ``endpoint=False``: >>> with jnp.printoptions(precision=3, suppress=True): ... jnp.geomspace(1, 16, 4, endpoint=False) Array([1., 2., 4., 8.], dtype=float32) Multi-dimensional geomspace: >>> start = jnp.array([1, 1000]) >>> stop = jnp.array([27, 1]) >>> with jnp.printoptions(precision=3, suppress=True): ... jnp.geomspace(start, stop, 4) Array([[ 1., 1000.], [ 3., 100.], [ 9., 10.], [ 27., 1.]], dtype=float32) z'num' argument of jnp.geomspacez 'axis' argument of jnp.geomspace)rrgrhri _geomspace)rWrXrYrZr'r\s r" geomspacersLb x~~s4UV#  6X Y$ E4ht <boolrarjitrjrrrrr_r#r"rsi  )))5!&EGG7 K  3c3C3tzz3-60437-6-6Y--6))h&--6%)D0-66:8< ->)n,->$&->->yy8+d2->+Q.5 ->BG ->->`(,->597; ->^+->%->->ii(*T1->*A-4 ->AF ->->`)- -N6:-N)n4-N$&-N-Nyy8+d2-N?D-N-N`?C9M599M^+9M#9M,5,<9M9Mii(*T19M>C9M9Mv ;=>C'+J7; JIJYJSJJ-4U^J$JJ H,t3 J@E J J  (,X7; XIXYXSXX&-dmX$XX H,t3 X@EUE\?R X X  ;="U'+37 UIUYUSUU07 U$UUYY)D0 U=B%,5:(,608< 60Y60i60c6060.260%6060X-4 60AFeUZlH[@[ 60T60r;=6:9:ABIABYABSABAB*3AB$AB36AB?DABABF =><>7;:;BYBiBcBB+4B%B47B@EB?B"QU:;2=Y2=i2=c2=$2=%2=472=@E2=2=h =>RV;<.i.y.s.4.$&.58.AF.?.r#