3

X'ícQVã@s
dZd
dl
Z
d
dlZdNZdZd	d
„ZGdd„dƒZd
d„Zdd„Zdd„Z	dd„Z
dd„Zdd„ZGdd„de
ƒZdddddd d!d"hZdejd#ejƒfd$ejd%d&jeƒ
›d'ƒ
fd(ejd)ƒ
fd*ejd+ƒ
fd,ejd-ejƒfgZd.d/„ZdOd0d1„
ZdPd2d3„
Zd4d5„Zd6d7„Zd8d9„Zd:d;„ZGd<d=„d=ƒZd>d?„Zd@dA„ZdBdC„ZGdDdE„dEƒZGdFdG„dGeƒZ GdHdI„dIeƒZ!GdJdK„dKe!ƒZ"GdLdM„dMeƒZ#dS)Qz°
    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Úotherc
CsÞt|ƒ
}
t
|
ƒ
}t|
tƒr6||
kr(|}
ntjt|
ƒ
ƒ
}
t|
tjƒr²|
jƒ}|j}|d
krf|j	|d…nf}dj
dd„|Dƒ
ƒ
}|jdƒ
}t|ƒ
}t|ƒ
}	t
|p d
ƒ
}
t
|p¬d
ƒ
}nd
}}	}
}d
}}
|
|||	|
|||
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]
    r
NÚc
ss|]}
t|
ƒ
V
qdS)
N)
Ústr)Ú.0Ú
d©rú-/tmp/pip-build-gk9425m9/babel/babel/plural.pyú	<genexpr>Asz#extract_operands.<locals>.<genexpr>Ú
0)
ÚabsÚintÚ
isinstanceÚfloatÚdecimalÚDecimalr	Úas_tupleÚexponentÚdigitsÚjoinÚrstripÚlen)ÚsourceÚ
nÚ
iZ	dec_tupleÚexpZfraction_digitsZtrailingZno_trailingÚ
vÚ
wÚ
fÚ
tÚ
cÚ
errr
Úextract_operandss&
















r&c@sdeZ
dZd
ZdZdd„Zdd„Zedd	„ƒ
Ze	d
d„ƒ
Z
e	dd
„ddZdd„Zdd„Z
dd„ZdS)Ú
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Ú_funccCsŽt|
t
ƒr|
jƒ}
tƒ}g|_xjtt|
ƒ
ƒ
D]Z\}}|tkrJtd
|ƒ
‚
n||kr^td|ƒ
‚
|j	|ƒ

t
|ƒ
j}|r,|jj||fƒ

q,WdS)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Úsetr(ÚsortedÚlistÚ_plural_tagsÚ
ValueErrorÚaddÚ_ParserÚastÚappend)ÚselfÚrulesÚfoundÚkeyÚexprr3rrr
Ú__init__ds














zPluralRule.__init__c

s,|j‰d
t
|ƒ
jdj‡f
dd„tDƒ
ƒ
fS)Nz<%s %r>z, c
s$g|]}
|
ˆkrd|
ˆ|
f‘qS)
z%s: %sr)r
Útag)
r6rr
ú
<listcomp>~s
z'PluralRule.__repr__.<locals>.<listcomp>)r6ÚtypeÚ__name__rr/)
r5r)
r6r
Ú__repr__zs



zPluralRule.__repr__cCst|
|ƒ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)Úclsr6rrr
Úparse‚s


zPluralRule.parsec

stƒj
‰‡f
d
d„|jDƒ
S)zŸThe `PluralRule` as a dict of unicode plural rules.

        >>> rule = PluralRule({'one': 'n is 1'})
        >>> rule.rules
        {'one': 'n is 1'}
        c
si|]\}
}ˆ|ƒ
|
“qSrr)r
r;r3)
Ú_compilerr
ú
<dictcomp>—sz$PluralRule.rules.<locals>.<dictcomp>)Ú_UnicodeCompilerÚcompiler()
r5r)
rBr
r6Žs
zPluralRule.rulesc

Cstd
d„|j
Dƒ
ƒ
S)Nc
ss|]}
|
dV
qd
S)r
Nr)r
rrrr
r™sz&PluralRule.<lambda>.<locals>.<genexpr>)Ú	frozensetr()
Ú
xrrr
Ú<lambda>™szPluralRule.<lambda>z°
        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


Cs|jS)
N)
r()
r5rrr
Ú__getstate__žs
zPluralRule.__getstate__cCs
|
|_dS)
N)
r()r5r(rrr
Ú__setstate__¡s
zPluralRule.__setstate__cCst|d
ƒst
|ƒ
|_|j|
ƒ
S)Nr))ÚhasattrÚ	to_pythonr))r5rrrr
Ú__call__¤s




zPluralRule.__call__N)r(r))r>Ú
__module__Ú__qualname__Ú__doc__Ú	__slots__r:r?ÚclassmethodrAÚpropertyr6ÚtagsrJrKrNrrrr
r'Msr'c
CsVtƒj
}
d
g
}x.tj|ƒ
jD]\}}|jd|
|ƒ
|fƒ

qW|jdtƒ

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
%s ? %r : z%r; })r)Ú_JavaScriptCompilerrEr'rAr(r4Ú
_fallback_tagr)ÚruleZto_jsÚresultr;r3rrr
Ú
to_javascriptªs




rZc
Cs„tt
ttd
œ}
tƒj}ddg}x2tj|ƒ
jD]"\}}|j	d||ƒ
t
|ƒ
fƒ

q,W|j	dtƒ

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
    )ÚINZWITHINZMODr&zdef evaluate(n):z- n, i, v, w, f, t, c, e = extract_operands(n)z if (%s): return %rz
 return %rÚ

z<rule>ÚexecÚevaluate)Ú
in_range_listÚwithin_range_listÚcldr_modulor&Ú_PythonCompilerrEr'rAr(r4r	rWrÚeval)rXÚ	namespaceZto_python_funcrYr;r3Úcoderrr
rMÁs








rMc
sŠtj
|ƒ
}|jth
B‰tƒj}
‡f
d
d„tDƒ
j}dtˆƒ
g
}x,|j	D]"\}}|j
d|
|ƒ
||ƒ
fƒ

qHW|j
d|tƒ
ƒ

dj|ƒ
S)a
The 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
    c
sg|]}
|
ˆkr|
‘qSrr)r
r;)
Ú	used_tagsrr
r<÷szto_gettext.<locals>.<listcomp>znplurals=%d; plural=(z
%s ? %d : z%d);r)r'rArUrWÚ_GettextCompilerrEr/Úindexrr(r4r)rXrBZ
_get_indexrYr;r3r)
rfr
Ú
to_gettextés







ricCs|t|ƒ
kot
||
ƒ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_listrrr
r_
sr_cst‡f
d
d„|
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
    c
3s"|]\}
}ˆ|
koˆ|k
V
qdS)
Nr)r
Zmin_Zmax_)
rjrr
r%
sz$within_range_list.<locals>.<genexpr>)
Úany)rjrkr)
rjr
r`
sr`cCs@d
}|d
kr|d9}d}|
d
kr(|
d9}
||
}|r<|d9}|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
é
éÿÿÿÿrnrnr)Ú
aÚ
bÚreverseÚrvrrr
ra(
s








rac
@seZ
dZd
ZdS)Ú	RuleErrorzRaised if a rule is malformed.N)r>rOrPrQrrrr
rs?
s
rsrrr 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
Cs|jd
ƒ
d}g}
d}t
|ƒ
}xb||kr€xTtD]<\}}|j||ƒ}|dk	r.|jƒ}|rh|
j||jƒfƒ

Pq.Wtd||ƒ
‚
q W|
ddd…S)Nú
@r
z5malformed CLDR pluralization rule.  Got unexpected %rrmrn)ÚsplitrÚ_RULESÚmatchÚendr4Úgrouprs)Ú
srYÚposr|ÚtokrXr{rrr
Ú
tokenize_ruleV
s














rcCs,|o*|dd|
ko*|dkp*|dd
|kS)Nrmr
rnrnr)ÚtokensÚtype_rurrr
Útest_next_tokeni
s

r„cCst||
|ƒr|j
ƒSdS)
N)r„Úpop)r‚rƒrurrr
Ú
skip_tokenn
s

r†c

Cs
d
|f
fS)Nrur)
rurrr
Ú
value_nodes
s
r‡c

Cs|ffS)
Nr)
Únamerrr
Ú
ident_nodew
s
r‰c

Csd
|fS)Nrkr)
rkrrr
Úrange_list_node{
s
rŠc

Cs
d
|f
fS)NÚnotr)
rrrrr
Únegate
s
rŒc@sbeZ
dZd
Zdd„Zddd„
Zdd„Zd	d
„Zdd„Zd
d„Z	dd„Z
dd„Zdd„Zdd„Z
dS)r2uò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`.
    cCsDt|
ƒ
|_
|j
sd|_dS|jƒ|_|j
r@td
|j
ddƒ
‚
dS)NzExpected end of rule, got %rrmrn)rr‚r3Ú	conditionrs)r5Ústringrrr
r:¥
s








z_Parser.__init__NcCsft|j
|
|ƒ}|dk	r|S|dkr6t|dkr0|
p2|ƒ
}|j
sHtd
|ƒ
‚
td||j
ddfƒ
‚
dS)Nz#expected %s but end of rule reachedzexpected %s but got %rrmrn)r†r‚Úreprrs)r5rƒruZtermÚtokenrrr
Úexpect±
s







z_Parser.expectc
Cs0|jƒ}
x"t
|jd
dƒr*d|
|jƒff}
q
W|
S)NrtÚor)Ú
and_conditionr†r‚)r5Úoprrr
r»
s



z_Parser.conditionc
Cs0|jƒ}
x"t
|jd
dƒr*d|
|jƒff}
q
W|
S)NrtÚand)Úrelationr†r‚)r5r”rrr
r“Á
s



z_Parser.and_conditionc
Cs¤|jƒ}
t
|jd
dƒr8t
|jd
dƒr(dp*d|
|jƒffSt
|jd
dƒ}d}t
|jd
dƒr^d}n$t
|jd
dƒs‚|rxtdƒ
‚
|j|
ƒ
Sd||
|jƒff}|r t|ƒ
S|S)	NrtÚisr‹ZisnotÚinZwithinz#Cannot negate operator based rules.r–)r9r†r‚rursÚnewfangled_relationrkrŒ)r5ÚleftÚnegatedÚmethodrrrrr
r–Ç
s













z_Parser.relationcCsRt|j
d
dƒrd}nt|j
d
dƒr(d}ntdƒ
‚
dd|
|jƒff}|rNt|ƒ
S|S)	Nrvú
=Fz!=Tz'Expected "=" or "!=" or legacy relationr–r˜)r†r‚rsrkrŒ)r5ršr›rrrrr
r™Ø
s





z_Parser.newfangled_relationc
Cs,|jƒ}
t
|jd
ƒr |
|jƒfS|
|
fSdS)Nrw)rur†r‚)r5ršrrr
Úrange_or_valueâ
s


z_Parser.range_or_valuec
Cs4|jƒg
}
x t
|jd
dƒr*|
j|jƒƒ

qWt|
ƒ
S)Nrvú
,)ržr†r‚r4rŠ)r5rkrrr
rké
s




z_Parser.range_listc
Cs|t|j
d
ƒ}
|
dks |
dtkr(tdƒ
‚
|
d}t|j
d
dƒrRd|ff|jƒffSt|j
ddƒrtd|ff|jƒffSt|ƒ
S)NrtrmzExpected identifier variableÚmodrvú
%)r†r‚Ú_VARSrsrur‰)r5rtrˆrrr
r9ï
s








z_Parser.exprc

Cstt
|jd
ƒ
dƒ
ƒ
S)Nrurm)r‡rr‘)
r5rrr
ruú
s
z
_Parser.value)NN)r>rOrPrQr:r‘rr“r–r™ržrkr9rurrrr
r2ƒ
s 


r2c

s‡f
d
d„S)z%Compiler factory for the `_Compiler`.csˆ|j|
ƒ
|j|ƒ
fS)
N)
rE)r5Ú
lÚ
r)
Útmplrr
rHsz"_binary_compiler.<locals>.<lambda>r)
r¥r)
r¥r
Ú_binary_compilerþ
sr¦c

s‡f
d
d„S)z%Compiler factory for the `_Compiler`.csˆ|j|
ƒ
S)
N)
rE)r5rG)
r¥rr
rHsz!_unary_compiler.<locals>.<lambda>r)
r¥r)
r¥r
Ú_unary_compilersr§c


Csd
S)Nrr)
rGrrr
rHsrHc@s˜eZ
dZd
Zdd„Zdd„Zdd„Zdd„Zdd„Zd	d„Z	d
d„Z
dd„Zdd„Zd
d„Z
edƒ
Zedƒ
Zedƒ
Zedƒ
Zedƒ
Zedƒ
Zdd„ZdS)Ú	_CompilerzZThe compilers are able to transform the expressions into multiple
    output formats.
    cCs|
\}}t|d
|ƒ|ŽS)NZcompile_)
Úgetattr)r5Úargr”Úargsrrr
rEs

z_Compiler.compilec


Csd
S)Nrr)
rGrrr
rHsz_Compiler.<lambda>c


Csd
S)Nrr)
rGrrr
rHsc


Csd
S)Nr r)
rGrrr
rHsc


Csd
S)Nr!r)
rGrrr
rHsc


Csd
S)Nr"r)
rGrrr
rHsc


Csd
S)Nr#r)
rGrrr
rHsc


Csd
S)Nr$r)
rGrrr
rHsc


Csd
S)Nr%r)
rGrrr
rHscCst|
ƒ
S)
N)
r	)rGr rrr
rHsz
(%s && %s)z
(%s || %s)z(!%s)z
(%s %% %s)z
(%s == %s)z
(%s != %s)c
Cs
tƒ‚
dS)
N)
ÚNotImplementedError)r5rœr9rkrrr
Úcompile_relation$s
z_Compiler.compile_relationN)r>rOrPrQrEÚ	compile_nÚ	compile_iÚ	compile_vÚ	compile_wÚ	compile_fÚ	compile_tZ	compile_cZ	compile_eZ
compile_valuer¦Úcompile_andÚ
compile_orr§Úcompile_notÚcompile_modÚ
compile_isÚ
compile_isnotr­rrrr
r¨s$













r¨c@s8eZ
dZd
Zedƒ
Zedƒ
Zedƒ
Zedƒ
Z	dd„Z
dS)	rbz!Compiles an expression to Python.z(%s and %s)z
(%s or %s)z(not %s)zMOD(%s, %s)cs8d
dj‡f
dd„|dDƒ
ƒ
}d|
j
ƒˆj|ƒ
|fS)Nz[%s]rŸc
s g|]}
dtt
ˆj|
ƒƒ
‘qS)
z(%s, %s))ÚtupleÚmaprE)r
Zrange_)
r5rr
r<2s
z4_PythonCompiler.compile_relation.<locals>.<listcomp>rmz
%s(%s, %s))rÚupperrE)r5rœr9rkZcompile_range_listr)
r5r
r­0s






z _PythonCompiler.compile_relationN)r>rOrPrQr¦r´rµr§r¶r·r­rrrr
rb(s



rbc@s.eZ
dZd
ZejZeZeZ	eZ
eZdd„ZdS)rgz)Compile into a gettext plural expression.cCs‚g}|j|ƒ
}xd|d
D]X}|d|d
krJ|j
d||j|dƒ
fƒ

qt|j|ƒ\}}|j
d||||fƒ

qWddj|ƒ
S)Nrmr
z
(%s == %s)z(%s >= %s && %s <= %s)z(%s)z || )rEr4r»r)r5rœr9rkrrÚitemÚminÚmaxrrr
r­As












z!_GettextCompiler.compile_relationN)
r>rOrPrQr¨r®r¯Úcompile_zeror°r±r²r³r­rrrr
rg8s




rgc@s0eZ
dZd
Zdd„ZeZeZeZeZ	dd„Z
dS)rVz/Compiles the expression to plain of JavaScript.c


Csd
S)NzparseInt(n, 10)r)
rGrrr
rHZsz_JavaScriptCompiler.<lambda>cCs4tj
||
||ƒ}|
d
kr0|j|ƒ
}d|||f}|S)Nr˜z(parseInt(%s, 10) == %s && %s))rgr­rE)r5rœr9rkrerrr
r­`s






z$_JavaScriptCompiler.compile_relationN)r>rOrPrQr¯rÀr°r±r²r³r­rrrr
rVUs




rVc@sJeZ
dZd
Zedƒ
Zedƒ
Zedƒ
Zedƒ
Zedƒ
Z	dd„Z
d
d
d„
ZdS)rDz+Returns a unicode pluralization rule again.z%s is %sz%s is not %sz	%s and %sz%s or %sz	%s mod %scCs|j|
d
ddi
Ž
S)Nrmr›T)
r­)r5r–rrr
r¶vs
z_UnicodeCompiler.compile_notFcCszg}xP|d
D]D}|d|d
kr8|j|j
|dƒ
ƒ

q|jdtt|j
|ƒƒ
ƒ

qWd|j
|ƒ
|rhdpjd|
dj|ƒ
fS)Nrmr
z%s..%sz
%s%s %s %sz notrrŸ)r4rErºr»r)r5rœr9rkr›Úrangesr½rrr
r­ys






z!_UnicodeCompiler.compile_relationN)
F)r>rOrPrQr¦r¸r¹r´rµr·r¶r­rrrr
rDis




rD)rrrrrr)
N)
N)$rQrÚrer/rWr&r'rZrMrir_r`raÚ	Exceptionrsr¢rEÚUNICODErrzrr„r†r‡r‰rŠrŒr2r¦r§rÀr¨rbrgrVrDrrrr
Ú<module>	sT


;](












{