+
    &j?                     P	   ^ RI t ^ RIHt ^ RIHt ^ RIHt ^ RIH	t	 R t
]! ]P                  RR7      R 4       t]! ]P                  RR7      R	 4       t]! ]P                  RR7      R
 4       t]! ]P                  RR7      R 4       t]! ]P                  RR7      R[R l4       t]! ]P                  RR7      R\R l4       t]! ]P                  RR7      R]R l4       t]! ]P                  RR7      R\R l4       t]! ]P                  RR7      R 4       t]! ]P                  RR7      R 4       t]! ]P                  RR7      R^R R ll4       t]! ]P                  RR7      R]R l4       t]! ]P                  RR7      R 4       t]! ]P                  RR7      R 4       t]! ]P                  RR7      R R l4       t]! ]P                  RR7      R 4       t]! ]P                  RR7      R 4       tR\R R llt]! ]P                  RR7      R_R R ll4       t]! ]P                  RR7      R 4       t]! ]P                  RR7      R  R! l4       t ]! ]P                  RR7      R" R# l4       t!]! ]P                  RR7      R$ 4       t"]! ]P                  RR7      R`R% l4       t#]! ]P                  RR7      R^R& l4       t$]! ]P                  RR7      R\R' l4       t%R( t& ! R) R*]	4      t']
! ]4       ! R+ R,]	4      4       t(]
! ]!4       ! R- R.]	4      4       t)]
! ]4       ! R/ R0]	4      4       t*]
! ]4       ! R1 R2]	4      4       t+]
! ]4       ! R3 R4]	4      4       t, ! R5 R6]	4      t- ! R7 R8]	4      t.]
! ]4       ! R9 R:]	4      4       t/]
! ]4       ! R; R<]	4      4       t0]
! ]4       ! R= R>]	4      4       t1 ! R? R@]	4      t2 ! RA RB]	4      t3]
! ]4       ! RC RD]	4      4       t4]
! ]4       ! RE RF]	4      4       t5]
! ]4       ! RG RH]	4      4       t6 ! RI RJ]	4      t7 ! RK RL]	4      t8]
! ]&4       ! RM RN]	4      4       t9]
! ]"4       ! RO RP]	4      4       t: ! RQ RR]	4      t;]
! ]4       ! RS RT]	4      4       t<]
! ]#4       ! RU RV]	4      4       t=]
! ]$4       ! RW RX]	4      4       t>]
! ]%4       ! RY RZ]	4      4       t?R# )a    N)partialAny)Modulec                    a  V 3R  lpV# )c                    < V3R  lV n         V # )c                    < S! V4      # N )_xfs   &&q/Users/jameslopez/projects/CWCArchive/cwc-podcast/.venv/lib/python3.14/site-packages/mlx/nn/layers/activations.py<lambda><_make_activation_module.<locals>.decorator.<locals>.<lambda>   s	    ad    )__call__)klassr   s   &r   	decorator*_make_activation_module.<locals>.decorator   s    *r   r   )r   r   s   f r   _make_activation_moduler      s     r   T)	shapelessc                .    \         P                  ! V 4      # )zdApplies the sigmoid function.

.. math::
    \text{Sigmoid}(x) = \sigma(x) = \frac{1}{1 + \exp(-x)}
mxsigmoidr   s   &r   r   r      s     ::a=r   c                0    \         P                  ! V ^ 4      # )zAApplies the Rectified Linear Unit.

Simply ``mx.maximum(x, 0)``.
r   maximumr   s   &r   relur!      s     ::ar   c                X    \         P                  ! \         P                  ! V ^ 4      4      # )uT   Applies the ReLU² activation function.

Applies :math:`\max(0, x)^2` element wise.
)r   squarer    r   s   &r   relu2r$   &   s     99RZZ1%&&r   c                Z    \         P                  ! \         P                  ! V ^ 4      R4      # )zXApplies the Rectified Linear Unit 6.

Applies :math:`\min(\max(x, 0), 6)` element wise.
g      @r   minimumr    r   s   &r   relu6r(   /   s      ::bjjA&,,r   c                <    \         P                  ! W,          V 4      # )zXApplies the Leaky Rectified Linear Unit.

Simply ``mx.maximum(negative_slope * x, x)``.
r   )r   negative_slopes   &&r   
leaky_relur+   8   s     ::n(!,,r   c                @    V \         P                  ! WRR7      ,
          # )zYApplies the Log Softmax function.

Applies :math:`x + \log \sum_i e^{x_i}` element wise.
T)axiskeepdims)r   	logsumexpr   r-   s   &&r   log_softmaxr1   A   s     r||A4888r   c                z    \         P                  ! V ^ 8  W\         P                  ! V 4      ^,
          ,          4      # )z^Applies the Exponential Linear Unit.

Simply ``mx.where(x > 0, x, alpha * (mx.exp(x) - 1))``.
)r   whereexpr   alphas   &&r   elur7   J   s*     88AE1rvvay1}566r   c                0    \         P                  ! WR7      # )z\Applies the Softmax function.

Applies :math:`\frac{e^{x_i}}{\sum_j e^{x_j}}` element wise.
r-   r   softmaxr0   s   &&r   r;   r;   S   s     ::a##r   c                0    \         P                  ! V ^ 4      # )zPApplies the Softplus function.

Applies :math:`\log(1 + \exp(x))` element wise.
)r   	logaddexpr   s   &r   softplusr>   \   s     <<1r   c                f    \         P                  ! V ^\         P                  ! V 4      ,           4      # )zPApplies the Softsign function.

Applies :math:`\frac{x}{1 + |x|}` element wise.
)r   divideabsr   s   &r   softsignrB   e   s!     99QBFF1I&&r   c                $    V ^8  d   QhR\         /# )   lambdfloat)formats   "r   __annotate__rI   o   s     
B 
B 
Br   c                    \         P                  ! \         P                  ! V 4      V8  V \         P                  ! V 4      V,          ,
          ^ 4      # )zApplies the Softshrink activation function.

.. math::
    \text{softshrink}(x) = \begin{cases}
    x - \lambda & \text{if } x > \lambda \\
    x + \lambda & \text{if } x < -\lambda \\
    0 & \text{otherwise}
    \end{cases}
)r   r3   rA   signr   rE   s   &&r   
softshrinkrM   n   s6     88BFF1I%q2771:+='=qAAr   c                    \         P                  ! V R4      V\         P                  ! \         P                  ! V R4      V,          4      ^,
          ,          ,           # )zApplies the Continuously Differentiable Exponential Linear Unit.

Applies :math:`\max(0, x) + \min(0, \alpha * (\exp(x / \alpha) - 1))`
element wise.
        )r   r    r4   r'   r5   s   &&r   celurP   |   s=     ::a

1c0BU0J)Ka)O PPPr   c                <    V \         P                  ! V 4      ,          # )zApplies the Sigmoid Linear Unit. Also known as Swish.

Applies :math:`x \sigma(x)` element wise, where :math:`\sigma(\cdot)` is
the logistic sigmoid.
r   r   s   &r   silurR      s     rzz!}r   c                    \        V ) 4      ) # )zeApplies the Log Sigmoid function.

Applies :math:`\log(\sigma(x)) = -\log(1 + e^{-x})` element wise.
)r>   r   s   &r   log_sigmoidrT      s     aRL=r   c                8    V ^8  d   QhR\         P                  /# rD   returnr   array)rH   s   "r   rI   rI      s     2 2rxx 2r   c                    V ^\         P                  ! V \        P                  ! ^4      ,          4      ,           ,          ^,          # )zApplies the Gaussian Error Linear Units function.

.. math::
    \textrm{GELU}(x) = x * \Phi(x)

where :math:`\Phi(x)` is the Gaussian CDF.

See also :func:`gelu_approx` and :func:`gelu_fast_approx` for faster
approximations.
)r   erfmathsqrtr   s   &r   gelur^      s/     BFF1tyy|+,,-11r   c           	         RV ,          ^\         P                  ! \        P                  ! ^\        P                  ,          4      V RV ^,          ,          ,           ,          4      ,           ,          # )a\  An approximation to Gaussian Error Linear Unit.

See :func:`gelu` for the exact computation.

This function approximates ``gelu`` with a maximum absolute error :math:`<
0.0005` in the range :math:`[-6, 6]` using the following

.. math::

    x = 0.5 * x * \left(1 + \text{Tanh}\left((\sqrt{2 / \pi} * \left(x + 0.044715 * x^3\right)\right)\right)

      ?gHm?)r   tanhr\   r]   pir   s   &r   gelu_approxrc      sD     7a"''$))AK"8A1a4<O"PQQRRr   c                J    V \         P                  ! RV ,          4      ,          # )a  A fast approximation to Gaussian Error Linear Unit.

See :func:`gelu` for the exact computation.

This function approximates ``gelu`` with a maximum absolute error :math:`<
0.015` in the range :math:`[-6, 6]` using the following

.. math::

    x = x \sigma\left(1.702 x\right)

where :math:`\sigma(\cdot)` is the logistic sigmoid.

References:
- https://github.com/hendrycks/GELUs
- https://arxiv.org/abs/1606.08415
gZd;?r   r   s   &r   gelu_fast_approxre      s    & rzz%!)$$$r   c                d    V ^8  d   QhR\         P                  R\        R\         P                  /# )rD   r   r-   rW   )r   rY   int)rH   s   "r   rI   rI      s)      288 3  r   c                r    \         P                  ! V ^VR7      w  r#V\         P                  ! V4      ,          # )#  Applies the gated linear unit function.

This function splits the ``axis`` dimension of the input into two halves
(:math:`a` and :math:`b`) and applies :math:`a * \sigma(b)`.

.. math::
    \textrm{GLU}(x) = a * \sigma(b)

Args:
    axis (int): The dimension to split along. Default: ``-1``
)indices_or_sectionsr-   )r   splitr   )r   r-   abs   &&  r   glurn      s+     88A148DArzz!}r   c                D    V ^8  d   QhR\         P                  R\        /# )rD   r   	threshold)r   rY   rG   )rH   s   "r   rI   rI      s     ) )BHH ) )r   c                6    \         P                  ! W8  ^^ 4      # )  Applies the Step Activation Function.

This function implements a binary step activation, where the output is set
to 1 if the input is greater than a specified threshold, and 0 otherwise.

.. math::
    \text{step}(x) = \begin{cases}
    0 & \text{if } x < \text{threshold} \\
    1 & \text{if } x \geq \text{threshold}
    \end{cases}

Args:
    threshold: The value to threshold at.
)r   r3   )r   rp   s   &&r   steprs      s    " 88AM1a((r   c                (    \        V R4      R,          # )a  Applies the Scaled Exponential Linear Unit.

.. math::
    \text{selu}(x) = \begin{cases}
    \lambda x & \text{if } x > 0 \\
    \lambda \alpha (\exp(x) - 1) & \text{if } x \leq 0
    \end{cases}

where :math:`\lambda = 1.0507` and :math:`\alpha = 1.67326`.

See also :func:`elu`.
gGG?g䃞ͪ?)r7   r   s   &r   seluru      s     q'?V##r   c                x    V ^8  d   QhR\         P                  R\         P                  R\         P                  /# )rD   r   r6   rW   rX   )rH   s   "r   rI   rI     s-     7 7RXX 7bhh 7288 7r   c                v    \         P                  ! ^ V 4      V\         P                  ! ^ V 4      ,          ,           # )zApplies the element-wise parametric ReLU.

.. math::
    \text{PReLU}(x) = \max(0,x) + a * \min(0,x)

where :math:`a` is an array.
r   r    r'   r5   s   &&r   prelury     s*     ::aebjjA&6666r   c                X    V ^8  d   QhR\         P                  R\         P                  /# )rD   r   rW   rX   )rH   s   "r   rI   rI     s"     $ $BHH $ $r   c                N    V \         P                  ! \        V 4      4      ,          # )zApplies the Mish function, element-wise.

Mish: A Self Regularized Non-Monotonic Neural Activation Function.

Reference: https://arxiv.org/abs/1908.08681

.. math::
    \text{Mish}(x) = x * \text{Tanh}(\text{Softplus}(x))

)r   ra   r>   r   s   &r   mishr|     s     rwwx{###r   c                    \         P                  ! V ^,           ^ 4      pV \         P                  ! V^4      ,          ^,          # )zsApplies the hardswish function, element-wise.

.. math::
    \text{Hardswish}(x) = x * \min(\max(x + 3, 0), 6) / 6
rx   )r   max_x_3s   & r   	hardswishr     s3     jjQ"Grzz'1%%))r   c                X    \         P                  ! \         P                  ! W4      V4      # )zrApplies the HardTanh function.

Applies :math:`\max(\min(x, \mathrm{max\_val}), \mathrm{min\_val})` element-wise.
r&   )r   min_valmax_vals   &&&r   	hard_tanhr   *  s     ::bjj,g66r   c                `    \         P                  ! \         P                  ! V 4      V8  V ^ 4      # )zApplies the HardShrink activation function.

.. math::
    \text{hardshrink}(x) = \begin{cases}
    x & \text{if } x > \lambda \\
    x & \text{if } x < -\lambda \\
    0 & \text{otherwise}
    \end{cases}
)r   r3   rA   rL   s   &&r   hard_shrinkr   3  s$     88BFF1I%q!,,r   c                4    \         P                  ! V ) VR7      # )z^Applies the Softmin function.

Applies :math:`\frac{e^{-x_i}}{\sum_j e^{-x_j}}` element-wise.
r9   r:   r0   s   &&r   softminr   A  s     ::qbt$$r   c                .    \         P                  ! V 4      # )zAApplies the hyperbolic tangent function.

Simply ``mx.tanh(x)``.
)r   ra   r   s   &r   ra   ra   J  s    
 771:r   c                   X   a a ] tR tRt oRtRV3R lV 3R llltV3R lR ltRtVtV ;t	# )	GLUiR  ri   c                    < V ^8  d   QhRS[ /# )rD   r-   )rg   )rH   __classdict__s   "r   rI   GLU.__annotate___  s      S r   c                0   < \         SV `  4        Wn        R # r
   )super__init__r-   )selfr-   	__class__s   &&r   r   GLU.__init___  s    	r   c                    < V ^8  d   QhRS[ /# rV   r   )rH   r   s   "r   rI   r   c  s     ( (S (r   c                .    \        WP                  R 7      # )r0   )rn   r-   r   r   s   &&r   r   GLU.__call__c  s    QYY''r   r9   
__name__
__module____qualname____firstlineno____doc__r   r   __static_attributes____classdictcell____classcell__r   r   s   @@r   r   r   R  s#     
 ( ( (r   r   c                       ] tR tRtRtRtR# )Sigmoidig  zrApplies the sigmoid function, element-wise.

.. math::
    \text{Sigmoid}(x) = \sigma(x) = \frac{1}{1 + \exp(-x)}
r   Nr   r   r   r   r   r   r   r   r   r   r   g      r   r   c                       ] tR tRtRtRtR# )Miship  zApplies the Mish function, element-wise.

Reference: https://arxiv.org/abs/1908.08681

.. math::
    \text{Mish}(x) = x * \text{Tanh}(\text{Softplus}(x))

r   Nr   r   r   r   r   r   p  s    r   r   c                       ] tR tRtRtRtR# )ReLUi|  zuApplies the Rectified Linear Unit.
    Simply ``mx.maximum(x, 0)``.

See :func:`relu` for the functional equivalent.
r   Nr   r   r   r   r   r   |  r   r   r   c                       ] tR tRtRtRtR# )ReLU2i  uZ   Applies the ReLU² activation function.

See :func:`relu2` for the functional equivalent.
r   Nr   r   r   r   r   r         r   r   c                       ] tR tRtRtRtR# )ReLU6i  zWApplies the Rectified Linear Unit 6.

See :func:`relu6` for the functional equivalent.
r   Nr   r   r   r   r   r     r   r   r   c                   @   a a ] tR tRt oRtRV 3R lltR tRtVtV ;t	# )	LeakyReLUi  zApplies the Leaky Rectified Linear Unit.

Simply ``mx.maximum(negative_slope * x, x)``.

Args:
    negative_slope: Controls the angle of the negative slope. Default: ``1e-2``
c                0   < \         SV `  4        Wn        R # r
   )r   r   _negative_slope)r   r*   r   s   &&r   r   LeakyReLU.__init__  s    -r   c                ,    \        WP                  4      # r
   )r+   r   r   s   &&r   r   LeakyReLU.__call__  s    !1122r   )r   g{Gz?r   r   s   @@r   r   r     s     .3 3r   r   c                   @   a a ] tR tRt oRtRV 3R lltR tRtVtV ;t	# )ELUi  zApplies the Exponential Linear Unit.
    Simply ``mx.where(x > 0, x, alpha * (mx.exp(x) - 1))``.

See :func:`elu` for the functional equivalent.

Args:
    alpha: the :math:`\alpha` value for the ELU formulation. Default: ``1.0``
c                0   < \         SV `  4        Wn        R # r
   r   r   _alphar   r6   r   s   &&r   r   ELU.__init__      r   c                ,    \        WP                  4      # r
   )r7   r   r   s   &&r   r   ELU.__call__  s    1kk""r   r         ?r   r   s   @@r   r   r     s     # #r   r   c                       ] tR tRtRtRtR# )Softmaxi  zRApplies the Softmax function.

See :func:`softmax` for the functional equivalent.
r   Nr   r   r   r   r   r     r   r   r   c                       ] tR tRtRtRtR# )Softplusi  zTApplies the Softplus function.

See :func:`softplus` for the functional equivalent.
r   Nr   r   r   r   r   r     r   r   r   c                       ] tR tRtRtRtR# )Softsigni  zTApplies the Softsign function.

See :func:`softsign` for the functional equivalent.
r   Nr   r   r   r   r   r     r   r   r   c                   @   a a ] tR tRt oRtRV 3R lltR tRtVtV ;t	# )
Softshrinki  zApplies the Softshrink function.

See :func:`softshrink` for the functional equivalent.

Args:
    lambd: the :math:`\lambda` value for Softshrink. Default: ``0.5``
c                0   < \         SV `  4        Wn        R # r
   )r   r   rE   )r   rE   r   s   &&r   r   Softshrink.__init__  s    
r   c                ,    \        WP                  4      # r
   )rM   rE   r   s   &&r   r   Softshrink.__call__  s    !ZZ((r   )rE   r`   r   r   s   @@r   r   r     s     ) )r   r   c                   @   a a ] tR tRt oRtRV 3R lltR tRtVtV ;t	# )CELUi  a$  Applies the Continuously Differentiable Exponential Linear Unit.
    Applies :math:`\max(0, x) + \min(0, \alpha * (\exp(x / \alpha) - 1))`
    element wise.

See :func:`celu` for the functional equivalent.

Args:
    alpha: the :math:`\alpha` value for the CELU formulation. Default: ``1.0``
c                0   < \         SV `  4        Wn        R # r
   r   r   s   &&r   r   CELU.__init__  r   r   c                ,    \        WP                  4      # r
   )rP   r   r   s   &&r   r   CELU.__call__  s    A{{##r   r   r   r   r   s   @@r   r   r     s     $ $r   r   c                       ] tR tRtRtRtR# )SiLUi  zgApplies the Sigmoid Linear Unit. Also known as Swish.

See :func:`silu` for the functional equivalent.
r   Nr   r   r   r   r   r     r   r   r   c                       ] tR tRtRtRtR# )
LogSoftmaxi  zZApplies the Log Softmax function.

See :func:`log_softmax` for the functional equivalent.
r   Nr   r   r   r   r   r     r   r   r   c                       ] tR tRtRtRtR# )
LogSigmoidi  zZApplies the Log Sigmoid function.

See :func:`log_sigmoid` for the functional equivalent.
r   Nr   r   r   r   r   r     r   r   r   c                   L   a a ] tR tRt oRtRV 3R lltV3R lR ltRtVtV ;t	# )PReLUi  a?  Applies the element-wise parametric ReLU.
    Applies :math:`\max(0, x) + a * \min(0, x)` element wise, where :math:`a`
    is an array.

See :func:`prelu` for the functional equivalent.

Args:
    num_parameters: number of :math:`a` to learn. Default: ``1``
    init: the initial value of :math:`a`. Default: ``0.25``
c                ^   < \         SV `  4        \        P                  ! V.V4      V n        R # r
   )r   r   r   fullweight)r   num_parametersinitr   s   &&&r   r   PReLU.__init__  s#    gg~.5r   c                4   < V ^8  d   QhRS[ P                  /# rD   r   rX   )rH   r   s   "r   rI   PReLU.__annotate__  s     % %"(( %r   c                ,    \        WP                  4      # r
   )ry   r   r   s   &&r   r   PReLU.__call__  s    Q$$r   )r   )   g      ?r   r   s   @@r   r   r     s     	6% % %r   r   c                   @   a a ] tR tRt oRtRV 3R lltR tRtVtV ;t	# )GELUi   a  Applies the Gaussian Error Linear Units.

.. math::
    \textrm{GELU}(x) = x * \Phi(x)

where :math:`\Phi(x)` is the Gaussian CDF.

However, if ``approx`` is set to 'precise' or 'fast' it applies

.. math::
    \textrm{GELUApprox}(x) &= 0.5 * x * \left(1 + \text{Tanh}\left((\sqrt{2 / \pi} * \left(x + 0.044715 * x^3\right)\right)\right) \\
    \textrm{GELUFast}(x) &= x * \sigma\left(1.702 * x\right)

respectively.

.. note::
   For compatibility with the PyTorch API, 'tanh' can be used as an alias
   for 'precise'.

See :func:`gelu`, :func:`gelu_approx` and :func:`gelu_fast_approx` for the
functional equivalents and information regarding error bounds.


Args:
    approx ('none' | 'precise' | 'fast'): Which approximation to gelu to use if any.
c                h   < \         SV `  4        Wn        . ROpW9  d   \        RV RV R24      hR# )nonezThe approximation should be in z but 'z' was givenN)r   precisera   fast)r   r   _approx
ValueError)r   approxallowedr   s   && r   r   GELU.__init__<  sB    5 1'&T  !r   c                    V P                   R 8X  d   \        V4      # V P                   R9   d   \        V4      # \        V4      # )r   )r   ra   )r   r^   rc   re   r   s   &&r   r   GELU.__call__E  s9    <<6!7N\\00q>!""r   )r   )r   r   r   s   @@r   r   r      s     6# #r   r   c                       ] tR tRtRtRtR# )TanhiM  zZApplies the hyperbolic tangent function.

See :func:`tanh` for the functional equivalent.
r   Nr   r   r   r   r   r   M  r   r   r   c                       ] tR tRtRtRtR# )	HardswishiU  zdApplies the hardswish function, element-wise.

See :func:`hardswish` for the functional equivalent.
r   Nr   r   r   r   r   r   U  r   r   r   c                   X   a a ] tR tRt oRtRV3R lV 3R llltV3R lR ltRtVtV ;t	# )	Stepi]  rr   c                    < V ^8  d   QhRS[ /# )rD   rp   rF   )rH   r   s   "r   rI   Step.__annotate__m  s     # #% #r   c                0   < \         SV `  4        Wn        R # r
   )r   r   rp   )r   rp   r   s   &&r   r   Step.__init__m  s    "r   c                4   < V ^8  d   QhRS[ P                  /# r   rX   )rH   r   s   "r   rI   r  q  s     ' '"(( 'r   c                ,    \        WP                  4      # r
   )rs   rp   r   s   &&r   r   Step.__call__q  s    A~~&&r   )rp   rO   r   r   s   @@r   r   r   ]  s#     # #' ' 'r   r   c                       ] tR tRtRtRtR# )SELUiu  z]Applies the Scaled Exponential Linear Unit.

See :func:`selu` for the functional equivalent.
r   Nr   r   r   r   r	  r	  u  r   r   r	  c                       ] tR tRtRtRtR# )HardTanhi}  zUApplies the HardTanh function.

See :func:`hard_tanh` for the functional equivalent.
r   Nr   r   r   r   r  r  }  r   r   r  c                       ] tR tRtRtRtR# )
HardShrinki  zApplies the HardShrink function.

See :func:`hard_shrink` for the functional equivalent.

Args:
    lambd: the :math:`\lambda` value for Hardshrink. Default: ``0.5``
r   Nr   r   r   r   r  r    s    r   r  c                       ] tR tRtRtRtR# )Softmini  zRApplies the Softmin function.

See :func:`softmin` for the functional equivalent.
r   Nr   r   r   r   r  r    r   r   r  r   r   r   r   r  )g      r   )@r\   	functoolsr   typingr   mlx.corecorer   mlx.nn.layers.baser   r   compiler   r!   r$   r(   r+   r1   r7   r;   r>   rB   rM   rP   rR   rT   r^   rc   re   rn   rs   ru   ry   r|   r   r   r   r   ra   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r	  r  r  r  r   r   r   <module>r     s       % 	t$ % 	t$ % 	t$' %' 	t$- %- 	t$- %- 	t$9 %9 	t$7 %7 	t$$ %$ 	t$ % 	t$' %' 	t$
B %
B 	t$Q %Q 	t$ % 	t$ % 	t$2 %2 	t$S %S  	t$% %%*  	t$) %)& 	t$$ %$  	t$7 %7 	t$$ %$ 	t$* %* 	t$7 %7 	t$
- %
- 	t$% %%(& (* !f  " 6   6   F    F   3 3"#& #$ !f  " "v  # "v  #) )"$6 $& 6   %  & %  &%F %(*#6 *#Z 6   #  $'6 '0 6   #v  $ %  & !f  "r   