+
    åûjpF  ã                   ó¾   € ^ RI t ^ RIHtHt ^ RIt^ RIHt ^ RIHt RR R llt	RR R llt
RR	 R
 l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R R lltR# )é    N)ÚOptionalÚTuple)Ú_check_async)Ú
ShapeErrorc                óÚ   € V ^8„  d   QhR\         P                  R\         P                  R\         P                  R\        R\        \         P                  \         P                  3,          /# )é   ÚvaluesÚbinsÚsigmaÚepsilonÚreturn)ÚtorchÚTensorÚfloatr   )Úformats   "ÚTC:\Ai_Coding\apps\studio\ComfyUI\.venv\Lib\site-packages\kornia\enhance\histogram.pyÚ__annotate__r      sR   € ÷ .ñ .Ü�L‰Lð.Ü %§¡ð.Ü5:·\±\ð.ÜLQð.ä
Œ5�<‰<œŸ™Ð%Õ&ñ.ó    c                ó   € \        V \        P                  4      '       g   \        R\	        V 4       24      h\        V\        P                  4      '       g   \        R\	        V4       24      h\        V\        P                  4      '       g   \        R\	        V4       24      hV P                  4       ^8X  g   \        RV P                   24      hVP                  4       ^8X  g   \        RVP                   24      hVP                  4       ^ 8X  g   \        RVP                   24      h\        \        P                  ! V4      V^ 8„  ,          R4       WP                  ^ 4      P                  ^ 4      ,
          p\        P                  ! R	WB,          P                  ^4      ,          4      p\        P                  ! V^R7      p\        P                  ! V^R7      P                  ^4      V,           pWg,          pWe3# )
a‹  Calculate the marginal probability distribution function of the input based on the number of histogram bins.

Args:
    values: shape [BxNx1].
    bins: shape [NUM_BINS].
    sigma: shape [1], gaussian smoothing factor.
    epsilon: scalar, for numerical stability.

Returns:
    Tuple[torch.Tensor, torch.Tensor]:
      - torch.Tensor: shape [BxN].
      - torch.Tensor: shape [BxNxNUM_BINS].

z-Input values type is not a torch.Tensor. Got z+Input bins type is not a torch.Tensor. Got z,Input sigma type is not a torch.Tensor. Got z/Input values must be a of the shape BxNx1. Got z0Input bins must be a of the shape NUM_BINS. Got z*Input sigma must be a of the shape 1. Got z/Bandwidth must be finite and greater than zero.©Údimç      à¿)Ú
isinstancer   r   Ú	TypeErrorÚtyper   Ú
ValueErrorÚshaper   ÚisfiniteÚ	unsqueezeÚexpÚpowÚmeanÚsum)r	   r
   r   r   Ú	residualsÚkernel_valuesÚpdfÚnormalizations   &&&&    r   Úmarginal_pdfr(      s‡  € ô" �fœeŸl™l×+Ò+ÜÐGÌÈVËÀ~ÐVÓWÐWä�dœEŸL™L×)Ò)ÜÐEÄdÈ4ÃjÀ\ÐRÓSÐSä�eœUŸ\™\×*Ò*ÜÐFÄtÈEÃ{ÀmÐTÓUÐUà�:‰:‹<˜1ÔÜÐJÈ6Ï<É<È.ÐYÓZÐZà�8‰8‹:˜Œ?ÜÐKÈDÏJÉJÈ<ÐXÓYÐYà�9‰9‹;˜!ÔÜÐEÀeÇkÁkÀ]ÐSÓTÐTô ”—’ Ó&¨%°!©)Õ4Ð6gÔhàŸ™¨Ó*×4Ñ4°QÓ7Õ7€IÜ—I’I˜d iÕ&7×%<Ñ%<¸QÓ%?Õ?Ó@€Mä
�*Š*�]¨Ô
*€CÜ—I’I˜c qÔ)×3Ñ3°AÓ6¸Õ@€MØ
Õ
€CàÐÐr   c                ó„   € V ^8„  d   QhR\         P                  R\         P                  R\        R\         P                  /# )r   Úkernel_values1Úkernel_values2r   r   ©r   r   r   )r   s   "r   r   r   L   s8   € ÷  /ñ  /œeŸl™lð  /¼E¿L¹Lð  /ÔSXð  /Ôej×eqÑeqñ  /r   c                óÐ  € \        V \        P                  4      '       g   \        R\	        V 4       24      h\        V\        P                  4      '       g   \        R\	        V4       24      hV P                  4       ^8X  g   \        RV P                   24      hVP                  4       ^8X  g   \        RVP                   24      hV P                  VP                  8w  d&   \        RV P                   RVP                   24      h\        P                  ! V P                  ^^4      V4      p\        P                  ! VRR7      P                  R	^^4      V,           pW4,          # )
a'  Calculate the joint probability distribution function of the input tensors based on the number of histogram bins.

Args:
    kernel_values1: shape [BxNxNUM_BINS].
    kernel_values2: shape [BxNxNUM_BINS].
    epsilon: scalar, for numerical stability.

Returns:
    shape [BxNUM_BINSxNUM_BINS].

z5Input kernel_values1 type is not a torch.Tensor. Got z5Input kernel_values2 type is not a torch.Tensor. Got z5Input kernel_values1 must be a of the shape BxN. Got z5Input kernel_values2 must be a of the shape BxN. Got zGInputs kernel_values1 and kernel_values2 must have the same shape. Got z and r   )é   r   éÿÿÿÿ)r   r   r   r   r   r   r   r   ÚmatmulÚ	transposer#   Úview)r*   r+   r   Újoint_kernel_valuesr'   s   &&&  r   Ú	joint_pdfr4   L   sH  € ô �n¤e§l¡l×3Ò3ÜÐOÔPTÐUcÓPdÐOeÐfÓgÐgä�n¤e§l¡l×3Ò3ÜÐOÔPTÐUcÓPdÐOeÐfÓgÐgà×ÑÓ 1Ô$ÜÐPÐQ_×QeÑQeÐPfÐgÓhÐhà×ÑÓ 1Ô$ÜÐPÐQ_×QeÑQeÐPfÐgÓhÐhà×Ñ˜~×3Ñ3Ô3ÜðØ"×(Ñ(Ð)¨¨~×/CÑ/CÐ.DðFó
ð 	
ô
  Ÿ,š, ~×'?Ñ'?ÀÀ1Ó'EÀ~ÓVÐÜ—I’IÐ1°vÔ>×CÑCÀBÈÈ1ÓMÐPWÕW€MØÕ.Ð.r   c          
      ó¤   € V ^8„  d   QhR\         P                  R\         P                  R\         P                  R\        R\         P                  /# )r   Úxr
   Ú	bandwidthr   r   r,   )r   s   "r   r   r   o   sC   € ÷ -ñ -”—‘ð -¤U§\¡\ð -¼e¿l¹lð -ÔUZð -Ôgl×gsÑgsñ -r   c                ó–  € \         P                  ! V P                  VP                  4      pV\         P                  \         P                  39   d[   \        V P                  4       P                  ^4      VP                  4       VP                  4       V4      w  rVVP                  V4      # \        V P                  ^4      WV4      w  rVV# )aõ  Estimate the normalized histogram of each sample row with Gaussian kernels.

``hist = histogram(x, bins, bandwidth)`` spreads every value of a row of ``x`` over the bin centers ``bins`` with a
Gaussian kernel and normalizes each row to sum to 1, with ``epsilon`` added to the divisor.

Convention:
    - Rows are independent samples, and ``bins`` is the one center grid they share.
    - A ``bandwidth`` that is not finite and positive raises ``RuntimeError``; on CUDA, and on MPS from torch 2.13,
      it raises by the next synchronization.
    - For float16 and bfloat16 samples and bins, the kernels are evaluated in float32 and the result is cast back to
      that dtype.

Args:
    x: samples with shape ``(B, D)``.
    bins: bin centers with shape ``(N_bins,)``, in the units of ``x``.
    bandwidth: 0-d tensor, the standard deviation of the Gaussian kernel in the units of ``x``. A Python float or a
        ``(1,)`` tensor raises.
    epsilon: value added to the normalization sum.

Returns:
    Histogram with shape ``(B, N_bins)``. When all kernel weights underflow to zero, it is zero for a positive
    ``epsilon`` and NaN for ``epsilon=0``.

See Also:
    - :func:`histogram2d`: the joint histogram of two sample rows.
    - :func:`image_histogram2d`: counts the pixels of each image channel, with a choice of kernel.

Examples:
    >>> x = torch.rand(1, 10)
    >>> bins = torch.linspace(0, 1, 128)
    >>> hist = histogram(x, bins, bandwidth=torch.tensor(0.01))
    >>> hist.shape
    torch.Size([1, 128])

)	r   Úpromote_typesÚdtypeÚfloat16Úbfloat16r(   r   r   Úto)r6   r
   r7   r   Úkernel_dtyper&   Ú_s   &&&&   r   Ú	histogramr@   o   s‘   € ôL ×&Ò& q§w¡w°·
±
Ó;€LØœŸ™¤u§~¡~Ð6Ô6Ü˜aŸg™g›i×1Ñ1°!Ó4°d·j±j³lÀIÇOÁOÓDUÐW^Ó_‰ˆØ�v‰v�lÓ#Ð#ä˜!Ÿ+™+ a›.¨$¸7ÓC�F€Cà€Jr   c                óÄ   € V ^8„  d   QhR\         P                  R\         P                  R\         P                  R\         P                  R\        R\         P                  /# )r   Úx1Úx2r
   r7   r   r   r,   )r   s   "r   r   r   Ÿ   sX   € ÷ -Oñ -OÜ�‰ð-OÜŸ,™,ð-OÜ.3¯l©lð-OÜGLÇ|Á|ð-OÜ^cð-Oä
‡\�\ñ-Or   c                óÒ  € \         P                  ! V P                  VP                  4      pV\         P                  \         P                  39   dB   V P                  4       VP                  4       VP                  4       VP                  4       3w  rr#\        V P                  ^4      W#V4      w  rg\        VP                  ^4      W#V4      w  rh\        WxV4      P                  V4      # )a®  Estimate the normalized joint histogram of two sample rows with Gaussian kernels.

``hist = histogram2d(x1, x2, bins, bandwidth)`` pairs ``x1[b, n]`` with ``x2[b, n]``: ``hist[b, i, j]`` is the
kernel weight of ``x1`` in bin ``i`` and ``x2`` in bin ``j``, normalized per batch element to sum to 1.

Convention:
    - ``x1`` and ``x2`` must have the same shape.
    - When ``x1`` and ``bins`` promote to float16 or bfloat16, the kernels, joint counts and normalization are
      evaluated in float32 and the result is cast back to that dtype.

Args:
    x1: first samples with shape ``(B, D)``.
    x2: second samples with shape ``(B, D)``.
    bins: bin centers with shape ``(N_bins,)``, in the units of the samples.
    bandwidth: 0-d tensor, the standard deviation of the Gaussian kernel in the units of the samples.
    epsilon: value added to the normalization sum.

Returns:
    Joint histogram with shape ``(B, N_bins, N_bins)``; the first bin axis belongs to ``x1``. All-zero kernel
    weights give zeros for a positive ``epsilon`` and NaN for ``epsilon=0``.

See Also:
    - :func:`histogram`: the histogram of one sample row.
    - :func:`image_histogram2d`: one histogram per image channel, not a joint one.

Examples:
    >>> x1 = torch.rand(2, 32)
    >>> x2 = torch.rand(2, 32)
    >>> bins = torch.linspace(0, 1, 128)
    >>> hist = histogram2d(x1, x2, bins, bandwidth=torch.tensor(0.01))
    >>> hist.shape
    torch.Size([2, 128, 128])

)
r   r9   r:   r;   r<   r   r(   r   r4   r=   )	rB   rC   r
   r7   r   r>   r?   r*   r+   s	   &&&&&    r   Úhistogram2drE   Ÿ   sª   € ôN ×&Ò& r§x¡x°·±Ó<€LØœŸ™¤u§~¡~Ð6Ô6Ø"$§(¡(£*¨b¯h©h«j¸$¿*¹*»,È	ÏÉÓHYÐ"YÑˆ�Ü$ R§\¡\°!£_°dÀwÓOÑ€AÜ$ R§\¡\°!£_°dÀwÓOÑ€Aä�^°WÓ=×@Ñ@ÀÓNÐNr   c                ó<   € V ^8„  d   QhR\         P                  RR/# )r   Úimager   N)r   r   )r   s   "r   r   r   Ï   s"   € ÷ oñ oœUŸ\™\ð o¨dñ or   c                óŒ   € V P                  4       ^8  g   V P                  4       ^8”  d   \        RV P                   R24      hR# )zdReject the ranks that image_histogram2d does not document instead of failing inside the computation.zCInput image must have shape (H, W), (C, H, W) or (B, C, H, W). Got Ú.N)r   r   r   )rG   s   &r   Ú_check_image_rankrJ   Ï   s>   € à‡y�yƒ{�Q„˜%Ÿ)™)›+¨œ/ÜÐ^Ð_d×_jÑ_jÐ^kÐklÐmÓnÐnñ *r   c                ó„   € V ^8„  d   QhR\         P                  R\         P                  R\        R\         P                  /# )r   ÚhistrG   Úauto_centersr   )r   r   Úbool)r   s   "r   r   r   Õ   s8   € ÷ ñ œuŸ|™|ð ´E·L±Lð ÔPTð ÔY^×YeÑYeñ r   c                óÖ   € V'       da   VP                  4       '       dK   VP                  \        P                  \        P                  39  d   V P                  VP                  4      # V # )a.  Hand back the image's dtype when it can represent the histogram counts.

Only for auto-built centers on a floating-point image: an integer image or explicit ``centers`` keep the promoted
dtype (at least float32), and half-precision counts stay float32 because ordinary image counts exceed their range.
)Úis_floating_pointr:   r   r;   r<   r=   )rL   rG   rM   s   &&&r   Ú_restore_float_dtyperQ   Õ   sH   € ÷ ˜×/Ñ/×1Ò1°e·k±kÌ%Ï-É-ÔY^×YgÑYgÐIhÔ6hØ�w‰w�u—{‘{Ó#Ð#Ø€Kr   c                ó0   € V ^8„  d   QhR\         R\        /# )r   Úvaluer   )r   rN   )r   s   "r   r   r   à   s   € ÷ (ñ (”eð (¤ñ (r   c                óh   € \         P                  ) T u;8  ;'       d    \         P                  8  # u # )zjSame as ``math.isfinite``, but traceable when Dynamo turns a changed float argument into a symbolic float.)ÚmathÚinf)rS   s   &r   Ú
_is_finiterW   à   s%   € ä�H‰Hˆ9�u×'Ô'œtŸx™xÑ'Ð'Ñ'Ð'r   c                óv   € V ^8„  d   QhR\         R\         R\        R\        \         ,          R\        R\         /# )r   ÚminÚmaxÚn_binsr7   rM   r   )r   Úintr   rN   )r   s   "r   r   r   å   s@   € ÷ ñ Ü	ðÜðÜ$'ðÜ4<¼UµOðÜSWðä
ñr   c                ój  € VRJ ;'       g    VR	8H  pV'       g	   V'       dQ   V^ 8:  d   \        RV R24      h\        V 4      '       d   \        V4      '       d   W8:  d   \        RV  RV R24      hVe   VR	8X  d   W,
          V,          p\        V4      '       d   VR8:  d   \        RV R24      hV# )
zRValidate the range needed for automatic values and resolve the bandwidth sentinel.NzIn_bins must be greater than zero for automatically generated values. Got rI   zOThe automatically generated histogram range must be finite and non-empty. Got [z, z].ç        z4Bandwidth must be finite and greater than zero. Got g      ð¿)r   rW   )rY   rZ   r[   r7   rM   Úauto_bandwidths   &&&&& r   Ú_validate_histogram_bandwidthr`   å   sÃ   € ð  $Ð&×;Ð;¨)°tÑ*;€Nß—~Ø�QŒ;ÜÐhÐioÐhpÐpqÐrÓsÐsÜ˜#�Š¤j°§o¢o¸¼ÜØaÐbeÐafÐfhÐilÐhmÐmoÐpóð ð Ò˜I¨Ô-Ø•Y &Õ(ˆ	ä�i× Ò  I°Ô$4ÜÐOÐPYÈ{ÐZ[Ð\Ó]Ð]ØÐr   c                ó.  € V ^8„  d   QhR\         P                  R\        R\        R\        R\        \        ,          R\        \         P                  ,          R\
        R\        R	\        R
\        \         P                  \         P                  3,          /
# )r   rG   rY   rZ   r[   r7   ÚcentersÚ
return_pdfÚkernelÚepsr   )r   r   r   r\   r   rN   Ústrr   )r   s   "r   r   r   ú   s›   € ÷ K(ñ K(Ü�<‰<ðK(ä	ðK(ô 
ðK(ô ð	K(ô
 œ�ðK(ô ”e—l‘lÕ#ðK(ô ðK(ô ðK(ô 
ðK(ô Œ5�<‰<œŸ™Ð%Õ&ñK(r   c	                óp	  € \        V \        P                  4      '       g   \        R\	        V 4       R24      h\        V 4       Ve9   \        V\        P                  4      '       g   \        R\	        V4       R24      hVeI   \        VP                  4      ^ 8”  d/   VP                  4       ^8w  d   \        RVP                   R24      h\        V\        4      '       g   \        R\	        V4       R24      h\        V\        4      '       g   \        R\	        V4       R24      h\        V\        4      '       g   \        R\	        V4       R24      hVe/   \        V\        4      '       g   \        R	\	        V4       R24      h\        V\        4      '       g   \        R
\	        V4       R24      hVe   VP                  4       ^ 8X  d   RpVRJ p	\        WW4V	4      pVe   VP                  M\        P                   p
\        P"                  ! \        P                   \        P"                  ! V P                  V
4      4      pVfF   W!,
          V,          pW\        P$                  ! W0P&                  VR7      R,           ,          ,           pVP)                  V4      P+                  R^^^^4      p\        P,                  ! V P)                  V4      P/                  ^ 4      V,
          4      V,          pVR8X  d&   \        P0                  ! RV^,          ,          4      pMnVR9   dY   V^8*  P)                  VP                  4      pVR8X  d   RV,
          V,          pM1VR8X  d   TpM'RV^,          ,
          V,          pM\        RV R24      h\        P2                  ! VRR7      P5                  ^^^ 4      p\7        VW	4      pV'       d�   \        P2                  ! VRRR7      V,           pVV,          pV P                  4       ^8X  d   VR,          pVR,          pVV3# V P                  4       ^8X  d#   VP9                  ^ 4      pVP9                  ^ 4      pVV3# V P                  4       ^8X  d   VR,          pM&V P                  4       ^8X  d   VP9                  ^ 4      pV\        P:                  ! V4      3# )ag  Estimate the intensity histogram of each channel of an image.

``hist, pdf = image_histogram2d(image, min, max, n_bins)`` weights every pixel over ``n_bins`` bin centers with a
kernel and returns the summed weights per channel as ``hist``, and their normalization as ``pdf`` if
``return_pdf=True``. Despite its name it is a one-dimensional histogram per channel; for the joint histogram of two
signals use :func:`histogram2d`.

Convention:
    - The spatial axes are the final two. An image ``(H, W)``, ``(C, H, W)`` or ``(B, C, H, W)`` gives ``hist`` with
      the same leading axes followed by the bins; another rank raises.
    - A pixel outside the range still adds the kernel's weight to the centers within reach; it is not clipped
      into an end bin.
    - Float16 and bfloat16 images are accumulated and returned in float32, or in the dtype of wider explicit
      ``centers``: ordinary bin counts exceed float16's range (65504) and bfloat16's precision.

Args:
    image: image with shape ``(H, W)``, ``(C, H, W)`` or ``(B, C, H, W)``.
    min: lower end of the range, a ``float``. It sets the automatic centers and bandwidth.
    max: upper end of the range, a ``float``. It sets the automatic centers and bandwidth. The default ``255.0``
        puts a :math:`[0, 1]` image in two bins; pass ``1.0`` for that range. It must exceed ``min`` while the
        centers are automatic.
    n_bins: number of automatic bins.
    bandwidth: kernel width, a positive finite ``float``; it does not move the automatic centers. The default,
        also ``-1``, is ``(max - min) / n_bins``.
    centers: bin centers with shape ``(K,)``. The default, also an empty tensor, is the ``n_bins`` equal-width bin
        centers over ``[min, max]``, ``min + (i + 0.5) * (max - min) / n_bins``. With explicit centers, also pass
        ``bandwidth``: the default bandwidth still comes from ``min``, ``max`` and ``n_bins``
        (`#6662 <https://github.com/kornia/kornia/issues/6662>`_).
    return_pdf: whether to also return the normalized histogram.
    kernel: weight of a pixel at distance ``d`` from a center, with ``u = d / bandwidth``: ``'triangular'``
        (:math:`1 - u` for :math:`u \leq 1`), ``'gaussian'`` (:math:`e^{-u^2 / 2}`), ``'uniform'`` (1 for
        :math:`u \leq 1`) or ``'epanechnikov'`` (:math:`1 - u^2` for :math:`u \leq 1`). Gradients reach ``image``
        except with ``'uniform'``.
    eps: value added to the normalization sum.

Returns:
    Tuple ``(hist, pdf)``. ``hist`` has shape ``(K,)``, ``(C, K)`` or ``(B, C, K)``, where the bin axis ``K`` has
    ``n_bins`` entries, or one per center. ``pdf`` has the same shape and divides the histogram by its bin sum
    plus ``eps``. Its sum approaches 1 when the bin sum dominates ``eps``; it is zeros when no pixels contribute
    or ``return_pdf`` is ``False``.

See Also:
    - :func:`histogram`: the Gaussian histogram of sample rows, normalized.
    - :func:`histogram2d`: the joint histogram of two sample rows.

Example:
    >>> image = torch.rand(2, 3, 8, 8)
    >>> hist, pdf = image_histogram2d(image, 0.0, 1.0, n_bins=16, return_pdf=True)
    >>> hist.shape
    torch.Size([2, 3, 16])

z,Input image type is not a torch.Tensor. Got rI   Nz.Bins' centers type is not a torch.Tensor. Got zABins' centers must be a torch.Tensor of the shape (n_bins,). Got z3Type of lower end of the range is not a float. Got z3Type of upper end of the range is not a float. Got z*Type of number of bins is not an int. Got z#Bandwidth type is not a float. Got z#Return_pdf type is not a bool. Got )Údevicer:   g      à?ÚgaussianÚ
triangularÚuniformg      ð?zJKernel must be 'triangular', 'gaussian', 'uniform' or 'epanechnikov'. Got r   T)r   Úkeepdimr/   r   )rj   rk   Úepanechnikov)éþÿÿÿr/   )r   r   )r   r   r   r   r   rJ   Úlenr   r   r   r   r\   rN   Únumelr`   r:   Úfloat32r9   Úarangerh   r=   ÚreshapeÚabsr   r    r#   ÚpermuterQ   ÚsqueezeÚ
zeros_like)rG   rY   rZ   r[   r7   rb   rc   rd   re   rM   Úcenter_dtypeÚcompute_dtypeÚ	bin_widthÚur%   ÚmaskrL   r'   r&   s   &&&&&&&&&          r   Úimage_histogram2dr}   ú   så  € ô~ �eœUŸ\™\×*Ò*ÜÐFÄtÈEÃ{ÀmÐSTÐUÓVÐVä�eÔàÒ¤:¨g´u·|±|×#DÒ#DÜÐHÌÈgËÈÐWXÐYÓZÐZàÒœs 7§=¡=Ó1°AÔ5¸'¿+¹+»-È1Ô:LÜÐ\Ð]d×]jÑ]jÐ\kÐklÐmÓnÐnä�cœ5×!Ò!ÜÐMÌdÐSVËiÈ[ÐXYÐZÓ[Ð[ä�cœ5×!Ò!ÜÐMÌdÐSVËiÈ[ÐXYÐZÓ[Ð[ä�fœc×"Ò"ÜÐDÄTÈ&Ã\ÀNÐRSÐTÓUÐUàÒ¤Z°	¼5×%AÒ%AÜÐ=¼dÀ9»oÐ=NÈaÐPÓQÐQä�j¤$×'Ò'ÜÐ=¼dÀ:Ó>NÐ=OÈqÐQÓRÐRàÒ˜wŸ}™}›°!Ô3ØˆØ˜d�?€LÜ-¨c¸È<ÓX€Ið %,Ò$7�7—=’=¼U¿]¹]€LÜ×'Ò'¬¯©´u×7JÒ7JÈ5Ï;É;ÐXdÓ7eÓf€MØ‚ð •Y &Õ(ˆ	Ø¤U§\¢\°&ÇÁÐUbÔ%cÐfiÕ%iÕjÕjˆØ�j‰j˜Ó'×/Ñ/°°A°q¸!¸QÓ?€Gä�	Š	�%—(‘(˜=Ó)×3Ñ3°AÓ6¸Õ@ÓAÀIÕM€Aà�ÔÜŸ	š	 $¨¨A­¥+Ó.‰Ø	Ð<Ô	<à�Q‘�{‰{˜1Ÿ7™7Ó#ˆØ�\Ô!Ø  1�W¨Õ,‰MØ�yÔ Ø ‰Mà  1 a¥4�Z¨4Õ/‰MäÐeÐflÐemÐmnÐoÓpÐpä�9Š9�]¨Ô1×9Ñ9¸!¸QÀÓB€DÜ  eÓ:€DçÜŸ	š	 $¨B¸Ô=ÀÕCˆØ�]Õ"ˆØ�9‰9‹;˜!ÔØ˜•:ˆDØ�d•)ˆCð �SˆyÐð �Y‰Y‹[˜AÔØ—<‘< “?ˆDØ—+‘+˜a“.ˆCØ�SˆyÐà‡y�yƒ{�aÔØ�D�z‰Ø	�‰‹˜Ô	Ø�|‰|˜A‹ˆà”×!Ò! $Ó'Ð'Ð'r   )ç»½×Ùß|Û=)r^   g     ào@é   NNFrj   r~   )rU   Útypingr   r   r   Úkornia.core.checkr   Úkornia.core.exceptionsr   r(   r4   r@   rE   rJ   rQ   rW   r`   r}   © r   r   Ú<module>r„      sP   ðó$ ß "ã å *Ý -÷.÷b /÷F-÷`-Oõ`oõõ(õ
÷*K(ñ K(r   