o
�J�h_� � @ s� d dl Z d dlZd dlmZ d dlmZmZmZmZm Z m
Z
m Z d dl Z
d dlZd dlmZ ddlmZmZmZmZmZmZmZmZmZmZm Z m Z ddl m Z m Z m!Z!m"Z"m#Z#m$Z$ e� r�d dl%Z&d dl'Z&e�(e�(e&j)�j*�e�(d�krye&j+j,Z-ne&j+Z-e� r�d d l.m/Z/ e-j0e/j0e-j1e/j1e-j2e/j2e-j3e/j3e-j4e/j4e-j5e/j5iZ6er�e� r�d dl7Z7e�8e9�Z:e d
e
j;d ed
ee
j; ed f Z<e ed
d d ed ed eed
eed
eed f Z=G dd� de�Z>G dd� de�Z?G dd� de�Z@eeAe eBeAee f f ZCdd� ZDG dd� de�ZEdd� ZFdd� ZGd d � ZHd d � ZId e
j;d!eJfd"d#�ZKdad%eBd!ee< fd&d'�ZLd!e
j;fd(d)�ZM dbd e
j;d*e e eBe
eBd+f f d!e>fd,d-�ZN dbd e
j;d.e e e>eAf d!eBfd/d0�ZOdbd e
j;d1e>d!e
eBeBf fd2d3�ZPd4eeAe ee
f f d!eJfd5d6�ZQd4eeAe ee
f f d!eJfd7d8�ZRd9eeeAe ee
f f d!eJfd:d;�ZSd9eeeAe ee
f f d!eJfd<d=�ZTdbd e eAd
f d>e eU d!d
fd?d@�ZV dbdAe ee
eAd
f d>e eU d!e d
ed
eed
f fdBdC�ZW dcdDe eJ dEe eU dFe eJ dGe e eUeeU f dHe e eUeeU f dIe eJ dJe eB dKe eJ dLe eeAeBf dMe eJ dNe eeAeBf dOe dP fdQdR�ZXddddddddddddde>jYfdDe eJ dEe eU dFe eJ dGe e eUeeU f dHe e eUeeU f dIe eJ dJe eB dKe eJ dLe eeAeBf dMe eJ dNe eeAeBf dOe dP dSe e eAef dTe e> f dUdV�ZZG dWdX� dX�Z[dYe?dZe
e?d+f d9ee d!dfd[d\�Z\d]eeA d^eeA fd_d`�Z]dS )d� N)�BytesIO)�
TYPE_CHECKING�Dict�Iterable�List�Optional�Tuple�Union)�version� ) � ExplicitEnum�
TensorType�
is_jax_tensor�is_numpy_array� is_tf_tensor�is_torch_available�is_torch_tensor�is_torchvision_available�is_vision_available�logging�requires_backends�to_numpy)�IMAGENET_DEFAULT_MEAN�IMAGENET_DEFAULT_STD�IMAGENET_STANDARD_MEAN�IMAGENET_STANDARD_STD�OPENAI_CLIP_MEAN�OPENAI_CLIP_STDz9.1.0)�InterpolationModezPIL.Image.Imagez torch.Tensorz
np.ndarrayz np.ndarrrayc @ � e Zd ZdZdZdS )�ChannelDimension�channels_first�
channels_lastN)�__name__�
__module__� __qualname__�FIRST�LAST� r( r( �VC:\pinokio\api\whisper-webui.git\app\env\lib\site-packages\transformers\image_utils.pyr ` � r c @ r )�AnnotationFormatZcoco_detectionZ
coco_panopticN)r# r$ r% �COCO_DETECTION�
COCO_PANOPTICr( r( r( r) r+ e r* r+ c @ s e Zd ZejjZejjZdS )�AnnotionFormatN)r# r$ r% r+ r, �valuer- r( r( r( r) r. j s r. c C s t � o t| tjj�S �N)r �
isinstance�PIL�Image��imgr( r( r) � is_pil_imager s r6 c @ s e Zd ZdZdZdZdZdZdS )� ImageType�pillow�torch�numpy�
tensorflow�jaxN)r# r$ r% r2 �TORCH�NUMPY�
TENSORFLOW�JAXr( r( r( r) r7 v s r7 c C sX t | �rtjS t| �rtjS t| �rtjS t| �r tjS t | �r#tj
S t dt | �� ���)NzUnrecognised image type )
r6 r7 r2 r r= r r> r r? r r@ �
ValueError�type��imager( r( r) �get_image_type~ s rE c C s( t | �pt| �pt| �pt| �pt| �S r0 )r6 r r r r r4 r( r( r) �is_valid_image� s (rF c C s: t | ttf�r| D ] }t|�s dS q dS t| �sdS dS )NFT)r1 �list�tuple� valid_imagesrF )�imgsr5 r( r( r) rI � s ��rI c C s t | ttf�r
t| d �S dS )Nr F)r1 rG rH rF r4 r( r( r) �
is_batched� s rK rD �returnc C s, | j tjkrdS t�| �dkot�| �dkS )zV
Checks to see whether the pixel values have already been rescaled to [0, 1].
Fr r )�dtype�np�uint8�min�maxrC r( r( r) �is_scaled_image� s rR � �expected_ndimsc C s� t | �r| S t| tjj�r| gS t| �r<| j|d kr!t| �} | S | j|kr+| g} | S td|d � d|� d| j� d���tdt| �� d���)a
Ensure that the input is a list of images. If the input is a single image, it is converted to a list of length 1.
If the input is a batch of images, it is converted to a list of images.
Args:
images (`ImageInput`):
Image of images to turn into a list of images.
expected_ndims (`int`, *optional*, defaults to 3):
Expected number of dimensions for a single input image. If the input image has a different number of
dimensions, an error is raised.
r z%Invalid image shape. Expected either z or z dimensions, but got z dimensions.ztInvalid image type. Expected either PIL.Image.Image, numpy.ndarray, torch.Tensor, tf.Tensor or jax.ndarray, but got �.) rK r1 r2 r3 rF �ndimrG rA rB )�imagesrT r( r( r) �make_list_of_images� s*
������rX c C s@ t | �s
tdt| �� ���t� r t| tjj�r t�| �S t | �S )NzInvalid image type: )
rF rA rB r r1 r2 r3 rN �arrayr r4 r( r( r) �to_numpy_array� s
rZ � num_channels.c C s� |dur|nd}t |t�r|fn|}| jdkr d\}}n| jdkr&d\}}ntd| j� ���| j| |v rI| j| |v rIt�d| j� d�� tjS | j| |v rStjS | j| |v r]tj S td ��)
a[
Infers the channel dimension format of `image`.
Args:
image (`np.ndarray`):
The image to infer the channel dimension of.
num_channels (`int` or `Tuple[int, ...]`, *optional*, defaults to `(1, 3)`):
The number of channels of the image.
Returns:
The channel dimension of the image.
N�r rS rS )r � � z(Unsupported number of image dimensions: z4The channel dimension is ambiguous. Got image shape z,. Assuming channels are the first dimension.z(Unable to infer channel dimension format)
r1 �intrV rA �shape�logger�warningr r& r' )rD r[ � first_dim�last_dimr( r( r) � infer_channel_dimension_format� s"
�re �input_data_formatc C sF |du rt | �}|tjkr| jd S |tjkr | jd S td|� ���)a�
Returns the channel dimension axis of the image.
Args:
image (`np.ndarray`):
The image to get the channel dimension axis of.
input_data_format (`ChannelDimension` or `str`, *optional*):
The channel dimension format of the image. If `None`, will infer the channel dimension from the image.
Returns:
The channel dimension axis of the image.
NrS r �Unsupported data format: )re r r& rV r' rA )rD rf r( r( r) �get_channel_dimension_axis s
rh � channel_dimc C sZ |du rt | �}|tjkr| jd | jd fS |tjkr&| jd | jd fS td|� ���)a�
Returns the (height, width) dimensions of the image.
Args:
image (`np.ndarray`):
The image to get the dimensions of.
channel_dim (`ChannelDimension`, *optional*):
Which dimension the channel dimension is in. If `None`, will infer the channel dimension from the image.
Returns:
A tuple of the image's height and width.
N���������������rg )re r r& r` r' rA )rD ri r( r( r) �get_image_size s
rm �
annotationc C sV t | t�r)d| v r)d| v r)t | d ttf�r)t| d �dks't | d d t�r)dS dS )N�image_id� annotationsr TF�r1 �dictrG rH �len�rn r( r( r) �"is_valid_annotation_coco_detection2 s ��"ru c C s^ t | t�r-d| v r-d| v r-d| v r-t | d ttf�r-t| d �dks+t | d d t�r-dS dS )Nro Z
segments_info� file_namer TFrq rt r( r( r) �!is_valid_annotation_coco_panopticA s ��"rw rp c C � t dd� | D ��S )Nc s � � | ]}t |�V qd S r0 )ru ��.0�annr( r( r) � <genexpr>R � � z3valid_coco_detection_annotations.<locals>.<genexpr>��all�rp r( r( r) � valid_coco_detection_annotationsQ � r� c C rx )Nc s ry r0 )rw rz r( r( r) r} V r~ z2valid_coco_panoptic_annotations.<locals>.<genexpr>r r� r( r( r) � valid_coco_panoptic_annotationsU r� r� �timeoutc
C s t tdg� t| t�re| �d�s| �d�r$tj�tt j
| |d�j ��} nOt j
�| �r1tj�| �} nB| �d�r=| �d�d } zt�| �� �}tj�t|��} W n$ tyd } z
td| � d |� ���d
}~ww t| tjj�ro| } ntd ��tj�| �} | �d �} | S )
a3
Loads `image` to a PIL Image.
Args:
image (`str` or `PIL.Image.Image`):
The image to convert to the PIL Image format.
timeout (`float`, *optional*):
The timeout value in seconds for the URL request.
Returns:
`PIL.Image.Image`: A PIL Image.
�visionzhttp://zhttps://�r� z data:image/�,r z�Incorrect image source. Must be a valid URL starting with `http://` or `https://`, a valid path to an image file, or a base64 encoded string. Got z. Failed with NzuIncorrect format used for image. Should be an url linking to an image, a base64 string, a local path, or a PIL image.�RGB)r �
load_imager1 �str�
startswithr2 r3 �openr �requests�get�content�os�path�isfile�split�base64� decodebytes�encode� ExceptionrA � TypeError�ImageOps�exif_transpose�convert)rD r� Zb64�er( r( r) r� Y s2
����
r� rW c sX t | ttf�r&t| �r t | d ttf�r � fdd�| D �S � fdd�| D �S t| � d�S )a Loads images, handling different levels of nesting.
Args:
images: A single image, a list of images, or a list of lists of images to load.
timeout: Timeout for loading images.
Returns:
A single image, a list of images, a list of lists of images.
r c s g | ] }� fd d�|D ��qS )c � g | ]}t |� d ��qS �r� �r� �r{ rD r� r( r) �
<listcomp>� � z*load_images.<locals>.<listcomp>.<listcomp>r( )r{ � image_groupr� r( r) r� � s z load_images.<locals>.<listcomp>c r� r� r� r� r� r( r) r� � r� r� )r1 rG rH rs r� )rW r� r( r� r) � load_images� s
r� �
do_rescale�rescale_factor� do_normalize�
image_mean� image_std�do_pad�size_divisibility�do_center_crop� crop_size� do_resize�size�resample�PILImageResamplingc C s| | r
|du r
t d��|r|du rt d��|r"|du s |du r"t d��|r,|du r,t d��| r:|
du s6| du r<t d��dS dS )a�
Checks validity of typically used arguments in an `ImageProcessor` `preprocess` method.
Raises `ValueError` if arguments incompatibility is caught.
Many incompatibilities are model-specific. `do_pad` sometimes needs `size_divisor`,
sometimes `size_divisibility`, and sometimes `size`. New models and processors added should follow
existing arguments when possible.
Nz=`rescale_factor` must be specified if `do_rescale` is `True`.zzDepending on the model, `size_divisibility`, `size_divisor`, `pad_size` or `size` must be specified if `do_pad` is `True`.zP`image_mean` and `image_std` must both be specified if `do_normalize` is `True`.z<`crop_size` must be specified if `do_center_crop` is `True`.zA`size` and `resample` must be specified if `do_resize` is `True`.)rA ) r� r� r� r� r� r� r� r� r� r� r� r� r( r( r) � validate_preprocess_arguments� s � �r� �return_tensors� data_formatc
C s> t | ||||| |
| d� | dkrtd��|
tjkr td��dS )z�
Checks validity of typically used arguments in an `ImageProcessorFast` `preprocess` method.
Raises `ValueError` if arguments incompatibility is caught.
)r� r� r� r� r� r� r� r� �ptz6Only returning PyTorch tensors is currently supported.z6Only channel first data format is currently supported.N)r� rA r r& )r� r� r� r� r� r� r� r� r� r� r� r� r� r� r( r( r) �"validate_fast_preprocess_arguments� s �
�r� c @ s� e Zd ZdZdd� Zd dd�Zdd� Zd ejd
e e
e f d ejfd d
�Z d dd�Z
dd� Zd!dd�Zd"dd�Zdd� Zdd� Zd#d d �ZdS )$�ImageFeatureExtractionMixinzD
Mixin that contain utilities for preparing image features.
c C s8 t |tjjtjf�st|�stdt|�� d���d S d S )Nz Got type zS which is not supported, only `PIL.Image.Image`, `np.array` and `torch.Tensor` are.)r1 r2 r3 rN �ndarrayr rA rB ��selfrD r( r( r) �_ensure_format_supported� s
��z4ImageFeatureExtractionMixin._ensure_format_supportedNc C s� | � |� t|�r
|�� }t|tj�rE|du r t|jd tj�}|jdkr3|j d dv r3|�
ddd�}|r9|d }|� tj �}t
j�|�S |S )a"
Converts `image` to a PIL Image. Optionally rescales it and puts the channel dimension back as the last axis if
needed.
Args:
image (`PIL.Image.Image` or `numpy.ndarray` or `torch.Tensor`):
The image to convert to the PIL Image format.
rescale (`bool`, *optional*):
Whether or not to apply the scaling factor (to make pixel values integers between 0 and 255). Will
default to `True` if the image type is a floating type, `False` otherwise.
Nr rS r\ r r] �� )r� r r: r1 rN r� �flat�floatingrV r` � transpose�astyperO r2 r3 � fromarray)r� rD �rescaler( r( r) � to_pil_image� s
z(ImageFeatureExtractionMixin.to_pil_imagec C s& | � |� t|tjj�s|S |�d�S )z�
Converts `PIL.Image.Image` to RGB format.
Args:
image (`PIL.Image.Image`):
The image to convert.
r� )r� r1 r2 r3 r� r� r( r( r) � convert_rgb s
z'ImageFeatureExtractionMixin.convert_rgbrD �scalerL c C s | � |� || S )z7
Rescale a numpy image by scale amount
)r� )r� rD r� r( r( r) r� " s
z#ImageFeatureExtractionMixin.rescaleTc C s� | � |� t|tjj�rt�|�}t|�r|�� }|du r&t|jd tj �n|}|r4| �
|� tj �d�}|rB|j
dkrB|�ddd�}|S )a�
Converts `image` to a numpy array. Optionally rescales it and puts the channel dimension as the first
dimension.
Args:
image (`PIL.Image.Image` or `np.ndarray` or `torch.Tensor`):
The image to convert to a NumPy array.
rescale (`bool`, *optional*):
Whether or not to apply the scaling factor (to make pixel values floats between 0. and 1.). Will
default to `True` if the image is a PIL Image or an array/tensor of integers, `False` otherwise.
channel_first (`bool`, *optional*, defaults to `True`):
Whether or not to permute the dimensions of the image to put the channel dimension first.
Nr �p?rS r] r )r� r1 r2 r3 rN rY r r: r� �integerr� r� �float32rV r� )r� rD r� �
channel_firstr( r( r) rZ ) s
z*ImageFeatureExtractionMixin.to_numpy_arrayc C sD | � |� t|tjj�r|S t|�r|�d�}|S tj|dd�}|S )z�
Expands 2-dimensional `image` to 3 dimensions.
Args:
image (`PIL.Image.Image` or `np.ndarray` or `torch.Tensor`):
The image to expand.
r )�axis)r� r1 r2 r3 r � unsqueezerN � expand_dimsr� r( r( r) r� I s
�z'ImageFeatureExtractionMixin.expand_dimsFc C sh | � |� t|tjj�r| j|dd�}n |r3t|tj�r'| �|�tj �d�}n t
|�r3| �|� � d�}t|tj�rXt|tj�sHt� |��|j
�}t|tj�sWt� |��|j
�}n6t
|�r�ddl}t||j�swt|tj�rr|�|�}n|�|�}t||j�s�t|tj�r�|�|�}n|�|�}|jdkr�|jd dv r�||dd�ddf |dd�ddf S || | S )a
Normalizes `image` with `mean` and `std`. Note that this will trigger a conversion of `image` to a NumPy array
if it's a PIL Image.
Args:
image (`PIL.Image.Image` or `np.ndarray` or `torch.Tensor`):
The image to normalize.
mean (`List[float]` or `np.ndarray` or `torch.Tensor`):
The mean (per channel) to use for normalization.
std (`List[float]` or `np.ndarray` or `torch.Tensor`):
The standard deviation (per channel) to use for normalization.
rescale (`bool`, *optional*, defaults to `False`):
Whether or not to rescale the image to be between 0 and 1. If a PIL image is provided, scaling will
happen automatically.
T)r� r� r NrS r\ )r� r1 r2 r3 rZ rN r� r� r� r� r �floatrY rM r9 �Tensor�
from_numpy�tensorrV r` )r� rD �mean�stdr� r9 r( r( r) � normalize] s6
�
( z%ImageFeatureExtractionMixin.normalizec
C sJ |dur|nt j}| �|� t|tjj�s| �|�}t|t�r#t|�}t|t �s.t
|�dkr�|rBt|t �r9||fn|d |d f}n\|j \}}||krO||fn||f\}} t|t �r\|n|d }
||
krf|S |
t |
| | �} } |dur�||
kr�t d|� d|� ���| |kr�t || | �|} } ||kr�| | fn| | f}|j
||d�S )a�
Resizes `image`. Enforces conversion of input to PIL.Image.
Args:
image (`PIL.Image.Image` or `np.ndarray` or `torch.Tensor`):
The image to resize.
size (`int` or `Tuple[int, int]`):
The size to use for resizing the image. If `size` is a sequence like (h, w), output size will be
matched to this.
If `size` is an int and `default_to_square` is `True`, then image will be resized to (size, size). If
`size` is an int and `default_to_square` is `False`, then smaller edge of the image will be matched to
this number. i.e, if height > width, then image will be rescaled to (size * height / width, size).
resample (`int`, *optional*, defaults to `PILImageResampling.BILINEAR`):
The filter to user for resampling.
default_to_square (`bool`, *optional*, defaults to `True`):
How to convert `size` when it is a single int. If set to `True`, the `size` will be converted to a
square (`size`,`size`). If set to `False`, will replicate
[`torchvision.transforms.Resize`](https://pytorch.org/vision/stable/transforms.html#torchvision.transforms.Resize)
with support for resizing only the smallest edge and providing an optional `max_size`.
max_size (`int`, *optional*, defaults to `None`):
The maximum allowed for the longer edge of the resized image: if the longer edge of the image is
greater than `max_size` after being resized according to `size`, then the image is resized again so
that the longer edge is equal to `max_size`. As a result, `size` might be overruled, i.e the smaller
edge may be shorter than `size`. Only used if `default_to_square` is `False`.
Returns:
image: A resized `PIL.Image.Image`.
Nr r z max_size = zN must be strictly greater than the requested size for the smaller edge size = )r� )r� �BILINEARr� r1 r2 r3 r� rG rH r_ rs r� rA �resize)
r� rD r� r� �default_to_square�max_size�width�height�short�long�requested_new_short� new_short�new_longr( r( r) r� � s4
$
��z"ImageFeatureExtractionMixin.resizec C s� | � |� t|t�s||f}t|�st|tj�r8|jdkr"| �|�}|jd dv r0|jdd� n|jdd� }n
|j d |j d f}|d |d d }||d }|d |d d }||d }t|t
j j �rr|� ||||f�S |jd dv r{dnd}|s�t|tj�r�|�
ddd�}t|�r�|�ddd�}|dkr�||d kr�|dkr�||d kr�|d||�||�f S |jdd � t|d |d �t|d |d �f } t|tj�r�tj|| d
�}
n t|�r�|�| �}
| d |d d } | |d } | d |d d }
|
|d }||
d| | �|
|�f< || 7 }|| 7 }||
7 }||
7 }|
dtd|�t|
jd |��td|�t|
jd |��f }
|
S ) a�
Crops `image` to the given size using a center crop. Note that if the image is too small to be cropped to the
size given, it will be padded (so the returned result has the size asked).
Args:
image (`PIL.Image.Image` or `np.ndarray` or `torch.Tensor` of shape (n_channels, height, width) or (height, width, n_channels)):
The image to resize.
size (`int` or `Tuple[int, int]`):
The size to which crop the image.
Returns:
new_image: A center cropped `PIL.Image.Image` or `np.ndarray` or `torch.Tensor` of shape: (n_channels,
height, width).
r] r r\ r NTF.rj )r` rk )r� r1 rH r rN r� rV r� r` r� r2 r3 �cropr� �permuterQ �
zeros_like� new_zerosrP )r� rD r� � image_shape�top�bottom�left�rightr� � new_shape� new_image�top_pad�
bottom_pad�left_pad� right_padr( r( r) � center_crop� sP
, (2
4�z'ImageFeatureExtractionMixin.center_cropc C s> | � |� t|tjj�r| �|�}|ddd�dd�dd�f S )a�
Flips the channel order of `image` from RGB to BGR, or vice versa. Note that this will trigger a conversion of
`image` to a NumPy array if it's a PIL Image.
Args:
image (`PIL.Image.Image` or `np.ndarray` or `torch.Tensor`):
The image whose color channels to flip. If `np.ndarray` or `torch.Tensor`, the channel dimension should
be first.
Nrk )r� r1 r2 r3 rZ r� r( r( r) �flip_channel_order s
z.ImageFeatureExtractionMixin.flip_channel_orderr c C sL |dur|nt jj}| �|� t|t jj�s| �|�}|j||||||d�S )a�
Returns a rotated copy of `image`. This method returns a copy of `image`, rotated the given number of degrees
counter clockwise around its centre.
Args:
image (`PIL.Image.Image` or `np.ndarray` or `torch.Tensor`):
The image to rotate. If `np.ndarray` or `torch.Tensor`, will be converted to `PIL.Image.Image` before
rotating.
Returns:
image: A rotated `PIL.Image.Image`.
N)r� �expand�center� translate� fillcolor)r2 r3 �NEARESTr� r1 r� �rotate)r� rD �angler� r� r� r� r� r( r( r) r� 0 s
�z"ImageFeatureExtractionMixin.rotater0 )NT)F)NTN)Nr NNN)r# r$ r% �__doc__r� r� r� rN r� r r� r_ r� rZ r� r� r� r� r� r� r( r( r( r) r� � s
"
4CKr� �annotation_format� supported_annotation_formatsc C sX | |vrt dt� d|� ���| tju rt|�st d��| tju r(t|�s*t d��d S d S )Nz Unsupported annotation format: z must be one of z�Invalid COCO detection annotations. Annotations must a dict (single image) or list of dicts (batch of images) with the following keys: `image_id` and `annotations`, with the latter being a list of annotations in the COCO format.z�Invalid COCO panoptic annotations. Annotations must a dict (single image) or list of dicts (batch of images) with the following keys: `image_id`, `file_name` and `segments_info`, with the latter being a list of annotations in the COCO format.)rA �formatr+ r, r� r- r� )r� r� rp r( r( r) �validate_annotationsI s
�
��r� �valid_processor_keys�captured_kwargsc C s: t |��t | ��}|rd�|�}t�d|� d�� d S d S )Nz, z Unused or unrecognized kwargs: rU )�set�
difference�joinra rb )r� r� Z unused_keysZunused_key_strr( r( r) �validate_kwargsb s
�r )rS r0 ) NNNNNNNNNNNN)^r� r� �ior �typingr r r r r r r r: rN r� � packagingr
�utilsr r
r r r r r r r r r r Zutils.constantsr r r r r r � PIL.Imager2 Z PIL.ImageOps�parse� __version__� base_versionr3 �
Resamplingr� �torchvision.transformsr r� �BOXr� �HAMMING�BICUBIC�LANCZOSZ pil_torch_interpolation_mappingr9 �
get_loggerr# ra r� �
ImageInputZ
VideoInputr r+ r. r� r_ ZAnnotationTyper6 r7 rE rF rI rK �boolrR rX rZ re rh rm ru rw r� r� r� r� r� r� r& r� r� r� r r( r( r( r) �<module> sd $ 8
�
�
�� '
���
�&���
�"""&&$-���
���������� �
� �
�*��������� �
� � �
�
�' a�
��
�