Ë
    È[;jd;  ã                   ó.  — d Z ddlZddlmZ dZdZdZdZ ed	«      Z	d
„ Z
d„ Zd„ Zd„ Zd„ Z G d„ d«      Zd„ Z G d„ de«      Z G d„ de«      Z e«       Z G d„ de«      Z G d„ de«      Z G d„ de«      Z G d„ de«      Z G d„ de«      Z e«       Zd e_         d!e_        d"„ Zd#„ Zd$„ Zd%„ Z ed&«      Zd'e_         d(e_        d4d)„Z d*„ Z!d+„ Z"d,„ Z#d-„ Z$ ee«      Z%d.e%_         d/e%_         ee«      Z&d0e&_         d1e&_         ee«      Z'd2e'_         d3e'_        y)5z.
Python Lexical Analyser

Regular Expressions
é    Né   )ÚErrorsiÿÿÿÚbolÚeolÚeofÚ
c                 óR  — t        | «      }|j                  «        d}t        |«      }g }||k  rwt        ||   «      }|dz   }|dz  }||k  r2|t        ||   «      k\  r!|dz  }|dz  }||k  r|t        ||   «      k\  rŒ!|j	                  |«       |j	                  |«       ||k  rŒw|S )z’
    Return a list of character codes consisting of pairs
    [code1a, code1b, code2a, code2b,...] which cover all
    the characters in |s|.
    r   r   )ÚlistÚsortÚlenÚordÚappend)ÚsÚ	char_listÚiÚnÚresultÚcode1Úcode2s          ú\G:\00. PROJECTS\API\Inventory\templateJSON\kerjaOCR\Lib\site-packages\Cython/Plex/Regexps.pyÚchars_to_rangesr      s½   € ô �Q“€IØ‡N�NÔØ	€AÜˆI‹€AØ€FØ
ˆaŠ%Ü�I˜a‘LÓ!ˆØ˜‘	ˆØ	ˆQ‰ˆØ�!Še˜¤ Y¨q¡\Ó!2Ò2Ø�Q‰JˆEØ�‰FˆAð �!Še˜¤ Y¨q¡\Ó!2Ó2ð 	�‰�eÔØ�‰�eÔð ˆa‹%ð €Mó    c                 óª   — t        | t        d«      «      }t        |t        d«      dz   «      }||k  r!t        d«      t        d«      z
  }||z   ||z   fS y)zŠ
    If the range of characters from code1 to code2-1 includes any
    lower case letters, return the corresponding upper case range.
    ÚaÚzr   ÚAN©Úmaxr   Úmin©r   r   Úcode3Úcode4Úds        r   Úuppercase_ranger$   3   óW   € ô
 �”s˜3“xÓ €EÜ�”s˜3“x !‘|Ó$€EØˆu‚}Ü�‹H”s˜3“xÑˆØ˜‘	˜5 1™9Ð%Ð%àr   c                 óª   — t        | t        d«      «      }t        |t        d«      dz   «      }||k  r!t        d«      t        d«      z
  }||z   ||z   fS y)zŠ
    If the range of characters from code1 to code2-1 includes any
    upper case letters, return the corresponding lower case range.
    r   ÚZr   r   Nr   r    s        r   Úlowercase_ranger(   A   r%   r   c           	      óˆ   — t        dt        | «      d«      D �cg c]  }t        | |   | |dz      «      ‘Œ }}t        |Ž S c c}w )zƒ
    Given a list of codes as returned by chars_to_ranges, return
    an RE which will match a character in any of the ranges.
    r   é   r   )Úranger   Ú	CodeRangeÚAlt)Ú	code_listr   Úre_lists      r   Ú
CodeRangesr0   O   sN   € ô
 CHÈÌ3ÈyË>Ð[\ÔB]Ó^ÑB]¸QŒy˜ 1™ y°°Q±Ñ'7Õ8ÐB]€GÐ^Ü�ˆ=Ðùò _s   ™?c                 óž   — | t         cxk  r|k  r3n n0t        t        | t         «      t        t        t         dz   |«      «      S t        | |«      S )z�
    CodeRange(code1, code2) is an RE which matches any character
    with a code |c| in the range |code1| <= |c| < |code2|.
    r   )Únl_coder-   ÚRawCodeRangeÚ
RawNewline©r   r   s     r   r,   r,   X   sG   € ð
 ”Ô˜%ÕÜ”< ¤wÓ/ÜÜ¤¨!¡¨UÓ3ó5ð 	5ô ˜E 5Ó)Ð)r   c                   óR   — e Zd ZdZdZdZdZd„ Zd„ Zd„ Z	d„ Z
d„ Zd	„ Zd
„ Zd„ Zd„ Zy)ÚREa  RE is the base class for regular expression constructors.
    The following operators are defined on REs:

         re1 + re2         is an RE which matches |re1| followed by |re2|
         re1 | re2         is an RE which matches either |re1| or |re2|
    r   Nc                 óF   — t        d| j                  j                  z  «      ‚)aM  
        This method should add states to |machine| to implement this
        RE, starting at |initial_state| and ending at |final_state|.
        If |match_bol| is true, the RE must be able to match at the
        beginning of a line. If nocase is true, upper and lower case
        letters should be treated as equivalent.
        z %s.build_machine not implemented)ÚNotImplementedErrorÚ	__class__Ú__name__)ÚselfÚmachineÚinitial_stateÚfinal_stateÚ	match_bolÚnocases         r   Úbuild_machinezRE.build_machineu   s&   € ô "Ð"DØ"&§.¡.×"9Ñ"9ñ#:ó ;ð 	;r   c                 ól   — |j                  «       }|j                  |«       |j                  ||«       |S )z~
        Given a state |s| of machine |m|, return a new state
        reachable from |s| on character |c| or epsilon.
        )Ú	new_stateÚlink_toÚadd_transition)r<   Úmr>   Úcr   s        r   Ú	build_optzRE.build_opt�   s2   € ð
 �K‰K‹MˆØ×Ñ˜aÔ Ø×$Ñ$ Q¨Ô*Øˆr   c                 ó   — t        | |«      S ©N)ÚSeq©r<   Úothers     r   Ú__add__z
RE.__add__‹   ó   € Ü�4˜ÓÐr   c                 ó   — t        | |«      S rK   )r-   rM   s     r   Ú__or__z	RE.__or__Ž   rP   r   c                 óR   — | j                   r| j                   S | j                  «       S rK   )ÚstrÚcalc_str©r<   s    r   Ú__str__z
RE.__str__‘   s   € Ø�8Š8Ø—8‘8ˆOà—=‘=“?Ð"r   c                 óL   — t        |t        «      s| j                  ||d«       y y )NzPlex.RE instance)Ú
isinstancer7   Ú
wrong_type©r<   ÚnumÚvalues      r   Úcheck_rezRE.check_re—   s"   € Ü˜%¤Ô$Ø�O‰O˜C Ð(:Õ;ð %r   c                 óN   — t        |«      t        ur| j                  ||d«       y y )NÚstring)ÚtyperT   rZ   r[   s      r   Úcheck_stringzRE.check_string›   s#   € Ü�‹;œcÑ!Ø�O‰O˜C ¨Õ1ð "r   c                 ó´   — | j                  ||«       t        |«      dk7  r8t        j                  d|| j                  j
                  t        |«      fz  «      ‚y )Nr   zOInvalid value for argument %d of Plex.%s.Expected a string of length 1, got: %s)rb   r   r   ÚPlexValueErrorr:   r;   Úreprr[   s      r   Ú
check_charzRE.check_charŸ   s_   € Ø×Ñ˜#˜uÔ%Üˆu‹:˜Š?Ü×'Ñ'ð )Qà,/°·±×1HÑ1HÌ$ÈuË+ðTWñ)Wó Xð Xð r   c                 ó”   — t        j                  d|d›d| j                  j                  › d|› dt	        |«      j
                  › �«      ‚)NzInvalid type for argument r#   z of z (expected z, got )r   ÚPlexTypeErrorr:   Ú__qualname__ra   r;   )r<   r\   r]   Úexpecteds       r   rZ   zRE.wrong_type¦   sQ   € Ü×"Ñ"Ø(¨¨Q¨¨t°D·N±N×4OÑ4OÐ3Pð QØ!˜
 &¬¨e«×)=Ñ)=Ð(>ð@ó
ð 	
r   )r;   Ú
__module__ri   Ú__doc__ÚnullableÚmatch_nlrT   rB   rI   rO   rR   rW   r^   rb   rf   rZ   © r   r   r7   r7   i   sF   „ ñð €HØ€HØ
€Cò
;òò ò ò#ò<ò2òXó
r   r7   c                 ó¢   — t        | «      dk(  r"t        t        | «      t        | «      dz   «      }nt        | «      }dt	        | «      z  |_        |S )z;
    Char(c) is an RE which matches the character |c|.
    r   zChar(%s))r   r,   r   ÚSpecialSymbolre   rT   )rH   r   s     r   ÚCharrr   ´   sF   € ô ˆ1ƒv�‚{Üœ3˜q›6¤3 q£6¨A¡:Ó.‰ä˜qÓ!ˆØœd 1›gÑ%€F„JØ€Mr   c                   ó6   — e Zd ZdZdZdZdZdZdZd„ Z	d„ Z
d„ Zy)r3   zÒ
    RawCodeRange(code1, code2) is a low-level RE which matches any character
    with a code |c| in the range |code1| <= |c| < |code2|, where the range
    does not include newline. For internal use only.
    r   Nc                 óZ   — ||f| _         t        ||«      | _        t        ||«      | _        y rK   )r+   r$   r(   )r<   r   r   s      r   Ú__init__zRawCodeRange.__init__Ì   s+   € Ø˜U�^ˆŒ
Ü.¨u°eÓ<ˆÔÜ.¨u°eÓ<ˆÕr   c                 ó  — |r| j                  ||t        «      }|j                  | j                  |«       |rR| j                  r|j                  | j                  |«       | j
                  r|j                  | j
                  |«       y y y rK   )rI   ÚBOLrF   r+   r$   r(   ©r<   rG   r>   r?   r@   rA   s         r   rB   zRawCodeRange.build_machineÑ   sv   € ÙØ ŸN™N¨1¨m¼SÓAˆMØ×$Ñ$ T§Z¡Z°Ô=ÙØ×#Ò#Ø×,Ñ,¨T×-AÑ-AÀ;ÔOØ×#Ò#Ø×,Ñ,¨T×-AÑ-AÀ;ÕOð $ð r   c                 ó8   — d| j                   | j                  fz  S )NzCodeRange(%d,%d)r5   rV   s    r   rU   zRawCodeRange.calc_strÛ   s   € Ø! T§Z¡Z°·±Ð$<Ñ<Ð<r   )r;   rk   ri   rl   rm   rn   r+   r$   r(   ru   rB   rU   ro   r   r   r3   r3   À   s2   „ ñð
 €HØ€HØ€EØ€OØ€Oò=ò
Pó=r   r3   c                   ó   — e Zd ZdZdZdZd„ Zy)Ú_RawNewlinezd
    RawNewline is a low-level RE which matches a newline character.
    For internal use only.
    r   r   c                 ó¢   — |r| j                  ||t        «      }| j                  ||t        «      }|j                  t        t        dz   f|«       y ©Nr   )rI   rw   ÚEOLrF   r2   )r<   rG   r>   r?   r@   rA   r   s          r   rB   z_RawNewline.build_machineç   sB   € ÙØ ŸN™N¨1¨m¼SÓAˆMØ�N‰N˜1˜m¬SÓ1ˆØ	×Ñœ'¤7¨Q¡;Ð/°Õ=r   N)r;   rk   ri   rl   rm   rn   rB   ro   r   r   r{   r{   ß   s   „ ñð €HØ€Hó>r   r{   c                   ó(   — e Zd ZdZdZdZdZd„ Zd„ Zy)rq   zx
    SpecialSymbol(sym) is an RE which matches the special input
    symbol |sym|, which is one of BOL, EOL or EOF.
    r   Nc                 ó   — || _         y rK   )Úsym)r<   r�   s     r   ru   zSpecialSymbol.__init__ú   s	   € Øˆ�r   c                 ó”   — |r*| j                   t        k(  r| j                  ||t        «      }|j	                  | j                   |«       y rK   )r�   r~   rI   rw   rF   rx   s         r   rB   zSpecialSymbol.build_machineý   s7   € ñ ˜Ÿ™¤SšØ ŸN™N¨1¨m¼SÓAˆMØ×$Ñ$ T§X¡X¨{Õ;r   )	r;   rk   ri   rl   rm   rn   r�   ru   rB   ro   r   r   rq   rq   ñ   s"   „ ñð €HØ€HØ
€Còó<r   rq   c                   ó"   — e Zd ZdZd„ Zd„ Zd„ Zy)rL   z]Seq(re1, re2, re3...) is an RE which matches |re1| followed by
    |re2| followed by |re3|...c                 ó,  — d}t        |«      D ]'  \  }}| j                  ||«       |xr |j                  }Œ) || _        || _        t	        |«      }d}|r9|dz  }||   }|j
                  rd}	 || _        y |j                  s		 || _        y |rŒ9|| _        y )Nr   r   )Ú	enumerater^   rm   r/   r   rn   )r<   r/   rm   r   Úrern   s         r   ru   zSeq.__init__	  s¢   € ØˆÜ˜wÖ'‰EˆAˆrØ�M‰M˜!˜RÔ ØÒ/ B§K¡K‰Hð (ð ˆŒØ ˆŒÜ�‹LˆØˆÙØ�‰FˆAØ˜‘ˆBØ�{Š{Ø�Øð !ˆ�ð —;’;ØØ ˆ�ò ð !ˆ�r   c                 ó<  — | j                   }t        |«      dk(  r|j                  |«       y |}t        |«      }t        |«      D ]U  \  }	}
|	|dz
  k  r|j	                  «       }n|}|
j                  |||||«       |}|
j                  xs |xr |
j                  }ŒW y ©Nr   r   )r/   r   rE   r…   rD   rB   rn   rm   )r<   rG   r>   r?   r@   rA   r/   Ús1r   r   r†   Ús2s               r   rB   zSeq.build_machine  s“   € Ø—,‘,ˆÜˆw‹<˜1ÒØ×!Ñ! +Õ.àˆBÜ�G“ˆAÜ" 7Ö+‘��2Ø�q˜1‘u’9ØŸ™›‘Bà$�BØ× Ñ   B¨¨I°vÔ>Ø�ØŸK™KÒF¨IÒ,E¸"¿+¹+‘	ñ ,r   c                 óZ   — ddj                  t        t        | j                  «      «      z  S )NzSeq(%s)Ú,©ÚjoinÚmaprT   r/   rV   s    r   rU   zSeq.calc_str,  ó!   € Ø˜3Ÿ8™8¤C¬¨T¯\©\Ó$:Ó;Ñ;Ð;r   N©r;   rk   ri   rl   ru   rB   rU   ro   r   r   rL   rL     s   „ ñ"ò!ò&Gó <r   rL   c                   ó"   — e Zd ZdZd„ Zd„ Zd„ Zy)r-   zRAlt(re1, re2, re3...) is an RE which matches either |re1| or
    |re2| or |re3|...c                 ó  — || _         d}d}g }g }d}|D ]X  }| j                  ||«       |j                  r|j                  |«       d}n|j                  |«       |j                  rd}|dz  }ŒZ || _        || _        || _        || _        y rˆ   )r/   r^   rm   r   rn   Únullable_resÚnon_nullable_res)r<   r/   rm   rn   r”   r•   r   r†   s           r   ru   zAlt.__init__4  s˜   € ØˆŒØˆØˆØˆØÐØˆÛˆBØ�M‰M˜!˜RÔ Ø�{Š{Ø×#Ñ# BÔ'Ø‘à ×'Ñ'¨Ô+Ø�{Š{Ø�Ø�‰F‰Að ð )ˆÔØ 0ˆÔØ ˆŒØ ˆ�r   c                 óè   — | j                   D ]  }|j                  |||||«       Œ | j                  r@|r| j                  ||t        «      }| j                  D ]  }|j                  |||d|«       Œ y y )Nr   )r”   rB   r•   rI   rw   )r<   rG   r>   r?   r@   rA   r†   s          r   rB   zAlt.build_machineJ  sq   € Ø×#Ô#ˆBØ×Ñ˜Q ¨{¸IÀvÕNð $à× Ò ÙØ $§¡¨q°-ÄÓ E�Ø×+Ô+�Ø× Ñ   M°;ÀÀ6ÕJñ ,ð !r   c                 óZ   — ddj                  t        t        | j                  «      «      z  S )NzAlt(%s)rŒ   r�   rV   s    r   rU   zAlt.calc_strS  r�   r   Nr‘   ro   r   r   r-   r-   0  s   „ ñò!ò,Kó<r   r-   c                   ó"   — e Zd ZdZd„ Zd„ Zd„ Zy)ÚRep1z@Rep1(re) is an RE which matches one or more repetitions of |re|.c                 óz   — | j                  d|«       || _        |j                  | _        |j                  | _        y r}   )r^   r†   rm   rn   )r<   r†   s     r   ru   zRep1.__init__Z  s-   € Ø�‰�a˜ÔØˆŒØŸ™ˆŒØŸ™ˆ�r   c                 ó  — |j                  «       }|j                  «       }|j                  |«       | j                  j                  ||||xs | j                  j                  |«       |j                  |«       |j                  |«       y rK   )rD   rE   r†   rB   rn   )r<   rG   r>   r?   r@   rA   r‰   rŠ   s           r   rB   zRep1.build_machine`  sf   € Ø�[‰[‹]ˆØ�[‰[‹]ˆØ×Ñ˜bÔ!Ø�‰×Ñ˜a  R¨Ò)F°d·g±g×6FÑ6FÈÔOØ
�
‰
�2ŒØ
�
‰
�;Õr   c                 ó    — d| j                   z  S )NzRep1(%s)©r†   rV   s    r   rU   zRep1.calc_strh  s   € Ø˜DŸG™GÑ#Ð#r   Nr‘   ro   r   r   r™   r™   W  s   „ ÙJò$ò ó$r   r™   c                   ó*   — e Zd ZdZdZdZd„ Zd„ Zd„ Zy)Ú
SwitchCasezÓ
    SwitchCase(re, nocase) is an RE which matches the same strings as RE,
    but treating upper and lower case letters according to |nocase|. If
    |nocase| is true, case is ignored, otherwise it is not.
    Nc                 ód   — || _         || _        |j                  | _        |j                  | _        y rK   )r†   rA   rm   rn   )r<   r†   rA   s      r   ru   zSwitchCase.__init__u  s&   € ØˆŒØˆŒØŸ™ˆŒØŸ™ˆ�r   c                 óV   — | j                   j                  ||||| j                  «       y rK   )r†   rB   rA   rx   s         r   rB   zSwitchCase.build_machine{  s#   € Ø�‰×Ñ˜a °¸YØ"Ÿk™kõ	+r   c                 óH   — | j                   rd}nd}|›d| j                  ›d�S )NÚNoCaseÚCaseÚ(Ú))rA   r†   )r<   Únames     r   rU   zSwitchCase.calc_str  s"   € Ø�;Š;Ø‰DàˆDÚ §£Ð)Ð)r   )	r;   rk   ri   rl   r†   rA   ru   rB   rU   ro   r   r   rŸ   rŸ   l  s"   „ ñð
 
€BØ€Fò$ò+ó*r   rŸ   z8
    Empty is an RE which matches the empty string.
    ÚEmptyc                 ój   — t        t        t        t        | «      «      Ž }dt	        | «      z  |_        |S )z@
    Str1(s) is an RE which matches the literal string |s|.
    úStr(%s))rL   Útupler�   rr   re   rT   ©r   r   s     r   ÚStr1r­   –  s.   € ô ”%œœD !›Ó%Ð&€FØœT !›WÑ$€F„JØ€Mr   c                  óÊ   — t        | «      dk(  rt        | d   «      S t        t        t	        t        | «      «      Ž }ddj                  t	        t        | «      «      z  |_        |S )zŽ
    Str(s) is an RE which matches the literal string |s|.
    Str(s1, s2, s3, ...) is an RE which matches any of |s1| or |s2| or |s3|...
    r   r   rª   rŒ   )r   r­   r-   r«   r�   rŽ   re   rT   )Ústrsr   s     r   ÚStrr°   Ÿ  sR   € ô
 ˆ4ƒy�A‚~Ü�D˜‘G‹}Ðä”eœC¤ d›OÓ,Ð-ˆØ §¡¬#¬d°D«/Ó!:Ñ:ˆŒ
Øˆr   c                 óT   — t        t        | «      «      }dt        | «      z  |_        |S )zH
    Any(s) is an RE which matches any character in the string |s|.
    zAny(%s))r0   r   re   rT   r¬   s     r   ÚAnyr²   ¬  s(   € ô œ¨Ó*Ó+€FØœT !›WÑ$€F„JØ€Mr   c                 ó°   — t        | «      }|j                  dt         «       |j                  t        «       t	        |«      }dt        | «      z  |_        |S )zp
    AnyBut(s) is an RE which matches any character (including
    newline) which is not in the string |s|.
    r   z
AnyBut(%s))r   ÚinsertÚmaxintr   r0   re   rT   )r   Úrangesr   s      r   ÚAnyButr·   µ  sI   € ô
 ˜QÓ€FØ
‡M�M�!”f�WÔØ
‡M�M”&ÔÜ˜Ó€FØ¤ Q£Ñ'€F„JØ€Mr   Ú zT
    AnyChar is an RE which matches any single character (including a newline).
    ÚAnyCharc                 óN  — |r1t        t        | «      t        |«      dz   «      }d| ›d|›d�|_        |S g }t        dt	        | «      d«      D ];  }|j                  t        t        | |   «      t        | |dz      «      dz   «      «       Œ= t        |Ž }dt        | «      z  |_        |S )a  
    Range(c1, c2) is an RE which matches any single character in the range
    |c1| to |c2| inclusive.
    Range(s) where |s| is a string of even length is an RE which matches
    any single character in the ranges |s[0]| to |s[1]|, |s[2]| to |s[3]|,...
    r   zRange(rŒ   r¦   r   r*   z	Range(%s))r,   r   rT   r+   r   r   r-   re   )r‰   rŠ   r   r¶   r   s        r   ÚRanger»   Ê  sš   € ñ 
Üœ3˜r›7¤C¨£G¨a¡KÓ0‰Ú')ª2Ð.ˆŒ
ð €Mð ˆÜ�qœ#˜b›' 1Ö%ˆAØ�M‰Mœ)¤C¨¨1©£J´°B°q¸1±u±I³ÀÑ0BÓCÕDð &ä�f�ˆØ ¤4¨£8Ñ+ˆŒ
Ø€Mr   c                 ó:   — t        | t        «      }d| z  |_        |S )zI
    Opt(re) is an RE which matches either |re| or the empty string.
    zOpt(%s))r-   r¨   rT   ©r†   r   s     r   ÚOptr¾   Ý  s   € ô �”U‹^€FØ˜R‘€F„JØ€Mr   c                 óB   — t        t        | «      «      }d| z  |_        |S )zJ
    Rep(re) is an RE which matches zero or more repetitions of |re|.
    zRep(%s))r¾   r™   rT   r½   s     r   ÚReprÀ   æ  s!   € ô ”�b“‹]€FØ˜R‘€F„JØ€Mr   c                 ó   — t        | d¬«      S )z€
    NoCase(re) is an RE which matches the same strings as RE, but treating
    upper and lower case letters as equivalent.
    r   ©rA   ©rŸ   r�   s    r   r£   r£   ï  s   € ô
 �b Ô#Ð#r   c                 ó   — t        | d¬«      S )z¶
    Case(re) is an RE which matches the same strings as RE, but treating
    upper and lower case letters as distinct, i.e. it cancels the effect
    of any enclosing NoCase().
    r   rÂ   rÃ   r�   s    r   r¤   r¤   ÷  s   € ô �b Ô#Ð#r   z=
    Bol is an RE which matches the beginning of a line.
    ÚBolz7
    Eol is an RE which matches the end of a line.
    ÚEolz9
    Eof is an RE which matches the end of the file.
    ÚEofrK   )(rl   Útypesr¸   r   rµ   rw   r~   ÚEOFr   r2   r   r$   r(   r0   r,   r7   rr   r3   r{   r4   rq   rL   r-   r™   rŸ   r¨   rT   r­   r°   r²   r·   r¹   r»   r¾   rÀ   r£   r¤   rÅ   rÆ   rÇ   ro   r   r   Ú<module>rÊ      sƒ  ðñó å à	€ð €Ø€Ø€á
ˆd‹)€òò.òòò
*÷"A
ñ A
òV	ô=�2ô =ô>>�"ô >ñ ‹]€
ô<�Bô <ô((<ˆ"ô (<ôV$<ˆ"ô $<ôN$ˆ2ô $ô**�ô *ñD 	‹€ðð „ð €„	òò
òò
ñ �‹*€ðð „ð €„óò&òò$ò$ñ ˆ3ƒi€ðð „ð €„á
ˆ3ƒi€ðð „ð €„á
ˆ3ƒi€ðð „ð €…r   