+
    åûjÜE  ã                   óê   € R t ^ RIHtHt ^ RIt^ RIHt ^ RIH	t	 ^ RI
HtHt ^ RIHtHt ^ RIHtHtHt ^RIHt R	 R
 ltR R ltR R ltR R ltRR R lltR R ltR R ltR R ltR R ltR# )zcCamera intrinsics and projection matrices: compose, decompose and build them for two-view geometry.)ÚTupleÚUnionN)Úqr)ÚKORNIA_CHECK_SHAPE)Ú
ShapeErrorÚValueCheckError)Úeye_likeÚvec_like)Ú_at_least_float32Ú_autocast_disabledÚ_torch_svd_cast)Úcross_product_matrixc                ód   € V ^8„  d   QhR\         R\        P                  R\        P                  /# )é   ÚfocalÚinputÚreturn)ÚfloatÚtorchÚTensor)Úformats   "Ú_C:\Ai_Coding\apps\studio\ComfyUI\.venv\Lib\site-packages\kornia\geometry\epipolar\projection.pyÚ__annotate__r   !   s)   € ÷ 0ñ 0œ5ð 0¬¯©ð 0¼%¿,¹,ñ 0ó    c                óô  € \        VP                  4      ^8w  d;   \        R\        VP                  4       R2\        VP                  4      . ROR7      hV ^ 8:  d   \	        RV  2V R7      hVP                  w   r#p\        ^V4      pVR;;,          V ,          uu&   VR	;;,          V ,          uu&   VR
;;,          RV,          ^,          ,          uu&   VR;;,          RV,          ^,          ,          uu&   V# )a^  Build a pinhole camera matrix per image of a batch from one focal length and the image size.

``K = intrinsics_like(focal, input)`` takes a focal length in pixels and a floating-point image batch
``(B, C, H, W)`` and returns ``(B, 3, 3)`` intrinsics with ``fx = fy = focal``, zero skew and the principal point
``(W / 2, H / 2)``, in the dtype and on the device of the images. That principal point is the half-pixel centre,
not the integer-pixel centre of kornia's grids (see the known defect below). For random intrinsics, use
:func:`random_intrinsics`; to resize existing ones with their image, :func:`scale_intrinsics`.

Convention:
    - ``focal`` must be positive and the input 4-D.
    - The input must be floating point, like kornia's images: an integer input raises by design rather than
      returning an integer ``K``.
    - Known defects: ``(W / 2, H / 2)`` is the half-pixel centre, not the integer-pixel centre
      ``((W - 1) / 2, (H - 1) / 2)`` of kornia's grids
      (`#4263 <https://github.com/kornia/kornia/issues/4263>`_).

Args:
    focal: the focal length for the camera matrix.
    input: image tensor that will determine the batch size and image height
      and width. It is assumed to be a floating-point tensor in the shape of ``(B, C, H, W)``.

Returns:
    The camera matrix with the shape of ``(B, 3, 3)``.

See Also:
    - :func:`random_intrinsics`: random focal lengths and principal point instead.
    - :func:`scale_intrinsics`: the intrinsics of a resized image.
    - :class:`~kornia.geometry.camera.pinhole.PinholeCamera`: a camera model that holds intrinsics and
      extrinsics together.

z(input must have shape (B, C, H, W), got Ú.)Úactual_shapeÚexpected_shapez(focal must not be zero or negative, got )Úactual_valueç      ð?)ÚBÚCÚHÚW©.é    r%   ©.é   r'   ©.r%   r   ©.r'   r   )ÚlenÚshaper   Úlistr   r   )r   r   Ú_r"   r#   Ú
intrinsicss   &&    r   Úintrinsics_liker/   !   sØ   € ô@ ˆ5�;‰;Ó˜1ÔÜØ6´t¸E¿K¹KÓ7HÐ6IÈÐKÜ˜eŸk™kÓ*Ú/ô
ð 	
ð
 �„zÜÐ HÈÈÐPÐ_dÔeÐeà—‘�J€A€qˆQä˜!˜UÓ#€JØˆy×˜UÕ"ÓØˆy×˜UÕ"ÓØˆy×˜S 1�W q�[Õ(ÓØˆy×˜S 1�W q�[Õ(ÓØÐr   c                ó¼   € V ^8„  d   QhR\         \        \        P                  3,          R\         \        \        P                  3,          R\        P                  /# )r   ÚlowÚhighr   )r   r   r   r   )r   s   "r   r   r   T   sD   € ÷ &ñ &œ5¤¬¯©Ð!4Õ5ð &¼UÄ5Ì%Ï,É,ÐCVÕ=Wð &Ô\a×\hÑ\hñ &r   c                ó<  € \         P                  P                  W4      pVP                  R4      pV^ ,          V^,          V^,          V^,          3w  rErg\         P                  ! VRV.RWW.. RO.VP
                  VP                  R7      pVP                  ^ 4      # )aÂ  Draw a random pinhole camera matrix with focal lengths and principal point uniform in one range.

``K = random_intrinsics(low, high)`` returns a ``(1, 3, 3)`` camera matrix with zero skew whose ``fx``, ``fy``,
``cx`` and ``cy`` are four independent draws from :math:`U(low, high)`, for synthetic data such as that of
:func:`generate_scene`. For deterministic intrinsics from a focal length and an image size, use
:func:`intrinsics_like`.

Convention:
    - The draws come from torch's global generator. The bounds are scalars; dtype and device follow tensor
      bounds, and Python floats give the default dtype and device.

Args:
    low: lower range (inclusive).
    high: upper range (exclusive).

Returns:
    the random camera matrix with the shape of ``(1, 3, 3)``.

See Also:
    - :func:`intrinsics_like`: deterministic intrinsics from a focal length and an image size.
    - :func:`generate_scene`: a random scene whose cameras share one such matrix.

ç        )ÚdtypeÚdevice)é   )r4   r4   r   )r   ÚdistributionsÚUniformÚsampleÚtensorr5   r6   Ú	unsqueeze)	r1   r2   ÚsamplerÚparamsÚfxÚfyÚcxÚcyÚcamera_matrixs	   &&       r   Úrandom_intrinsicsrD   T   sŒ   € ô0 ×!Ñ!×)Ñ)¨#Ó4€GØ�^‰^˜DÓ!€FØ˜A•Y  q¥	¨6°!­9°f¸QµiÐ?�N€BˆBÜ—L’L 2 s¨B -°#°r°ÂÐ!PÐXZ×X`ÑX`Ðik×irÑirÔs€MØ×"Ñ" 1Ó%Ð%r   c                óš   € V ^8„  d   QhR\         P                  R\        \        \         P                  3,          R\         P                  /# )r   rC   Úscale_factorr   )r   r   r   r   )r   s   "r   r   r   s   s:   € ÷ $ñ $¤E§L¡Lð $ÄÄeÌUÏ\É\ÐFYÕ@Zð $Ô_d×_kÑ_kñ $r   c                óÎ   € V P                  4       pVR;;,          V,          uu&   VR;;,          V,          uu&   VR;;,          V,          uu&   VR;;,          V,          uu&   V# )aŠ  Scale the focal lengths and principal point of camera matrices by an image resize factor.

``K_scaled = scale_intrinsics(camera_matrix, scale_factor)`` takes camera matrices ``(B, 3, 3)`` and a factor, a
float or a ``(B,)`` tensor, and returns a new tensor of the input's shape with ``fx``, ``fy``, ``cx`` and ``cy``
multiplied by it, for an image resized by that factor. This is the rule of
:meth:`~kornia.geometry.camera.pinhole.PinholeCamera.scale`, with its known defects (below): the principal point
does not follow kornia's integer pixel centres, and the skew is left unscaled. For the camera of a whole
:class:`~kornia.geometry.camera.pinhole.PinholeCamera`, use that method.

Convention:
    - Applies the rule of :meth:`~kornia.geometry.camera.pinhole.PinholeCamera.scale` and returns a new tensor.
    - Known defects: the principal-point rule of
      :meth:`~kornia.geometry.camera.pinhole.PinholeCamera.scale`, and the skew ``K[0, 1]``, which is left
      unscaled although resizing by ``scale_factor`` scales it
      (`#4263 <https://github.com/kornia/kornia/issues/4263>`_).

Args:
    camera_matrix: the camera calibration matrix containing the intrinsic
      parameters. The expected shape for the tensor is ``(B, 3, 3)``.
    scale_factor: the scaling factor to be applied: a float, or a tensor of shape ``(B,)`` that
      scales each batch element by its own factor.

Returns:
    The scaled camera matrix with the same shape as the input ``(B, 3, 3)``.

See Also:
    - :meth:`~kornia.geometry.camera.pinhole.PinholeCamera.scale`: the same rule on a camera model.
    - :func:`intrinsics_like`: new intrinsics from a focal length and an image size.

r$   r&   r(   r)   )Úclone)rC   rF   ÚK_scales   && r   Úscale_intrinsicsrJ   s   sW   € ð> ×!Ñ!Ó#€GØˆI×˜,Õ&ÓØˆI×˜,Õ&ÓØˆI×˜,Õ&ÓØˆI×˜,Õ&ÓØ€Nr   c                ó˜   € V ^8„  d   QhR\         P                  R\         P                  R\         P                  R\         P                  /# )r   ÚKÚRÚtr   ©r   r   )r   s   "r   r   r   š   s8   € ÷ -ñ -œ5Ÿ<™<ð -¬E¯L©Lð -¼U¿\¹\ð -ÌeÏlÉlñ -r   c           
     óÔ  € \        V . R	O4       \        V. R	O4       \        V. R
O4       \        V P                  4      \        VP                  4      u;8X  d   \        VP                  4      8X  gQ   M \        R\	        V P                  4       R\	        VP                  4       R\	        VP                  4       R24      h\
        P                  ! W.RR7      p\
        P                  P                  P                  V. RORR4      pVR;;,          R,          uu&   \
        P                  P                  P                  V . RORR4      pVR;;,          R,          uu&   W,          # )a  Compose the 3x4 projection matrix P = K [R | t] of intrinsics and a world-to-camera pose.

``P = projection_from_KRt(K, R, t)`` takes intrinsics ``(*, 3, 3)``, world-to-camera rotations ``(*, 3, 3)``
and translations ``(*, 3, 1)`` and returns the projection matrices :math:`P = K [R|t]`, ``(*, 3, 4)``, that take
homogeneous world points to homogeneous pixels. For the reverse, use :func:`KRt_from_projection`; for
``[R | t]`` without intrinsics, :func:`~kornia.geometry.transform.projection_from_Rt`.

Convention:
    - ``R`` and ``t`` take world points into the camera frame, ``X_cam = R @ X + t``, and ``K`` takes the
      camera frame to pixels. ``t`` is the extrinsic translation; the camera centre is ``-R.T @ t``.
    - ``K``, ``R`` and ``t`` must have the same number of dimensions, and ``R`` and ``t`` the same batch shape;
      ``K`` broadcasts against them. :func:`depth_from_point` gives the depth of a point in this camera.

Args:
   K: the camera matrix with the intrinsics with shape ``(*, 3, 3)``.
   R: The rotation matrix with shape ``(*, 3, 3)``.
   t: The translation vector with shape ``(*, 3, 1)``.

Returns:
   The projection matrix P with shape ``(*, 3, 4)``.

See Also:
    - :func:`KRt_from_projection`: the reverse, ``K``, ``R`` and ``t`` of a projection matrix.
    - :func:`~kornia.geometry.transform.projection_from_Rt`: ``[R | t]`` alone, without intrinsics.
    - :func:`depth_from_point`: the depth of points in the camera of this matrix.
    - :func:`triangulate_points`: 3D points from two such matrices and matched pixels.

zgK, R and t must have shapes (*, 3, 3), (*, 3, 3) and (*, 3, 1) with the same number of dimensions, got z, z and r   ©ÚdimÚconstantr4   r   )Ú*Ú3rU   )rT   rU   Ú1éÿÿÿÿ)r%   r%   r%   r'   ).rW   rW   )r%   r'   r%   r'   )
r   r*   r+   r   r,   r   ÚcatÚnnÚ
functionalÚpad)rL   rM   rN   ÚRtÚRt_hÚK_hs   &&&   r   Úprojection_from_KRtr_   š   s  € ô: �qš/Ô*Ü�qš/Ô*Ü�qš/Ô*Üˆq�w‰w‹<œ3˜qŸw™w›<Ö7¬3¨q¯w©w«<Ö7ÜðÜ˜Ÿ™“=�/ ¤D¨¯©£M ?°%¼¸Q¿W¹W»°ÀaðIó
ð 	
ô
 
�Š�A�6˜rÔ	"€BÜ�8‰8×Ñ×"Ñ" 2¢|°ZÀÓE€DØˆ×˜ÕÓä
�(‰(×
Ñ
×
!Ñ
! !¢\°:¸sÓ
C€CØˆ×˜ÕÓà�6€Mr   c          	      ó¸   € V ^8„  d   QhR\         P                  R\        R\        \         P                  \         P                  \         P                  3,          /# )r   ÚPÚepsr   )r   r   r   r   )r   s   "r   r   r   Ê   sC   € ÷ .1ñ .1œ5Ÿ<™<ð .1¬eð .1¼uÄUÇ\Á\ÔSX×S_ÑS_Ôaf×amÑamÐEmÕ?nñ .1r   c                óÈ  € \        V . ROR4       V P                  p\        P                  P	                  4       '       d   \        \        V 4      4      w  r4pMG\        V P                  P                  4      ;_uu_ 4        \        \        V 4      4      w  r4pRRR4       XP                  V4      XP                  V4      XP                  V4      3#   + '       g   i     LB; i)a  Decompose a 3x4 projection matrix into intrinsics, rotation and translation, with K [R | t] = +-P.

``K, R, t = KRt_from_projection(P)`` takes projection matrices ``(B, 3, 4)`` and returns, by an RQ decomposition
of their left ``3 x 3`` block, the intrinsics ``K`` ``(B, 3, 3)``, upper triangular with a positive diagonal, the
world-to-camera rotation ``R`` ``(B, 3, 3)`` with ``det R = 1`` and the translation ``t`` ``(B, 3, 1)``, not the
camera centre: the inverse of :func:`projection_from_KRt` up to the scale and sign of ``P``. ``K`` keeps the scale
of ``P``; divide it by ``K[..., 2:, 2:]`` for ``K[2, 2] = 1``.

Convention:
    - :ref:`Two-view geometry <two-view-conventions>` compares this with OpenCV's
      ``decomposeProjectionMatrix``, which returns the camera centre.
    - ``P`` is defined up to a nonzero scale, sign included: ``s * P`` gives the same ``R`` and ``t`` for
      every nonzero ``s`` and ``|s| * K``. So :math:`K [R|t]` is ``P`` when ``P[:, :3, :3]`` has positive
      determinant and ``-P`` when it has negative determinant (``-P`` gives the factors of ``P``). ``K`` is
      not normalised to ``K[2, 2] = 1``; divide by ``K[..., 2:, 2:]`` to normalise.
    - ``P`` must have exactly one batch dimension. A float16 or bfloat16 ``P`` is decomposed in float32 and the
      factors are returned in its dtype.
    - A caller's autocast region does not change the result, outside TorchScript.

Args:
    P: the projection matrix with shape ``(B, 3, 4)``.
    eps: unused; kept for backward compatibility. The sign of the triangular factor's diagonal is taken
      exactly.

Returns:
    - The Camera matrix with shape ``(B, 3, 3)``.
    - The Rotation matrix with shape ``(B, 3, 3)``.
    - The Translation vector with shape ``(B, 3, 1)``.

See Also:
    - :func:`projection_from_KRt`: the reverse, ``P = K [R | t]``.
    - :func:`projections_from_fundamental`: a projective camera pair consistent with a fundamental matrix; the
      left ``3 x 3`` block of its second camera has rank 2, so this decomposition gives no metric camera for it.

zP must have shape (B, 3, 4).N)r    rU   Ú4)r   r5   r   ÚjitÚis_scriptingÚ_KRt_from_projectionr
   r   r6   ÚtypeÚto)ra   rb   r5   rL   rM   rN   s   &&    r   ÚKRt_from_projectionrj   Ê   sž   € ôH �qš/Ð+IÔJð �G‰G€EÜ‡y�y×Ñ×ÒÜ&Ô'8¸Ó';Ó<‰ˆ‰aä §¡§¡×.Õ.Ü*Ô+<¸QÓ+?Ó@‰GˆA�!÷ /à�4‰4�‹;˜Ÿ™˜U› Q§T¡T¨%£[Ð0Ð0÷ /×.ús   Á?CÃC!	c                ó¬   € V ^8„  d   QhR\         P                  R\        \         P                  \         P                  \         P                  3,          /# )r   ra   r   ©r   r   r   )r   s   "r   r   r   û   s6   € ÷ ñ œEŸL™Lð ¬U´5·<±<ÄÇÁÌuÏ|É|Ð3[Õ-\ñ r   c           
      ó4  € V R,          pV R,          P                  R4      p\        P                  ! . RO. RO. RO.V P                  V P                  R7      P                  ^ 4      p\        P
                  ! W14      P                  ^ ^^4      p\        V4      w  rE\        P
                  ! W4P                  ^ ^^4      4      p\        P
                  ! V\        P
                  ! VP                  ^ ^^4      V4      4      p\        P                  ! VR	RR7      p\        P                  ! V^ 8  \        P                  ! V4      ) \        P                  ! V4      4      p\        P                  ! V4      p\        P
                  ! WX4      p	\        P
                  ! W„4      p
\        P                  P                  W’4      p\        P                  P                  V
4      R
,          ^ 8  p\        P                  ! WÊ) V
4      p
\        P                  ! WË) V4      pWšV3# )ºNNN)r6   r5   )Údim1Údim2)rn   ºr%   é   Nrq   )rn   rq   rr   rW   )r%   r%   r'   )r%   r'   r%   )r'   r%   r%   éþÿÿÿ)rn   NN)r<   r   r;   r6   r5   ÚmatmulÚpermuteÚ	linalg_qrÚdiagonalÚwhereÚ	ones_likeÚ
diag_embedÚlinalgÚsolveÚdet)ra   Ú
submat_3x3Úlast_columnÚreverseÚ	ortho_matÚ	upper_matÚ	diagonalsÚsignsÚ	signs_matrL   rM   rN   Úflips   &            r   rg   rg   û   s�  € Ø�;•€JØ�I•,×(Ñ(¨Ó,€Kô �lŠlšI¢y²)Ð<ÀQÇXÁXÐUV×U\ÑU\Ô]×gÑgÐhiÓj€GÜ—’˜gÓ2×:Ñ:¸1¸aÀÓC€JÜ$ ZÓ0Ñ€IÜ—’˜W×&7Ñ&7¸¸1¸aÓ&@ÓA€IÜ—’˜W¤e§l¢l°9×3DÑ3DÀQÈÈ1Ó3MÈwÓ&WÓX€Iô —’˜y¨r¸Ô;€IÜ�KŠK˜	 A™¬¯ª¸	Ó(BÐ'BÄEÇOÂOÐT]ÓD^Ó_€EÜ× Ò  Ó'€Iä�Š�YÓ*€AÜ�Š�YÓ*€AÜ�‰×Ñ˜1Ó*€Aô �<‰<×Ñ˜AÓ˜}Õ-°Ñ1€DÜ�Š�D˜"˜aÓ €AÜ�Š�D˜"˜aÓ €Aà�ˆ7€Nr   c                ó˜   € V ^8„  d   QhR\         P                  R\         P                  R\         P                  R\         P                  /# )r   rM   rN   ÚXr   rO   )r   s   "r   r   r     s8   € ÷ +ñ +œŸ™ð +¬¯©ð +¼%¿,¹,ð +Ì5Ï<É<ñ +r   c                ó`   € WP                  RR4      ,          pVR,          VR,          ,           # )ad  Compute the camera-frame depth of 3D points under a world-to-camera rotation and translation.

``depth = depth_from_point(R, t, X)`` takes a world-to-camera rotation ``(*, 3, 3)`` and translation
``(*, 3, 1)`` and points ``(*, N, 3)`` and returns the ``z`` coordinate of ``R @ X + t``, ``(*, N)``: the depth
of each point in the camera of :func:`projection_from_KRt` with the same ``R`` and ``t``, positive in front of
it. :func:`motion_from_essential_choose_solution` tests its candidate poses with it.

Convention:
    - The sign is not checked. An ``X`` of shape ``(B, 3)`` with a batched ``R`` is read as ``B`` points seen
      by every camera and gives ``(B, B)``, not one point per camera.

Args:
   R: The rotation matrix with shape ``(*, 3, 3)``.
   t: The translation vector with shape ``(*, 3, 1)``.
   X: The 3d points with shape ``(*, N, 3)``.

Returns:
   The depth value per point with shape ``(*, N)``.

See Also:
    - :func:`projection_from_KRt`: the projection matrix of the camera this depth is measured in.
    - :func:`triangulate_points`: the 3D points of matched pixels, whose depths this measures.

rs   rW   ).r   rn   )Ú	transpose)rM   rN   rˆ   ÚX_tmps   &&& r   Údepth_from_pointrŒ     s+   € ð2 —‘˜B Ó#Õ#€EØ�Õ˜a 	�lÕ*Ð*r   c                óŽ   € V ^8„  d   QhR\         P                  R\        \         P                  \         P                  3,          /# )r   ÚAr   rl   )r   s   "r   r   r   :  s0   € ÷ "ñ "”%—,‘,ð "¤5¬¯©´u·|±|Ð)CÕ#Dñ "r   c                óB   € \        V 4      w  rpVR,          VR,          3# )z_Compute the null space of A.

Return the smallest singular value and the corresponding vector.
).rW   )r   )rŽ   r-   ÚsÚvs   &   r   Ú
_nullspacer’   :  s%   € ô
 ˜aÓ �G€Aˆ!ØˆW�:�q˜•zÐ!Ð!r   c                óX   € V ^8„  d   QhR\         P                  R\         P                  /# )r   ÚF_matr   rO   )r   s   "r   r   r   C  s"   € ÷ *)ñ *)¬¯©ð *)¼¿¹ñ *)r   c                óZ  € \        V . ROR4       \        ^V 4      p\        ^V 4      pV P                  RR4      p\	        V4      w  rE\        V4      V ,          pVR,          p\        P                  ! W.RR7      p\        P                  ! Wg.RR7      p	\        P                  ! W‰.RR7      # )a\  Build a canonical pair of projection matrices consistent with a fundamental matrix.

``P = projections_from_fundamental(F_mat)`` takes fundamental matrices ``(B, 3, 3)`` in the
:math:`x_2^\top F x_1 = 0` order of :func:`find_fundamental` and returns the canonical camera pair of Hartley
and Zisserman, ``(B, 3, 4, 2)`` with the two matrices stacked on the last dimension, for which
:func:`fundamental_from_projections` gives back ``F`` up to scale. The pair is determined only up to a
projective transformation of the world, so it is not a metric pose; for the rotation and translation of
calibrated cameras, use :func:`motion_from_essential_choose_solution` on an essential matrix.

Convention:
    - ``[..., 0] = [I | 0]`` for the first image and ``[..., 1] = [[e2]_x F | e2]``, with ``e2`` the
      left null vector of ``F``, the epipole in the second image (``e2^T F = 0``).
    - ``F_mat`` must have exactly one batch dimension.

Args:
   F_mat: the fundamental matrix with the shape ``(B, 3, 3)``.

Returns:
    The projection matrices with shape ``(B, 3, 4, 2)``.

See Also:
    - :func:`fundamental_from_projections`: the reverse, the fundamental matrix of two projection matrices.
    - :func:`triangulate_points`: a projective reconstruction of matched pixels from this pair.
    - :func:`KRt_from_projection`: the decomposition of a metric projection matrix.

z F_mat must have shape (B, 3, 3).rQ   )r    rU   rU   rs   rW   ).rn   N)	r   r   r	   rŠ   r’   r   r   rX   Ústack)
r”   ÚR1Út1ÚFt_matr-   Úe2ÚR2Út2ÚP1ÚP2s
   &         r   Úprojections_from_fundamentalrŸ   C  s•   € ô6 �ušoÐ/QÔRä	�!�UÓ	€BÜ	�!�UÓ	€Bà�_‰_˜R Ó$€Fä�vÓ�E€Aä	˜bÓ	! EÕ	)€BØ	ˆLÕ	€Bä	�Š�B�8 Ô	$€BÜ	�Š�B�8 Ô	$€Bä�;Š;˜�x RÔ(Ð(r   )g�íµ ÷Æ°>)Ú__doc__Útypingr   r   r   Útorch.linalgr   rv   Úkornia.core.checkr   Úkornia.core.exceptionsr   r   Úkornia.core.opsr   r	   Úkornia.core.utilsr
   r   r   Únumericr   r/   rD   rJ   r_   rj   rg   rŒ   r’   rŸ   © r   r   Ú<module>r©      sX   ðñ$ jç ã Ý (å 0ß >ß .ß TÑ Tå )õ0õf&õ>$õN-÷`.1õbõ>+õ@"÷*)r   