
    JTh}X                     	   S SK Jr  S SKJr  S SKJrJrJr  S SKrS SKJ	r	  S SK
JrJrJr  / SQr\" S5      r\" \" S	5      \S
S05      rS\S\\/\4   4S jrS\S\S\R(                  S\R*                  SS4
S jr\" SSR.                  " SH0 \D65      SSSS\R0                  SSS.S\S\\   S\S\S\\R(                     S\R*                  S\\R6                     S\S\	4S jj5       r\" S S!R.                  " SH0 \D65      SS\R0                  SSS".S\S\S\\R(                     S\R*                  S\\R6                     S\S\	4S# jj5       r\" S$S%R.                  " SH0 \D65      SSS\R0                  SSS&.S\S'\S\S\\R(                     S\R*                  S\\R6                     S\S\	4S( jj5       r\" S)S*R.                  " SH0 \D65      S+SS\R0                  SSS,.S\S-\S\S\\R(                     S\R*                  S\\R6                     S\S\	4S. jj5       r\" S/S0R.                  " SH0 \D65      SS\R0                  SSS".S\S\S\\R(                     S\R*                  S\\R6                     S\S\	4S1 jj5       r \" S2S3R.                  " SH0 \D65      SS\R0                  SSS".S\S\S\\R(                     S\R*                  S\\R6                     S\S\	4S4 jj5       r!\" S5S6R.                  " SH0 \D65      SS\R0                  SSS".S\S\S\\R(                     S\R*                  S\\R6                     S\S\	4S7 jj5       r"\" S8S9R.                  " SH0 \D65      SS\R0                  SSS".S\S\S\\R(                     S\R*                  S\\R6                     S\S\	4S: jj5       r#\" S;S<R.                  " SH0 \D65      SS\R0                  SSS".S=\S\S\\R(                     S\R*                  S\\R6                     S\S\	4S> jj5       r$\" S?S@R.                  " SH0 \D65      SASS\R0                  SSSB.SC\S\S\\R(                     S\R*                  S\\R6                     S\S\	4SD jj5       r%\" SESFR.                  " SH0 \D65      SS\R0                  SSS".S\S\S\\R(                     S\R*                  S\\R6                     S\S\	4SG jj5       r&g)I    )Iterable)sqrt)CallableOptionalTypeVarN)Tensor)factory_common_argsmerge_dictsparse_kwargs)bartlettblackmancosineexponentialgaussiangeneral_cosinegeneral_hamminghamminghannkaisernuttall_Ta6  
    M (int): the length of the window.
        In other words, the number of points of the returned window.
    sym (bool, optional): If `False`, returns a periodic window suitable for use in spectral analysis.
        If `True`, returns a symmetric window suitable for use in filter design. Default: `True`.
normalizationzThe window is normalized to 1 (maximum value is 1). However, the 1 doesn't appear if :attr:`M` is even and :attr:`sym` is `True`.argsreturnc                  0   ^  S[         S[         4U 4S jjnU$ )a  Adds docstrings to a given decorated function.

Specially useful when then docstrings needs string interpolation, e.g., with
str.format().
REMARK: Do not use this function if the docstring doesn't need string
interpolation, just write a conventional docstring.

Args:
    args (str):
or   c                 4   > SR                  T5      U l        U $ )N )join__doc__)r   r   s    T/var/www/auris/envauris/lib/python3.13/site-packages/torch/signal/windows/windows.py	decorator_add_docstr.<locals>.decorator8   s    GGDM	    )r   )r   r"   s   ` r!   _add_docstrr%   ,   s    R B  r$   function_nameMdtypelayoutc                     US:  a  [        U  SU 35      eU[        R                  La  [        U  SU 35      eU[        R                  [        R                  4;  a  [        U  SU 35      eg)ag  Performs common checks for all the defined windows.
This function should be called before computing any window.

Args:
    function_name (str): name of the window function.
    M (int): length of the window.
    dtype (:class:`torch.dtype`): the desired data type of returned tensor.
    layout (:class:`torch.layout`): the desired layout of returned tensor.
r   z, requires non-negative window length, got M=z/ is implemented for strided tensors only, got: z) expects float32 or float64 dtypes, got: N)
ValueErrortorchstridedfloat32float64)r&   r'   r(   r)   s       r!   _window_function_checksr0   ?   s     	1uoI!M
 	
 U]]"oLVHU
 	
 U]]EMM22oFugN
 	
 3r$   z
Computes a window with an exponential waveform.
Also known as Poisson window.

The exponential window is defined as follows:

.. math::
    w_n = \exp{\left(-\frac{|n - c|}{\tau}\right)}

where `c` is the ``center`` of the window.
    aF  

{normalization}

Args:
    {M}

Keyword args:
    center (float, optional): where the center of the window will be located.
        Default: `M / 2` if `sym` is `False`, else `(M - 1) / 2`.
    tau (float, optional): the decay value.
        Tau is generally associated with a percentage, that means, that the value should
        vary within the interval (0, 100]. If tau is 100, it is considered the uniform window.
        Default: 1.0.
    {sym}
    {dtype}
    {layout}
    {device}
    {requires_grad}

Examples::

    >>> # Generates a symmetric exponential window of size 10 and with a decay value of 1.0.
    >>> # The center will be at (M - 1) / 2, where M is 10.
    >>> torch.signal.windows.exponential(10)
    tensor([0.0111, 0.0302, 0.0821, 0.2231, 0.6065, 0.6065, 0.2231, 0.0821, 0.0302, 0.0111])

    >>> # Generates a periodic exponential window and decay factor equal to .5
    >>> torch.signal.windows.exponential(10, sym=False,tau=.5)
    tensor([4.5400e-05, 3.3546e-04, 2.4788e-03, 1.8316e-02, 1.3534e-01, 1.0000e+00, 1.3534e-01, 1.8316e-02, 2.4788e-03, 3.3546e-04])
          ?TF)centertausymr(   r)   devicerequires_gradr2   r3   r4   r5   r6   c          
         Uc  [         R                  " 5       n[        SXU5        US::  a  [        SU S35      eU(       a  Ub  [        S5      eU S:X  a  [         R                  " SXEXgS9$ Uc  U(       d  U S:  a  U OU S-
  S	-  nSU-  n[         R
                  " U* U-  U* U S-
  -   U-  U UUUUS
9n	[         R                  " [         R                  " U	5      * 5      $ )Nr   r   zTau must be positive, got: 	 instead.z)Center must be None for symmetric windowsr   r(   r)   r5   r6             @startendstepsr(   r)   r5   r6   )r,   get_default_dtyper0   r+   emptylinspaceexpabs)
r'   r2   r3   r4   r(   r)   r5   r6   constantks
             r!   r   r   Y   s    r }'')M1V<
ax6se9EFF
v!DEEAv{{V
 	
 ~1q5!a!es:3wHg WA(*#	A 99eiil]##r$   a  
Computes a window with a simple cosine waveform, following the same implementation as SciPy.
This window is also known as the sine window.

The cosine window is defined as follows:

.. math::
    w_n = \sin\left(\frac{\pi (n + 0.5)}{M}\right)

This formula differs from the typical cosine window formula by incorporating a 0.5 term in the numerator,
which shifts the sample positions. This adjustment results in a window that starts and ends with non-zero values.

a  

{normalization}

Args:
    {M}

Keyword args:
    {sym}
    {dtype}
    {layout}
    {device}
    {requires_grad}

Examples::

    >>> # Generates a symmetric cosine window.
    >>> torch.signal.windows.cosine(10)
    tensor([0.1564, 0.4540, 0.7071, 0.8910, 0.9877, 0.9877, 0.8910, 0.7071, 0.4540, 0.1564])

    >>> # Generates a periodic cosine window.
    >>> torch.signal.windows.cosine(10, sym=False)
    tensor([0.1423, 0.4154, 0.6549, 0.8413, 0.9595, 1.0000, 0.9595, 0.8413, 0.6549, 0.4154])
r4   r(   r)   r5   r6   c          
      F   Uc  [         R                  " 5       n[        SXU5        U S:X  a  [         R                  " SX#XES9$ Sn[         R                  U(       d  U S:  a  U S-   OU -  n[         R
                  " Xg-  X`S-
  -   U-  U UUUUS9n[         R                  " U5      $ )Nr   r   r9   r:         ?r;   r=   )r,   rA   r0   rB   pirC   sin	r'   r4   r(   r)   r5   r6   r>   rF   rG   s	            r!   r   r      s    d }'')Ha7Av{{V
 	
 ExxA1q51=H!e_(#	A 99Q<r$   z
Computes a window with a gaussian waveform.

The gaussian window is defined as follows:

.. math::
    w_n = \exp{\left(-\left(\frac{n}{2\sigma}\right)^2\right)}
    a   

{normalization}

Args:
    {M}

Keyword args:
    std (float, optional): the standard deviation of the gaussian. It controls how narrow or wide the window is.
        Default: 1.0.
    {sym}
    {dtype}
    {layout}
    {device}
    {requires_grad}

Examples::

    >>> # Generates a symmetric gaussian window with a standard deviation of 1.0.
    >>> torch.signal.windows.gaussian(10)
    tensor([4.0065e-05, 2.1875e-03, 4.3937e-02, 3.2465e-01, 8.8250e-01, 8.8250e-01, 3.2465e-01, 4.3937e-02, 2.1875e-03, 4.0065e-05])

    >>> # Generates a periodic gaussian window and standard deviation equal to 0.9.
    >>> torch.signal.windows.gaussian(10, sym=False,std=0.9)
    tensor([1.9858e-07, 5.1365e-05, 3.8659e-03, 8.4658e-02, 5.3941e-01, 1.0000e+00, 5.3941e-01, 8.4658e-02, 3.8659e-03, 5.1365e-05])
)stdr4   r(   r)   r5   r6   rN   c          
      |   Uc  [         R                  " 5       n[        SXU5        US::  a  [        SU S35      eU S:X  a  [         R                  " SX4XVS9$ U(       d  U S:  a  U OU S-
  * S-  nSU[        S	5      -  -  n[         R                  " Xx-  XpS-
  -   U-  U UUUUS
9n	[         R                  " U	S	-  * 5      $ )Nr   r   z*Standard deviation must be positive, got: r8   r9   r:   r;   r<      r=   )r,   rA   r0   r+   rB   r   rC   rD   )
r'   rN   r4   r(   r)   r5   r6   r>   rF   rG   s
             r!   r   r      s    ` }'')J&9
axEcU)TUUAv{{V
 	
 q1ua!a%036EC$q'M"H!e_(#	A 99q!tWr$   aK  
Computes the Kaiser window.

The Kaiser window is defined as follows:

.. math::
    w_n = I_0 \left( \beta \sqrt{1 - \left( {\frac{n - N/2}{N/2}} \right) ^2 } \right) / I_0( \beta )

where ``I_0`` is the zeroth order modified Bessel function of the first kind (see :func:`torch.special.i0`), and
``N = M - 1 if sym else M``.
    a  

{normalization}

Args:
    {M}

Keyword args:
    beta (float, optional): shape parameter for the window. Must be non-negative. Default: 12.0
    {sym}
    {dtype}
    {layout}
    {device}
    {requires_grad}

Examples::

    >>> # Generates a symmetric gaussian window with a standard deviation of 1.0.
    >>> torch.signal.windows.kaiser(5)
    tensor([4.0065e-05, 2.1875e-03, 4.3937e-02, 3.2465e-01, 8.8250e-01, 8.8250e-01, 3.2465e-01, 4.3937e-02, 2.1875e-03, 4.0065e-05])
    >>> # Generates a periodic gaussian window and standard deviation equal to 0.9.
    >>> torch.signal.windows.kaiser(5, sym=False,std=0.9)
    tensor([1.9858e-07, 5.1365e-05, 3.8659e-03, 8.4658e-02, 5.3941e-01, 1.0000e+00, 5.3941e-01, 8.4658e-02, 3.8659e-03, 5.1365e-05])
g      (@)betar4   r(   r)   r5   r6   rQ   c          
      f   Uc  [         R                  " 5       n[        SXU5        US:  a  [        SU S35      eU S:X  a  [         R                  " SX4XVS9$ U S:X  a  [         R
                  " SX4XVS9$ [         R                  " XUS	9nU* nS
U-  U(       d  U OU S-
  -  n[         R                  " XU S-
  U-  -   5      n	[         R                  " UU	U UUUUS9n
[         R                  " [         R                  " X-  [         R                  " U
S5      -
  5      5      [         R                  " U5      -  $ )Nr   r   z beta must be non-negative, got: r8   r9   r:   r;   r;   )r(   r5   r<   r=   rP   )r,   rA   r0   r+   rB   onestensorminimumrC   i0r   pow)r'   rQ   r4   r(   r)   r5   r6   r>   rF   r?   rG   s              r!   r   r   N  s&   b }'')Ha7ax;D6KLLAv{{V
 	
 	AvzzV
 	

 <<&9DEETzcQq1u5H
--q1u&88
9C#	A 88EJJt{UYYq!_<=>$OOr$   z
Computes the Hamming window.

The Hamming window is defined as follows:

.. math::
    w_n = \alpha - \beta\ \cos \left( \frac{2 \pi n}{M - 1} \right)
    a  

{normalization}

Arguments:
    {M}

Keyword args:
    {sym}
    alpha (float, optional): The coefficient :math:`\alpha` in the equation above.
    beta (float, optional): The coefficient :math:`\beta` in the equation above.
    {dtype}
    {layout}
    {device}
    {requires_grad}

Examples::

    >>> # Generates a symmetric Hamming window.
    >>> torch.signal.windows.hamming(10)
    tensor([0.0800, 0.1876, 0.4601, 0.7700, 0.9723, 0.9723, 0.7700, 0.4601, 0.1876, 0.0800])

    >>> # Generates a periodic Hamming window.
    >>> torch.signal.windows.hamming(10, sym=False)
    tensor([0.0800, 0.1679, 0.3979, 0.6821, 0.9121, 1.0000, 0.9121, 0.6821, 0.3979, 0.1679])
c          	          [        U UUUUUS9$ )NrH   r   r'   r4   r(   r)   r5   r6   s         r!   r   r     s$    ^ 	# r$   z
Computes the Hann window.

The Hann window is defined as follows:

.. math::
    w_n = \frac{1}{2}\ \left[1 - \cos \left( \frac{2 \pi n}{M - 1} \right)\right] =
    \sin^2 \left( \frac{\pi n}{M - 1} \right)
    a  

{normalization}

Arguments:
    {M}

Keyword args:
    {sym}
    {dtype}
    {layout}
    {device}
    {requires_grad}

Examples::

    >>> # Generates a symmetric Hann window.
    >>> torch.signal.windows.hann(10)
    tensor([0.0000, 0.1170, 0.4132, 0.7500, 0.9698, 0.9698, 0.7500, 0.4132, 0.1170, 0.0000])

    >>> # Generates a periodic Hann window.
    >>> torch.signal.windows.hann(10, sym=False)
    tensor([0.0000, 0.0955, 0.3455, 0.6545, 0.9045, 1.0000, 0.9045, 0.6545, 0.3455, 0.0955])
c          
           [        U SUUUUUS9$ )NrJ   alphar4   r(   r)   r5   r6   rZ   r[   s         r!   r   r     s'    \ 	# r$   z
Computes the Blackman window.

The Blackman window is defined as follows:

.. math::
    w_n = 0.42 - 0.5 \cos \left( \frac{2 \pi n}{M - 1} \right) + 0.08 \cos \left( \frac{4 \pi n}{M - 1} \right)
    a  

{normalization}

Arguments:
    {M}

Keyword args:
    {sym}
    {dtype}
    {layout}
    {device}
    {requires_grad}

Examples::

    >>> # Generates a symmetric Blackman window.
    >>> torch.signal.windows.blackman(5)
    tensor([-1.4901e-08,  3.4000e-01,  1.0000e+00,  3.4000e-01, -1.4901e-08])

    >>> # Generates a periodic Blackman window.
    >>> torch.signal.windows.blackman(5, sym=False)
    tensor([-1.4901e-08,  2.0077e-01,  8.4923e-01,  8.4923e-01,  2.0077e-01])
c          
      n    Uc  [         R                  " 5       n[        SXU5        [        U / SQUUUUUS9$ )Nr   )gzG?rJ   g{Gz?ar4   r(   r)   r5   r6   )r,   rA   r0   r   r[   s         r!   r   r     sF    Z }'')J&9	
# r$   a4  
Computes the Bartlett window.

The Bartlett window is defined as follows:

.. math::
    w_n = 1 - \left| \frac{2n}{M - 1} - 1 \right| = \begin{cases}
        \frac{2n}{M - 1} & \text{if } 0 \leq n \leq \frac{M - 1}{2} \\
        2 - \frac{2n}{M - 1} & \text{if } \frac{M - 1}{2} < n < M \\ \end{cases}
    a  

{normalization}

Arguments:
    {M}

Keyword args:
    {sym}
    {dtype}
    {layout}
    {device}
    {requires_grad}

Examples::

    >>> # Generates a symmetric Bartlett window.
    >>> torch.signal.windows.bartlett(10)
    tensor([0.0000, 0.2222, 0.4444, 0.6667, 0.8889, 0.8889, 0.6667, 0.4444, 0.2222, 0.0000])

    >>> # Generates a periodic Bartlett window.
    >>> torch.signal.windows.bartlett(10, sym=False)
    tensor([0.0000, 0.2000, 0.4000, 0.6000, 0.8000, 1.0000, 0.8000, 0.6000, 0.4000, 0.2000])
c          
      X   Uc  [         R                  " 5       n[        SXU5        U S:X  a  [         R                  " SX#XES9$ U S:X  a  [         R                  " SX#XES9$ SnSU(       d  U OU S-
  -  n[         R
                  " UX`S-
  U-  -   U UUUUS	9nS[         R                  " U5      -
  $ )
Nr   r   r9   r:   r;   rS   rP   r=   )r,   rA   r0   rB   rT   rC   rE   rM   s	            r!   r   r   T  s    ^ }'')J&9Av{{V
 	
 	AvzzV
 	
 ESAa!e,HUh&&#	A uyy|r$   z
Computes the general cosine window.

The general cosine window is defined as follows:

.. math::
    w_n = \sum^{M-1}_{i=0} (-1)^i a_i \cos{ \left( \frac{2 \pi i n}{M - 1}\right)}
    a  

{normalization}

Arguments:
    {M}

Keyword args:
    a (Iterable): the coefficients associated to each of the cosine functions.
    {sym}
    {dtype}
    {layout}
    {device}
    {requires_grad}

Examples::

    >>> # Generates a symmetric general cosine window with 3 coefficients.
    >>> torch.signal.windows.general_cosine(10, a=[0.46, 0.23, 0.31], sym=True)
    tensor([0.5400, 0.3376, 0.1288, 0.4200, 0.9136, 0.9136, 0.4200, 0.1288, 0.3376, 0.5400])

    >>> # Generates a periodic general cosine window wit 2 coefficients.
    >>> torch.signal.windows.general_cosine(10, a=[0.5, 1 - 0.5], sym=False)
    tensor([0.0000, 0.0955, 0.3455, 0.6545, 0.9045, 1.0000, 0.9045, 0.6545, 0.3455, 0.0955])
ra   c          
      <   Uc  [         R                  " 5       n[        SXU5        U S:X  a  [         R                  " SX4XVS9$ U S:X  a  [         R                  " SX4XVS9$ [        U[        5      (       d  [        S5      eU(       d  [        S5      eS	[         R                  -  U(       d  U OU S-
  -  n[         R                  " SU S-
  U-  U UUUUS
9n[         R                  " [        U5       V	V
s/ s H  u  pSU	-  U
-  PM     sn
n	UUUS9n[         R                  " UR                  S   UR                  UR                   UR"                  S9n	UR%                  S5      [         R&                  " U	R%                  S5      U-  5      -  R)                  S5      $ s  sn
n	f )Nr   r   r9   r:   r;   rS   z!Coefficients must be a list/tuplezCoefficients cannot be emptyrP   r=   rc   )r5   r(   r6   )r(   r5   r6   )r,   rA   r0   rB   rT   
isinstancer   	TypeErrorr+   rK   rC   rU   	enumeratearangeshaper(   r5   r6   	unsqueezecossum)r'   ra   r4   r(   r)   r5   r6   rF   rG   iwa_is               r!   r   r     s|   ^ }''),a?Av{{V
 	
 	AvzzV
 	
 a"";<<788588|qQ7HUh#	A ,,#,Q<0<41"Q<0#	C 			!iizz''		A MM"		!++b/A*= >>CCAFF 	1s   0F
z
Computes the general Hamming window.

The general Hamming window is defined as follows:

.. math::
    w_n = \alpha - (1 - \alpha) \cos{ \left( \frac{2 \pi n}{M-1} \right)}
    a  

{normalization}

Arguments:
    {M}

Keyword args:
    alpha (float, optional): the window coefficient. Default: 0.54.
    {sym}
    {dtype}
    {layout}
    {device}
    {requires_grad}

Examples::

    >>> # Generates a symmetric Hamming window with the general Hamming window.
    >>> torch.signal.windows.general_hamming(10, sym=True)
    tensor([0.0800, 0.1876, 0.4601, 0.7700, 0.9723, 0.9723, 0.7700, 0.4601, 0.1876, 0.0800])

    >>> # Generates a periodic Hann window with the general Hamming window.
    >>> torch.signal.windows.general_hamming(10, alpha=0.5, sym=False)
    tensor([0.0000, 0.0955, 0.3455, 0.6545, 0.9045, 1.0000, 0.9045, 0.6545, 0.3455, 0.0955])
gHzG?r]   r^   c          
      *    [        U USU-
  /UUUUUS9$ )Nr1   r`   r   )r'   r^   r4   r(   r)   r5   r6   s          r!   r   r     s0    ^ 	#+
# r$   z
Computes the minimum 4-term Blackman-Harris window according to Nuttall.

.. math::
    w_n = 1 - 0.36358 \cos{(z_n)} + 0.48917 \cos{(2z_n)} - 0.13659 \cos{(3z_n)} + 0.01064 \cos{(4z_n)}

where :math:`z_n = \frac{2 \pi n}{M}`.
    a  

{normalization}

Arguments:
    {M}

Keyword args:
    {sym}
    {dtype}
    {layout}
    {device}
    {requires_grad}

References::

    - A. Nuttall, "Some windows with very good sidelobe behavior,"
      IEEE Transactions on Acoustics, Speech, and Signal Processing, vol. 29, no. 1, pp. 84-91,
      Feb 1981. https://doi.org/10.1109/TASSP.1981.1163506

    - Heinzel G. et al., "Spectrum and spectral density estimation by the Discrete Fourier transform (DFT),
      including a comprehensive list of window functions and some new flat-top windows",
      February 15, 2002 https://holometer.fnal.gov/GH_FFT.pdf

Examples::

    >>> # Generates a symmetric Nutall window.
    >>> torch.signal.windows.general_hamming(5, sym=True)
    tensor([3.6280e-04, 2.2698e-01, 1.0000e+00, 2.2698e-01, 3.6280e-04])

    >>> # Generates a periodic Nuttall window.
    >>> torch.signal.windows.general_hamming(5, sym=False)
    tensor([3.6280e-04, 1.1052e-01, 7.9826e-01, 7.9826e-01, 1.1052e-01])
c          
      $    [        U / SQUUUUUS9$ )N)gzD?g;%N?g1|?gC ˅?r`   rq   r[   s         r!   r   r   ;  s'    n 	
6# r$    )'collections.abcr   mathr   typingr   r   r   r,   r   torch._torch_docsr	   r
   r   __all__r   window_common_argsstrr%   intr(   r)   r0   formatr-   floatboolr5   r   r   r   r   r   r   r   r   r   r   r   rs   r$   r!   <module>r      s   $  . .   L L T] 	  7 "s xb1 &


',{{
<ALL
	
4 
< 	=  > ? -b ##' ==%)*$
*$ UO*$ 
	*$
 
*$ EKK *$ LL*$ U\\"*$ *$ *$]-\*$Z . F/ 0 1(X #' ==%) 
  
  EKK 	 
 LL  U\\"     S(R F 2 F3 4 5%R #' ==%)%
% 
% 
	%
 EKK % LL% U\\"% % %M%L%P 
. F/ 0 1&T #' ==%)-P
-P -P 
	-P
 EKK -P LL-P U\\"-P -P -PO&N-P` 2 F3 4 5%R #' ==%)
 
 EKK 	
 LL U\\"  M%L& . F/ 0 1$P #' ==%)
 
 EKK 	
 LL U\\"  K$J( . F/ 0 1#N #' ==%)
 
 EKK 	
 LL U\\"  I#H2 	. F/ 0 1%R #' ==%)%
% 
% EKK 	%
 LL% U\\"% % %M%L%P 0 F1 2 3$R #' ==%)7G 7G 
	7G
 EKK 7G LL7G U\\"7G 7G 7GK$J7Gt 0 F1 2 3$P #' ==%)  
	
 EKK  LL U\\"  K$J* !B FC! #D E#-b #' ==%)
 
 EKK 	
 LL U\\"  ]-\r$   