U
    ð»ÑgÈo  ã                   @   sö  d Z ddlZzddlmZ W n   ddlmZ Y nX ddlmZ ddlmZm	Z	m
Z
mZ ddlmZ ddlmZ edƒZe d	ej¡Ze d
ej¡Ze d¡Zzedddƒ W n" ek
rÒ   e d¡ZdZY nBX ddlmZ e d ej¡¡ZdZddlZejd= ddlZe`[e d¡Z e d¡Z!e	dƒZ"e	dƒZ#e	dƒZ$e	dƒZ%e	dƒZ&e	dƒZ'e	dƒZ(e	dƒZ)e	dƒZ*e	d ƒZ+e	d!ƒZ,e	d"ƒZ-e	d#ƒZ.e	d$ƒZ/e	d%ƒZ0e	d&ƒZ1e	d'ƒZ2e	d(ƒZ3e	d)ƒZ4e	d*ƒZ5e	d+ƒZ6e	d,ƒZ7e	d-ƒZ8e	d.ƒZ9e	d/ƒZ:e	d0ƒZ;e	d1ƒZ<e	d2ƒZ=e	d3ƒZ>e	d4ƒZ?e	d5ƒZ@e	d6ƒZAe	d7ƒZBe	d8ƒZCe	d9ƒZDe	d:ƒZEe	d;ƒZFe	d<ƒZGe	d=ƒZHe	d>ƒZIe	d?ƒZJe	d@ƒZKe	dAƒZLe	dBƒZMe	dCƒZNe	dDƒZOe	dEƒZPe	dFƒZQe	dGƒZRe"e:e&e)e2e1e5e;e-e7e.e8e,e6e(e3e*e+e/e0e#e'e$e4e%e9dHœZSeTdIdJ„ e
eSƒD ƒƒZUeVeSƒeVeUƒk�stWdKƒ‚e dLdM XdNdO„ eYeSdPdQ„ dR�D ƒ¡ ¡ZZe[eHeJeIe<eMeNeOgƒZ\e[e<ePeJeOgƒZ]dSdT„ Z^dUdV„ Z_dWdX„ Z`dYdZ„ Zad[d\„ ZbG d]d^„ d^ecƒZdG d_d`„ d`eeƒZfeG dadb„ dbecƒƒZgeG dcdd„ ddecƒƒZhdedf„ ZiG dgdh„ dhecƒZjdS )iaã  
    jinja2.lexer
    ~~~~~~~~~~~~

    This module implements a Jinja / Python combination lexer. The
    `Lexer` class provided by this module is used to do some preprocessing
    for Jinja.

    On the one hand it filters out invalid operators like the bitshift
    operators we don't allow in templates. On the other hand it separates
    template code and python code in expressions.

    :copyright: (c) 2017 by the Jinja Team.
    :license: BSD, see LICENSE for more details.
é    N)Údeque)Ú
itemgetter)Úimplements_iteratorÚinternÚ	iteritemsÚ	text_type)ÚTemplateSyntaxError)ÚLRUCacheé2   z\s+z7('([^'\\]*(?:\\.[^'\\]*)*)'|"([^"\\]*(?:\\.[^"\\]*)*)")z\d+u   fÃ¶Ã¶z	<unknown>Úevalz[a-zA-Z_][a-zA-Z0-9_]*F)Ú_identifierz[\w{0}]+Tzjinja2._identifierz(?<!\.)\d+\.\d+z(\r\n|\r|\n)ÚaddZassignZcolonZcommaZdivÚdotÚeqÚfloordivÚgtZgteqZlbraceZlbracketZlparenÚltZlteqÚmodÚmulÚneÚpipeÚpowZrbraceZrbracketZrparenZ	semicolonÚsubÚtildeZ
whitespaceÚfloatÚintegerÚnameÚstringÚoperatorÚblock_beginÚ	block_endZvariable_beginÚvariable_endÚ	raw_beginÚraw_endZcomment_beginZcomment_endÚcommentÚlinestatement_beginÚlinestatement_endZlinecomment_beginZlinecomment_endÚlinecommentÚdataÚinitialÚeof)ú+ú-ú/z//Ú*ú%z**ú~ú[ú]ú(ú)ú{ú}z==z!=ú>z>=ú<z<=ú=Ú.ú:ú|ú,ú;c                 C   s   g | ]\}}||f‘qS © r?   )Ú.0ÚkÚvr?   r?   ú./usr/lib/python3/dist-packages/jinja2/lexer.pyÚ
<listcomp>�   s     rD   zoperators droppedz(%s)r<   c                 c   s   | ]}t  |¡V  qd S ©N)ÚreÚescape©r@   Úxr?   r?   rC   Ú	<genexpr>’   s     rJ   c                 C   s
   t | ƒ S rE   )Úlen©rI   r?   r?   rC   Ú<lambda>“   ó    rM   )Úkeyc                 C   sL   | t krt |  S tdtdtdtdtdtdtdtdt	dt
d	td
tdi | | ¡S )Nzbegin of commentzend of commentr$   zbegin of statement blockzend of statement blockzbegin of print statementzend of print statementzbegin of line statementzend of line statementztemplate data / textzend of template)Úreverse_operatorsÚTOKEN_COMMENT_BEGINÚTOKEN_COMMENT_ENDÚTOKEN_COMMENTÚTOKEN_LINECOMMENTÚTOKEN_BLOCK_BEGINÚTOKEN_BLOCK_ENDÚTOKEN_VARIABLE_BEGINÚTOKEN_VARIABLE_ENDÚTOKEN_LINESTATEMENT_BEGINÚTOKEN_LINESTATEMENT_ENDÚ
TOKEN_DATAÚ	TOKEN_EOFÚget)Ú
token_typer?   r?   rC   Ú_describe_token_type�   s<                ô ór_   c                 C   s   | j dkr| jS t| j ƒS )z#Returns a description of the token.r   )ÚtypeÚvaluer_   )Útokenr?   r?   rC   Údescribe_token°   s    
rc   c                 C   s2   d| kr&|   dd¡\}}|dkr*|S n| }t|ƒS )z0Like `describe_token` but for token expressions.r;   é   r   )Úsplitr_   )Úexprr`   ra   r?   r?   rC   Údescribe_token_expr·   s    rg   c                 C   s   t t | ¡ƒS )zsCount the number of newline characters in the string.  This is
    useful for extensions that filter a stream.
    )rK   Ú
newline_reÚfindall)ra   r?   r?   rC   Úcount_newlinesÂ   s    rj   c                 C   s°   t j}t| jƒd|| jƒft| jƒd|| jƒft| jƒd|| jƒfg}| jdk	rp| t| jƒdd|| jƒ f¡ | jdk	rš| t| jƒdd|| jƒ f¡ d	d
„ t	|dd�D ƒS )zACompiles all the rules from the environment into a list of rules.r$   ÚblockÚvariableNZlinestatementz	^[ \t\v]*r'   z(?:^|(?<=\S))[^\S\r\n]*c                 S   s   g | ]}|d d… ‘qS )rd   Nr?   rH   r?   r?   rC   rD   Ý   s     z!compile_rules.<locals>.<listcomp>T)Úreverse)
rF   rG   rK   Úcomment_start_stringÚblock_start_stringÚvariable_start_stringÚline_statement_prefixÚappendÚline_comment_prefixÚsorted)ÚenvironmentÚeÚrulesr?   r?   rC   Úcompile_rulesÉ   s,    
ÿ
ÿ
ÿû	
ÿ
ÿÿrx   c                   @   s$   e Zd ZdZefdd„Zdd„ ZdS )ÚFailurezjClass that raises a `TemplateSyntaxError` if called.
    Used by the `Lexer` to specify known errors.
    c                 C   s   || _ || _d S rE   )ÚmessageÚerror_class)Úselfrz   Úclsr?   r?   rC   Ú__init__å   s    zFailure.__init__c                 C   s   |   | j||¡‚d S rE   )r{   rz   )r|   ÚlinenoÚfilenamer?   r?   rC   Ú__call__é   s    zFailure.__call__N)Ú__name__Ú
__module__Ú__qualname__Ú__doc__r   r~   r�   r?   r?   r?   rC   ry   à   s   ry   c                   @   sT   e Zd ZdZdZdd„ edƒD ƒ\ZZZdd„ Z	dd	„ Z
d
d„ Zdd„ Zdd„ ZdS )ÚTokenzToken class.r?   c                 c   s   | ]}t t|ƒƒV  qd S rE   )Úpropertyr   rH   r?   r?   rC   rJ   ð   s     zToken.<genexpr>é   c                 C   s   t  | |tt|ƒƒ|f¡S rE   )ÚtupleÚ__new__r   Ústr)r}   r   r`   ra   r?   r?   rC   rŠ   ò   s    zToken.__new__c                 C   s*   | j tkrt| j  S | j dkr$| jS | j S )Nr   )r`   rP   ra   ©r|   r?   r?   rC   Ú__str__õ   s
    


zToken.__str__c                 C   s2   | j |krdS d|kr.| dd¡| j | jgkS dS )z¸Test a token against a token expression.  This can either be a
        token type or ``'token_type:token_value'``.  This can only test
        against string values and types.
        Tr;   rd   F)r`   re   ra   ©r|   rf   r?   r?   rC   Útestü   s
    
z
Token.testc                 G   s   |D ]}|   |¡r dS qdS )z(Test against multiple token expressions.TF)r�   )r|   Úiterablerf   r?   r?   rC   Útest_any	  s    
zToken.test_anyc                 C   s   d| j | j| jf S )NzToken(%r, %r, %r))r   r`   ra   rŒ   r?   r?   rC   Ú__repr__  s
    ýzToken.__repr__N)r‚   rƒ   r„   r…   Ú	__slots__Úranger   r`   ra   rŠ   r�   r�   r‘   r’   r?   r?   r?   rC   r†   í   s   r†   c                   @   s(   e Zd ZdZdd„ Zdd„ Zdd„ ZdS )	ÚTokenStreamIteratorz`The iterator for tokenstreams.  Iterate over the stream
    until the eof token is reached.
    c                 C   s
   || _ d S rE   )Ústream)r|   r–   r?   r?   rC   r~     s    zTokenStreamIterator.__init__c                 C   s   | S rE   r?   rŒ   r?   r?   rC   Ú__iter__!  s    zTokenStreamIterator.__iter__c                 C   s0   | j j}|jtkr"| j  ¡  tƒ ‚t| j ƒ |S rE   )r–   Úcurrentr`   r\   ÚcloseÚStopIterationÚnext©r|   rb   r?   r?   rC   Ú__next__$  s    


zTokenStreamIterator.__next__N)r‚   rƒ   r„   r…   r~   r—   r�   r?   r?   r?   rC   r•     s   r•   c                   @   s~   e Zd ZdZdd„ Zdd„ Zdd„ ZeZedd	„ d
d�Z	dd„ Z
dd„ Zddd„Zdd„ Zdd„ Zdd„ Zdd„ Zdd„ ZdS )ÚTokenStreamzÛA token stream is an iterable that yields :class:`Token`\s.  The
    parser however does not iterate over it but calls :meth:`next` to go
    one token ahead.  The current active token is stored as :attr:`current`.
    c                 C   s>   t |ƒ| _tƒ | _|| _|| _d| _tdtdƒ| _	t
| ƒ d S )NFrd   Ú )ÚiterÚ_iterr   Ú_pushedr   r€   Úclosedr†   ÚTOKEN_INITIALr˜   r›   )r|   Ú	generatorr   r€   r?   r?   rC   r~   4  s    
zTokenStream.__init__c                 C   s   t | ƒS rE   )r•   rŒ   r?   r?   rC   r—   =  s    zTokenStream.__iter__c                 C   s   t | jƒp| jjtk	S rE   )Úboolr¢   r˜   r`   r\   rŒ   r?   r?   rC   Ú__bool__@  s    zTokenStream.__bool__c                 C   s   |  S rE   r?   rL   r?   r?   rC   rM   D  rN   zTokenStream.<lambda>z Are we at the end of the stream?)Údocc                 C   s   | j  |¡ dS )z Push a token back to the stream.N)r¢   rr   rœ   r?   r?   rC   ÚpushF  s    zTokenStream.pushc                 C   s"   t | ƒ}| j}|  |¡ || _|S )zLook at the next token.)r›   r˜   r©   )r|   Z	old_tokenÚresultr?   r?   rC   ÚlookJ  s
    
zTokenStream.lookrd   c                 C   s   t |ƒD ]}t| ƒ qdS )zGot n tokens ahead.N)r”   r›   )r|   ÚnrI   r?   r?   rC   ÚskipR  s    zTokenStream.skipc                 C   s   | j  |¡rt| ƒS dS )zqPerform the token test and return the token if it matched.
        Otherwise the return value is `None`.
        N)r˜   r�   r›   rŽ   r?   r?   rC   Únext_ifW  s    zTokenStream.next_ifc                 C   s   |   |¡dk	S )z8Like :meth:`next_if` but only returns `True` or `False`.N)r®   rŽ   r?   r?   rC   Úskip_if^  s    zTokenStream.skip_ifc                 C   sX   | j }| jr| j ¡ | _ n:| j jtk	rTzt| jƒ| _ W n tk
rR   |  ¡  Y nX |S )z|Go one token ahead and return the old one.

        Use the built-in :func:`next` instead of calling this directly.
        )	r˜   r¢   Úpopleftr`   r\   r›   r¡   rš   r™   )r|   Úrvr?   r?   rC   r�   b  s    zTokenStream.__next__c                 C   s"   t | jjtdƒ| _d| _d| _dS )zClose the stream.rŸ   NT)r†   r˜   r   r\   r¡   r£   rŒ   r?   r?   rC   r™   q  s    zTokenStream.closec                 C   sx   | j  |¡s^t|ƒ}| j jtkr:td| | j j| j| jƒ‚td|t	| j ƒf | j j| j| jƒ‚z
| j W ¢S t
| ƒ X dS )z}Expect a given token type and return it.  This accepts the same
        argument as :meth:`jinja2.lexer.Token.test`.
        z(unexpected end of template, expected %r.zexpected token %r, got %rN)r˜   r�   rg   r`   r\   r   r   r   r€   rc   r›   rŽ   r?   r?   rC   Úexpectw  s(    ÿ ýÿ ý
zTokenStream.expectN)rd   )r‚   rƒ   r„   r…   r~   r—   r§   Z__nonzero__r‡   Zeosr©   r«   r­   r®   r¯   r�   r™   r²   r?   r?   r?   rC   rž   -  s   	
rž   c                 C   sZ   | j | j| j| j| j| j| j| j| j| j	| j
| jf}t |¡}|dkrVt| ƒ}|t|< |S )z(Return a lexer which is probably cached.N)ro   Úblock_end_stringrp   Úvariable_end_stringrn   Úcomment_end_stringrq   rs   Útrim_blocksÚlstrip_blocksÚnewline_sequenceÚkeep_trailing_newlineÚ_lexer_cacher]   ÚLexer)ru   rO   Zlexerr?   r?   rC   Ú	get_lexerŒ  s$    õ
r¼   c                   @   s>   e Zd ZdZdd„ Zdd„ Zddd„Zdd	d
„Zddd„ZdS )r»   a  Class that implements a lexer for a given environment. Automatically
    created by the environment class, usually you don't have to do that.

    Note that the lexer is not automatically bound to an environment.
    Multiple environments can share the same lexer.
    c                    sÜ  dd„ }t j}ttd fttd fttd ftt	d ft
td fttd fg}t|ƒ}|jrTdpVd}i ‰ |j�r\|dƒ}|d||jƒ ƒ}| |j¡}	||	r¢d||	 d¡ƒ p¤d7 }| |j¡}	||	rÌd||	 d¡ƒ pÎd7 }|d||jƒ ƒ}
|
 |j¡}	|	�r
d	||	 d¡ƒ �pd}d
}d|||jƒ|||jƒf }d|||jƒ|||jƒf }|ˆ d< |ˆ d< nd||jƒ }|j| _|j| _d|dd d||jƒ|||jƒ||jƒf g‡ fdd„|D ƒ ¡ ƒtdfdf|dƒtd fgt|d||jƒ||jƒ|f ƒttfdf|dƒtdƒfd fgt |d||jƒ||jƒ|f ƒt!dfg| t"|d||j#ƒ||j#ƒf ƒt$dfg| t%|d||jƒ|||jƒ||jƒ|f ƒtt&fdf|dƒtdƒfd fgt'|d ƒt(dfg| t)|d!ƒt*t+fdfgi| _,d S )"Nc                 S   s   t  | t jt jB ¡S rE   )rF   ÚcompileÚMÚSrL   r?   r?   rC   rM   «  rN   z Lexer.__init__.<locals>.<lambda>z\n?rŸ   r+   z^%s(.*)z|%srd   z(?!%s)z^[ \t]*z%s%s(?!%s)|%s\+?z%s%s%s|%s\+?rk   r$   z%sÚrootz(.*?)(?:%s)r<   z4(?P<raw_begin>(?:\s*%s\-|%s)\s*raw\s*(?:\-%s\s*|%s))c              	      s&   g | ]\}}d ||ˆ   ||¡f ‘qS )z(?P<%s_begin>\s*%s\-|%s))r]   )r@   r¬   Úr©Z	prefix_rer?   rC   rD   ô  s   ÿz"Lexer.__init__.<locals>.<listcomp>ú#bygroupz.+z(.*?)((?:\-%s\s*|%s)%s)ú#popz(.)zMissing end of comment tagz(?:\-%s\s*|%s)%sz
\-%s\s*|%sz1(.*?)((?:\s*%s\-|%s)\s*endraw\s*(?:\-%s\s*|%s%s))zMissing end of raw directivez	\s*(\n|$)z(.*?)()(?=\n|$))-rF   rG   Úwhitespace_reÚTOKEN_WHITESPACEÚfloat_reÚTOKEN_FLOATÚ
integer_reÚTOKEN_INTEGERÚname_reÚ
TOKEN_NAMEÚ	string_reÚTOKEN_STRINGÚoperator_reÚTOKEN_OPERATORrx   r¶   r·   ro   Úmatchrn   Úgrouprp   r¸   r¹   Újoinr³   r[   rQ   rµ   rS   rR   ry   rU   rV   rW   r´   rX   ÚTOKEN_RAW_BEGINÚTOKEN_RAW_ENDrY   rZ   ÚTOKEN_LINECOMMENT_BEGINrT   ÚTOKEN_LINECOMMENT_ENDrw   )r|   ru   Úcrv   Z	tag_rulesZroot_tag_rulesZblock_suffix_reZno_lstrip_reZ
block_diffÚmZcomment_diffZno_variable_reZ	lstrip_reZblock_prefix_reZcomment_prefix_rer?   rÂ   rC   r~   ©  sì    úüü
ü
þûÿ	 ÷óý üú	ý üÿúþ ýÿûû úøÿþÿÿÿÈzLexer.__init__c                 C   s   t  | j|¡S )z@Called for strings and template data to normalize it to unicode.)rh   r   r¸   )r|   ra   r?   r?   rC   Ú_normalize_newlines)  s    zLexer._normalize_newlinesNc                 C   s&   |   ||||¡}t|  |||¡||ƒS )zCCalls tokeniter + tokenize and wraps it in a token stream.
        )Ú	tokeniterrž   Úwrap)r|   Úsourcer   r€   Ústater–   r?   r?   rC   Útokenize-  s    zLexer.tokenizec           	      c   sb  |D �]V\}}}|t krq�n0|dkr.d}�n |dkr>d}�n|dkrLq�n|dkr`|  |¡}nî|dkrn|}nà|dkršt|ƒ}tr˜| ¡ s˜td	|||ƒ‚n´|d
k�rz$|  |dd… ¡ dd¡ d¡}W nH tk
�r } z(t|ƒ 	d¡d  
¡ }t||||ƒ‚W 5 d}~X Y nX n:|dk�r(t|ƒ}n&|dk�r<t|ƒ}n|dk�rNt| }t|||ƒV  qdS )z‹This is called with the stream as returned by `tokenize` and wraps
        every token in a :class:`Token` and converts the value.
        r%   r   r&   r    )r"   r#   r(   Úkeywordr   zInvalid character in identifierr   rd   éÿÿÿÿÚasciiÚbackslashreplacezunicode-escaper;   Nr   r   r   )Úignored_tokensrÚ   r‹   Úcheck_identÚisidentifierr   ÚencodeÚdecodeÚ	Exceptionre   ÚstripÚintr   Ú	operatorsr†   )	r|   r–   r   r€   r   rb   ra   rv   Úmsgr?   r?   rC   rÜ   3  sP      þ
 ÿþ"




z
Lexer.wrapc                 c   s@  t |ƒ}| ¡ }| jr<|r<dD ]}| |¡r| d¡  q<qd |¡}d}d}dg}	|dk	r„|dkr„|dksttd	ƒ‚|	 |d
 ¡ nd}| j|	d  }
t|ƒ}g }|
D �]h\}}}| 	||¡}|dkrÈq¦|rÖ|dkrÖq¦t
|tƒ�r t|ƒD ]²\}}|jtk�r
|||ƒ‚qê|dk�rdt| ¡ ƒD ]4\}}|dk	�r |||fV  || d¡7 } �qœ�q td| ƒ‚qê| |d ¡}|�s‚|tk�rŽ|||fV  || d¡7 }qênÈ| ¡ }|dk�r>|dk�rÈ| d¡ nv|dk�rÞ| d¡ n`|dk�rô| d¡ nJ|dk�r>|�std| |||ƒ‚| ¡ }||k�r>td||f |||ƒ‚|�sN|tk�rZ|||fV  || d¡7 }| ¡ }|dk	�rò|dk�rŽ|	 ¡  nT|dk�rØt| ¡ ƒD ]$\}}|dk	�r¤|	 |¡  �qâ�q¤td| ƒ‚n
|	 |¡ | j|	d  }
n||k�rtd| ƒ‚|} q¢q¦||k�r dS td|| |f |||ƒ‚q¢dS )z�This method tokenizes the text and returns the tokens in a
        generator.  Use this method if you just want to tokenize a template.
        )z
úÚ
rŸ   rï   r   rd   rÀ   N)rl   rk   zinvalid stateZ_beginrá   )r!   r    r&   rÃ   z?%r wanted to resolve the token dynamically but no group matchedr   r5   r6   r3   r4   r1   r2   )r6   r4   r2   zunexpected '%s'zunexpected '%s', expected '%s'rÄ   zC%r wanted to resolve the new state dynamically but no group matchedz,%r yielded empty string without stack changezunexpected char %r at %d)r   Ú
splitlinesr¹   Úendswithrr   rÓ   ÚAssertionErrorrw   rK   rÑ   Ú
isinstancer‰   Ú	enumerateÚ	__class__ry   r   Ú	groupdictÚcountÚRuntimeErrorrÒ   Úignore_if_emptyr   ÚpopÚend)r|   rÝ   r   r€   rÞ   ÚlinesÚnewlineÚposr   ÚstackZstatetokensZsource_lengthZbalancing_stackZregexÚtokensZ	new_staterÙ   Úidxrb   rO   ra   r(   Zexpected_opZpos2r?   r?   rC   rÛ   \  sÊ    



ÿ


ý




ÿ þ
þ ü






ý

ÿ

ÿ þzLexer.tokeniter)NNN)NN)NN)	r‚   rƒ   r„   r…   r~   rÚ   rß   rÜ   rÛ   r?   r?   r?   rC   r»   ¡  s    

)r»   )kr…   rF   Zcollections.abcr   Úcollectionsr   r   Zjinja2._compatr   r   r   r   Zjinja2.exceptionsr   Zjinja2.utilsr	   rº   r½   ÚUrÅ   r¿   rÍ   rÉ   ÚSyntaxErrorrË   rå   Zjinja2r   ÚformatÚpatternÚsysÚmodulesrÇ   rh   Z	TOKEN_ADDZTOKEN_ASSIGNZTOKEN_COLONZTOKEN_COMMAZ	TOKEN_DIVZ	TOKEN_DOTZTOKEN_EQZTOKEN_FLOORDIVZTOKEN_GTZ
TOKEN_GTEQZTOKEN_LBRACEZTOKEN_LBRACKETZTOKEN_LPARENZTOKEN_LTZ
TOKEN_LTEQZ	TOKEN_MODZ	TOKEN_MULZTOKEN_NEZ
TOKEN_PIPEZ	TOKEN_POWZTOKEN_RBRACEZTOKEN_RBRACKETZTOKEN_RPARENZTOKEN_SEMICOLONZ	TOKEN_SUBZTOKEN_TILDErÆ   rÈ   rÊ   rÌ   rÎ   rÐ   rU   rV   rW   rX   rÔ   rÕ   rQ   rR   rS   rY   rZ   rÖ   r×   rT   r[   r¤   r\   rì   ÚdictrP   rK   rò   rÓ   rt   rÏ   Ú	frozenseträ   rù   r_   rc   rg   rj   rx   Úobjectry   r‰   r†   r•   rž   r¼   r»   r?   r?   r?   rC   Ú<module>   s  ÿ




æÿ  ý ÿ+^