o
    /ôjÒH  ã                   @   sh  d Z ddlZg d¢ZG dd„ dƒZG dd„ deƒZdd	„ ZG d
d„ deeƒZG dd„ deƒZG dd„ deƒZ	G dd„ deƒZ
G dd„ deƒZG dd„ deƒZG dd„ deƒZG dd„ deƒZG dd„ deƒZG dd„ deƒZG dd„ deƒZG d d!„ d!eƒZG d"d#„ d#eƒZG d$d%„ d%eƒZG d&d'„ d'eƒZG d(d)„ d)eƒZG d*d+„ d+eƒZG d,d-„ d-eƒZG d.d/„ d/eƒZG d0d1„ d1eƒZG d2d3„ d3eƒZG d4d5„ d5eƒZG d6d7„ d7eƒZG d8d9„ d9eƒZeƒ ZeZ eZ!e	ƒ Z"e
ƒ Z#edƒZ$ed:ƒZ%eZ&eƒ Z'e!e'd:ƒZ(ed;ƒZ)ed;ƒZ*eZ+eZ,eZ-eZ.ed;d<ƒZ/eZ0eZ1eƒ Z2eƒ Z3eƒ Z4eƒ Z5eƒ Z6eƒ Z7eƒ Z8eƒ Z9eZ:eZ;dS )=aö  
The following constraints are implemented:

- ``constraints.boolean``
- ``constraints.cat``
- ``constraints.corr_cholesky``
- ``constraints.dependent``
- ``constraints.greater_than(lower_bound)``
- ``constraints.greater_than_eq(lower_bound)``
- ``constraints.independent(constraint, reinterpreted_batch_ndims)``
- ``constraints.integer_interval(lower_bound, upper_bound)``
- ``constraints.interval(lower_bound, upper_bound)``
- ``constraints.less_than(upper_bound)``
- ``constraints.lower_cholesky``
- ``constraints.lower_triangular``
- ``constraints.multinomial``
- ``constraints.nonnegative``
- ``constraints.nonnegative_integer``
- ``constraints.one_hot``
- ``constraints.positive_integer``
- ``constraints.positive``
- ``constraints.positive_semidefinite``
- ``constraints.positive_definite``
- ``constraints.real_vector``
- ``constraints.real``
- ``constraints.simplex``
- ``constraints.symmetric``
- ``constraints.stack``
- ``constraints.square``
- ``constraints.symmetric``
- ``constraints.unit_interval``
é    N)Ú
ConstraintÚbooleanÚcatÚcorr_choleskyÚ	dependentÚdependent_propertyÚgreater_thanÚgreater_than_eqÚindependentÚinteger_intervalÚintervalÚhalf_open_intervalÚis_dependentÚ	less_thanÚlower_choleskyÚlower_triangularÚmultinomialÚnonnegativeÚnonnegative_integerÚone_hotÚpositiveÚpositive_semidefiniteÚpositive_definiteÚpositive_integerÚrealÚreal_vectorÚsimplexÚsquareÚstackÚ	symmetricÚunit_intervalc                   @   ó(   e Zd ZdZdZdZdd„ Zdd„ ZdS )	r   aã  
    Abstract base class for constraints.

    A constraint object represents a region over which a variable is valid,
    e.g. within which a variable can be optimized.

    Attributes:
        is_discrete (bool): Whether constrained space is discrete.
            Defaults to False.
        event_dim (int): Number of rightmost dimensions that together define
            an event. The :meth:`check` method will remove this many dimensions
            when computing validity.
    Fr   c                 C   s   t ‚)z“
        Returns a byte tensor of ``sample_shape + batch_shape`` indicating
        whether each event in value satisfies this constraint.
        )ÚNotImplementedError©ÚselfÚvalue© r&   úp/var/www/html/academy/tools/voices/clone/sv-venv/lib/python3.10/site-packages/torch/distributions/constraints.pyÚcheckZ   s   zConstraint.checkc                 C   s   | j jdd … d S )Né   z())Ú	__class__Ú__name__©r$   r&   r&   r'   Ú__repr__a   ó   zConstraint.__repr__N)r+   Ú
__module__Ú__qualname__Ú__doc__Úis_discreteÚ	event_dimr(   r-   r&   r&   r&   r'   r   H   s    r   c                       sX   e Zd ZdZeedœ‡ fdd„
Zedd„ ƒZedd„ ƒZeedœd	d
„Z	dd„ Z
‡  ZS )Ú
_DependentaI  
    Placeholder for variables whose support depends on other variables.
    These variables obey no simple coordinate-wise constraints.

    Args:
        is_discrete (bool): Optional value of ``.is_discrete`` in case this
            can be computed statically. If not provided, access to the
            ``.is_discrete`` attribute will raise a NotImplementedError.
        event_dim (int): Optional value of ``.event_dim`` in case this
            can be computed statically. If not provided, access to the
            ``.event_dim`` attribute will raise a NotImplementedError.
    ©r2   r3   c                   ó   || _ || _tƒ  ¡  d S ©N)Ú_is_discreteÚ
_event_dimÚsuperÚ__init__©r$   r2   r3   ©r*   r&   r'   r;   s   ó   z_Dependent.__init__c                 C   ó   | j tu r	tdƒ‚| j S )Nz,.is_discrete cannot be determined statically)r8   ÚNotImplementedr"   r,   r&   r&   r'   r2   x   ó   
z_Dependent.is_discretec                 C   r?   )Nz*.event_dim cannot be determined statically)r9   r@   r"   r,   r&   r&   r'   r3   ~   rA   z_Dependent.event_dimc                C   s(   |t u r| j}|t u r| j}t||d�S )z‡
        Support for syntax to customize static attributes::

            constraints.dependent(is_discrete=True, event_dim=1)
        r5   )r@   r8   r9   r4   r<   r&   r&   r'   Ú__call__„   s
   z_Dependent.__call__c                 C   s   t dƒ‚)Nz1Cannot determine validity of dependent constraint)Ú
ValueError©r$   Úxr&   r&   r'   r(   �   ó   z_Dependent.check)r+   r/   r0   r1   r@   r;   Úpropertyr2   r3   rB   r(   Ú__classcell__r&   r&   r=   r'   r4   e   s    

r4   c                 C   s
   t | tƒS r7   )Ú
isinstancer4   )Z
constraintr&   r&   r'   r   ”   ó   
r   c                       s4   e Zd ZdZ	deedœ‡ fdd„Zdd„ Z‡  ZS )	Ú_DependentPropertyaÙ  
    Decorator that extends @property to act like a `Dependent` constraint when
    called on a class and act like a property when called on an object.

    Example::

        class Uniform(Distribution):
            def __init__(self, low, high):
                self.low = low
                self.high = high
            @constraints.dependent_property(is_discrete=False, event_dim=0)
            def support(self):
                return constraints.interval(self.low, self.high)

    Args:
        fn (Callable): The function to be decorated.
        is_discrete (bool): Optional value of ``.is_discrete`` in case this
            can be computed statically. If not provided, access to the
            ``.is_discrete`` attribute will raise a NotImplementedError.
        event_dim (int): Optional value of ``.event_dim`` in case this
            can be computed statically. If not provided, access to the
            ``.event_dim`` attribute will raise a NotImplementedError.
    Nr5   c                   s   t ƒ  |¡ || _|| _d S r7   )r:   r;   r8   r9   )r$   Úfnr2   r3   r=   r&   r'   r;   ±   s   
z_DependentProperty.__init__c                 C   s   t || j| jd�S )zÄ
        Support for syntax to customize static attributes::

            @constraints.dependent_property(is_discrete=True, event_dim=1)
            def support(self):
                ...
        r5   )rK   r8   r9   )r$   rL   r&   r&   r'   rB   ¸   s   
ÿz_DependentProperty.__call__r7   )r+   r/   r0   r1   r@   r;   rB   rH   r&   r&   r=   r'   rK   ˜   s    ÿÿrK   c                       sH   e Zd ZdZ‡ fdd„Zedd„ ƒZedd„ ƒZdd	„ Zd
d„ Z	‡  Z
S )Ú_IndependentConstraintz»
    Wraps a constraint by aggregating over ``reinterpreted_batch_ndims``-many
    dims in :meth:`check`, so that an event is valid only if all its
    independent entries are valid.
    c                    sB   t |tƒsJ ‚t |tƒsJ ‚|dksJ ‚|| _|| _tƒ  ¡  d S ©Nr   )rI   r   ÚintÚbase_constraintÚreinterpreted_batch_ndimsr:   r;   )r$   rP   rQ   r=   r&   r'   r;   Ì   s   z_IndependentConstraint.__init__c                 C   s   | j jS r7   )rP   r2   r,   r&   r&   r'   r2   Ô   s   z"_IndependentConstraint.is_discretec                 C   s   | j j| j S r7   )rP   r3   rQ   r,   r&   r&   r'   r3   Ø   s   z _IndependentConstraint.event_dimc                 C   sp   | j  |¡}| ¡ | jk r | j j| j }td|› d| ¡ › �ƒ‚| |jd | ¡ | j … d ¡}| d¡}|S )NzExpected value.dim() >= z	 but got ©éÿÿÿÿrS   )	rP   r(   ÚdimrQ   r3   rC   ÚreshapeÚshapeÚall)r$   r%   ÚresultÚexpectedr&   r&   r'   r(   Ü   s   ÿÿ
z_IndependentConstraint.checkc                 C   s*   | j jdd … › dt| jƒ› d| j› d�S )Nr)   ú(z, ú))r*   r+   ÚreprrP   rQ   r,   r&   r&   r'   r-   é   s   *z_IndependentConstraint.__repr__)r+   r/   r0   r1   r;   rG   r2   r3   r(   r-   rH   r&   r&   r=   r'   rM   Å   s    

rM   c                   @   ó   e Zd ZdZdZdd„ ZdS )Ú_Booleanz/
    Constrain to the two values `{0, 1}`.
    Tc                 C   s   |dk|dkB S )Nr   r)   r&   r#   r&   r&   r'   r(   ô   s   z_Boolean.checkN)r+   r/   r0   r1   r2   r(   r&   r&   r&   r'   r^   í   ó    r^   c                   @   s    e Zd ZdZdZdZdd„ ZdS )Ú_OneHotz'
    Constrain to one-hot vectors.
    Tr)   c                 C   s.   |dk|dkB }|  d¡ d¡}| d¡|@ S )Nr   r)   rS   )ÚsumÚeqrW   )r$   r%   Z
is_booleanÚis_normalizedr&   r&   r'   r(      s   z_OneHot.checkN)r+   r/   r0   r1   r2   r3   r(   r&   r&   r&   r'   r`   ø   s
    r`   c                       ó4   e Zd ZdZdZ‡ fdd„Zdd„ Zdd„ Z‡  ZS )	Ú_IntegerIntervalzH
    Constrain to an integer interval `[lower_bound, upper_bound]`.
    Tc                    r6   r7   ©Úlower_boundÚupper_boundr:   r;   ©r$   rg   rh   r=   r&   r'   r;     r>   z_IntegerInterval.__init__c                 C   s    |d dk| j |k@ || jk@ S ©Nr)   r   ©rg   rh   r#   r&   r&   r'   r(     s   ÿz_IntegerInterval.checkc                 C   ó.   | j jdd … }|d| j› d| j› d�7 }|S ©Nr)   ú(lower_bound=z, upper_bound=r[   ©r*   r+   rg   rh   ©r$   Z
fmt_stringr&   r&   r'   r-     ó
   ÿz_IntegerInterval.__repr__©	r+   r/   r0   r1   r2   r;   r(   r-   rH   r&   r&   r=   r'   re     s    re   c                       rd   )	Ú_IntegerLessThanzA
    Constrain to an integer interval `(-inf, upper_bound]`.
    Tc                    ó   || _ tƒ  ¡  d S r7   ©rh   r:   r;   ©r$   rh   r=   r&   r'   r;   &  ó   z_IntegerLessThan.__init__c                 C   s   |d dk|| j k@ S rj   ©rh   r#   r&   r&   r'   r(   *  ó   z_IntegerLessThan.checkc                 C   ó&   | j jdd … }|d| j› d�7 }|S ©Nr)   z(upper_bound=r[   ©r*   r+   rh   rp   r&   r&   r'   r-   -  ó   z_IntegerLessThan.__repr__rr   r&   r&   r=   r'   rs     ó    rs   c                       rd   )	Ú_IntegerGreaterThanz@
    Constrain to an integer interval `[lower_bound, inf)`.
    Tc                    rt   r7   ©rg   r:   r;   ©r$   rg   r=   r&   r'   r;   :  rw   z_IntegerGreaterThan.__init__c                 C   s   |d dk|| j k@ S rj   ©rg   r#   r&   r&   r'   r(   >  ry   z_IntegerGreaterThan.checkc                 C   rz   ©Nr)   rn   r[   ©r*   r+   rg   rp   r&   r&   r'   r-   A  r}   z_IntegerGreaterThan.__repr__rr   r&   r&   r=   r'   r   3  r~   r   c                   @   s   e Zd ZdZdd„ ZdS )Ú_RealzF
    Trivially constrain to the extended real line `[-inf, inf]`.
    c                 C   s   ||kS r7   r&   r#   r&   r&   r'   r(   L  rF   z_Real.checkN)r+   r/   r0   r1   r(   r&   r&   r&   r'   r…   G  s    r…   c                       ó0   e Zd ZdZ‡ fdd„Zdd„ Zdd„ Z‡  ZS )Ú_GreaterThanz=
    Constrain to a real half line `(lower_bound, inf]`.
    c                    rt   r7   r€   r�   r=   r&   r'   r;   U  rw   z_GreaterThan.__init__c                 C   s
   | j |k S r7   r‚   r#   r&   r&   r'   r(   Y  rJ   z_GreaterThan.checkc                 C   rz   rƒ   r„   rp   r&   r&   r'   r-   \  r}   z_GreaterThan.__repr__©r+   r/   r0   r1   r;   r(   r-   rH   r&   r&   r=   r'   r‡   P  ó
    r‡   c                       r†   )Ú_GreaterThanEqz=
    Constrain to a real half line `[lower_bound, inf)`.
    c                    rt   r7   r€   r�   r=   r&   r'   r;   g  rw   z_GreaterThanEq.__init__c                 C   s
   | j |kS r7   r‚   r#   r&   r&   r'   r(   k  rJ   z_GreaterThanEq.checkc                 C   rz   rƒ   r„   rp   r&   r&   r'   r-   n  r}   z_GreaterThanEq.__repr__rˆ   r&   r&   r=   r'   rŠ   b  r‰   rŠ   c                       r†   )Ú	_LessThanz>
    Constrain to a real half line `[-inf, upper_bound)`.
    c                    rt   r7   ru   rv   r=   r&   r'   r;   y  rw   z_LessThan.__init__c                 C   s
   || j k S r7   rx   r#   r&   r&   r'   r(   }  rJ   z_LessThan.checkc                 C   rz   r{   r|   rp   r&   r&   r'   r-   €  r}   z_LessThan.__repr__rˆ   r&   r&   r=   r'   r‹   t  r‰   r‹   c                       r†   )Ú	_IntervalzD
    Constrain to a real interval `[lower_bound, upper_bound]`.
    c                    r6   r7   rf   ri   r=   r&   r'   r;   ‹  r>   z_Interval.__init__c                 C   s   | j |k|| jk@ S r7   rk   r#   r&   r&   r'   r(   �  r.   z_Interval.checkc                 C   rl   rm   ro   rp   r&   r&   r'   r-   “  rq   z_Interval.__repr__rˆ   r&   r&   r=   r'   rŒ   †  ó
    rŒ   c                       r†   )Ú_HalfOpenIntervalzD
    Constrain to a real interval `[lower_bound, upper_bound)`.
    c                    r6   r7   rf   ri   r=   r&   r'   r;      r>   z_HalfOpenInterval.__init__c                 C   s   | j |k|| jk @ S r7   rk   r#   r&   r&   r'   r(   ¥  r.   z_HalfOpenInterval.checkc                 C   rl   rm   ro   rp   r&   r&   r'   r-   ¨  rq   z_HalfOpenInterval.__repr__rˆ   r&   r&   r=   r'   rŽ   ›  r�   rŽ   c                   @   r]   )Ú_Simplexz€
    Constrain to the unit simplex in the innermost (rightmost) dimension.
    Specifically: `x >= 0` and `x.sum(-1) == 1`.
    r)   c                 C   s(   t j|dkdd�| d¡d  ¡ dk @ S )Nr   rS   ©rT   r)   ç�íµ ÷Æ°>)ÚtorchrW   ra   Úabsr#   r&   r&   r'   r(   ¸  s   (z_Simplex.checkN©r+   r/   r0   r1   r3   r(   r&   r&   r&   r'   r�   °  ó    r�   c                   @   r!   )	Ú_Multinomiala3  
    Constrain to nonnegative integer values summing to at most an upper bound.

    Note due to limitations of the Multinomial distribution, this currently
    checks the weaker condition ``value.sum(-1) <= upper_bound``. In the future
    this may be strengthened to ``value.sum(-1) == upper_bound``.
    Tr)   c                 C   s
   || _ d S r7   rx   rv   r&   r&   r'   r;   È  rJ   z_Multinomial.__init__c                 C   s"   |dkj dd�|jdd�| jk@ S )Nr   rS   r�   )rW   ra   rh   rD   r&   r&   r'   r(   Ë  s   "z_Multinomial.checkN)r+   r/   r0   r1   r2   r3   r;   r(   r&   r&   r&   r'   r–   ¼  s    r–   c                   @   r]   )Ú_LowerTriangularz8
    Constrain to lower-triangular square matrices.
    é   c                 C   s.   |  ¡ }||k |jd d… d ¡ d¡d S )NéþÿÿÿrR   rS   r   )ÚtrilÚviewrV   Úmin)r$   r%   Ú
value_trilr&   r&   r'   r(   Ö  s   &z_LowerTriangular.checkNr”   r&   r&   r&   r'   r—   Ï  r_   r—   c                   @   r]   )Ú_LowerCholeskyzP
    Constrain to lower-triangular square matrices with positive diagonals.
    r˜   c                 C   sR   |  ¡ }||k |jd d… d ¡ d¡d }|jddd�dk d¡d }||@ S )Nr™   rR   rS   r   )Údim1Údim2)rš   r›   rV   rœ   Údiagonal)r$   r%   r�   r   Zpositive_diagonalr&   r&   r'   r(   â  s
   $ÿz_LowerCholesky.checkNr”   r&   r&   r&   r'   rž   Û  r_   rž   c                   @   r]   )Ú_CorrCholeskyz}
    Constrain to lower-triangular square matrices with positive diagonals and each
    row vector being of unit length.
    r˜   c                 C   sZ   t  |j¡j| d¡ d }t jj| ¡ dd�}|d  ¡  	|¡j
dd�}tƒ  |¡|@ S )NrS   é
   r�   ç      ð?)r’   ÚfinfoÚdtypeÚepsÚsizeÚlinalgÚnormÚdetachr“   ÚlerW   rž   r(   )r$   r%   ÚtolZrow_normZunit_row_normr&   r&   r'   r(   ô  s
   ÿz_CorrCholesky.checkNr”   r&   r&   r&   r'   r¢   ì  r•   r¢   c                   @   r]   )Ú_Squarez'
    Constrain to square matrices.
    r˜   c                 C   s0   t j|jd d… |jd |jd kt j|jd�S )Nr™   rS   )r¨   Ú
fill_valuer¦   Údevice)r’   ÚfullrV   Úboolr°   r#   r&   r&   r'   r(     s   üz_Square.checkNr”   r&   r&   r&   r'   r®   ý  r_   r®   c                       ó    e Zd ZdZ‡ fdd„Z‡  ZS )Ú
_Symmetricz1
    Constrain to Symmetric square matrices.
    c                    s6   t ƒ  |¡}| ¡ s|S tj||jdd� d¡ d¡S )Nr‘   )Úatolr™   rS   )r:   r(   rW   r’   ÚiscloseÚmT)r$   r%   Zsquare_checkr=   r&   r'   r(     s   z_Symmetric.check©r+   r/   r0   r1   r(   rH   r&   r&   r=   r'   r´     ó    r´   c                       r³   )Ú_PositiveSemidefinitez6
    Constrain to positive-semidefinite matrices.
    c                    s0   t ƒ  |¡}| ¡ s|S tj |¡ d¡ d¡S )Nr   rS   )r:   r(   rW   r’   r©   ÚeigvalshÚge©r$   r%   Z	sym_checkr=   r&   r'   r(     s   z_PositiveSemidefinite.checkr¸   r&   r&   r=   r'   rº     r¹   rº   c                       r³   )Ú_PositiveDefinitez2
    Constrain to positive-definite matrices.
    c                    s,   t ƒ  |¡}| ¡ s|S tj |¡j d¡S rN   )r:   r(   rW   r’   r©   Úcholesky_exÚinforb   r½   r=   r&   r'   r(   *  s   z_PositiveDefinite.checkr¸   r&   r&   r=   r'   r¾   %  r¹   r¾   c                       sB   e Zd ZdZd‡ fdd„	Zedd„ ƒZedd	„ ƒZd
d„ Z‡  Z	S )Ú_CatzÂ
    Constraint functor that applies a sequence of constraints
    `cseq` at the submatrices at dimension `dim`,
    each of size `lengths[dim]`, in a way compatible with :func:`torch.cat`.
    r   Nc                    sn   t dd„ |D ƒƒsJ ‚t|ƒ| _|d u rdgt| jƒ }t|ƒ| _t| jƒt| jƒks-J ‚|| _tƒ  ¡  d S )Nc                 s   ó   � | ]}t |tƒV  qd S r7   ©rI   r   ©Ú.0Úcr&   r&   r'   Ú	<genexpr>9  ó   € z _Cat.__init__.<locals>.<genexpr>r)   )rW   ÚlistÚcseqÚlenÚlengthsrT   r:   r;   )r$   rÊ   rT   rÌ   r=   r&   r'   r;   8  s   

z_Cat.__init__c                 C   ó   t dd„ | jD ƒƒS )Nc                 s   ó   � | ]}|j V  qd S r7   ©r2   rÄ   r&   r&   r'   rÇ   D  ó   € z#_Cat.is_discrete.<locals>.<genexpr>©ÚanyrÊ   r,   r&   r&   r'   r2   B  ó   z_Cat.is_discretec                 C   rÍ   )Nc                 s   rÎ   r7   ©r3   rÄ   r&   r&   r'   rÇ   H  rÐ   z!_Cat.event_dim.<locals>.<genexpr>)ÚmaxrÊ   r,   r&   r&   r'   r3   F  rÓ   z_Cat.event_dimc                 C   s~   |  ¡  | j   kr|  ¡ k sJ ‚ J ‚g }d}t| j| jƒD ]\}}| | j ||¡}| | |¡¡ || }qt || j ¡S rN   )	rT   ÚziprÊ   rÌ   ÚnarrowÚappendr(   r’   r   )r$   r%   ZchecksÚstartÚconstrÚlengthÚvr&   r&   r'   r(   J  s   (
z
_Cat.check)r   N©
r+   r/   r0   r1   r;   rG   r2   r3   r(   rH   r&   r&   r=   r'   rÁ   1  s    


rÁ   c                       sB   e Zd ZdZd‡ fdd„	Zedd„ ƒZedd„ ƒZd	d
„ Z‡  Z	S )Ú_Stackz§
    Constraint functor that applies a sequence of constraints
    `cseq` at the submatrices at dimension `dim`,
    in a way compatible with :func:`torch.stack`.
    r   c                    s4   t dd„ |D ƒƒsJ ‚t|ƒ| _|| _tƒ  ¡  d S )Nc                 s   rÂ   r7   rÃ   rÄ   r&   r&   r'   rÇ   ]  rÈ   z"_Stack.__init__.<locals>.<genexpr>)rW   rÉ   rÊ   rT   r:   r;   )r$   rÊ   rT   r=   r&   r'   r;   \  s   
z_Stack.__init__c                 C   rÍ   )Nc                 s   rÎ   r7   rÏ   rÄ   r&   r&   r'   rÇ   d  rÐ   z%_Stack.is_discrete.<locals>.<genexpr>rÑ   r,   r&   r&   r'   r2   b  rÓ   z_Stack.is_discretec                 C   s.   t dd„ | jD ƒƒ}| j| dk r|d7 }|S )Nc                 s   rÎ   r7   rÔ   rÄ   r&   r&   r'   rÇ   h  rÐ   z#_Stack.event_dim.<locals>.<genexpr>r   r)   )rÕ   rÊ   rT   )r$   rT   r&   r&   r'   r3   f  s   z_Stack.event_dimc                    sh   ˆ  ¡  ˆ j   krˆ  ¡ k sJ ‚ J ‚‡ ‡fdd„tˆ ˆ j ¡ƒD ƒ}t dd„ t|ˆ jƒD ƒˆ j ¡S )Nc                    s   g | ]	}ˆ  ˆ j|¡‘qS r&   )ÚselectrT   )rÅ   Úir#   r&   r'   Ú
<listcomp>o  ó    z _Stack.check.<locals>.<listcomp>c                 S   s   g | ]	\}}|  |¡‘qS r&   )r(   )rÅ   rÜ   rÚ   r&   r&   r'   rá   q  râ   )rT   Úranger¨   r’   r   rÖ   rÊ   )r$   r%   Zvsr&   r#   r'   r(   m  s
   ( ÿz_Stack.check)r   rÝ   r&   r&   r=   r'   rÞ   U  s    

rÞ   r)   g        r¤   )<r1   r’   Ú__all__r   r4   r   rG   rK   rM   r^   r`   re   rs   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   r   r   r   r	   r   r   r    r   r   r   r   r   r   r   r   r   r   r   r   r&   r&   r&   r'   Ú<module>   sv   !#/-(	$!

