%PDF- %PDF-
Mini Shell

Mini Shell

Direktori : /usr/lib/python3/dist-packages/babel/__pycache__/
Upload File :
Create Path :
Current File : //usr/lib/python3/dist-packages/babel/__pycache__/plural.cpython-312.pyc

�

ƪbQV�	�P�dZddlZddlZdZdZd�ZGd�d�Zd�Zd	�Zd
�Z	d�Z
d�Zd
�ZGd�de
�Zhd�Zdej dej"�fdej ddj%e��d��fdej d�fdej d�fdej dej"�fgZd�Zd2d�Zd2d�Zd�Zd �Zd!�Zd"�ZGd#�d$�Zd%�Zd&�Zd'�ZGd(�d)�ZGd*�d+e�Z Gd,�d-e�Z!Gd.�d/e!�Z"Gd0�d1e�Z#y)3z�
    babel.numbers
    ~~~~~~~~~~~~~

    CLDR Plural support.  See UTS #35.

    :copyright: (c) 2013-2022 by the Babel Team.
    :license: BSD, see LICENSE for more details.
�N)�zero�one�two�few�many�otherrc��t|�}t|�}t|t�r&||k(r|}nt	j
t
|��}t|tj
�r�|j�}|j}|dkr|j|dnd}djd�|D��}|jd�}t|�}t|�}	t|xsd�}
t|xsd�}ndx}x}	x}
}dx}}
||||	|
|||
fS)u�Extract operands from a decimal, a float or an int, according to `CLDR rules`_.

    The result is a 8-tuple (n, i, v, w, f, t, c, e), where those symbols are as follows:

    ====== ===============================================================
    Symbol Value
    ------ ---------------------------------------------------------------
    n      absolute value of the source number (integer and decimals).
    i      integer digits of n.
    v      number of visible fraction digits in n, with trailing zeros.
    w      number of visible fraction digits in n, without trailing zeros.
    f      visible fractional digits in n, with trailing zeros.
    t      visible fractional digits in n, without trailing zeros.
    c      compact decimal exponent value: exponent of the power of 10 used in compact decimal formatting.
    e      currently, synonym for ‘c’. however, may be redefined in the future.
    ====== ===============================================================

    .. _`CLDR rules`: https://www.unicode.org/reports/tr35/tr35-61/tr35-numbers.html#Operands

    :param source: A real number
    :type source: int|float|decimal.Decimal
    :return: A n-i-v-w-f-t-c-e tuple
    :rtype: tuple[decimal.Decimal, int, int, int, int, int, int, int]
    rN��c3�2K�|]}t|����y�w�N��str)�.0�ds  �./usr/lib/python3/dist-packages/babel/plural.py�	<genexpr>z#extract_operands.<locals>.<genexpr>As����;�a�3�q�6�;�s��0)
�abs�int�
isinstance�float�decimal�Decimalr�as_tuple�exponent�digits�join�rstrip�len)�source�n�i�	dec_tuple�exp�fraction_digits�trailing�no_trailing�v�w�f�t�c�es              r�extract_operandsr/s��2	�F��A��A��A��!�U����6��A�����A��'�A��!�W�_�_�%��J�J�L�	�� � ��47�!�G�)�*�*�3�4�0����7�7�;�?�;�;���o�o�c�*����M��������
�A����� �q�!������A���A�
�I�A���a��A�q�!�Q��!�!�c�h�eZdZdZdZd�Zd�Zed��Ze	d��Z
e	d�d�	�Zd
�Zd�Z
d�Zy
)�
PluralRuleafRepresents a set of language pluralization rules.  The constructor
    accepts a list of (tag, expr) tuples or a dict of `CLDR rules`_. The
    resulting object is callable and accepts one parameter with a positive or
    negative number (both integer and float) for the number that indicates the
    plural form for a string and returns the tag for the format:

    >>> rule = PluralRule({'one': 'n is 1'})
    >>> rule(1)
    'one'
    >>> rule(2)
    'other'

    Currently the CLDR defines these tags: zero, one, two, few, many and
    other where other is an implicit default.  Rules should be mutually
    exclusive; for a given numeric value, only one rule should apply (i.e.
    the condition should only be true for one of the plural rule elements.

    .. _`CLDR rules`: https://www.unicode.org/reports/tr35/tr35-33/tr35-numbers.html#Language_Plural_Rules
    )�abstract�_funcc�z�t|t�r|j�}t�}g|_tt
|��D]s\}}|tvrtd|z��||vrtd|z��|j|�t|�j}|s�W|jj||f��uy)a$Initialize the rule instance.

        :param rules: a list of ``(tag, expr)``) tuples with the rules
                      conforming to UTS #35 or a dict with the tags as keys
                      and expressions as values.
        :raise RuleError: if the expression is malformed
        zunknown tag %rztag %r defined twiceN)
r�dict�items�setr3�sorted�list�_plural_tags�
ValueError�add�_Parser�ast�append)�self�rules�found�key�exprr?s      r�__init__zPluralRule.__init__ds����e�T�"��K�K�M�E������
���U��,�	1�I�C���,�&� �!1�C�!7�8�8���� �!7�#�!=�>�>��I�I�c�N��$�-�#�#�C���
�
�$�$�c�3�Z�0�	1r0c��|j}dt|�j�ddjtD�cgc]}||vr
|�d||����c}��d�Scc}w)N�<� �, z: �>)rB�type�__name__rr;)rArB�tags   r�__repr__zPluralRule.__repr__zsW���
�
����J����I�I�|�(����,�$'��c�
�3�(�
)�
�	
��(s�Ac�.�t||�r|S||�S)a
Create a `PluralRule` instance for the given rules.  If the rules
        are a `PluralRule` object, that object is returned.

        :param rules: the rules as list or dict, or a `PluralRule` object
        :raise RuleError: if the expression is malformed
        )r)�clsrBs  r�parsezPluralRule.parse�s���e�S�!��L��5�z�r0c��t�j}|jD��cic]\}}|||���c}}Scc}}w)z�The `PluralRule` as a dict of unicode plural rules.

        >>> rule = PluralRule({'one': 'n is 1'})
        >>> rule.rules
        {'one': 'n is 1'}
        )�_UnicodeCompiler�compiler3)rA�_compilerNr?s    rrBzPluralRule.rules�s7��$�%�-�-��37�=�=�A�x�s�C��X�c�]�"�A�A��As�;c�:�td�|jD��S)Nc3�&K�|]	}|d���y�w)rNr
)rr#s  rrz&PluralRule.<lambda>.<locals>.<genexpr>�s����'A���!��'A�s�)�	frozensetr3��xs r�<lambda>zPluralRule.<lambda>�s��i�'A�a�j�j�'A�A�r0z�
        A set of explicitly defined tags in this rule.  The implicit default
        ``'other'`` rules is not part of this set unless there is an explicit
        rule for it.)�docc��|jSr
�r3�rAs r�__getstate__zPluralRule.__getstate__�s���}�}�r0c��||_yr
r_)rAr3s  r�__setstate__zPluralRule.__setstate__�s	�� ��
r0c�\�t|d�st|�|_|j|�S)Nr4)�hasattr�	to_pythonr4)rAr"s  r�__call__zPluralRule.__call__�s%���t�W�%�"�4��D�J��z�z�!�}�r0N)rM�
__module__�__qualname__�__doc__�	__slots__rFrO�classmethodrR�propertyrB�tagsrarcrgr
r0rr2r2Msf���(&�I�1�,
��	��	��B��B��A�H��D�
�!�r0r2c�
�t�j}dg}tj|�jD]"\}}|j||��d|�d���$|jdtz�dj|�S)a�Convert a list/dict of rules or a `PluralRule` object into a JavaScript
    function.  This function depends on no external library:

    >>> to_javascript({'one': 'n is 1'})
    "(function(n) { return (n == 1) ? 'one' : 'other'; })"

    Implementation detail: The function generated will probably evaluate
    expressions involved into range operations multiple times.  This has the
    advantage that external helper functions are not required and is not a
    big performance hit for these simple calculations.

    :param rule: the rules as list or dict, or a `PluralRule` object
    :raise RuleError: if the expression is malformed
    z(function(n) { return z ? z : z%r; })r)�_JavaScriptCompilerrUr2rRr3r@�
_fallback_tagr)�rule�to_js�resultrNr?s     r�
to_javascriptru�sr��
 �!�)�)�E�&�
'�F��$�$�T�*�3�3�8���S��
�
�e�C�j�#�6�7�8�
�M�M�(�]�*�+�
�7�7�6�?�r0c	��ttttd�}t	�j
}ddg}tj|�jD]+\}}|jd||��dt|�����-|jdtz�tdj|�dd	�}t||�|d
S)a<Convert a list/dict of rules or a `PluralRule` object into a regular
    Python function.  This is useful in situations where you need a real
    function and don't are about the actual rule object:

    >>> func = to_python({'one': 'n is 1', 'few': 'n in 2..4'})
    >>> func(1)
    'one'
    >>> func(3)
    'few'
    >>> func = to_python({'one': 'n in 1,11', 'few': 'n in 3..10,13..19'})
    >>> func(11)
    'one'
    >>> func(15)
    'few'

    :param rule: the rules as list or dict, or a `PluralRule` object
    :raise RuleError: if the expression is malformed
    )�IN�WITHIN�MODr/zdef evaluate(n):z- n, i, v, w, f, t, c, e = extract_operands(n)z if (z
): return z
 return %r�
z<rule>�exec�evaluate)�
in_range_list�within_range_list�cldr_modulor/�_PythonCompilerrUr2rRr3r@rrqr�eval)rr�	namespace�to_python_funcrtrNr?�codes       rrfrf�s���(�#��,�	�I�%�&�.�.�N��7��F��$�$�T�*�3�3�O���S�	�
�
�~�c�/B�C��H�M�N�O��M�M�,��.�/��4�9�9�V�$�h��7�D���y���Z� � r0c��tj|�}|jthz}t	�j
}tD�cgc]	}||vs�|��c}j}dt|�zg}|jD]'\}}|jd||�||�fz��)|jd|t�z�dj|�Scc}w)aThe plural rule as gettext expression.  The gettext expression is
    technically limited to integers and returns indices rather than tags.

    >>> to_gettext({'one': 'n is 1', 'two': 'n is 2'})
    'nplurals=3; plural=((n == 1) ? 0 : (n == 2) ? 1 : 2);'

    :param rule: the rules as list or dict, or a `PluralRule` object
    :raise RuleError: if the expression is malformed
    znplurals=%d; plural=(z
%s ? %d : z%d);r)r2rRrnrq�_GettextCompilerrUr;�indexr r3r@r)rr�	used_tagsrVrN�
_get_indexrtr?s       r�
to_gettextr��s������D�!�D��	�	�]�O�+�I��!�)�)�H�!-�B�#��	�1A�#�B�H�H�J�%��I��6�
7�F��M�M�G���S��
�
�l�h�s�m�Z��_�%E�E�F�G�
�M�M�&�:�m�4�4�5�
�7�7�6�?���
Cs�	C�Cc�:�|t|�k(xrt||�S)a�Integer range list test.  This is the callback for the "in" operator
    of the UTS #35 pluralization rule language:

    >>> in_range_list(1, [(1, 3)])
    True
    >>> in_range_list(3, [(1, 3)])
    True
    >>> in_range_list(3, [(1, 3), (5, 8)])
    True
    >>> in_range_list(1.2, [(1, 4)])
    False
    >>> in_range_list(10, [(1, 4)])
    False
    >>> in_range_list(10, [(1, 4), (6, 8)])
    False
    )rr~��num�
range_lists  rr}r}s��"�#�c�(�?�A�0��j�A�Ar0c�,��t�fd�|D��S)a�Float range test.  This is the callback for the "within" operator
    of the UTS #35 pluralization rule language:

    >>> within_range_list(1, [(1, 3)])
    True
    >>> within_range_list(1.0, [(1, 3)])
    True
    >>> within_range_list(1.2, [(1, 4)])
    True
    >>> within_range_list(8.8, [(1, 4), (7, 15)])
    True
    >>> within_range_list(10, [(1, 4)])
    False
    >>> within_range_list(10.5, [(1, 4), (20, 30)])
    False
    c3�<�K�|]\}}�|k\xr�|k���y�wr
r
)r�min_�max_r�s   �rrz$within_range_list.<locals>.<genexpr>%s%�����H�z�t�T�s�d�{�*�s�d�{�*�H�s�)�anyr�s` rr~r~s���"�H�Z�H�H�Hr0c�N�d}|dkr|dz}d}|dkr|dz}||z}|r|dz}|S)z�Javaish modulo.  This modulo operator returns the value with the sign
    of the dividend rather than the divisor like Python does:

    >>> cldr_modulo(-3, 5)
    -3
    >>> cldr_modulo(-3, -5)
    -3
    >>> cldr_modulo(3, 5)
    3
    r����r
)�a�b�reverse�rvs    rrr(sH���G��1�u�	�R������1�u�	�R���	
�Q��B��
�b���
�Ir0c��eZdZdZy)�	RuleErrorzRaised if a rule is malformed.N)rMrhrirjr
r0rr�r�?s��(r0r�>r-r.r+r#r"r,r)r*z\s+�wordz"\b(and|or|is|(?:with)?in|not|mod|[rz])\b�valuez\d+�symbolz%|,|!=|=�ellipsisz\.{2,3}|\u2026c�>�|jd�d}g}d}t|�}||krntD]N\}}|j||�}|��|j	�}|r!|j||j
�f�ntd||z��||kr�n|ddd�S)N�@rz5malformed CLDR pluralization rule.  Got unexpected %rr�)�splitr �_RULES�match�endr@�groupr�)�srt�posr��tokrrr�s       r�
tokenize_ruler�Vs���	�����Q��A�
�F�
�C�

�a�&�C�

��)��		:�I�C���J�J�q�#�&�E�� ��i�i�k����M�M�3����
�"6�7��
		:��0�23�C�&�9�:�
:���)��$�B�$�<�r0c�F�|xr|dd|k(xr|duxs|dd|k(S)Nr�rr�r
��tokens�type_r�s   r�test_next_tokenr�is<���2�f�R�j��m�u�,�2�	�$��	0�&��*�Q�-�5�0�2r0c�>�t|||�r|j�Syr
)r��popr�s   r�
skip_tokenr�ns���v�u�e�,��z�z�|��-r0c��d|ffS)Nr�r
)r�s r�
value_noder�ss���U�I��r0c�
�|dfS)Nr
r
)�names r�
ident_noder�ws����8�Or0c�
�d|fS)Nr�r
)r�s r�range_list_noder�{s
����#�#r0c��d|ffS)N�notr
)r�s r�negater�s���2�%�<�r0c�N�eZdZdZd�Zd
d�Zd�Zd�Zd�Zd�Z	d	�Z
d
�Zd�Zd�Z
y)r>u�Internal parser.  This class can translate a single rule into an abstract
    tree of tuples. It implements the following grammar::

        condition     = and_condition ('or' and_condition)*
                        ('@integer' samples)?
                        ('@decimal' samples)?
        and_condition = relation ('and' relation)*
        relation      = is_relation | in_relation | within_relation
        is_relation   = expr 'is' ('not')? value
        in_relation   = expr (('not')? 'in' | '=' | '!=') range_list
        within_relation = expr ('not')? 'within' range_list
        expr          = operand (('mod' | '%') value)?
        operand       = 'n' | 'i' | 'f' | 't' | 'v' | 'w'
        range_list    = (range | value) (',' range_list)*
        value         = digit+
        digit         = 0|1|2|3|4|5|6|7|8|9
        range         = value'..'value
        samples       = sampleRange (',' sampleRange)* (',' ('…'|'...'))?
        sampleRange   = decimalValue '~' decimalValue
        decimalValue  = value ('.' value)?

    - Whitespace can occur between or around any of the above tokens.
    - Rules should be mutually exclusive; for a given numeric value, only one
      rule should apply (i.e. the condition should only be true for one of
      the plural rule elements).
    - The in and within relations can take comma-separated lists, such as:
      'n in 3,5,7..15'.
    - Samples are ignored.

    The translator parses the expression on instanciation into an attribute
    called `ast`.
    c���t|�|_|jsd|_y|j�|_|jrt	d|jddz��y)NzExpected end of rule, got %rr�r�)r�r�r?�	conditionr�)rA�strings  rrFz_Parser.__init__�s`��#�F�+����{�{��D�H���>�>�#����;�;��:� �K�K��O�A�.�/�0�
0�r0Nc���t|j||�}|�|S|�t|duxr|xs|�}|jstd|z��td|�d|jdd����)Nz#expected %s but end of rule reachedz	expected z	 but got r�r�)r�r��reprr�)rAr�r��term�tokens     r�expectz_Parser.expect�sq���4�;�;��u�5�����L��<����
�/�%�8�5�9�D��{�{��A�D�H�I�I��D�$�+�+�b�/�!�:L�M�N�Nr0c��|j�}t|jdd�r,d||j�ff}t|jdd�r�,|S)Nr��or)�
and_conditionr�r��rA�ops  rr�z_Parser.condition�sO��
�
�
�
!������f�d�3���D�.�.�0�1�1�B�����f�d�3��	r0c��|j�}t|jdd�r,d||j�ff}t|jdd�r�,|S)Nr��and)�relationr�r�r�s  rr�z_Parser.and_condition�sI��
�]�]�_������f�e�4���T�]�]�_�-�-�B�����f�e�4��	r0c���|j�}t|jdd�r1t|jdd�xrdxsd||j�ffSt|jdd�}d}t|jdd�rd}n5t|jdd�s|rt	d��|j|�Sd|||j
�ff}|rt|�S|S)	Nr��isr��isnot�in�withinz#Cannot negate operator based rules.r�)rEr�r�r�r��newfangled_relationr�r�)rA�left�negated�methodr�s     rr�z_Parser.relation�s����y�y�{���d�k�k�6�4�0��d�k�k�6�5�9�E�g�M���t�z�z�|�$�%�
%��T�[�[�&�%�8�����d�k�k�6�8�4��F��d�k�k�6�4�8��#�$I�J�J��/�/��5�5�
�&�$����(9�:�
:��$�v�b�z�,�"�,r0c���t|jdd�rd}n%t|jdd�rd}ntd��dd||j�ff}|rt	|�S|S)	Nr��=Fz!=Tz'Expected "=" or "!=" or legacy relationr�r�)r�r�r�r�r�)rAr�r�r�s    rr�z_Parser.newfangled_relation�sa���d�k�k�8�S�1��G�
����X�t�
4��G��E�F�F�
�$��d�o�o�&7�8�
8��$�v�b�z�,�"�,r0c�z�|j�}t|jd�r||j�fS||fS)Nr�)r�r�r�)rAr�s  r�range_or_valuez_Parser.range_or_value�s6���z�z�|���d�k�k�:�.������%�%���:�r0c���|j�g}t|jdd�r7|j|j��t|jdd�r�7t	|�S)Nr��,)r�r�r�r@r�)rAr�s  rr�z_Parser.range_list�sW���)�)�+�,�
�����h��4����d�1�1�3�4�����h��4��z�*�*r0c�2�t|jd�}|�|dtvrtd��|d}t|jdd�rd|df|j	�ffSt|jdd�rd|df|j	�ffSt|�S)Nr�r�zExpected identifier variable�modr
r��%)r�r��_VARSr�r�r�)rAr�r�s   rrEz_Parser.expr�s����$�+�+�v�.���<�4��7�%�/��:�;�;��A�w���d�k�k�6�5�1��D�"�:�t�z�z�|�4�4�4�
����X�s�
3��D�"�:�t�z�z�|�4�4�4��$��r0c�N�tt|jd�d��S)Nr�r�)r�rr�r`s rr�z
_Parser.value�s ���#�d�k�k�'�2�1�5�6�7�7r0)NN)rMrhrirjrFr�r�r�r�r�r�r�rEr�r
r0rr>r>�s;���B
0�O���-�"-��+�	 �8r0r>c����fd�S)�%Compiler factory for the `_Compiler`.c�N���|j|�|j|�fzSr
�rU)rA�l�r�tmpls   �rr\z"_binary_compiler.<locals>.<lambda>s!���d�d�l�l�1�o�t�|�|�A��%G�G�r0r
�r�s`r�_binary_compilerr��s	���G�Gr0c����fd�S)r�c�,���|j|�zSr
r�)rAr[r�s  �rr\z!_unary_compiler.<locals>.<lambda>s���4�$�,�,�q�/�1�r0r
r�s`r�_unary_compilerr�s	���1�1r0c��y)Nrr
rZs rr\r\��r0c��eZdZdZd�Zd�Zd�Zd�Zd�Zd�Z	d�Z
d	�Zd
�Zd�Z
ed�Zed
�Zed�Zed�Zed�Zed�Zd�Zy)�	_CompilerzZThe compilers are able to transform the expressions into multiple
    output formats.
    c�0�|\}}t|d|z�|�S)N�compile_)�getattr)rA�argr��argss    rrUz_Compiler.compiles#�����D�-�w�t�Z�"�_�-�t�4�4r0c��y)Nr"r
rZs rr\z_Compiler.<lambda>r�r0c��y)Nr#r
rZs rr\z_Compiler.<lambda>r�r0c��y)Nr)r
rZs rr\z_Compiler.<lambda>r�r0c��y)Nr*r
rZs rr\z_Compiler.<lambda>r�r0c��y)Nr+r
rZs rr\z_Compiler.<lambda>r�r0c��y)Nr,r
rZs rr\z_Compiler.<lambda>r�r0c��y)Nr-r
rZs rr\z_Compiler.<lambda>r�r0c��y)Nr.r
rZs rr\z_Compiler.<lambda>r�r0c��t|�Sr
r)r[r)s  rr\z_Compiler.<lambda>s
���Q��r0z
(%s && %s)z
(%s || %s)z(!%s)z
(%s %% %s)z
(%s == %s)z
(%s != %s)c��t��r
)�NotImplementedError)rAr�rEr�s    r�compile_relationz_Compiler.compile_relation$s��!�#�#r0N)rMrhrirjrU�	compile_n�	compile_i�	compile_v�	compile_w�	compile_f�	compile_t�	compile_c�	compile_e�
compile_valuer��compile_and�
compile_orr��compile_not�compile_mod�
compile_is�
compile_isnotrr
r0rr�r�s|���5��I��I��I��I��I��I��I��I�'�M�"�<�0�K�!�,�/�J�!�'�*�K�"�<�0�K�!�,�/�J�$�\�2�M�$r0r�c�V�eZdZdZed�Zed�Zed�Zed�Z	d�Z
y)r�z!Compiles an expression to Python.z(%s and %s)z
(%s or %s)z(not %s)zMOD(%s, %s)c
���ddj|dD�cgc]$}dtt|j|��z��&c}�z}|j	��d|j|��d|�d�Scc}w)Nz[%s]r�r�z(%s, %s)�(rJ�))r�tuple�maprU�upper)rAr�rEr��range_�compile_range_lists      rrz _PythonCompiler.compile_relation0so��#�c�h�h�%�a�=�
*���%��D�L�L�&� 9�:�
:�
*�'+�+�� &�|�|�~�t�|�|�D�/A�1�3�	3��
*s�)A.
N)rMrhrirjr�r
rr�rrrr
r0rr�r�(s2��+�"�=�1�K�!�,�/�J�!�*�-�K�"�=�1�K�3r0r�c�>�eZdZdZej
ZeZeZ	eZ
eZd�Zy)r�z)Compile into a gettext plural expression.c�>�g}|j|�}|dD]o}|d|dk(r+|jd|�d|j|d��d���9t|j|�\}}|jd|�d|�d|�d|�d�	��qd	d
j|�zS)Nr�rrz == rz >= � && z <= z(%s)z || )rUr@rr)rAr�rEr�r��item�min�maxs        rrz!_GettextCompiler.compile_relationAs���
���|�|�D�!���q�M�
	�D��A�w�$�q�'�!��	�	���L�L��a��)���
�t�|�|�T�2���S��	�	�����	��
	�����B��'�'r0N)
rMrhrirjr�rr�compile_zerorrrr	rr
r0rr�r�8s)��3��#�#�I��I��I��I��I�(r0r�c�,�eZdZdZd�ZeZeZeZeZ	d�Z
y)rpz/Compiles the expression to plain of JavaScript.c��y)NzparseInt(n, 10)r
rZs rr\z_JavaScriptCompiler.<lambda>Zr�r0c�z�tj||||�}|dk(r|j|�}d|�d|�d|�d�}|S)Nr�z
(parseInt(z	, 10) == rr)r�rrU)rAr�rEr�r�s     rrz$_JavaScriptCompiler.compile_relation`sA���0�0��&�$�
�,���T�>��<�<��%�D�7;�T�4�H�D��r0N)rMrhrirjrr"rrrr	rr
r0rrprpUs%��9�,�I��I��I��I��I�r0rpc�n�eZdZdZed�Zed�Zed�Zed�Zed�Z	d�Z
d
d�Zy	)rTz+Returns a unicode pluralization rule again.z%s is %sz%s is not %sz	%s and %sz%s or %sz	%s mod %sc�,�|j|dddi�S)Nr�r�T)r)rAr�s  rrz_UnicodeCompiler.compile_notvs��$�t�$�$�H�Q�K�@�T�@�@r0c
�>�g}|dD]b}|d|dk(r$|j|j|d���2|jdtt|j|��z��d|j|��|xrdxsd�d|�ddj	|���S)Nr�rz%s..%sz notrrIr�)r@rUrrr)rAr�rEr�r��rangesrs       rrz!_UnicodeCompiler.compile_relationys������q�M�	I�D��A�w�$�q�'�!��
�
�d�l�l�4��7�3�4��
�
�h��s�4�<�<��/F�)G�G�H�		I�
�L�L���� 2�F� 8�b� 8��C�H�H�V�$�
�	
r0N)F)rMrhrirjr�rrr
rrrrr
r0rrTrTisD��5�"�*�-�J�$�^�4�M�"�;�/�K�!�*�-�J�"�;�/�K�A�

r0rTr
)$rjr�rer;rqr/r2rurfr�r}r~r�	Exceptionr�r�rU�UNICODErr�r�r�r�r�r�r�r�r>r�r�r"r�r�r�rprTr
r0r�<module>r-sj����	�>���
�8"�vZ�Z�z�.%!�P�.B�(I�(�.)�	�)�		��
�:�2�:�:�f�b�j�j�)�*��Z�R�Z�Z�=�b�g�g�e�n�=M�T�R�
S�T��j�b�j�j�� �!�
�z�r�z�z�+�&�'������-�r�z�z�:�;�
���&2�
�
��$��x8�x8�vH�
2�
��$�$�:
3�i�
3� (�y�(�:�*��(
�y�
r0

Zerion Mini Shell 1.0