Ë
    þÍ:j¢\  ã                   ód  — d dl mZmZmZ d dlZd dlmZmZ d dlmZ d dl	m
Z
mZmZmZmZmZmZmZmZmZmZmZ d dlmZmZmZ d dlmZmZ d dlmZ d d	lm Z  d d
l!m"Z" 	 	 	 d*deeee   f   deeee   f   deed      dee   de#defd„Z$	 	 	 d+dee#   deee%e&e#   ef      dee%   ddfd„Z'	 	 d,deee(eef   f   dee   dee#   de%def
d„Z)	 	 	 	 d-dededee#   deee%e&e#   ef      dee%   de*defd„Z+	 	 	 d.de%deed      deee%e&e#   ef      dee%   ddf
d„Z,	 	 d/deee(eef   f   de%deed      dee   def
d „Z-	 	 	 	 d0dedede%deed      deee%e&e#   ef      dee%   de*defd!„Z.	 	 d1d"e%deed#      deee%e&e#   ef      dee%   ddf
d$„Z/	 d2deee(eef   f   d"e%deed#      dee   dee%   defd%„Z0	 	 	 	 d0deded"e%deed#      deee%e&e#   ef      dee%   de*defd&„Z1	 	 	 	 	 	 	 d3deded'ed(   deee%e&e#   ef      dee%   d"ee%   deed      dee#   dee%   de*dee   fd)„Z2y)4é    )ÚListÚOptionalÚUnionN)ÚTensorÚtensor)ÚLiteral)Ú-_binary_precision_recall_curve_arg_validationÚ%_binary_precision_recall_curve_formatÚ0_binary_precision_recall_curve_tensor_validationÚ%_binary_precision_recall_curve_updateÚ1_multiclass_precision_recall_curve_arg_validationÚ)_multiclass_precision_recall_curve_formatÚ4_multiclass_precision_recall_curve_tensor_validationÚ)_multiclass_precision_recall_curve_updateÚ1_multilabel_precision_recall_curve_arg_validationÚ)_multilabel_precision_recall_curve_formatÚ4_multilabel_precision_recall_curve_tensor_validationÚ)_multilabel_precision_recall_curve_update)Ú_binary_roc_computeÚ_multiclass_roc_computeÚ_multilabel_roc_compute)Ú_auc_compute_without_checkÚ_safe_divide)Ú	_bincount)ÚClassificationTask)Úrank_zero_warnÚfprÚtprÚaverage)ÚmacroÚweightedÚnoneÚweightsÚ	directionÚreturnc                 óV  — t        | t        «      r t        |t        «      rt        | ||d¬«      }n>t        j                  t        | |«      D ��cg c]  \  }}t        |||¬«      ‘Œ c}}«      }|�|dk(  r|S t        j                  |«      j                  «       rt        d|› d�t        «       t        j                  |«       }|dk(  r||   j                  «       S |dk(  r8|�6t        ||   ||   j                  «       «      }||   |z  j                  «       S t        d	«      ‚c c}}w )
z8Reduce multiple average precision score into one number.é   )r$   Úaxis)r$   r"   zUAverage precision score for one or more classes was `nan`. Ignoring these classes in z-averager    r!   zBReceived an incompatible combinations of inputs to make reduction.)Ú
isinstancer   r   ÚtorchÚstackÚzipÚisnanÚanyr   ÚUserWarningÚmeanr   ÚsumÚ
ValueError)	r   r   r   r#   r$   ÚresÚxÚyÚidxs	            ú�/home/mcse/projects/srt_converter/srt-converter-venv/lib/python3.12/site-packages/torchmetrics/functional/classification/auroc.pyÚ_reduce_aurocr8   -   s  € ô �#”vÔ¤:¨c´6Ô#:Ü(¨¨c¸YÈQÔO‰ä�k‰kÔ]`ÐadÐfiÓ]j×kÑUYÐUVÐXYÔ5°a¸ÀiÖPÓkÓlˆØ€˜' VÒ+Øˆ
Ü‡{�{�3Ó×ÑÔÜØcÐdkÐclÐltÐuÜô	
ô �;‰;�sÓÐ
€CØ�'ÒØ�3‰x�}‰}‹ÐØ�*Ò Ð!4Ü˜w s™|¨W°S©\×-=Ñ-=Ó-?Ó@ˆØ�C‘˜7Ñ"×'Ñ'Ó)Ð)Ü
ÐYÓ
ZÐZùó ls   ÁD%
Úmax_fprÚ
thresholdsÚignore_indexc                 ó|   — t        ||«       | �.t        | t        «      sd| cxk  rdk  rn y t        d| › �«      ‚y y y )Nr   r'   z@Arguments `max_fpr` should be a float in range (0, 1], but got: )r	   r)   Úfloatr2   )r9   r:   r;   s      r7   Ú_binary_auroc_arg_validationr>   I   sL   € ô
 2°*¸lÔKØÐ¤:¨g´uÔ#=À!ÀgÔBRÐQRÕBRÜÐ[Ð\cÐ[dÐeÓfÐfð CSÐ#=Ðó    ÚstateÚ	pos_labelc                 óž  — t        | ||«      \  }}}|�+|dk(  s&|j                  «       dk(  s|j                  «       dk(  rt        ||d«      S t        |t        «      r|j
                  n|d   j
                  }t        ||¬«      }t        j                  ||dd¬«      }	|||	dz
     z
  ||	   ||	dz
     z
  z  }
t        j                  ||	dz
     ||	   |
«      }t        j                  |d |	 |j                  d«      g«      }t        j                  |d |	 |j                  d«      g«      }t        ||d«      }d|dz  z  }dd||z
  ||z
  z  z   z  S )	Nr'   r   ç      ð?)ÚdeviceT)Ú	out_int32Úrightg      à?é   )r   r1   r   r)   r   rD   r   r*   Ú	bucketizeÚlerpÚcatÚview)r@   r:   r9   rA   r   r   Ú_Ú_deviceÚmax_areaÚstopÚweightÚ
interp_tprÚpartial_aucÚmin_areas                 r7   Ú_binary_auroc_computerT   S   sO  € ô & e¨Z¸ÓC�K€CˆˆaØ€˜' Qš,¨#¯'©'«)°qª.¸C¿G¹G»IÈºNÜ)¨#¨s°CÓ8Ð8ä& s¬FÔ3ˆc�jŠj¸¸Q¹¿¹€GÜ˜g¨gÔ6€Hä�?‰?˜8 S°DÀÔE€DØ˜˜T A™X™Ñ&¨3¨t©9°s¸4À!¹8±}Ñ+DÑE€FÜŸ™ C¨¨q©¡M°3°t±9¸fÓE€JÜ
�)‰)�S˜˜$�Z §¡°Ó!3Ð4Ó
5€CÜ
�)‰)�S˜˜$�Z §¡¨qÓ!1Ð2Ó
3€Cô -¨S°#°sÓ;€Kð ˜X q™[Ñ(€HØ�!�{ XÑ-°(¸XÑ2EÑFÑFÑGÐGr?   ÚpredsÚtargetÚvalidate_argsc                 ó’   — |rt        |||«       t        | ||«       t        | |||«      \  } }}t        | ||«      }t	        |||«      S )aß  Compute Area Under the Receiver Operating Characteristic Curve (`ROC AUC`_) for binary tasks.

    The AUROC score summarizes the ROC curve into an single number that describes the performance of a model for
    multiple thresholds at the same time. Notably, an AUROC score of 1 is a perfect score and an AUROC score of 0.5
    corresponds to random guessing.

    Accepts the following input tensors:

    - ``preds`` (float tensor): ``(N, ...)``. Preds should be a tensor containing probabilities or logits for each
      observation. If preds has values outside [0,1] range we consider the input to be logits and will auto apply
      sigmoid per element.
    - ``target`` (int tensor): ``(N, ...)``. Target should be a tensor containing ground truth labels, and therefore
      only contain {0,1} values (except if `ignore_index` is specified). The value 1 always encodes the positive class.

    Additional dimension ``...`` will be flattened into the batch dimension.

    The implementation both supports calculating the metric in a non-binned but accurate version and a binned version
    that is less accurate but more memory efficient. Setting the `thresholds` argument to `None` will activate the
    non-binned  version that uses memory of size :math:`\mathcal{O}(n_{samples})` whereas setting the `thresholds`
    argument to either an integer, list or a 1d tensor will use a binned version that uses memory of
    size :math:`\mathcal{O}(n_{thresholds})` (constant memory).

    Args:
        preds: Tensor with predictions
        target: Tensor with true labels
        max_fpr: If not ``None``, calculates standardized partial AUC over the range ``[0, max_fpr]``.
        thresholds:
            Can be one of:

            - If set to `None`, will use a non-binned approach where thresholds are dynamically calculated from
              all the data. Most accurate but also most memory consuming approach.
            - If set to an `int` (larger than 1), will use that number of thresholds linearly spaced from
              0 to 1 as bins for the calculation.
            - If set to an `list` of floats, will use the indicated thresholds in the list as bins for the calculation
            - If set to an 1d `tensor` of floats, will use the indicated thresholds in the tensor as
              bins for the calculation.

        ignore_index:
            Specifies a target value that is ignored and does not contribute to the metric calculation
        validate_args: bool indicating if input arguments and tensors should be validated for correctness.
            Set to ``False`` for faster computations.

    Returns:
        A single scalar with the auroc score

    Example:
        >>> from torchmetrics.functional.classification import binary_auroc
        >>> preds = torch.tensor([0, 0.5, 0.7, 0.8])
        >>> target = torch.tensor([0, 1, 1, 0])
        >>> binary_auroc(preds, target, thresholds=None)
        tensor(0.5000)
        >>> binary_auroc(preds, target, thresholds=5)
        tensor(0.5000)

    )r>   r   r
   r   rT   )rU   rV   r9   r:   r;   rW   r@   s          r7   Úbinary_aurocrY   n   sV   € ñ~ Ü$ W¨j¸,ÔGÜ8¸ÀÈÔUÜ EÀeÈVÐU_ÐamÓ nÑ€Eˆ6�:Ü1°%¸ÀÓL€EÜ  ¨
°GÓ<Ð<r?   Únum_classesc                 óL   — t        | ||«       d}||vrt        d|› d|› �«      ‚y )N)r    r!   r"   Nú)Expected argument `average` to be one of ú	 but got )r   r2   )rZ   r   r:   r;   Úallowed_averages        r7   Ú _multiclass_auroc_arg_validationr_   µ   s?   € ô 6°kÀ:È|Ô\Ø9€OØ�oÑ%ÜÐDÀ_ÐDUÐU^Ð_fÐ^gÐhÓiÐið &r?   c           
      óÄ   — t        | ||«      \  }}}t        ||||€#t        | d   |¬«      j                  «       ¬«      S | d   d d …dd d …f   j	                  d«      ¬«      S )Nr'   )Ú	minlengthr   éÿÿÿÿ©r#   )r   r8   r   r=   r1   )r@   rZ   r   r:   r   r   rL   s          r7   Ú_multiclass_auroc_computerd   Á   s|   € ô *¨%°¸jÓI�K€CˆˆaÜØØØØFPÐFX”	˜% ™(¨kÔ:×@Ñ@ÓBô	ð ð _dÐdeÑ^fÒghÐjkÒmnÐgnÑ^o×^sÑ^sÐtvÓ^wô	ð r?   c                 óœ   — |rt        ||||«       t        | |||«       t        | ||||«      \  } }}t        | |||«      }t	        ||||«      S )a  Compute Area Under the Receiver Operating Characteristic Curve (`ROC AUC`_) for multiclass tasks.

    The AUROC score summarizes the ROC curve into an single number that describes the performance of a model for
    multiple thresholds at the same time. Notably, an AUROC score of 1 is a perfect score and an AUROC score of 0.5
    corresponds to random guessing.

    Accepts the following input tensors:

    - ``preds`` (float tensor): ``(N, C, ...)``. Preds should be a tensor containing probabilities or logits for each
      observation. If preds has values outside [0,1] range we consider the input to be logits and will auto apply
      softmax per sample.
    - ``target`` (int tensor): ``(N, ...)``. Target should be a tensor containing ground truth labels, and therefore
      only contain values in the [0, n_classes-1] range (except if `ignore_index` is specified).

    Additional dimension ``...`` will be flattened into the batch dimension.

    The implementation both supports calculating the metric in a non-binned but accurate version and a binned version
    that is less accurate but more memory efficient. Setting the `thresholds` argument to `None` will activate the
    non-binned  version that uses memory of size :math:`\mathcal{O}(n_{samples})` whereas setting the `thresholds`
    argument to either an integer, list or a 1d tensor will use a binned version that uses memory of
    size :math:`\mathcal{O}(n_{thresholds} \times n_{classes})` (constant memory).

    Args:
        preds: Tensor with predictions
        target: Tensor with true labels
        num_classes: Integer specifying the number of classes
        average:
            Defines the reduction that is applied over classes. Should be one of the following:

            - ``macro``: Calculate score for each class and average them
            - ``weighted``: calculates score for each class and computes weighted average using their support
            - ``"none"`` or ``None``: calculates score for each class and applies no reduction
        thresholds:
            Can be one of:

            - If set to `None`, will use a non-binned approach where thresholds are dynamically calculated from
              all the data. Most accurate but also most memory consuming approach.
            - If set to an `int` (larger than 1), will use that number of thresholds linearly spaced from
              0 to 1 as bins for the calculation.
            - If set to an `list` of floats, will use the indicated thresholds in the list as bins for the calculation
            - If set to an 1d `tensor` of floats, will use the indicated thresholds in the tensor as
              bins for the calculation.

        ignore_index:
            Specifies a target value that is ignored and does not contribute to the metric calculation
        validate_args: bool indicating if input arguments and tensors should be validated for correctness.
            Set to ``False`` for faster computations.

    Returns:
        If `average=None|"none"` then a 1d tensor of shape (n_classes, ) will be returned with auroc score per class.
        If `average="macro"|"weighted"` then a single scalar is returned.

    Example:
        >>> from torchmetrics.functional.classification import multiclass_auroc
        >>> preds = torch.tensor([[0.75, 0.05, 0.05, 0.05, 0.05],
        ...                       [0.05, 0.75, 0.05, 0.05, 0.05],
        ...                       [0.05, 0.05, 0.75, 0.05, 0.05],
        ...                       [0.05, 0.05, 0.05, 0.75, 0.05]])
        >>> target = torch.tensor([0, 1, 3, 2])
        >>> multiclass_auroc(preds, target, num_classes=5, average="macro", thresholds=None)
        tensor(0.5333)
        >>> multiclass_auroc(preds, target, num_classes=5, average=None, thresholds=None)
        tensor([1.0000, 1.0000, 0.3333, 0.3333, 0.0000])
        >>> multiclass_auroc(preds, target, num_classes=5, average="macro", thresholds=5)
        tensor(0.5333)
        >>> multiclass_auroc(preds, target, num_classes=5, average=None, thresholds=5)
        tensor([1.0000, 1.0000, 0.3333, 0.3333, 0.0000])

    )r_   r   r   r   rd   )rU   rV   rZ   r   r:   r;   rW   r@   s           r7   Úmulticlass_aurocrf   Ð   se   € ñ\ Ü(¨°g¸zÈ<ÔXÜ<¸UÀFÈKÐYeÔfÜ IØˆv�{ J°ó!Ñ€Eˆ6�:ô 6°e¸VÀ[ÐR\Ó]€EÜ$ U¨K¸À*ÓMÐMr?   Ú
num_labels)Úmicror    r!   r"   c                 óL   — t        | ||«       d}||vrt        d|› d|› �«      ‚y )N)rh   r    r!   r"   Nr\   r]   )r   r2   )rg   r   r:   r;   r^   s        r7   Ú _multilabel_auroc_arg_validationrj   (  s?   € ô 6°jÀ*ÈlÔ[ØB€OØ�oÑ%ÜÐDÀ_ÐDUÐU^Ð_fÐ^gÐhÓiÐið &r?   c           
      óÐ  — |dk(  rxt        | t        «      r|�t        | j                  d«      |d ¬«      S | d   j	                  «       }| d   j	                  «       }|�||k(  }||    }||    }t        ||f|d ¬«      S t        | |||«      \  }}	}
t        ||	||€+| d   dk(  j                  d¬«      j                  «       ¬«      S | d   d d …dd d …f   j                  d«      ¬«      S )Nrh   r'   )r9   r   )Údimrb   rc   )r)   r   rT   r1   Úflattenr   r8   r=   )r@   rg   r   r:   r;   rU   rV   r6   r   r   rL   s              r7   Ú_multilabel_auroc_computern   4  s  € ð �'ÒÜ�eœVÔ$¨Ð)?Ü(¨¯©°1«°zÈ4ÔPÐPà�a‘× Ñ Ó"ˆØ�q‘×!Ñ!Ó#ˆØÐ#Ø˜LÑ(ˆCØ˜3˜$‘KˆEØ˜S˜D‘\ˆFÜ$ e¨V _°jÈ$ÔOÐOä)¨%°¸ZÈÓV�K€CˆˆaÜØØØØ6@Ð6H��q‘˜Q‘×#Ñ#¨Ð#Ó*×0Ñ0Ó2ô	ð ð OTÐTUÉhÒWXÐZ[Ò]^ÐW^ÑN_×NcÑNcÐdfÓNgô	ð r?   c                 óž   — |rt        ||||«       t        | |||«       t        | ||||«      \  } }}t        | |||«      }t	        |||||«      S )al  Compute Area Under the Receiver Operating Characteristic Curve (`ROC AUC`_) for multilabel tasks.

    The AUROC score summarizes the ROC curve into an single number that describes the performance of a model for
    multiple thresholds at the same time. Notably, an AUROC score of 1 is a perfect score and an AUROC score of 0.5
    corresponds to random guessing.

    Accepts the following input tensors:

    - ``preds`` (float tensor): ``(N, C, ...)``. Preds should be a tensor containing probabilities or logits for each
      observation. If preds has values outside [0,1] range we consider the input to be logits and will auto apply
      sigmoid per element.
    - ``target`` (int tensor): ``(N, C, ...)``. Target should be a tensor containing ground truth labels, and therefore
      only contain {0,1} values (except if `ignore_index` is specified).

    Additional dimension ``...`` will be flattened into the batch dimension.

    The implementation both supports calculating the metric in a non-binned but accurate version and a binned version
    that is less accurate but more memory efficient. Setting the `thresholds` argument to `None` will activate the
    non-binned  version that uses memory of size :math:`\mathcal{O}(n_{samples})` whereas setting the `thresholds`
    argument to either an integer, list or a 1d tensor will use a binned version that uses memory of
    size :math:`\mathcal{O}(n_{thresholds} \times n_{labels})` (constant memory).

    Args:
        preds: Tensor with predictions
        target: Tensor with true labels
        num_labels: Integer specifying the number of labels
        average:
            Defines the reduction that is applied over labels. Should be one of the following:

            - ``micro``: Sum score over all labels
            - ``macro``: Calculate score for each label and average them
            - ``weighted``: calculates score for each label and computes weighted average using their support
            - ``"none"`` or ``None``: calculates score for each label and applies no reduction
        thresholds:
            Can be one of:

            - If set to `None`, will use a non-binned approach where thresholds are dynamically calculated from
              all the data. Most accurate but also most memory consuming approach.
            - If set to an `int` (larger than 1), will use that number of thresholds linearly spaced from
              0 to 1 as bins for the calculation.
            - If set to an `list` of floats, will use the indicated thresholds in the list as bins for the calculation
            - If set to an 1d `tensor` of floats, will use the indicated thresholds in the tensor as
              bins for the calculation.

        ignore_index:
            Specifies a target value that is ignored and does not contribute to the metric calculation
        validate_args: bool indicating if input arguments and tensors should be validated for correctness.
            Set to ``False`` for faster computations.

    Returns:
        If `average=None|"none"` then a 1d tensor of shape (n_classes, ) will be returned with auroc score per class.
        If `average="micro|macro"|"weighted"` then a single scalar is returned.

    Example:
        >>> from torchmetrics.functional.classification import multilabel_auroc
        >>> preds = torch.tensor([[0.75, 0.05, 0.35],
        ...                       [0.45, 0.75, 0.05],
        ...                       [0.05, 0.55, 0.75],
        ...                       [0.05, 0.65, 0.05]])
        >>> target = torch.tensor([[1, 0, 1],
        ...                        [0, 0, 0],
        ...                        [0, 1, 1],
        ...                        [1, 1, 1]])
        >>> multilabel_auroc(preds, target, num_labels=3, average="macro", thresholds=None)
        tensor(0.6528)
        >>> multilabel_auroc(preds, target, num_labels=3, average=None, thresholds=None)
        tensor([0.6250, 0.5000, 0.8333])
        >>> multilabel_auroc(preds, target, num_labels=3, average="macro", thresholds=5)
        tensor(0.6528)
        >>> multilabel_auroc(preds, target, num_labels=3, average=None, thresholds=5)
        tensor([0.6250, 0.5000, 0.8333])

    )rj   r   r   r   rn   )rU   rV   rg   r   r:   r;   rW   r@   s           r7   Úmultilabel_aurocrp   P  sg   € ñd Ü(¨°W¸jÈ,ÔWÜ<¸UÀFÈJÐXdÔeÜ IØˆv�z :¨|ó!Ñ€Eˆ6�:ô 6°e¸VÀZÐQ[Ó\€EÜ$ U¨J¸ÀÈ\ÓZÐZr?   Útask)ÚbinaryÚ
multiclassÚ
multilabelc
           	      ó¤  — t        j                  |«      }|t         j                  k(  rt        | |||||	«      S |t         j                  k(  r9t        |t        «      st        dt        |«      › d�«      ‚t        | ||||||	«      S |t         j                  k(  r9t        |t        «      st        dt        |«      › d�«      ‚t        | ||||||	«      S y)aÂ  Compute Area Under the Receiver Operating Characteristic Curve (`ROC AUC`_).

    The AUROC score summarizes the ROC curve into an single number that describes the performance of a model for
    multiple thresholds at the same time. Notably, an AUROC score of 1 is a perfect score and an AUROC score of 0.5
    corresponds to random guessing.

    This function is a simple wrapper to get the task specific versions of this metric, which is done by setting the
    ``task`` argument to either ``'binary'``, ``'multiclass'`` or ``'multilabel'``. See the documentation of
    :func:`~torchmetrics.functional.classification.binary_auroc`,
    :func:`~torchmetrics.functional.classification.multiclass_auroc` and
    :func:`~torchmetrics.functional.classification.multilabel_auroc` for the specific details of
    each argument influence and examples.

    Legacy Example:
        >>> preds = torch.tensor([0.13, 0.26, 0.08, 0.19, 0.34])
        >>> target = torch.tensor([0, 0, 1, 1, 1])
        >>> auroc(preds, target, task='binary')
        tensor(0.5000)

        >>> preds = torch.tensor([[0.90, 0.05, 0.05],
        ...                       [0.05, 0.90, 0.05],
        ...                       [0.05, 0.05, 0.90],
        ...                       [0.85, 0.05, 0.10],
        ...                       [0.10, 0.10, 0.80]])
        >>> target = torch.tensor([0, 1, 1, 2, 2])
        >>> auroc(preds, target, task='multiclass', num_classes=3)
        tensor(0.7778)

    z+`num_classes` is expected to be `int` but `z was passed.`z*`num_labels` is expected to be `int` but `N)r   Úfrom_strÚBINARYrY   Ú
MULTICLASSr)   Úintr2   Útyperf   Ú
MULTILABELrp   )
rU   rV   rq   r:   rZ   rg   r   r9   r;   rW   s
             r7   Úaurocr|   ¬  sÙ   € ôR ×&Ñ& tÓ,€DØÔ!×(Ñ(Ò(Ü˜E 6¨7°JÀÈmÓ\Ð\ØÔ!×,Ñ,Ò,Ü˜+¤sÔ+ÜÐJÌ4ÐP[ÓK\ÐJ]Ð]jÐkÓlÐlÜ  v¨{¸GÀZÐQ]Ð_lÓmÐmØÔ!×,Ñ,Ò,Ü˜*¤cÔ*ÜÐIÌ$ÈzÓJZÐI[Ð[hÐiÓjÐjÜ  v¨z¸7ÀJÐP\Ð^kÓlÐlØr?   )r    NrC   )NNN)Nr'   )NNNT)r    NN)r    N)r    NNT)NN)N)NNNr    NNT)3Útypingr   r   r   r*   r   r   Útyping_extensionsr   Ú=torchmetrics.functional.classification.precision_recall_curver	   r
   r   r   r   r   r   r   r   r   r   r   Ú*torchmetrics.functional.classification.rocr   r   r   Útorchmetrics.utilities.computer   r   Útorchmetrics.utilities.datar   Útorchmetrics.utilities.enumsr   Útorchmetrics.utilities.printsr   r=   r8   ry   Úlistr>   ÚtuplerT   ÚboolrY   r_   rd   rf   rj   rn   rp   r|   © r?   r7   ú<module>r‰      sv  ð÷ )Ñ (ã ß  Ý %÷÷ ÷ ó ÷ñ ÷
 TÝ 1Ý ;Ý 8ð ?FØ $Øñ[Ø	ˆv�t˜F‘|Ð#Ñ	$ð[à	ˆv�t˜F‘|Ð#Ñ	$ð[ð �gÐ9Ñ:Ñ;ð[ð �fÑð	[ð
 ð[ð ó[ð:  $Ø<@Ø"&ñgØ�e‰_ðgà˜˜s D¨¡K°Ð7Ñ8Ñ9ðgð ˜3‘-ðgð 
ó	gð  $Øñ	HØ�˜˜v v˜~Ñ.Ð.Ñ/ðHà˜Ñ ðHð �e‰_ðHð ð	Hð
 óHð<  $Ø<@Ø"&ØñD=ØðD=àðD=ð �e‰_ðD=ð ˜˜s D¨¡K°Ð7Ñ8Ñ9ð	D=ð
 ˜3‘-ðD=ð ðD=ð óD=ðR ?FØ<@Ø"&ñ		jØð	jà�gÐ9Ñ:Ñ;ð	jð ˜˜s D¨¡K°Ð7Ñ8Ñ9ð	jð ˜3‘-ð		jð
 
ó	jð ?FØ#'ñ	Ø�˜˜v v˜~Ñ.Ð.Ñ/ðàðð �gÐ9Ñ:Ñ;ðð ˜Ñ ð	ð
 óð& ?FØ<@Ø"&ØñUNØðUNàðUNð ðUNð �gÐ9Ñ:Ñ;ð	UNð
 ˜˜s D¨¡K°Ð7Ñ8Ñ9ðUNð ˜3‘-ðUNð ðUNð óUNðv =AØ"&ñ		jØð	jà�gÐBÑCÑDð	jð ˜˜s D¨¡K°Ð7Ñ8Ñ9ð	jð ˜3‘-ð		jð
 
ó	jð" #'ñØ�˜˜v v˜~Ñ.Ð.Ñ/ðàðð �gÐBÑCÑDðð ˜Ñ ð	ð
 ˜3‘-ðð óð@ HOØ<@Ø"&ØñY[ØðY[àðY[ð ðY[ð �gÐBÑCÑDð	Y[ð
 ˜˜s D¨¡K°Ð7Ñ8Ñ9ðY[ð ˜3‘-ðY[ð ðY[ð óY[ð@ =AØ!%Ø $Ø>EØ#Ø"&Øñ4Øð4àð4ð Ð6Ñ
7ð4ð ˜˜s D¨¡K°Ð7Ñ8Ñ9ð	4ð
 ˜#‘ð4ð ˜‘ð4ð �gÐ9Ñ:Ñ;ð4ð �e‰_ð4ð ˜3‘-ð4ð ð4ð ˆfÑô4r?   