Files
Home-AssistantConfig/deps/sqlalchemy/sql/__pycache__/operators.cpython-34.pyc

461 lines
28 KiB
Plaintext
Raw Normal View History

2016-10-11 16:42:06 +00:00
<EFBFBD>
|<7C><>W<EFBFBD>Y<00> @s<>dZddlmZddlmZmZmZmZmZm Z m
Z
m Z m Z m Z mZmZmZmZmZmZmZmZmZejr<>ddlmZne ZGdd<00>de<00>ZGdd <00>d e<00>ZGd
d <00>d e<00>Zd d <00>Zdd<00>Zdd<00>Zdd<00>Z dd<00>Z!dd<00>Z"dd<00>Z#dd<00>Z$dd<00>Z%ddd <00>Z&dd!d"<00>Z'dd#d$<00>Z(dd%d&<00>Z)d'd(d)<00>Z*d'd*d+<00>Z+d,d-<00>Z,d.d/<00>Z-d0d1<00>Z.dd2d3<00>Z/dd4d5<00>Z0dd6d7<00>Z1dd8d9<00>Z2dd:d;<00>Z3dd<d=<00>Z4d>d?<00>Z5d@dA<00>Z6dBdC<00>Z7dDdE<00>Z8dFdG<00>Z9dHdI<00>Z:dJdK<00>Z;dLdM<00>Z<e=eeeeg<00>Z>e=eee eee e*e&g<00>Z?dNdO<00>Z@dPdQ<00>ZAdRdS<00>ZBe>jCe8eeg<00>ZDeDjCeg<00>ZEejFdTdUdV <0B>ZGejFdWdUdX <0B>ZHejFdYdUdX<00>ZIi+dZe6dZe6d[e6d[e 6d[e6d[e
6d[e6d\e6d\e 6d]e86d]e56d]e66d]e(6d]e)6d]e&6d]e'6d]e,6d]e-6d]e"6d]e#6d^e6d^e6d^e6d^e 6d^e6d^e 6d^e*6d^e+6d^e.6d^e6d^e 6d^e!6d_e6de6d` e76d_e96d_e:6dae$6d` e6de6dV eG6eHeH6eIeI6ZJdbdc<00>ZKdS)dz*Defines operators used in SQL expressions.<2E>)<01>util<69>)<13>and_<64>or_<72>inv<6E>add<64>mul<75>sub<75>mod<6F>truediv<69>lt<6C>le<6C>ne<6E>gt<67>ge<67>eq<65>neg<65>getitem<65>lshift<66>rshift<66>contains)<01>divc@sjeZdZdZfZdd<00>Zdd<00>Zdd<00>Zdd d
d <00>Zd d <00>Z dd<00>Z
dS)<11> Operatorsa<73>Base of comparison and logical operators.
Implements base methods
:meth:`~sqlalchemy.sql.operators.Operators.operate` and
:meth:`~sqlalchemy.sql.operators.Operators.reverse_operate`, as well as
:meth:`~sqlalchemy.sql.operators.Operators.__and__`,
:meth:`~sqlalchemy.sql.operators.Operators.__or__`,
:meth:`~sqlalchemy.sql.operators.Operators.__invert__`.
Usually is used via its most common subclass
:class:`.ColumnOperators`.
cCs|jt|<00>S)a.Implement the ``&`` operator.
When used with SQL expressions, results in an
AND operation, equivalent to
:func:`~.expression.and_`, that is::
a & b
is equivalent to::
from sqlalchemy import and_
and_(a, b)
Care should be taken when using ``&`` regarding
operator precedence; the ``&`` operator has the highest precedence.
The operands should be enclosed in parenthesis if they contain
further sub expressions::
(a == 2) & (b == 4)
)<02>operater)<02>self<6C>other<65>r<00>>/tmp/pip-build-zkr322cu/sqlalchemy/sqlalchemy/sql/operators.py<70>__and__+szOperators.__and__cCs|jt|<00>S)a*Implement the ``|`` operator.
When used with SQL expressions, results in an
OR operation, equivalent to
:func:`~.expression.or_`, that is::
a | b
is equivalent to::
from sqlalchemy import or_
or_(a, b)
Care should be taken when using ``|`` regarding
operator precedence; the ``|`` operator has the highest precedence.
The operands should be enclosed in parenthesis if they contain
further sub expressions::
(a == 2) | (b == 4)
)rr)rrrrr<00>__or__CszOperators.__or__cCs |jt<00>S)aImplement the ``~`` operator.
When used with SQL expressions, results in a
NOT operation, equivalent to
:func:`~.expression.not_`, that is::
~a
is equivalent to::
from sqlalchemy import not_
not_(a)
)rr)rrrr<00>
__invert__[szOperators.__invert__rFcs+t|||<00><00><00><00>fdd<00>}|S)ahproduce a generic operator function.
e.g.::
somecolumn.op("*")(5)
produces::
somecolumn * 5
This function can also be used to make bitwise operators explicit. For
example::
somecolumn.op('&')(0xff)
is a bitwise AND of the value in ``somecolumn``.
:param operator: a string which will be output as the infix operator
between this element and the expression passed to the
generated function.
:param precedence: precedence to apply to the operator, when
parenthesizing expressions. A lower number will cause the expression
to be parenthesized when applied against another operator with
higher precedence. The default value of ``0`` is lower than all
operators except for the comma (``,``) and ``AS`` operators.
A value of 100 will be higher or equal to all operators, and -100
will be lower than or equal to all operators.
.. versionadded:: 0.8 - added the 'precedence' argument.
:param is_comparison: if True, the operator will be considered as a
"comparison" operator, that is which evaluates to a boolean
true/false value, like ``==``, ``>``, etc. This flag should be set
so that ORM relationships can establish that the operator is a
comparison operator when used in a custom join condition.
.. versionadded:: 0.9.2 - added the
:paramref:`.Operators.op.is_comparison` flag.
.. seealso::
:ref:`types_operators`
:ref:`relationship_custom_operator`
cs <00><00>|<00>S)Nr)r)<02>operatorrrr<00>against<73>szOperators.op.<locals>.against)<01> custom_op)r<00>opstring<6E>
precedence<EFBFBD> is_comparisonr"r)r!rr<00>opls0z Operators.opcOstt|<00><00><00>dS)a3Operate on an argument.
This is the lowest level of operation, raises
:class:`NotImplementedError` by default.
Overriding this on a subclass can allow common
behavior to be applied to all operations.
For example, overriding :class:`.ColumnOperators`
to apply ``func.lower()`` to the left and right
side::
class MyComparator(ColumnOperators):
def operate(self, op, other):
return op(func.lower(self), func.lower(other))
:param op: Operator callable.
:param \*other: the 'other' side of the operation. Will
be a single scalar for most operations.
:param \**kwargs: modifiers. These may be passed by special
operators such as :meth:`ColumnOperators.contains`.
N)<02>NotImplementedError<6F>str)rr'r<00>kwargsrrrr<00>szOperators.operatecKstt|<00><00><00>dS)zXReverse operate on an argument.
Usage is the same as :meth:`operate`.
N)r(r))rr'rr*rrr<00>reverse_operate<74>szOperators.reverse_operateN) <0B>__name__<5F>
__module__<EFBFBD> __qualname__<5F>__doc__<5F> __slots__rrr r'rr+rrrrrs    6 rc@sReZdZdZdZdddd<00>Zdd<00>Zdd <00>Zd
d <00>Zd S) r#aURepresent a 'custom' operator.
:class:`.custom_op` is normally instantitated when the
:meth:`.ColumnOperators.op` method is used to create a
custom operator callable. The class can also be used directly
when programmatically constructing expressions. E.g.
to represent the "factorial" operation::
from sqlalchemy.sql import UnaryExpression
from sqlalchemy.sql import operators
from sqlalchemy import Numeric
unary = UnaryExpression(table.c.somecolumn,
modifier=operators.custom_op("!"),
type_=Numeric)
rFcCs||_||_||_dS)N)r$r%r&)rr$r%r&rrr<00>__init__<5F>s  zcustom_op.__init__cCst|t<00>o|j|jkS)N)<03>
isinstancer#r$)rrrrr<00>__eq__<5F>szcustom_op.__eq__cCs
t|<00>S)N)<01>id)rrrr<00>__hash__<5F>szcustom_op.__hash__cKs|j|||<00>S)N)r)r<00>left<66>right<68>kwrrr<00>__call__<5F>szcustom_op.__call__N)r,r-r.r/r1r3r5r9rrrrr#<00>s   r#c@s>eZdZdZfZdZdd<00>Zdd<00>Zej Z dd<00>Z
d d
<00>Z d d <00>Z d d<00>Z dd<00>Zdd<00>Zdd<00>Zdd<00>Zdd<00>Zdd<00>Zddd<00>Zddd<00>Zdd <00>Zd!d"<00>Zdd#d$<00>Zdd%d&<00>Zd'd(<00>Zd)d*<00>Zd+d,<00>Zd-d.<00>Zd/d0<00>Zd1d2<00>Zd3d4<00>Z d5d6<00>Z!d7d8<00>Z"d9d:<00>Z#d;d<<00>Z$d=d><00>Z%d?d@<00>Z&dAdB<00>Z'dCdD<00>Z(dEdF<00>Z)dGdHdI<00>Z*dJdK<00>Z+dLdM<00>Z,dNdO<00>Z-dPdQ<00>Z.dRdS<00>Z/dTdU<00>Z0dVdW<00>Z1dXdY<00>Z2dS)Z<>ColumnOperatorsa<73>Defines boolean, comparison, and other operators for
:class:`.ColumnElement` expressions.
By default, all methods call down to
:meth:`.operate` or :meth:`.reverse_operate`,
passing in the appropriate operator function from the
Python builtin ``operator`` module or
a SQLAlchemy-specific operator function from
:mod:`sqlalchemy.expression.operators`. For example
the ``__eq__`` function::
def __eq__(self, other):
return self.operate(operators.eq, other)
Where ``operators.eq`` is essentially::
def eq(a, b):
return a == b
The core column expression unit :class:`.ColumnElement`
overrides :meth:`.Operators.operate` and others
to return further :class:`.ColumnElement` constructs,
so that the ``==`` operation above is replaced by a clause
construct.
See also:
:ref:`types_operators`
:attr:`.TypeEngine.comparator_factory`
:class:`.ColumnOperators`
:class:`.PropComparator`
NcCs|jt|<00>S)zdImplement the ``<`` operator.
In a column context, produces the clause ``a < b``.
)rr )rrrrr<00>__lt__szColumnOperators.__lt__cCs|jt|<00>S)zfImplement the ``<=`` operator.
In a column context, produces the clause ``a <= b``.
)rr )rrrrr<00>__le__szColumnOperators.__le__cCs|jt|<00>S)z<>Implement the ``==`` operator.
In a column context, produces the clause ``a = b``.
If the target is ``None``, produces ``a IS NULL``.
)rr)rrrrrr3&szColumnOperators.__eq__cCs|jt|<00>S)z<>Implement the ``!=`` operator.
In a column context, produces the clause ``a != b``.
If the target is ``None``, produces ``a IS NOT NULL``.
)rr)rrrrr<00>__ne__/szColumnOperators.__ne__cCs|jt|<00>S)zdImplement the ``>`` operator.
In a column context, produces the clause ``a > b``.
)rr)rrrrr<00>__gt__8szColumnOperators.__gt__cCs|jt|<00>S)zfImplement the ``>=`` operator.
In a column context, produces the clause ``a >= b``.
)rr)rrrrr<00>__ge__@szColumnOperators.__ge__cCs |jt<00>S)zaImplement the ``-`` operator.
In a column context, produces the clause ``-a``.
)rr)rrrr<00>__neg__HszColumnOperators.__neg__cCs|jt|<00>S)N)rr)rrrrr<00> __contains__PszColumnOperators.__contains__cCs|jt|<00>S)z<>Implement the [] operator.
This can be used by some database-specific types
such as Postgresql ARRAY and HSTORE.
)rr)r<00>indexrrr<00> __getitem__SszColumnOperators.__getitem__cCs|jt|<00>S)z<>implement the << operator.
Not used by SQLAlchemy core, this is provided
for custom operator systems which want to use
<< as an extension point.
)rr)rrrrr<00>
__lshift__\szColumnOperators.__lshift__cCs|jt|<00>S)z<>implement the >> operator.
Not used by SQLAlchemy core, this is provided
for custom operator systems which want to use
>> as an extension point.
)rr)rrrrr<00>
__rshift__eszColumnOperators.__rshift__cCs|jt|<00>S)z<>Implement the 'concat' operator.
In a column context, produces the clause ``a || b``,
or uses the ``concat()`` operator on MySQL.
)r<00> concat_op)rrrrr<00>concatnszColumnOperators.concatcCs|jt|d|<00>S)a<>Implement the ``like`` operator.
In a column context, produces the clause ``a LIKE other``.
E.g.::
select([sometable]).where(sometable.c.column.like("%foobar%"))
:param other: expression to be compared
:param escape: optional escape character, renders the ``ESCAPE``
keyword, e.g.::
somecolumn.like("foo/%bar", escape="/")
.. seealso::
:meth:`.ColumnOperators.ilike`
<20>escape)r<00>like_op)rrrHrrr<00>likewszColumnOperators.likecCs|jt|d|<00>S)a<>Implement the ``ilike`` operator.
In a column context, produces the clause ``a ILIKE other``.
E.g.::
select([sometable]).where(sometable.c.column.ilike("%foobar%"))
:param other: expression to be compared
:param escape: optional escape character, renders the ``ESCAPE``
keyword, e.g.::
somecolumn.ilike("foo/%bar", escape="/")
.. seealso::
:meth:`.ColumnOperators.like`
rH)r<00>ilike_op)rrrHrrr<00>ilike<6B>szColumnOperators.ilikecCs|jt|<00>S)z<>Implement the ``in`` operator.
In a column context, produces the clause ``a IN other``.
"other" may be a tuple/list of column expressions,
or a :func:`~.expression.select` construct.
)r<00>in_op)rrrrr<00>in_<6E>szColumnOperators.in_cCs|jt|<00>S)z<>implement the ``NOT IN`` operator.
This is equivalent to using negation with
:meth:`.ColumnOperators.in_`, i.e. ``~x.in_(y)``.
.. versionadded:: 0.8
.. seealso::
:meth:`.ColumnOperators.in_`
)r<00>notin_op)rrrrr<00>notin_<6E>s zColumnOperators.notin_cCs|jt|d|<00>S)z<>implement the ``NOT LIKE`` operator.
This is equivalent to using negation with
:meth:`.ColumnOperators.like`, i.e. ``~x.like(y)``.
.. versionadded:: 0.8
.. seealso::
:meth:`.ColumnOperators.like`
rH)r<00>
notlike_op)rrrHrrr<00>notlike<6B>s zColumnOperators.notlikecCs|jt|d|<00>S)aimplement the ``NOT ILIKE`` operator.
This is equivalent to using negation with
:meth:`.ColumnOperators.ilike`, i.e. ``~x.ilike(y)``.
.. versionadded:: 0.8
.. seealso::
:meth:`.ColumnOperators.ilike`
rH)r<00> notilike_op)rrrHrrr<00>notilike<6B>s zColumnOperators.notilikecCs|jt|<00>S)awImplement the ``IS`` operator.
Normally, ``IS`` is generated automatically when comparing to a
value of ``None``, which resolves to ``NULL``. However, explicit
usage of ``IS`` may be desirable if comparing to boolean values
on certain platforms.
.. versionadded:: 0.7.9
.. seealso:: :meth:`.ColumnOperators.isnot`
)r<00>is_)rrrrrrU<00>s zColumnOperators.is_cCs|jt|<00>S)a<>Implement the ``IS NOT`` operator.
Normally, ``IS NOT`` is generated automatically when comparing to a
value of ``None``, which resolves to ``NULL``. However, explicit
usage of ``IS NOT`` may be desirable if comparing to boolean values
on certain platforms.
.. versionadded:: 0.7.9
.. seealso:: :meth:`.ColumnOperators.is_`
)r<00>isnot)rrrrrrV<00>s zColumnOperators.isnotcKs|jt||<00>S)zuImplement the ``startwith`` operator.
In a column context, produces the clause ``LIKE '<other>%'``
)r<00> startswith_op)rrr*rrr<00>
startswith<EFBFBD>szColumnOperators.startswithcKs|jt||<00>S)zrImplement the 'endswith' operator.
In a column context, produces the clause ``LIKE '%<other>'``
)r<00> endswith_op)rrr*rrr<00>endswithszColumnOperators.endswithcKs|jt||<00>S)zsImplement the 'contains' operator.
In a column context, produces the clause ``LIKE '%<other>%'``
)r<00> contains_op)rrr*rrrrszColumnOperators.containscKs|jt||<00>S)aYImplements a database-specific 'match' operator.
:meth:`~.ColumnOperators.match` attempts to resolve to
a MATCH-like function or operator provided by the backend.
Examples include:
* Postgresql - renders ``x @@ to_tsquery(y)``
* MySQL - renders ``MATCH (x) AGAINST (y IN BOOLEAN MODE)``
* Oracle - renders ``CONTAINS(x, y)``
* other backends may provide special implementations.
* Backends without any special implementation will emit
the operator as "MATCH". This is compatible with SQlite, for
example.
)r<00>match_op)rrr*rrr<00>matchszColumnOperators.matchcCs |jt<00>S)zMProduce a :func:`~.expression.desc` clause against the
parent object.)r<00>desc_op)rrrr<00>desc"szColumnOperators.desccCs |jt<00>S)zLProduce a :func:`~.expression.asc` clause against the
parent object.)r<00>asc_op)rrrr<00>asc'szColumnOperators.asccCs |jt<00>S)zSProduce a :func:`~.expression.nullsfirst` clause against the
parent object.)r<00> nullsfirst_op)rrrr<00>
nullsfirst,szColumnOperators.nullsfirstcCs |jt<00>S)zRProduce a :func:`~.expression.nullslast` clause against the
parent object.)r<00> nullslast_op)rrrr<00> nullslast1szColumnOperators.nullslastcCs|jt|<00>S)zlProduce a :func:`~.expression.collate` clause against
the parent object, given the collation string.)r<00>collate)rZ collationrrrrf6szColumnOperators.collatecCs|jt|<00>S)zaImplement the ``+`` operator in reverse.
See :meth:`.ColumnOperators.__add__`.
)r+r)rrrrr<00>__radd__;szColumnOperators.__radd__cCs|jt|<00>S)zaImplement the ``-`` operator in reverse.
See :meth:`.ColumnOperators.__sub__`.
)r+r )rrrrr<00>__rsub__CszColumnOperators.__rsub__cCs|jt|<00>S)zaImplement the ``*`` operator in reverse.
See :meth:`.ColumnOperators.__mul__`.
)r+r)rrrrr<00>__rmul__KszColumnOperators.__rmul__cCs|jt|<00>S)zaImplement the ``/`` operator in reverse.
See :meth:`.ColumnOperators.__div__`.
)r+r)rrrrr<00>__rdiv__SszColumnOperators.__rdiv__cCs|jt|<00>S)zaImplement the ``%`` operator in reverse.
See :meth:`.ColumnOperators.__mod__`.
)r+r
)rrrrr<00>__rmod__[szColumnOperators.__rmod__FcCs|jt||d|<00>S)z{Produce a :func:`~.expression.between` clause against
the parent object, given the lower and upper range.
<20> symmetric)r<00>
between_op)rZcleftZcrightrlrrr<00>betweencszColumnOperators.betweencCs |jt<00>S)z[Produce a :func:`~.expression.distinct` clause against the
parent object.
)r<00> distinct_op)rrrr<00>distinctjszColumnOperators.distinctcCs|jt|<00>S)a4Implement the ``+`` operator.
In a column context, produces the clause ``a + b``
if the parent object has non-string affinity.
If the parent object has a string affinity,
produces the concatenation operator, ``a || b`` -
see :meth:`.ColumnOperators.concat`.
)rr)rrrrr<00>__add__qs
zColumnOperators.__add__cCs|jt|<00>S)zdImplement the ``-`` operator.
In a column context, produces the clause ``a - b``.
)rr )rrrrr<00>__sub__}szColumnOperators.__sub__cCs|jt|<00>S)zdImplement the ``*`` operator.
In a column context, produces the clause ``a * b``.
)rr)rrrrr<00>__mul__<5F>szColumnOperators.__mul__cCs|jt|<00>S)zdImplement the ``/`` operator.
In a column context, produces the clause ``a / b``.
)rr)rrrrr<00>__div__<5F>szColumnOperators.__div__cCs|jt|<00>S)zdImplement the ``%`` operator.
In a column context, produces the clause ``a % b``.
)rr
)rrrrr<00>__mod__<5F>szColumnOperators.__mod__cCs|jt|<00>S)zeImplement the ``//`` operator.
In a column context, produces the clause ``a / b``.
)rr )rrrrr<00> __truediv__<5F>szColumnOperators.__truediv__cCs|jt|<00>S)zfImplement the ``//`` operator in reverse.
See :meth:`.ColumnOperators.__truediv__`.
)r+r )rrrrr<00> __rtruediv__<5F>szColumnOperators.__rtruediv__)3r,r-r.r/r0<00> timetupler;r<rr5r3r=r>r?r@rArCrDrErGrJrLrNrPrRrTrUrVrXrZrr]r_rarcrerfrgrhrirjrkrnrprqrrrsrtrurvrwrrrrr:<00>s^ $        
                      r:cCs t<00><00>dS)N)r(rrrr<00>from_<6D>srycCs t<00><00>dS)N)r(rrrr<00>as_<73>srzcCs t<00><00>dS)N)r(rrrr<00>exists<74>sr{cCs t<00><00>dS)N)r()<01>arrr<00>istrue<75>sr}cCs t<00><00>dS)N)r()r|rrr<00>isfalse<73>sr~cCs |j|<00>S)N)rU)r|<00>brrrrU<00>srUcCs |j|<00>S)N)rV)r|rrrrrV<00>srVcCs |j|<00>S)N)rf)r|rrrrrf<00>srfcCs|j|<00>|<00>S)N)r')r|r$rrrrr'<00>sr'NcCs|j|d|<00>S)NrH)rJ)r|rrHrrrrI<00>srIcCs|j|d|<00>S)NrH)rR)r|rrHrrrrQ<00>srQcCs|j|d|<00>S)NrH)rL)r|rrHrrrrK<00>srKcCs|j|d|<00>S)NrH)rT)r|rrHrrrrS<00>srSFcCs|j||d|<00>S)Nrl)rn)r|r<00>crlrrrrm<00>srmcCs|j||d|<00>S)Nrl)Z
notbetween)r|rr<>rlrrr<00> notbetween_op<6F>sr<>cCs |j|<00>S)N)rN)r|rrrrrM<00>srMcCs |j|<00>S)N)rP)r|rrrrrO<00>srOcCs
|j<00>S)N)rp)r|rrrro<00>srocCs|j|d|<00>S)NrH)rX)r|rrHrrrrW<00>srWcCs|j|d|<00>S)NrH)rX)r|rrHrrr<00>notstartswith_op<6F>sr<>cCs|j|d|<00>S)NrH)rZ)r|rrHrrrrY<00>srYcCs|j|d|<00>S)NrH)rZ)r|rrHrrr<00>notendswith_opsr<>cCs|j|d|<00>S)NrH)r)r|rrHrrrr[sr[cCs|j|d|<00>S)NrH)r)r|rrHrrr<00>notcontains_op
sr<>cKs|j||<00>S)N)r])r|rr8rrrr\sr\cKs|j||<00>S)N)Znotmatch)r|rr8rrr<00> notmatch_opsr<>cCs t<00><00>dS)N)r()r|rrrr<00>comma_opsr<>cCs |j|<00>S)N)rG)r|rrrrrFsrFcCs
|j<00>S)N)r_)r|rrrr^sr^cCs
|j<00>S)N)ra)r|rrrr`"sr`cCs
|j<00>S)N)rc)r|rrrrb&srbcCs
|j<00>S)N)re)r|rrrrd*srdcCs"|tkp!t|t<00>o!|jS)N)<04> _comparisonr2r#r&)r'rrrr&3s r&cCs
|tkS)N)<01> _commutative)r'rrr<00>is_commutative8sr<>cCs|ttttfkS)N)r`r^rbrd)r'rrr<00>is_ordering_modifier<s r<><00>_asbool<6F> canonical<61>
<00> _smallest<73>d<00>_largest<73><00><00><00><00><00><00><00>cCsZ||kr|tkrdStj|t|dt<00><00>tj|t|dt<00><00>kSdS)NFr%)<06>_natural_self_precedent<6E> _PRECEDENCE<43>get<65>getattrr<72>r<>)r!r"rrr<00> is_precedent<6E>s   r<>)Lr/<00>rr!rrrrrr r
r r r rrrrrrrrrZpy2kr<00>objectrr#r:ryrzr{r}r~rUrVrfr'rIrQrKrSrmr<>rMrOrorWr<>rYr<>r[r<>r\r<>r<>rFr^r`rbrd<00>setr<74>r<>r&r<>r<><00>unionZ _associativer<65><00>symbolr<6C>r<>r<>r<>r<>rrrr<00><module> s<>| <16>$<16><00>                    $