ó
    „ñ:i	<  ã            
       óä  • S SK r S SKJrJrJrJrJrJrJr  S SK	J
r
  S SKJr  S SKJrJr  S SKJr  S SKJr  \" S/ S	Q5      rS
 rS\4S jr " S S\5      rS rS rS r\S    rSSSSSSSSSS.	rS&S jr S r! " S S\
RD                  5      r#\$" / S Q5      r%\$" / S!Q5      r& " S" S#\
RD                  5      r' " S$ S%\
RD                  5      r(\" \5      /\
RR                  RT                  l+        \\" \5      \" \5      \" \5      \" \5      /\
RR                  RX                  l+        \" \5      /\
RR                  RZ                  l+        \\
RR                  RZ                  l.        \" \5      /\
RR                  R^                  l+        \" \5      /\
RR                  R`                  l+        \/\
RR                  Rb                  l+        \\
RR                  Rb                  l.        \/\
RR                  Rd                  l+        \
Rf                  \
RR                  Rd                  l.        \
Rf                  \" \5      /\
RR                  Rh                  l+        \
Rf                  /\
RR                  Rj                  l+        \
Rf                  \
Rl                  /\
RR                  Rn                  l+        \\
RR                  Rn                  l.        \
Rf                  \
Rl                  \/\
RR                  Rp                  l+        \\
RR                  Rp                  l.        \
Rf                  \
Rl                  /\
RR                  Rr                  l+        \\
RR                  Rr                  l.        \\" \5      /\
RR                  Rt                  l+        \
Rv                  \
RR                  Rt                  l.        \
Rv                  /\
RR                  Rx                  l+        \\
RR                  Rx                  l.        \
Rv                  /\
RR                  Rz                  l+        \\
RR                  Rz                  l.        \
Rv                  \\\\\\\\\/
\
RR                  R|                  l+        \
R~                  \
RR                  R|                  l.        \
R~                  /\
RR                  R€                  l+        \
R~                  \" \5      /\
RR                  R‚                  l+        \
R~                  \/\
RR                  R„                  l+        \
R~                  \
R†                  /\
RR                  Rˆ                  l+        \
R~                  \
RŠ                  \\" \5      /\
RR                  RŒ                  l+        \
RŽ                  \
RR                  RŒ                  l.        \
RŽ                  /\
RR                  R�                  l+        \\
RR                  R�                  l.        \
RŽ                  /\
RR                  R’                  l+        \\
RR                  R’                  l.        \
RŽ                  /\
RR                  R”                  l+        \
R~                  /\
RR                  R–                  l+        \
Rf                  \
RR                  R–                  l.        g)'é    N)ÚPOINTERÚc_char_pÚ
c_longlongÚc_intÚc_size_tÚc_void_pÚ	string_at)Úffi)Úllvm_version_info)Ú_decode_stringÚ_encode_string)Ú
namedtuple)Ú	_has_svmlÚTriple)ÚArchÚSubArchÚVendorÚOSÚEnvÚObjectFormatc                  ó¶   • [         R                  " 5        n [         R                  R                  U 5        [	        U 5      sSSS5        $ ! , (       d  f       g= f)zó
Return a target triple suitable for generating code for the current process.
An example when the default triple from ``get_default_triple()`` is not be
suitable is when LLVM is compiled for 32-bit but the process is executing
in 64-bit mode.
N)r
   ÚOutputStringÚlibÚLLVMPY_GetProcessTripleÚstr©Úouts    Ú[/srv/projetos/modelo_ml_acdoc/venv/lib/python3.13/site-packages/llvmlite/binding/targets.pyÚget_process_tripler      s7   € ô 
×	Ò	Ô	˜sÜ�‰×'Ñ'¨Ô,Ü�3‹x÷ 
×	×	úó   –*A
Á

AÚtriplec                 ó  • [         R                  " 5        n[         R                  " 5        n[         R                  " 5        n[         R                  " 5        n[         R                  R                  U R	                  S5      XX45        [        U5      nSnU R                  S5       H)  nUR                  U5      (       d  M  U[        U5      S n  O   [        X[        U5      [        U5      [        U5      [        U 5      5      sSSS5        sSSS5        sSSS5        sSSS5        $ ! , (       d  f       O= fSSS5        O! , (       d  f       O= fSSS5        O! , (       d  f       O= fSSS5        g! , (       d  f       g= f)z2
Return a tuple of the parts of the given triple.
Úutf8Ú Ú-N)r
   r   r   ÚLLVMPY_GetTriplePartsÚencoder   ÚsplitÚ
startswithÚlenr   Úget_object_format)r!   ÚarchÚvendorÚosÚenvÚsubarchÚ_strs          r   Úget_triple_partsr2      s  € ô 
×	Ò	Ô	˜tÜ×ÒÔ &Ü×ÒÔ "¤c×&6Ò&6Ô&8¸CÜ�‰×%Ñ% f§m¡m°FÓ&;Ø&*°Bô	=ä�4‹yˆØˆØ—L‘L Ö%ˆDØ�‰˜t×$Ó$Øœs 4›y˜zÐ*�Ùñ &ô �d¤S¨£[´#°b³'Ü˜#“hÔ 1°&Ó 9ó;÷ '9Ð&8×Ð÷ Ð÷ 
Ñ	ç&8Õ&8ú××Öú÷ ×Öú÷ 
×	Ö	úsf   –E9¬EÁEÁA&D+	ÃAD+	Ä	EÄ	EÄ	E9Ä+
D9Ä5EÄ<	EÅ
EÅEÅ	E9Å
E-	Å)E9Å9
Fc                   ó"   • \ rS rSrSrSS jrSrg)Ú
FeatureMapé1   zy
Maps feature name to a boolean indicating the availability of the feature.
Extends ``dict`` to add `.flatten()` method.
c                 ó¶   ^• U(       a  [        U R                  5       5      O[        U R                  5       5      nSSS.mSR                  U4S jU 5       5      $ )a(  
Args
----
sort: bool
    Optional.  If True, the features are sorted by name; otherwise,
    the ordering is unstable between python session due to hash
    randomization.  Defaults to True.

Returns a string suitable for use as the ``features`` argument to
``Target.create_target_machine()``.

Ú+r%   )TFÚ,c              3   óR   >#   • U  H  u  pS R                  TU   U5      v •  M     g7f)z{0}{1}N)Úformat)Ú.0ÚkÚvÚflag_maps      €r   Ú	<genexpr>Ú%FeatureMap.flatten.<locals>.<genexpr>F   s,   øé € ð .Ú$,™D˜Að !Ÿ™¨°©°Q×7Ð7Ú$,ùs   ƒ$')ÚsortedÚitemsÚiterÚjoin)ÚselfÚsortÚiteratorr>   s      @r   ÚflattenÚFeatureMap.flatten7   sL   ø€ ö ,0”6˜$Ÿ*™*›,Ô'´T¸$¿*¹*»,Ó5GˆØ cÑ*ˆØ�x‰xô .Ù$,ó.ó .ð 	.ó    © N)T)Ú__name__Ú
__module__Ú__qualname__Ú__firstlineno__Ú__doc__rH   Ú__static_attributes__rK   rJ   r   r4   r4   1   s   † ñ÷
.rJ   r4   c                  ó`  • [         R                  " 5        n [        5       n[         R                  R	                  U 5      (       d  UsSSS5        $ SSS.n[        U 5      nU(       a-  UR                  S5       H  nU(       d  M  X$S      XSS '   M     UsSSS5        $ ! , (       d  f       g= f)a?  
Returns a dictionary-like object indicating the CPU features for current
architecture and whether they are enabled for this CPU.  The key-value pairs
are the feature name as string and a boolean indicating whether the feature
is available.  The returned value is an instance of ``FeatureMap`` class,
which adds a new method ``.flatten()`` for returning a string suitable for
use as the "features" argument to ``Target.create_target_machine()``.

If LLVM has not implemented this feature or it fails to get the information,
this function will raise a RuntimeError exception.
NTF)r7   r%   r8   r   é   )r
   r   r4   r   ÚLLVMPY_GetHostCPUFeaturesr   r(   )r   Úoutdictr>   ÚcontentÚfeats        r   Úget_host_cpu_featuresrX   J   s�   € ô 
×	Ò	Ô	˜sÜ“,ˆÜ�w‰w×0Ñ0°×5Ñ5Ø÷ 
Ñ	ð  EÑ*ˆÜ�c“(ˆÞØŸ™ cÖ*�ß�4Ø(0°a±Ñ(9�G  ˜HÓ%ñ +ð ÷ 
×	×	ús   –0BÁ0BÂBÂ
B-c                  ó¶   • [         R                  " 5        n [         R                  R                  U 5        [	        U 5      sSSS5        $ ! , (       d  f       g= f)zJ
Return the default target triple LLVM is configured to produce code for.
N)r
   r   r   ÚLLVMPY_GetDefaultTargetTripler   r   s    r   Úget_default_tripler[   c   s7   € ô 
×	Ò	Ô	˜sÜ�‰×-Ñ-¨cÔ2Ü�3‹x÷ 
×	×	úr    c                  ó¶   • [         R                  " 5        n [         R                  R                  U 5        [	        U 5      sSSS5        $ ! , (       d  f       g= f)za
Get the name of the host's CPU, suitable for using with
:meth:`Target.create_target_machine()`.
N)r
   r   r   ÚLLVMPY_GetHostCPUNamer   r   s    r   Úget_host_cpu_namer^   l   s7   € ô
 
×	Ò	Ô	˜sÜ�‰×%Ñ% cÔ*Ü�3‹x÷ 
×	×	úr    ÚUnknownÚCOFFÚDXContainerÚELFÚGOFFÚMachOÚSPIRVÚWasmÚXCOFF)	r   rS   é   é   é   é   é   é   é   c                 ó~   • U c
  [        5       n [        R                  R                  [	        U 5      5      n[
        U   $ )zn
Get the object format for the given *triple* string (or the default
triple if omitted).
A string is returned
)r[   r
   r   ÚLLVMPY_GetTripleObjectFormatr   Ú_object_formats)r!   Úress     r   r+   r+   ‡   s5   € ð �~Ü#Ó%ˆÜ
�'‰'×
.Ñ
.¬~¸fÓ/EÓ
F€CÜ˜3ÑÐrJ   c                 ód   • [        [        R                  R                  [	        U 5      5      5      $ )z=
Create a TargetData instance for the given *layout* string.
)Ú
TargetDatar
   r   ÚLLVMPY_CreateTargetDatar   )Úlayouts    r   Úcreate_target_datarw   “   s#   € ô ”c—g‘g×5Ñ5´nÀVÓ6LÓMÓNÐNrJ   c                   ó6   • \ rS rSrSrS rS rS rS rS r	Sr
g	)
rt   éš   zo
A TargetData provides structured access to a data layout.
Use :func:`create_target_data` to create instances.
c                 óÚ   • U R                   (       a  g[        R                  " 5        n[        R                  R	                  X5        [        U5      sS S S 5        $ ! , (       d  f       g = f)Nz<dead TargetData>)Ú_closedr
   r   r   Ú LLVMPY_CopyStringRepOfTargetDatar   ©rE   r   s     r   Ú__str__ÚTargetData.__str__    s?   € Ø�<�<Ø&Ü×ÒÔ 3Ü�G‰G×4Ñ4°TÔ?Ü�s“8÷  ××ús   ¨*AÁ
A*c                 ó:   • U R                   R                  U 5        g ©N)Ú_capiÚLLVMPY_DisposeTargetData©rE   s    r   Ú_disposeÚTargetData._dispose§   s   € Ø�
‰
×+Ñ+¨DÕ1rJ   c                 ó@   • [         R                  R                  X5      $ )z!
Get ABI size of LLVM type *ty*.
)r
   r   ÚLLVMPY_ABISizeOfType©rE   Útys     r   Úget_abi_sizeÚTargetData.get_abi_sizeª   s   € ô �w‰w×+Ñ+¨DÓ5Ð5rJ   c                 óš   • [         R                  R                  XU5      nUS:X  a$  [        SR	                  U[        U5      5      5      eU$ )z<
Get byte offset of type's ty element at the given position
éÿÿÿÿzQCould not determined offset of {}th element of the type '{}'. Is it a structtype?)r
   r   ÚLLVMPY_OffsetOfElementÚ
ValueErrorr:   r   )rE   rŠ   ÚpositionÚoffsets       r   Úget_element_offsetÚTargetData.get_element_offset°   sL   € ô
 —‘×/Ñ/°¸(ÓCˆØ�R‹<Üð %ç%+¡V¨H´c¸"³gÓ%>ó@ð @ð ˆrJ   c                 ó@   • [         R                  R                  X5      $ )z.
Get minimum ABI alignment of LLVM type *ty*.
)r
   r   ÚLLVMPY_ABIAlignmentOfTyper‰   s     r   Úget_abi_alignmentÚTargetData.get_abi_alignment¼   s   € ô �w‰w×0Ñ0°Ó:Ð:rJ   rK   N)rL   rM   rN   rO   rP   r~   r…   r‹   r“   r—   rQ   rK   rJ   r   rt   rt   š   s    † ñò
ò2ò6ò
õ;rJ   rt   )ÚdefaultÚstaticÚpicÚdynamicnopic)r™   Ú
jitdefaultÚsmallÚkernelÚmediumÚlargec                   ó~   • \ rS rSrSr\S 5       r\S 5       r\S 5       r	\S 5       r
\S 5       rS r   SS	 jrS
rg)ÚTargetéÈ   r$   c                 ó8   • [        5       nU R                  U5      $ )z2
Create a Target instance for the default triple.
)r[   Úfrom_triple)Úclsr!   s     r   Úfrom_default_tripleÚTarget.from_default_tripleÎ   s   € ô
 $Ó%ˆØ�‰˜vÓ&Ð&rJ   c                 ó  • [         R                  " 5        n[         R                  R                  UR	                  S5      U5      nU(       d  [        [        U5      5      eU " U5      nXl        UsSSS5        $ ! , (       d  f       g= f)z;
Create a Target instance for the given triple (a string).
r#   N)r
   r   r   ÚLLVMPY_GetTargetFromTripler'   ÚRuntimeErrorr   Ú_triple)r§   r!   ÚouterrÚtargets       r   r¦   ÚTarget.from_tripleÖ   sd   € ô
 ×ÒÔ 6Ü—W‘W×7Ñ7¸¿¹ÀfÓ8MØ8>ó@ˆFæÜ"¤3 v£;Ó/Ð/Ù˜“[ˆFØ#ŒNØ÷  ××ús   –AA:Á:
Bc                 óV   • [         R                  R                  U 5      n[        U5      $ r�   )r
   r   ÚLLVMPY_GetTargetNamer   ©rE   Úss     r   ÚnameÚTarget.nameä   s!   € ä�G‰G×(Ñ(¨Ó.ˆÜ˜aÓ Ð rJ   c                 óV   • [         R                  R                  U 5      n[        U5      $ r�   )r
   r   ÚLLVMPY_GetTargetDescriptionr   r³   s     r   ÚdescriptionÚTarget.descriptioné   s!   € ä�G‰G×/Ñ/°Ó5ˆÜ˜aÓ Ð rJ   c                 ó   • U R                   $ r�   )r­   r„   s    r   r!   ÚTarget.tripleî   s   € à�|‰|ÐrJ   c                 óN   • SR                  U R                  U R                  5      $ )Nz<Target {0} ({1})>)r:   rµ   r¹   r„   s    r   r~   ÚTarget.__str__ò   s   € Ø#×*Ñ*¨4¯9©9°d×6FÑ6FÓGÐGrJ   c	                 óÆ  • SUs=::  a  S::  d   e   eU[         ;   d   eU[        ;   d   eU R                  n	[        R                  S:X  a  US:X  a  U	S-  n	[
        R                  R                  U [        U	5      [        U5      [        U5      U[        U5      [        U5      [        U5      [        U5      [        U5      5
      n
U
(       a  [        U
5      $ [        S5      e)a  
Create a new TargetMachine for this target and the given options.

Specifying codemodel='default' will result in the use of the "small"
code model. Specifying codemodel='jitdefault' will result in the code
model being picked based on platform bitness (32="small", 64="large").

The `printmc` option corresponds to llvm's `-print-machineinstrs`.

The `jit` option should be set when the target-machine is to be used
in a JIT engine.

The `abiname` option specifies the ABI. RISC-V targets with hard-float
needs to pass the ABI name to LLVM.
r   ri   Úntr�   z-elfzCannot create target machine)ÚRELOCÚ	CODEMODELr­   r.   rµ   r
   r   ÚLLVMPY_CreateTargetMachiner   ÚintÚTargetMachiner¬   )rE   ÚcpuÚfeaturesÚoptÚrelocÚ	codemodelÚprintmcÚjitÚabinamer!   Útms              r   Úcreate_target_machineÚTarget.create_target_machineõ   sÍ   € ð$ �C�}˜1‹}Ð‰}Ðˆ}Øœ‹~Ðˆ~ØœIÓ%Ð%Ð%Ø—‘ˆô �7‰7�d‹?˜y¨LÓ8Ø�fÑˆFÜ�W‰W×/Ñ/°Ü0>¸vÓ0FÜ0>¸sÓ0CÜ0>¸xÓ0HØ03Ü0>¸uÓ0EÜ0>¸yÓ0IÜ03°G³Ü03°C³Ü0>¸wÓ0Gó
2ˆö Ü  Ó$Ð$äÐ=Ó>Ð>rJ   rK   N)r$   r$   rh   r™   r�   FFr$   )rL   rM   rN   rO   r­   Úclassmethodr¨   r¦   Úpropertyrµ   r¹   r!   r~   rÏ   rQ   rK   rJ   r   r£   r£   È   s�   † Ø€Gð
 ñ'ó ð'ð ñó ðð ñ!ó ð!ð ñ!ó ð!ð ñó ðòHð 68Ø@LØ@B÷)?rJ   r£   c                   ó\   • \ rS rSrS rS rS rS rS rSS jr	\
S 5       r\
S	 5       rS
rg)rÅ   i!  c                 ó:   • U R                   R                  U 5        g r�   )r‚   ÚLLVMPY_DisposeTargetMachiner„   s    r   r…   ÚTargetMachine._dispose#  s   € Ø�
‰
×.Ñ.¨tÕ4rJ   c                 óB   • [         R                  R                  X5        g)zG
Register analysis passes for this target machine with a pass manager.
N)r
   r   ÚLLVMPY_AddAnalysisPasses)rE   Úpms     r   Úadd_analysis_passesÚ!TargetMachine.add_analysis_passes&  s   € ô 	�‰×(Ñ(¨Õ2rJ   c                 óB   • [         R                  R                  X5        g)zˆ
Set whether this target machine will emit assembly with human-readable
comments describing control flow, debug information, and so on.
N)r
   r   Ú#LLVMPY_SetTargetMachineAsmVerbosity)rE   Úverboses     r   Úset_asm_verbosityÚTargetMachine.set_asm_verbosity,  s   € ô
 	�‰×3Ñ3°DÕBrJ   c                 ó"   • U R                  USS9$ )zm
Represent the module as a code object, suitable for use with
the platform's linker.  Returns a byte string.
T©Ú
use_object)Ú_emit_to_memory©rE   Úmodules     r   Úemit_objectÚTargetMachine.emit_object3  s   € ð
 ×#Ñ# F°tÐ#Ð<Ð<rJ   c                 ó4   • [        U R                  USS95      $ )zx
Return the raw assembler of the module, as a string.

llvm.initialize_native_asmprinter() must have been called first.
Frâ   )r   rä   rå   s     r   Úemit_assemblyÚTargetMachine.emit_assembly:  s   € ô ˜d×2Ñ2°6ÀeÐ2ÐLÓMÐMrJ   c                 ó  • [         R                  " 5        n[         R                  R                  X[	        U5      U5      nU(       d  [        [        U5      5      e SSS5        [         R                  R                  W5      n[         R                  R                  U5      n [        XV5      [         R                  R                  U5        $ ! , (       d  f       Nw= f! [         R                  R                  U5        f = f)z€Returns bytes of object code of the module.

Args
----
use_object : bool
    Emit object code or (if False) emit assembly code.
N)r
   r   r   Ú LLVMPY_TargetMachineEmitToMemoryrÄ   r¬   r   ÚLLVMPY_GetBufferStartÚLLVMPY_GetBufferSizer	   ÚLLVMPY_DisposeMemoryBuffer)rE   ræ   rã   r®   ÚmbÚbufptrÚbufszs          r   rä   ÚTargetMachine._emit_to_memoryB  s¸   € ô ×ÒÔ 6Ü—‘×9Ñ9¸$Ü:=¸j»/Ø:@óBˆBö Ü"¤3 v£;Ó/Ð/ð ÷	  ô —‘×.Ñ.¨rÓ2ˆÜ—‘×,Ñ,¨RÓ0ˆð	3Ü˜VÓ+ä�G‰G×.Ñ.¨rÕ2÷  Õûô �G‰G×.Ñ.¨rÕ2ús   –ACÂ$
C Ã
CÃ!D c                 óR   • [        [        R                  R                  U 5      5      $ r�   )rt   r
   r   ÚLLVMPY_CreateTargetMachineDatar„   s    r   Útarget_dataÚTargetMachine.target_dataX  s   € äœ#Ÿ'™'×@Ñ@ÀÓFÓGÐGrJ   c                 ó¶   • [         R                  " 5        n[         R                  R                  X5        [	        U5      sS S S 5        $ ! , (       d  f       g = fr�   )r
   r   r   ÚLLVMPY_GetTargetMachineTripler   r}   s     r   r!   ÚTargetMachine.triple\  s5   € ä×ÒÔ 3Ü�G‰G×1Ñ1°$Ô<Ü�s“8÷  ××úr    rK   N)F)rL   rM   rN   rO   r…   rÚ   rß   rç   rê   rä   rÒ   r÷   r!   rQ   rK   rJ   r   rÅ   rÅ   !  sL   † ò5ò3òCò=òNô3ð, ñHó ðHð ñó órJ   rÅ   r�   )Lr.   Úctypesr   r   r   r   r   r   r	   Úllvmlite.bindingr
   Úllvmlite.binding.initfinir   Úllvmlite.binding.commonr   r   Úcollectionsr   Úllvmlite.binding.configr   Úhas_svmlr   r   r   r2   Údictr4   rX   r[   r^   Úllvm_version_majorrq   r+   rw   Ú	ObjectRefrt   Ú	frozensetrÁ   rÂ   r£   rÅ   r   r   Úargtypesr&   rT   ÚrestyperZ   r]   rp   ru   ÚLLVMTargetDataRefr|   rƒ   ÚLLVMTypeRefrˆ   r�   r–   r«   ÚLLVMTargetRefr²   r¸   rÃ   ÚLLVMTargetMachineRefrÕ   rú   rÝ   ÚLLVMPassManagerRefrØ   ÚLLVMModuleRefrí   ÚLLVMMemoryBufferRefrî   rï   rð   rö   rK   rJ   r   Ú<module>r     sQ  ðÛ 	÷)÷ )ñ )õ !Ý 7ß BÝ "õ :ñ 
�Hò <ó 
=€ò	ð;˜Sô ;ô&.�ô .ò2ò2òð ' qÑ)Ð ð ØØØØØØØØñ
€ô	 òOô&;�—‘ô &;ñR 	Ò>Ó?€Ùò  ó !€	ôV?ˆS�]‰]ô V?ôr?�C—M‘Mô ?ñJ -4°HÓ,=Ð+>€‡�× Ñ Ô (Ø*2±G¸HÓ4EÙ*1°(Ó*;¹WÀXÓ=NÙ*1°(Ó*;ð*=€‡�× Ñ Ô &ñ /6°hÓ.?Ð-@€‡�× !Ñ !Ô *Ø,1€‡�× !Ñ !Ô )á29¸(Ó2CÐ1D€‡�× %Ñ %Ô .á*1°(Ó*;Ð)<€‡�× Ñ Ô &à19°
€‡�× $Ñ $Ô -Ø/4€‡�× $Ñ $Ô ,à,4¨:€‡�× Ñ Ô (Ø*-×*?Ñ*?€‡�× Ñ Ô 'ð ×ÑÙˆHÓð5€‡�× (Ñ (Ô 1ð ×Ñð-€‡�×  Ñ  Ô )ð *-×)>Ñ)>Ø),¯©ð):€‡�× Ñ Ô %à'1€‡�× Ñ Ô $à+.×+@Ñ+@Ø+.¯?©?Ø+0ð+2€‡�× Ñ Ô 'ð *4€‡�× Ñ Ô &à.1×.CÑ.CØ.1¯o©oð.?€‡�× !Ñ !Ô *à,6€‡�× !Ñ !Ô )à/7¹ÀÓ9JÐ.K€‡�× "Ñ "Ô +Ø-0×->Ñ->€‡�× "Ñ "Ô *à),×):Ñ):Ð(;€‡�× Ñ Ô %Ø'/€‡�× Ñ Ô $à03×0AÑ0AÐ/B€‡�× #Ñ #Ô ,Ø.6€‡�× #Ñ #Ô +ð ×Ñàààà	ààà	à	àð'/€‡�× "Ñ "Ô +ð* .1×-EÑ-E€‡�× "Ñ "Ô *à03×0HÑ0HÐ/I€‡�× #Ñ #Ô ,à25×2JÑ2JÙ29¸(Ó2Cð2E€‡�× %Ñ %Ô .ð ×Ñ˜eð8%€‡�× +Ñ +Ô 4ð ×ÑØ×Ñð-€‡�×  Ñ  Ô )ð ×ÑØ×ÑØ	ÙˆHÓð	5€‡�× (Ñ (Ô 1ð 47×3JÑ3J€‡�× (Ñ (Ô 0à*-×*AÑ*AÐ)B€‡�× Ñ Ô &Ø(0€‡�× Ñ Ô %à),×)@Ñ)@Ð(A€‡�× Ñ Ô %Ø'/€‡�× Ñ Ô $à/2×/FÑ/FÐ.G€‡�× "Ñ "Ô +ð ×Ñð3€‡�× &Ñ &Ô /ð 25×1FÑ1F€‡�× &Ñ &Õ .rJ   