§
    ¢”j¶=  ã                  ó0  — d Z ddlmZ ddlZddlmZ ddlmZ g d¢ZdZ	de	z
  Z
d	e	z   Zdd„Z G d„ de¦  «        Z e¦   «         Zddd„Zddd„Ze G d„ d¦  «        ¦   «         Zedk    r,ddlZddlZ ej         ej        ¦   «         j        ¦  «         dS dS )a7  Affine 2D transformation matrix class.

The Transform class implements various transformation matrix operations,
both on the matrix itself, as well as on 2D coordinates.

Transform instances are effectively immutable: all methods that operate on the
transformation itself always return a new instance. This has as the
interesting side effect that Transform instances are hashable, ie. they can be
used as dictionary keys.

This module exports the following symbols:

Transform
	this is the main class
Identity
	Transform instance set to the identity transformation
Offset
	Convenience function that returns a translating transformation
Scale
	Convenience function that returns a scaling transformation

The DecomposedTransform class implements a transformation with separate
translate, rotation, scale, skew, and transformation-center components.

:Example:

	>>> t = Transform(2, 0, 0, 3, 0, 0)
	>>> t.transformPoint((100, 100))
	(200, 300)
	>>> t = Scale(2, 3)
	>>> t.transformPoint((100, 100))
	(200, 300)
	>>> t.transformPoint((0, 0))
	(0, 0)
	>>> t = Offset(2, 3)
	>>> t.transformPoint((100, 100))
	(102, 103)
	>>> t.transformPoint((0, 0))
	(2, 3)
	>>> t2 = t.scale(0.5)
	>>> t2.transformPoint((100, 100))
	(52.0, 53.0)
	>>> import math
	>>> t3 = t2.rotate(math.pi / 2)
	>>> t3.transformPoint((0, 0))
	(2.0, 3.0)
	>>> t3.transformPoint((100, 100))
	(-48.0, 53.0)
	>>> t = Identity.scale(0.5).translate(100, 200).skew(0.1, 0.2)
	>>> t.transformPoints([(0, 0), (1, 1), (100, 100)])
	[(50.0, 100.0), (50.550167336042726, 100.60135501775433), (105.01673360427253, 160.13550177543362)]
	>>>
é    )ÚannotationsN)Ú
NamedTuple)Ú	dataclass)Ú	TransformÚIdentityÚOffsetÚScaleÚDecomposedTransformgVçž¯Ò<é   éÿÿÿÿÚvÚfloatÚreturnc                ór   — t          | ¦  «        t          k     rd} n| t          k    rd} n| t          k     rd} | S )Nr   r   r   )ÚabsÚ_EPSILONÚ_ONE_EPSILONÚ_MINUS_ONE_EPSILON)r   s    úg/var/www/finuniver-perm.ru/html/portfolio/venv/lib/python3.11/site-packages/fontTools/misc/transform.pyÚ_normSinCosr   F   sB   € Ý
ˆ1�v„v•ÒÐØˆˆØ	
�\Ò	Ð	ØˆˆØ	
ÕÒ	Ð	ØˆØ€Hó    c                  óØ   — e Zd ZU dZdZded<   dZded<   dZded<   dZded<   dZ	ded	<   dZ
ded
<   d„ Zd„ Zd„ Zd„ Zd#d$d„Zd%d&d„Zd'd„Zd#d$d„Zd„ Zd„ Zd„ Zd(d„Zd)d„Zd*d!„Zd(d"„ZdS )+r   aœ	  2x2 transformation matrix plus offset, a.k.a. Affine transform.
    Transform instances are immutable: all transforming methods, eg.
    rotate(), return a new Transform instance.

    :Example:

            >>> t = Transform()
            >>> t
            <Transform [1 0 0 1 0 0]>
            >>> t.scale(2)
            <Transform [2 0 0 2 0 0]>
            >>> t.scale(2.5, 5.5)
            <Transform [2.5 0 0 5.5 0 0]>
            >>>
            >>> t.scale(2, 3).transformPoint((100, 100))
            (200, 300)

    Transform's constructor takes six arguments, all of which are
    optional, and can be used as keyword arguments::

            >>> Transform(12)
            <Transform [12 0 0 1 0 0]>
            >>> Transform(dx=12)
            <Transform [1 0 0 1 12 0]>
            >>> Transform(yx=12)
            <Transform [1 0 12 1 0 0]>

    Transform instances also behave like sequences of length 6::

            >>> len(Identity)
            6
            >>> list(Identity)
            [1, 0, 0, 1, 0, 0]
            >>> tuple(Identity)
            (1, 0, 0, 1, 0, 0)

    Transform instances are comparable::

            >>> t1 = Identity.scale(2, 3).translate(4, 6)
            >>> t2 = Identity.translate(8, 18).scale(2, 3)
            >>> t1 == t2
            1

    But beware of floating point rounding errors::

            >>> t1 = Identity.scale(0.2, 0.3).translate(0.4, 0.6)
            >>> t2 = Identity.translate(0.08, 0.18).scale(0.2, 0.3)
            >>> t1
            <Transform [0.2 0 0 0.3 0.08 0.18]>
            >>> t2
            <Transform [0.2 0 0 0.3 0.08 0.18]>
            >>> t1 == t2
            0

    Transform instances are hashable, meaning you can use them as
    keys in dictionaries::

            >>> d = {Scale(12, 13): None}
            >>> d
            {<Transform [12 0 0 13 0 0]>: None}

    But again, beware of floating point rounding errors::

            >>> t1 = Identity.scale(0.2, 0.3).translate(0.4, 0.6)
            >>> t2 = Identity.translate(0.08, 0.18).scale(0.2, 0.3)
            >>> t1
            <Transform [0.2 0 0 0.3 0.08 0.18]>
            >>> t2
            <Transform [0.2 0 0 0.3 0.08 0.18]>
            >>> d = {t1: None}
            >>> d
            {<Transform [0.2 0 0 0.3 0.08 0.18]>: None}
            >>> d[t2]
            Traceback (most recent call last):
              File "<stdin>", line 1, in ?
            KeyError: <Transform [0.2 0 0 0.3 0.08 0.18]>
    r   r   Úxxr   ÚxyÚyxÚyyÚdxÚdyc                óV   — |\  }}| \  }}}}}}	||z  ||z  z   |z   ||z  ||z  z   |	z   fS )zÍTransform a point.

        :Example:

                >>> t = Transform()
                >>> t = t.scale(2.5, 5.5)
                >>> t.transformPoint((100, 100))
                (250.0, 550.0)
        © )
ÚselfÚpÚxÚyr   r   r   r   r   r   s
             r   ÚtransformPointzTransform.transformPoint¦   sL   € ð ‰ˆˆAØ!%ÑˆˆB��B˜˜BØ�Q‘˜˜a™‘ "Ñ$ b¨1¡f¨r°A©v¡o¸Ñ&:Ð;Ð;r   c                óF   ‡‡‡‡‡‡— | \  ŠŠŠŠŠŠˆˆˆˆˆˆfd„|D ¦   «         S )zùTransform a list of points.

        :Example:

                >>> t = Scale(2, 3)
                >>> t.transformPoints([(0, 0), (0, 100), (100, 100), (100, 0)])
                [(0, 0), (0, 300), (200, 300), (200, 0)]
                >>>
        c                óN   •— g | ]!\  }}‰|z  ‰|z  z   ‰z   ‰|z  ‰|z  z   ‰z   f‘Œ"S r    r    )	Ú.0r#   r$   r   r   r   r   r   r   s	      €€€€€€r   ú
<listcomp>z-Transform.transformPoints.<locals>.<listcomp>¿   sD   ø€ ÐPÐPÐPÁÀÀA��a‘˜"˜q™&‘ 2Ñ% r¨A¡v°°Q±¡¸Ñ';Ð<ÐPÐPÐPr   r    )r!   Úpointsr   r   r   r   r   r   s     @@@@@@r   ÚtransformPointszTransform.transformPoints´   sE   øøøøøø€ ð "&ÑˆˆB��B˜˜BØPÐPÐPÐPÐPÐPÐPÐPÐPÈÐPÑPÔPÐPr   c                óV   — |\  }}| dd…         \  }}}}||z  ||z  z   ||z  ||z  z   fS )zéTransform an (dx, dy) vector, treating translation as zero.

        :Example:

                >>> t = Transform(2, 0, 0, 2, 10, 20)
                >>> t.transformVector((3, -4))
                (6, -8)
                >>>
        Né   r    )r!   r   r   r   r   r   r   r   s           r   ÚtransformVectorzTransform.transformVectorÁ   sG   € ð ‰ˆˆRØ˜b˜q˜bœ‰ˆˆB��BØ�R‘˜"˜r™'Ñ! 2¨¡7¨R°"©WÑ#4Ð5Ð5r   c                óJ   ‡‡‡‡— | dd…         \  ŠŠŠŠˆˆˆˆfd„|D ¦   «         S )a  Transform a list of (dx, dy) vector, treating translation as zero.

        :Example:
                >>> t = Transform(2, 0, 0, 2, 10, 20)
                >>> t.transformVectors([(3, -4), (5, -6)])
                [(6, -8), (10, -12)]
                >>>
        Nr-   c                óB   •— g | ]\  }}‰|z  ‰|z  z   ‰|z  ‰|z  z   f‘ŒS r    r    )r(   r   r   r   r   r   r   s      €€€€r   r)   z.Transform.transformVectors.<locals>.<listcomp>Ù   s<   ø€ ÐMÐMÐM¹6¸2¸r��b‘˜2 ™7Ñ" B¨¡G¨b°2©gÑ$5Ð6ÐMÐMÐMr   r    )r!   Úvectorsr   r   r   r   s     @@@@r   ÚtransformVectorszTransform.transformVectorsÏ   s@   øøøø€ ð ˜b˜q˜bœ‰ˆˆB��BØMÐMÐMÐMÐMÐMÐMÀWÐMÑMÔMÐMr   r#   r$   c                ó8   — |                       dddd||f¦  «        S )záReturn a new transformation, translated (offset) by x, y.

        :Example:
                >>> t = Transform()
                >>> t.translate(20, 30)
                <Transform [1 0 0 1 20 30]>
                >>>
        r   r   ©Ú	transform©r!   r#   r$   s      r   Ú	translatezTransform.translateÛ   s#   € ð �~Š~˜q ! Q¨¨1¨aÐ0Ñ1Ô1Ð1r   Núfloat | Nonec                ó@   — |€|}|                       |dd|ddf¦  «        S )ak  Return a new transformation, scaled by x, y. The 'y' argument
        may be None, which implies to use the x value for y as well.

        :Example:
                >>> t = Transform()
                >>> t.scale(5)
                <Transform [5 0 0 5 0 0]>
                >>> t.scale(5, 6)
                <Transform [5 0 0 6 0 0]>
                >>>
        Nr   r4   r6   s      r   ÚscalezTransform.scaleæ   s-   € ð ˆ9ØˆAØ�~Š~˜q ! Q¨¨1¨aÐ0Ñ1Ô1Ð1r   Úanglec                ó¾   — t          t          j        |¦  «        ¦  «        }t          t          j        |¦  «        ¦  «        }|                      ||| |ddf¦  «        S )a  Return a new transformation, rotated by 'angle' (radians).

        :Example:
                >>> import math
                >>> t = Transform()
                >>> t.rotate(math.pi / 2)
                <Transform [0 1 -1 0 0 0]>
                >>>
        r   )r   ÚmathÚcosÚsinr5   )r!   r;   ÚcÚss       r   ÚrotatezTransform.rotateö   sO   € õ �œ ™œÑ(Ô(ˆÝ�œ ™œÑ(Ô(ˆØ�~Š~˜q ! a R¨¨A¨qÐ1Ñ2Ô2Ð2r   c                ó€   — |                       dt          j        |¦  «        t          j        |¦  «        dddf¦  «        S )zõReturn a new transformation, skewed by x and y.

        :Example:
                >>> import math
                >>> t = Transform()
                >>> t.skew(math.pi / 4)
                <Transform [1 0 1 1 0 0]>
                >>>
        r   r   )r5   r=   Útanr6   s      r   ÚskewzTransform.skew  s3   € ð �~Š~˜q¥$¤(¨1¡+¤+­t¬x¸©{¬{¸A¸qÀ!ÐDÑEÔEÐEr   c           
     óÒ   — |\  }}}}}}| \  }}	}
}}}|                       ||z  ||
z  z   ||	z  ||z  z   ||z  ||
z  z   ||	z  ||z  z   ||z  |
|z  z   |z   |	|z  ||z  z   |z   ¦  «        S )a  Return a new transformation, transformed by another
        transformation.

        :Example:
                >>> t = Transform(2, 0, 0, 3, 1, 6)
                >>> t.transform((4, 3, 2, 1, 5, 6))
                <Transform [8 9 4 3 11 24]>
                >>>
        ©Ú	__class__©r!   ÚotherÚxx1Úxy1Úyx1Úyy1Údx1Údy1Úxx2Úxy2Úyx2Úyy2Údx2Údy2s                 r   r5   zTransform.transform  s¨   € ð (-Ñ$ˆˆS�#�s˜C Ø'+Ñ$ˆˆS�#�s˜C Ø�~Š~Ø�#‰I˜˜c™	Ñ!Ø�#‰I˜˜c™	Ñ!Ø�#‰I˜˜c™	Ñ!Ø�#‰I˜˜c™	Ñ!Ø�#‰I˜˜c™	Ñ! CÑ'Ø�#‰I˜˜c™	Ñ! CÑ'ñ
ô 
ð 	
r   c           
     óÒ   — | \  }}}}}}|\  }}	}
}}}|                       ||z  ||
z  z   ||	z  ||z  z   ||z  ||
z  z   ||	z  ||z  z   ||z  |
|z  z   |z   |	|z  ||z  z   |z   ¦  «        S )aí  Return a new transformation, which is the other transformation
        transformed by self. self.reverseTransform(other) is equivalent to
        other.transform(self).

        :Example:
                >>> t = Transform(2, 0, 0, 3, 1, 6)
                >>> t.reverseTransform((4, 3, 2, 1, 5, 6))
                <Transform [8 6 6 3 21 15]>
                >>> Transform(4, 3, 2, 1, 5, 6).transform((2, 0, 0, 3, 1, 6))
                <Transform [8 6 6 3 21 15]>
                >>>
        rG   rI   s                 r   ÚreverseTransformzTransform.reverseTransform%  s¨   € ð (,Ñ$ˆˆS�#�s˜C Ø',Ñ$ˆˆS�#�s˜C Ø�~Š~Ø�#‰I˜˜c™	Ñ!Ø�#‰I˜˜c™	Ñ!Ø�#‰I˜˜c™	Ñ!Ø�#‰I˜˜c™	Ñ!Ø�#‰I˜˜c™	Ñ! CÑ'Ø�#‰I˜˜c™	Ñ! CÑ'ñ
ô 
ð 	
r   c                óÚ   — | t           k    r| S | \  }}}}}}||z  ||z  z
  }||z  | |z  | |z  ||z  f\  }}}}| |z  ||z  z
  | |z  ||z  z
  }}|                      ||||||¦  «        S )aK  Return the inverse transformation.

        :Example:
                >>> t = Identity.translate(2, 3).scale(4, 5)
                >>> t.transformPoint((10, 20))
                (42, 103)
                >>> it = t.inverse()
                >>> it.transformPoint((42, 103))
                (10.0, 20.0)
                >>>
        )r   rH   )r!   r   r   r   r   r   r   Údets           r   ÚinversezTransform.inverse=  s¥   € ð •8ÒÐØˆKØ!%ÑˆˆB��B˜˜BØ�2‰g˜˜R™ÑˆØ˜c™ B 3¨¡9¨r¨c°C©i¸¸c¹ÐA‰ˆˆB��BØ��r‘˜B ™GÑ# b S¨2¡X°°R±Ñ%7ˆBˆØ�~Š~˜b " b¨"¨b°"Ñ5Ô5Ð5r   r   Ústrc                ó   — d| z  S )zÎReturn a PostScript representation

        :Example:

                >>> t = Identity.scale(2, 3).translate(4, 5)
                >>> t.toPS()
                '[2 0 0 3 8 15]'
                >>>
        z[%s %s %s %s %s %s]r    ©r!   s    r   ÚtoPSzTransform.toPSQ  s   € ð % tÑ+Ð+r   ú'DecomposedTransform'c                ó6   — t                                | ¦  «        S )z%Decompose into a DecomposedTransform.)r
   ÚfromTransformr^   s    r   ÚtoDecomposedzTransform.toDecomposed]  s   € å"×0Ò0°Ñ6Ô6Ð6r   Úboolc                ó   — | t           k    S )aë  Returns True if transform is not identity, False otherwise.

        :Example:

                >>> bool(Identity)
                False
                >>> bool(Transform())
                False
                >>> bool(Scale(1.))
                False
                >>> bool(Scale(2))
                True
                >>> bool(Offset())
                False
                >>> bool(Offset(0))
                False
                >>> bool(Offset(2))
                True
        )r   r^   s    r   Ú__bool__zTransform.__bool__a  s   € ð( •xÒÐr   c                ó(   — d| j         j        f| z   z  S )Nz<%s [%g %g %g %g %g %g]>)rH   Ú__name__r^   s    r   Ú__repr__zTransform.__repr__w  s   € Ø)¨d¬nÔ.EÐ-GÈ$Ñ-NÑOÐOr   ©r   r   )r#   r   r$   r   )r   N)r#   r   r$   r8   )r;   r   )r   r\   )r   r`   )r   rd   )rh   Ú
__module__Ú__qualname__Ú__doc__r   Ú__annotations__r   r   r   r   r   r%   r+   r.   r2   r7   r:   rB   rE   r5   rX   r[   r_   rc   rf   ri   r    r   r   r   r   P   sœ  € € € € € € ðLð Lð\ €B€M€M€M�MØ€B€M€M€M�MØ€B€M€M€M�MØ€B€M€M€M�MØ€B€M€M€M�MØ€B€M€M€M�Mð<ð <ð <ðQð Qð Qð6ð 6ð 6ð
Nð 
Nð 
Nð	2ð 	2ð 	2ð 	2ð 	2ð2ð 2ð 2ð 2ð 2ð 3ð 3ð 3ð 3ð
Fð 
Fð 
Fð 
Fð 
Fð
ð 
ð 
ð*
ð 
ð 
ð06ð 6ð 6ð(
,ð 
,ð 
,ð 
,ð7ð 7ð 7ð 7ð ð  ð  ð  ð,Pð Pð Pð Pð Pð Pr   r   r#   r$   c                ó*   — t          dddd| |¦  «        S )z™Return the identity transformation offset by x, y.

    :Example:
            >>> Offset(2, 3)
            <Transform [1 0 0 1 2 3]>
            >>>
    r   r   ©r   ©r#   r$   s     r   r   r   ~  s   € õ �Q˜˜1˜a  AÑ&Ô&Ð&r   r8   c                ó2   — |€| }t          | dd|dd¦  «        S )zêReturn the identity transformation scaled by x, y. The 'y' argument
    may be None, which implies to use the x value for y as well.

    :Example:
            >>> Scale(2, 3)
            <Transform [2 0 0 3 0 0]>
            >>>
    Nr   rp   rq   s     r   r	   r	   ‰  s&   € ð 	€yØˆÝ�Q˜˜1˜a  AÑ&Ô&Ð&r   c                  ó¶   — e Zd ZU dZdZded<   dZded<   dZded<   dZded<   dZ	ded	<   dZ
ded
<   dZded<   dZded<   dZded<   d„ Zed„ ¦   «         Zdd„ZdS )r
   z˜The DecomposedTransform class implements a transformation with separate
    translate, rotation, scale, skew, and transformation-center components.
    r   r   Ú
translateXÚ
translateYÚrotationr   ÚscaleXÚscaleYÚskewXÚskewYÚtCenterXÚtCenterYc                óÈ   — | j         dk    pW| j        dk    pL| j        dk    pA| j        dk    p6| j        dk    p+| j        dk    p | j        dk    p| j        dk    p
| j        dk    S )Nr   r   )	rt   ru   rv   rw   rx   ry   rz   r{   r|   r^   s    r   rf   zDecomposedTransform.__bool__§  s“   € àŒO˜qÒ ð "ØŒ !Ò#ð"àŒ} Ò!ð"ð Œ{˜aÒð"ð Œ{˜aÒð	"ð
 Œz˜QŠð"ð Œz˜QŠð"ð Œ} Ò!ð"ð Œ} Ò!ð
	
r   c                ó  — |\  }}}}}}t          j        d|¦  «        }|dk     r
||z  }||z  }||z  ||z  z
  }	d}
dx}}d}|dk    s|dk    r}t          j        ||z  ||z  z   ¦  «        }|dk    rt          j        ||z  ¦  «        nt          j        ||z  ¦  «         }
||	|z  }}t          j        ||z  ||z  z   ||z  z  ¦  «        }nx|dk    s|dk    rkt          j        ||z  ||z  z   ¦  «        }t           j        dz  |dk    rt          j        | |z  ¦  «        nt          j        ||z  ¦  «         z
  }
|	|z  |}}n	 t          ||t          j        |
¦  «        ||z  |t          j        |¦  «        |z  ddd¦	  «	        S )au  Return a DecomposedTransform() equivalent of this transformation.
        The returned solution always has skewY = 0, and angle in the (-180, 180].

        :Example:
                >>> DecomposedTransform.fromTransform(Transform(3, 0, 0, 2, 0, 0))
                DecomposedTransform(translateX=0, translateY=0, rotation=0.0, scaleX=3.0, scaleY=2.0, skewX=0.0, skewY=0.0, tCenterX=0, tCenterY=0)
                >>> DecomposedTransform.fromTransform(Transform(0, 0, 0, 1, 0, 0))
                DecomposedTransform(translateX=0, translateY=0, rotation=0.0, scaleX=0.0, scaleY=1.0, skewX=0.0, skewY=0.0, tCenterX=0, tCenterY=0)
                >>> DecomposedTransform.fromTransform(Transform(0, 0, 1, 1, 0, 0))
                DecomposedTransform(translateX=0, translateY=0, rotation=-45.0, scaleX=0.0, scaleY=1.4142135623730951, skewX=0.0, skewY=0.0, tCenterX=0, tCenterY=0)
        r   r   é   g        )r=   ÚcopysignÚsqrtÚacosÚatanÚpir
   Údegrees)r!   r5   ÚaÚbr@   Údr#   r$   ÚsxÚdeltarv   rw   rx   ry   ÚrrA   s                   r   rb   z!DecomposedTransform.fromTransform´  sÆ  € ð  %Ñˆˆ1ˆa��A�qåŒ]˜1˜aÑ Ô ˆØ�Š6ˆ6Ø�‰GˆAØ�‰GˆAà�A‘˜˜A™‘ˆàˆØÐˆ�Øˆð �Š6ˆ6�Q˜!’V�VÝ”	˜!˜a™% ! a¡%™-Ñ(Ô(ˆAØ+,°ª6¨6•t”y  Q¡Ñ'Ô'Ð'½¼	À!ÀaÁ%Ñ8HÔ8HÐ7HˆHØ ¨¡�FˆFÝ”I˜q 1™u q¨1¡u™}°°Q±Ñ7Ñ8Ô8ˆEˆEØ�!ŠVˆV�q˜A’v�vÝ”	˜!˜a™% ! a¡%™-Ñ(Ô(ˆAÝ”w ‘{Ø%&¨!¢V V•”	˜1˜"˜q™&Ñ!Ô!Ð!µ$´)¸AÀ¹EÑ2BÔ2BÐ1BñˆHð $ a™i¨�FˆFˆFð å"ØØÝŒL˜Ñ"Ô"Ø�R‰KØÝŒL˜ÑÔ "Ñ$ØØØñ

ô 

ð 
	
r   r   r   c                óæ  — t          ¦   «         }|                     | j        | j        z   | j        | j        z   ¦  «        }|                     t          j        | j	        ¦  «        ¦  «        }| 
                    | j        | j        ¦  «        }|                     t          j        | j        ¦  «        t          j        | j        ¦  «        ¦  «        }|                     | j         | j         ¦  «        }|S )zÝReturn the Transform() equivalent of this transformation.

        :Example:
                >>> DecomposedTransform(scaleX=2, scaleY=2).toTransform()
                <Transform [2 0 0 2 0 0]>
                >>>
        )r   r7   rt   r{   ru   r|   rB   r=   Úradiansrv   r:   rw   rx   rE   ry   rz   )r!   Úts     r   ÚtoTransformzDecomposedTransform.toTransformí  s¸   € õ ‰KŒKˆØ�KŠKØŒO˜dœmÑ+¨T¬_¸t¼}Ñ-Lñ
ô 
ˆð �HŠH•T”\ $¤-Ñ0Ô0Ñ1Ô1ˆØ�GŠG�D”K ¤Ñ-Ô-ˆØ�FŠF•4”< ¤
Ñ+Ô+­T¬\¸$¼*Ñ-EÔ-EÑFÔFˆØ�KŠK˜œ˜¨¬¨Ñ7Ô7ˆØˆr   N)r   r   )rh   rk   rl   rm   rt   rn   ru   rv   rw   rx   ry   rz   r{   r|   rf   Úclassmethodrb   r�   r    r   r   r
   r
   —  sú   € € € € € € ðð ð €JÐÐÐÑØ€JÐÐÐÑØ€HÐÐÐÑØ€FÐÐÐÑØ€FÐÐÐÑØ€EÐÐÐÑØ€EÐÐÐÑØ€HÐÐÐÑØ€HÐÐÐÑð
ð 
ð 
ð ð6
ð 6
ñ „[ð6
ðpð ð ð ð ð r   r
   Ú__main__)r   r   r   r   rj   )r#   r   r$   r   r   r   )N)r#   r   r$   r8   r   r   )rm   Ú
__future__r   r=   Útypingr   Údataclassesr   Ú__all__r   r   r   r   r   r   r   r	   r
   rh   ÚsysÚdoctestÚexitÚtestmodÚfailedr    r   r   ú<module>r›      s�  ðð4ð 4ðl #Ð "Ð "Ð "Ð "Ð "à €€€Ø Ð Ð Ð Ð Ð Ø !Ð !Ð !Ð !Ð !Ð !ð NÐ
MÐ
M€ð €Ø�8‰|€Ø˜(‘]Ð ðð ð ð ðhPð hPð hPð hPð hP�
ñ hPô hPð hPðV	 ˆ9‰;Œ;€ð'ð 'ð 'ð 'ð 'ð'ð 'ð 'ð 'ð 'ð ðeð eð eð eð eñ eô eñ „ðeðP ˆzÒÐØ€J€J€JØ€N€N€Nà€C„Hˆ_ˆWŒ_ÑÔÔ%Ñ&Ô&Ð&Ð&Ð&ð	 Ðr   