AVha dZddlZddlZddlZddlmZddlmZddlmZddlm Z ddlm Z ddl m Z dd l m Z dd l mZdd l mZdd l mZdd l mZddlmZddlmZddlmZddlmZddlmZedej4ddddej6fdZdZej<ddZ dkdZ ejBejD dldejFdejFfdZ$ejBejJ dldejFdejFfdZ&ejBejN dldejFdejFfdZ(ejBejR dldejFdejFfdZ*ejBejV dldejFdejFfd Z,ejBejZ dldejFdejFfd!Z.d"Z/e/e$d#d$e/e&d%d&e/e(d'd(e/e*d)d*e/e,d+d,e/e.d-d$d.Z0d/Z1d0Z2d1Z3d2Z4d3Z5d4Z6d5Z7d6Z8d7Z9 dkd8Z:ejBejv dmd9ejxfd:Z;ejBejz dmd9ejxfd;Z=ejBej| dmd9ejxfd<Z>ejBej~ dmd9ejxfd=Z?ejBej dmd9ejxfd>Z@ejBej dnd9ejxfd?ZAejBej dnd9ejxfd@ZBdAZCejBej dmd9ejxfdBZDejBej dmd9ejxfdCZEdDZFeFe;d#d$dEe1eFe=d%d&dFe2eFe>d'd(dGe3eFe?d)d*dHe4eFe@d+d,dIe5eFeAdJd,dIe6eFeBdKd,dIe7eFeDdLdMdNe8eFeEdOdPdQe9ejBej dodRejFdSejFfdTZGdUZHdVZIdWZJejBejdkdXejxfdYZLejBejdldZejejFfd[ZMejBej dpd\ejxfd]ZPejBej dmd\ejxfd^ZQejBej dmd\ejxfd_ZRejBejd`ejFdaejFfdbZSejBejd`ejFdaejFfdcZTddZU dqdeZVejBej drd\ejxdfeXdgeYdheYdieje[f djZ\y)szSupport for ragged tensors.N)dtypes)errors)ops)tensor) tensor_util) array_ops) check_ops)gen_ragged_math_ops)map_fn)math_ops)nn_ops)ragged_functional_ops) ragged_tensor)segment_id_ops)dispatch) tf_exportz ragged.rangecjtj|}|d|}}tj|d|||g5}tj||d}tj||d}tj||d}|Ot |||gtj tjtjtjg\}}}tj|||||}tjj|j|j d cdddS#1swYyxYw) a'Returns a `RaggedTensor` containing the specified sequences of numbers. Each row of the returned `RaggedTensor` contains a single sequence: ```python ragged.range(starts, limits, deltas)[i] == tf.range(starts[i], limits[i], deltas[i]) ``` If `start[i] < limits[i] and deltas[i] > 0`, then `output[i]` will be an empty list. Similarly, if `start[i] > limits[i] and deltas[i] < 0`, then `output[i]` will be an empty list. This behavior is consistent with the Python `range` function, but differs from the `tf.range` op, which returns an error for these cases. Examples: >>> tf.ragged.range([3, 5, 2]).to_list() [[0, 1, 2], [0, 1, 2, 3, 4], [0, 1]] >>> tf.ragged.range([0, 5, 8], [3, 3, 12]).to_list() [[0, 1, 2], [], [8, 9, 10, 11]] >>> tf.ragged.range([0, 5, 8], [3, 3, 12], 2).to_list() [[0, 2], [], [8, 10]] The input tensors `starts`, `limits`, and `deltas` may be scalars or vectors. The vector inputs must all have the same size. Scalar inputs are broadcast to match the size of the vector inputs. Args: starts: Vector or scalar `Tensor`. Specifies the first entry for each range if `limits` is not `None`; otherwise, specifies the range limits, and the first entries default to `0`. limits: Vector or scalar `Tensor`. Specifies the exclusive upper limits for each range. deltas: Vector or scalar `Tensor`. Specifies the increment for each range. Defaults to `1`. dtype: The type of the elements of the resulting tensor. If not specified, then a value is chosen based on the other args. name: A name for the operation. row_splits_dtype: `dtype` for the returned `RaggedTensor`'s `row_splits` tensor. One of `tf.int32` or `tf.int64`. Returns: A `RaggedTensor` of type `dtype` with `ragged_rank=1`. Nr RaggedRangestarts)dtypenamelimitsdeltas)TsplitsrFvalidate)ras_dtyper name_scopeconvert_to_tensor_infer_matching_dtypeint32int64float32float64r ragged_ranger RaggedTensorfrom_row_splitsrt_dense_valuesrt_nested_splits)rrrrrrow_splits_dtyperesults \/home/dcms/DCMS/lib/python3.12/site-packages/tensorflow/python/ops/ragged/ragged_math_ops.pyranger.,sj__%56 ^FF ~~dMFFF+CDI  " "6X FF  " "6X FF  " "6X FF }4 66 " <<v~~v~~ F Hfff! - -(8tEF  % % 5 5 7 7% 6 IIIIs C)D))D2ctfd|DsJt|Dcgc]}|jc}j}|Dcgc]}t j ||c}Scc}wcc}w)zBInfers a matching dtype for tensors, and casts them to that dtype.c3:K|]}|jvywN)r).0tdtype_hierarchys r- z(_infer_matching_dtype..xs 9AQWW ' 9s)key)allmaxrindexr cast)tensorsr4r3inferred_dtypes ` r-r!r!vs\ 9 9 99 91A17L7LM.4; * <<2 >> rt = tf.ragged.constant([[3, 1, 4], [1, 5], [9], [2, 6]]) >>> tf.reduce_sum(rt, axis=0).numpy() # = [3+1+9+2, 1+5+6, 4] array([15, 12, 4], dtype=int32) >>> tf.reduce_sum(rt, axis=1).numpy() # = [3+1+4, 1+5, 9, 2+6] array([8, 6, 9, 8], dtype=int32) a >>> rt = tf.ragged.constant([[3, 1, 4], [1, 5], [9], [2, 6]]) >>> tf.reduce_prod(rt, axis=0).numpy() # = [3*1*9*2, 1*5*6, 4] array([54, 30, 4], dtype=int32) >>> tf.reduce_prod(rt, axis=1).numpy() # = [3*1*4, 1*5, 9, 2*6] array([12, 5, 9, 12], dtype=int32) z >>> rt = tf.ragged.constant([[3, 1, 4], [1, 5], [9], [2, 6]]) >>> tf.reduce_min(rt, axis=0).numpy() array([1, 1, 4], dtype=int32) >>> tf.reduce_min(rt, axis=1).numpy() array([1, 1, 9, 2], dtype=int32) z >>> rt = tf.ragged.constant([[3, 1, 4], [1, 5], [9], [2, 6]]) >>> tf.reduce_max(rt, axis=0).numpy() array([9, 6, 4], dtype=int32) >>> tf.reduce_max(rt, axis=1).numpy() array([4, 5, 9, 6], dtype=int32) z >>> rt = tf.ragged.constant([[3, 1, 4], [1, 5], [9], [2, 6]]) >>> tf.reduce_mean(rt, axis=0).numpy() array([3.75, 4. , 4. ]) >>> tf.reduce_mean(rt, axis=1).numpy() array([2.66666667, 3. , 9. , 4. ]) a >>> rt = tf.ragged.constant([[1, 1, 4], [2, 1], [3], [4, 1]], ... dtype=tf.float64) >>> tf.math.reduce_variance(rt, axis=0).numpy() array([1.25, 0., 0.]) >>> tf.math.reduce_variance(rt, axis=1).numpy() array([2., 0.25, 0., 2.25]) a >>> rt = tf.ragged.constant([[1, 0], [2, 1], [3], [4, 1]], ... dtype=tf.float64) >>> tf.math.reduce_std(rt, axis=0).numpy() array([1.11803399, 0.47140452]) >>> tf.math.reduce_std(rt, axis=1).numpy() array([0.5, 0.5, 0., 1.5]) z >>> rt = tf.ragged.constant([[True, True], [True, True, False, True], [False, True]]) >>> tf.reduce_all(rt, axis=0).numpy() array([False, True, False, True]) >>> tf.reduce_all(rt, axis=1).numpy() array([ True, False, False]) z >>> rt = tf.ragged.constant([[True, True], [True, True, False, True], [False, True]]) >>> tf.reduce_any(rt, axis=0).numpy() array([ True, True, False, True]) >>> tf.reduce_any(rt, axis=1).numpy() array([ True, True, True]) c |i}nd|i}tj|s |||f||d|St|tjrLt j |}| tdt|tjr|j}|F||jdf||d|}|r+|jddD]} tj|d}|Stj |d||g5t|t"t$fr|s |cdddSt'|dk(r|d}nt)|D cgc]4\} } tj*| |jj,d | zd 6}} } t/|}t1||||d ||} t1||| |dd ||cdddStj2|d }tj*||jj,d }|dk(r|j4dd|j4dd z } t7j8t7j:| d}t=| j>}tA||j>|||}|rtj|d}|cdddS|dk(rtj|j4ddz }tCjD|j4}tA||j>|||}|rtj|d}|cdddS|jGt1|||j>|dz ||cdddScc} } w#1swYyxYw)a?Aggregates across axes of a RaggedTensor using the given `Tensor` ops. Reduces `rt_input` along the dimensions given in `axis`. The rank of the tensor is reduced by 1 for each entry in `axis`. If `axis` is not specified, then all dimensions are reduced, and a scalar value is returned. This op assumes that `reduce_op` and `unsorted_segment_op` are associative; if not, then reducing multiple axes will return incorrect results. (In particular, reducing multiple axes is currently implemented by reducing the axes one at a time.) Args: reduce_op: The tensorflow `op` that should be used to reduce values in uniform dimensions. Must have the same signature and basic behavior as `reduce_sum`, `reduce_max`, etc. unsorted_segment_op: The tensorflow `op` that should be used to combine values in ragged dimensions. Must have the same signature and basic behavior as `unsorted_segment_sum`, `unsorted_segment_max`, etc. rt_input: A `Tensor` or `RaggedTensor` containing the values to be reduced. axis: The axis or axes to reduce. May be `None` (to reduce all axes), an `int` (to reduce a single axis), a `list` or `tuple` of `int` (to reduce a given set of axes), or a `Tensor` with a constant value. Must be in the range `[0, rt_input.rank)`. keepdims: If true, retains reduced dimensions with length 1. separator: An optional string. Defaults to None. The separator to use when joining. The separator must not be set for non-string data types. (i.e. if separator is not None then it uses string ops) name: A name prefix for the returned tensor (optional). Returns: A `RaggedTensor` containing the reduced values. The returned tensor has the same dtype as `data`, and its shape is given by removing the dimensions specified in `axis` from `rt_input.shape`. The `ragged_rank` of the returned tensor is given by substracting any ragged dimensions specified in `axis` from `rt_input.ragged_rank`. Raises: ValueError: If `axis` contains a `Tensor` whose value is not constant. NrX)keepdimsrz.axis must be known at graph construction time.rrrE RaggedReducezaxis[%s]zrank(input_tensor)rDrt_inputr@ ndims_name)$rrG isinstancerTensorrconstant_valuerJnpndarraytolistrxshaper expand_dimsrrtuplelistlen enumerateget_positive_axisndimssortedragged_reduce_aggregaterHrLr rP reduce_maxr.rOrNrrow_splits_to_segment_ids with_values) reduce_oprVrrFrrXrmaybe_separatorr,_ia inner_reduced row_lengthsrWrAs r-rrs^O"I.O   * $ I!) I8G IIfmm$  % %d +D | G HH$ # [[]d \ x++T5H 5$35F~~ab!7!&&vA67 M ~~dNXt,<=<.$ & <.<. t9>Aw"$ 1  ' '8>>+?+?a(< >  d|/ ;N08$r(H09; 'y2E'4d3Bi'021<.<.8??z#H  & & hnn""/C ED qy''+h.A.A#2.FFk%%h&9&9+&FJl+&--k() >   l66 7  ( (?d   .d tT8 ,Eu%  ' ' > >   e// /  ! !? U]!sC&D DD!ctj|d||g5tj|d}|jj r t dtj|}t|||}t|||}tj|}tj||z dcdddS#1swYyxYw)rRaggedReduceVariancerr@zGreduce_variance is not supported for RaggedTensors with complex dtypes.rFrrN) rrrrHr is_complexrJr squarerrP)rrFrrsquare_of_inputmean_of_squarersquare_of_means r-reduce_variancers  ~~d2\44HI@ CC>+L$$   ool3O thON |$ BD__T*N   N^;Q ?@@@s BB;;Cctj|d||g5t|||}tj|cdddS#1swYyxYw)rRaggedReduceStdrN)rrrr r)rrFrrvariances r- reduce_stdrsI  ~~d- d/CD#|$JH == "###s #AAcLtjtj||Sr1)rmap_flat_valuesr r:)rrs r-_castrs  . .x}}l/4 66rgc tj|d||g5ttt|tj ||tj cdddS#1swYyxYw)rRaggedReduceAllN)rrrrrr"boolrs r- reduce_allrsU  ~~d- d/CD E, 5tXF   =A!!A*c tj|d||g5ttt|tj ||tj cdddS#1swYyxYw)rRaggedReduceAnyN)rrrrrr"rrs r- reduce_anyrsU  ~~d- d/CD 5v||4dHE  rc:tt||||z|_y)N)rrdefaultexample)_RAGGED_REDUCE_DOCSTRINGrr)rrrrrs r-_set_ragged_reduce_docstringrs!)D -$,rg01z`input_tensor.dtype.min`z`input_tensor.dtype.max`NaNrstdz logical andzand-edTruez logical orzor-edFalserbc ~ ~ |r |r td|r |r tdt|||||||} tj| d||g5} t j |d}t j |d}t |tj} t |tj}| s"|s tj||fi| cdddS|j|jk7r td |jj8|jj td |jj}nd|jj8|jj|jjk7r td |jj}|d kr td |d kDrd}| s!tjj|d}|s!tjj|d}tjtj |j"|j"|g5t|j$|j$fi| }|j'|cdddcdddS|d k(rt)||fi| cdddS|d k(sJ| r |j*nd}|dk(r|s|s|st-||fi| cdddSt/||fi| cdddS#1swYrxYw#1swYyxYw)aMultiplies matrix `a` by matrix `b`. If all transpose or adjoint attributes are `False` then: ``` output[..., i, j] = sum_k (a[..., i, k] * b[..., k, j]), for all indices i, j. ``` The inputs `a` and `b` must have `rank >= 2`, where the outermost `rank - 2` dimensions are batch dimensions. The inputs must have the same dtype. See `tf.matmul` for more information. Args: a: `tf.Tensor` or `RaggedTensor` with `rank > 1`. b: `tf.Tensor` or `RaggedTensor` with same type and rank as `a`. transpose_a: If `True`, `a` is transposed before multiplication. transpose_b: If `True`, `b` is transposed before multiplication. adjoint_a: If `True`, `a` is conjugated & transposed before multiplication. adjoint_b: If `True`, `b` is conjugated & transposed before multiplication. a_is_sparse: If `True`, optimize assuming `a` is mostly zero. b_is_sparse: If `True`, optimize assuming `b` is mostly zero. output_type: The output datatype (optional). grad_a: Unused. grad_b: Unused. name: Name for the operation (optional). Returns: A `Tensor` or `RaggedTensor` with the same rank and shape as `a`, where each inner-most matrix is the product of the corresponding matrices in `a` and `b`. z2Only one of transpose_a and adjoint_a can be True.z2Only one of transpose_b and adjoint_b can be True.) transpose_a transpose_b adjoint_a adjoint_b a_is_sparse b_is_sparse output_type RaggedMatMulrr@rNz%`a` and `b` must have the same dtype.zPmatmul requires at least one input to have known rank if either input is ragged.z$`a` and `b` must have the same rank.z:Batch dimensions of `a` and `b` do not have the same size.r) ragged_rankrBr)rJrrrrrHrr'r matmulrrrank from_tensorrMr rKrLrOr _matmul_2dr!_matmul_3d_with_batch_dim_folding_matmul_3d_with_map_fn)rrrrrrrrrgrad_agrad_brkwargs a_is_ragged b_is_raggedr shape_err flat_result a_ragged_ranks r-rrs\  Y I JJY I JJ  & ~~dNQF3>4t88EA88EAQ : :;KQ : :;K ; __Q ,V ,>4>4 ww!'' > ?? ww||  ;< < WW\\d  !aggllaggll&B?@@ WW\\d ax = >>  axNi   & & 2 21! 2 D   & & 2 21! 2 D  # #  q||Y O% *QXXqxx:6: }}[) **Y>4>4d qy 1 ' 'g>4>4j 199%0AMMaM;+/q! >v >w>4>4|$Aq 3F 3}>4>4X**Y>4>4s> A=LE3L2K48 L L&.L L4K= 9LL c d}g}t|tjritj|j }|j }|jtj|tj||t|tjritj|j }|j }|jtj|tj||tj|5tj||fi|cdddS#1swYyxYw)aMultiplies potentially ragged 2D tensors. Args: a: A 2D Tensor or RaggedTensor with `shape=[I, J]` b: A 2D Tensor or RaggedTensor with `shape=[J, K]` **kwargs: Additional arguments for `tf.matmul` (e.g. transpose_a). Returns: A 2D Tensor with `shape=[I, K]`. zKThe matrices in `a` and `b` may not be ragged in their innermost dimension.rBN)rrr'rsizerx to_tensorappendr rKrrMr r)rrr ragged_errchecks original_sizes r-rrs7* &=--.NN1==1M A MM 9>>!,j BC=--.NN1==1M A MM 9>>!,j BC '+ ??1a *6 *+++s EE c  t|tjr4|jdk(s"j dsj drd nd  fd}d}t|tjr|j j n|j j }d}| |j }tj|| dz |}tj|||f| }j d sj d r3|j|jdd |jd dzdgzn2|j|jdd |jd d zdgzj dsj dr4|j|jdd dgz|jd d z|S|j|jdd dgz|jd dz|S)a7Multiplies batches of 2D matrices using map_fn. `output[n, i, k]` = sum_j (a[n, i, j] * b[n, j, k])` (for all `n`, `i`, `k`). Requires that `a[n, i].nrows()` == `b[n].nrows()` (for all `n` and `i`). Args: a: A 3D Tensor or RaggedTensor with `shape=[B, I, J]`, where dimensions `I` and `J` may be ragged. b: A 3D Tensor or RaggedTensor with `shape=[B, J, K]`, where dimensions `J` and `K` may be ragged. **kwargs: Additional arguments for `tf.matmul` (e.g. transpose_a). Returns: A 3D RaggedTensor with `shape=[B, (I), (K)]`. rrrrcvt|d|dfi}dk(rtjj|}|S)Nrrr)rrr'r)xoutroutput_ragged_ranks r-single_batch_matmulz3_matmul_3d_with_map_fn..single_batch_matmuls? QqT1Q4 *6 *CQ  & & 2 23 7c JrgNr)rrrr+)elemsfn_output_signaturerrrD) rrr'rgetrLrRaggedTensorSpecr _set_shaper) rrrr fn_out_shaper+rspecr,rs ` @r-rrs,M../}}VZZ 6 zz+ , A}11 2ll89 8J8J}%+''K  ' '  $q('  )$ ==!QT C&  ZZ &**["9 aggcrlQWWRS\1TF:; aggcrlQWWR^3tf<= ZZ &**["9 aggcrldV+aggbn<= - aggcrldV+aggbcl:; -rgc tj|jd}tj||j d}t j ||fi|}|jtj|dS)apMultiply batches of 2D matrices where only `a.shape[1]` is ragged. Args: a: A RaggedTensor with `shape=[B, (I), J]`. (ragged_rank must be 1.) b: A Tensor with `shape=[B, J, K]` **kwargs: Additional arguments for `tf.matmul` (e.g. transpose_a). transpose_a and adjoint_a must not be true. Returns: A RaggedTensor with `shape=[B, (I), K]. rrrE) rrrOrepeatrr rrsqueeze)rrr reshaped_a reshaped_brs r-rrse$$QXXq1*1==?;* JA&A+ y((1= >>rglogitsc|d}tj|d|g5}t||d}tjtj ||}t ||d}tj||cdddS#1swYyxYw)aComputes softmax activations. Used for multi-class predictions. The sum of all outputs generated by softmax is 1. This function performs the equivalent of softmax = tf.exp(logits) / tf.reduce_sum(tf.exp(logits), axis) Example usage: >>> softmax = tf.nn.softmax([-1, 0., 1.]) >>> softmax >>> sum(softmax) Args: logits: A non-empty `Tensor`. Must be one of the following types: `half`, `float32`, `float64`. axis: The dimension softmax would be performed on. The default is -1 which indicates the last dimension. name: A name for the operation (optional). Returns: A `Tensor`. Has the same type and shape as `logits`. Raises: InvalidArgumentError: if `logits` is empty or `axis` is beyond the last dimension of `logits`. NrD RaggedSoftmaxTr)rrrr expsubtractrdivide)r rFr max_input logits_exp denominators r-softmaxr)s}D \ D ~~dOfX64$6t> ~~dL&1I 0 0 HIIIs $AA(rc  | tdtj|d||g5tj|d}|j t j|j|||cdddS#1swYyxYw))Ragged dispatch target for tf.nn.dropout.N3noise_shape is not supported yet for RaggedTensor xRaggedNNDropoutrr@) keep_probseedrate) rJrrrrHrzr dropoutrx)rr2 noise_shaper3rr4s r- dropout_v1r7Os J KK ~~d-4y9G88EA   MMYT F GGGG A A::Bc | tdtj|d||g5tj|d}|j t j|j||cdddS#1swYyxYw)r/Nr0r1rr@)r4r3) rJrrrrHrzr dropout_v2rx)rr4r6r3rs r-r:r:`s{ J KK ~~d-4y9@88EA  !--d> @@@@s AA99Bc  | tdtj|d||g5tj|d}|j t j|j|||cdddS#1swYyxYw)z@Ragged dispatch target for tf.nn.experimental.stateless_dropout.Nr0RaggedNNStatelessDropoutrr@)r4r3rng_alg) rJrrrrHrzr stateless_dropoutrx)rr4r3r=r6rs r-r>r>os J KK ~~d6D BC88EA    MM4 B CCCCr8selfotherc|yt|r||uS tj||S#tjt f$rYywxYw)z;Ragged version of the operation invoked by `Tensor.__eq__`.F)$_use_legacy_mode_for_tensor_equalityr equalrInvalidArgumentErrorrJr?r@s r- tensor_equalsrFsQ ] +D1 5= ^^D% ((  ' ' 4 *AAc|yt|r||uS tj||S#tjt f$rYywxYw)z;Ragged version of the operation invoked by `Tensor.__ne__`.FT)rBr not_equalrrDrJrEs r-tensor_not_equalsrJsT ] +D1 u    e ,,  ' ' 4 rGct|dd}tjjxr(t j xr|duxs |j S)Ngraph)getattrrr _USE_EQUALITYr#executing_eagerly_outside_functionsbuilding_function)r?gs r-rBrBsO dGT"!mm))15571Dy/A// 22rgc|st||d|}||zS|rmtj|j|j dzdz }t j |dd}tj||}||z Stj|j|j }t j |d}tj||}||z S)zACalculate flat_values for math_ops.cumsum when axis==ragged_rank.T exclusivereverser)paramsindices)rT)"_cumsum_flat_values_at_ragged_rankrrUrL value_rowidsr rT) last_rprxrTrUpartialyoungest_siblingnew_flat_valuesinitial_valueseldest_siblings r-rXrXs 0g?G [    ''!!#W-A-A-Ca-GIKLMookT4PO%%_.>@N ^ ++%%!!#W-A-A-CENookTBO%%_.<>N ^ ++rgrFrTrUrc tj|d||||g5tj||jj d}||j k(r@|jd}|jt||j||cdddS||j kDrU||j z }tjtj|||}tj ||cdddS|j#}tj|||||} t$j&j)| |j+ cdddS#1swYyxYw) aCalculate math_ops.cumsum for a RaggedTensor. Given a ragged tensor `x`, the `result` is a ragged tensor with the same shape. One can calculate the value of `result[i_1...i_k]` as follows: ``` dense_result=tf.math.cumsum(rt.to_tensor(), axis=axis, exclusive=exclusive, reverse=reverse) result[i_1...i_k]=dense_result[i_1...i_k] ``` Args: x: the original ragged tensor to sum. axis: the axis along which to sum, can range -rank<=axis? 22   %h&& //IwPl " 2 2< C22kkmm G$Pf  ' ' 3 3 !..042#222sA2EAErFrJrBrXrTintrOptionalstrrirgr-rs" ..+.3++5(*(>67+6 > !<< EIEIP= D)-#' f6R8889 )m11 )*88 ): )899: *}22 *+99 *; *8889 )m11 )*88 ): )8889 )m11 )*88 ): )899:}22+99;&8;;<*44* - ; ;*=*(2 k5(;lI|Dk9kBk9kBlFJ?n.F&(8#'+!% E.P8../ (]11 (0 (8//0 )m22 )1 )8../ (]11 (0 (8../ (]11 (0 (8//0m22108334"@-"6"6@5@,8../#]11#0#6 8../]1108../]110Z#79[)\38:ZK779ZK779[&*e8:_j*e<>Z E79Z&79Zw798??+   {4""{4""{4,{4|+B=@?26,,-(4M(((4.(4\8>>*I&++m99:I+I6>>* G-&& G+ G 6,,-  @-&& @. @6334#"& C-- C5 C&8112  33 &44 3 8556 M77 *88 7 2HM/4,28??+$)"'/3 +2]))+2+2!+2 +2, +2,+2rg