
    qiEk                     @   d dl Z d dlmZ d dlmc mZ d dlmZ d dlm	Z	 d dl
mZmZ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mZ ddlmZ ddlmZ dd	l m!Z!m"Z"m#Z#m$Z$ dd
l%m&Z& ddl'm(Z(  G d de	      Z) G d de      Z* G d de      Z+ G d de      Z, G d de      Z- G d de      Z. G d de      Z/ G d dej`                        Z1 G d de      Z2 G d de      Z3 G d  d!e      Z4 G d" d#e      Z5 G d$ d%e      Z6 G d& d'e      Z7 G d( d)e      Z8g d*Z9y)+    N)normalizers)GemmaTokenizer)SiglipConfigSiglipTextConfigSiglipVisionConfig)BaseModelOutputBaseModelOutputWithPoolingImageClassifierOutputSiglipForImageClassificationSiglipModel#SiglipMultiheadAttentionPoolingHeadSiglipOutputSiglipPreTrainedModelSiglipTextModelSiglipTextModelOutputSiglipVisionModelSiglipVisionModelOutputSiglipVisionTransformer   )create_bidirectional_mask)Unpack)TransformersKwargsauto_docstringcan_return_tupletorch_compilable_check)merge_with_config_defaults)capture_outputsc                   x     e Zd ZdZ	 	 	 	 	 	 	 ddeeeef   z  dz  deee   z  dz  dedededed	ef fd
Z xZ	S )Siglip2TokenizerzN
    Gemma tokenizer + SigLIP2 training default: lowercase normalization.
    Nvocabmerges	unk_token	bos_token	eos_token	pad_token
mask_tokenc                    t        
|   d|||||||d| t        | d      rJt        | j                  t
              r0| j                  j                  d| j                  j                         t        | dd       }	|	F|	j                  9t        j                  t        j                         |	j                  g      |	_
        y y y )N)r    r!   r"   r#   r$   r%   r&   init_kwargstokenizer_class
_tokenizer )super__init__hasattr
isinstancer(   dict
setdefault	__class____name__getattr
normalizerr   Sequence	Lowercase)selfr    r!   r"   r#   r$   r%   r&   kwargsbackendr2   s             ]/opt/pipecat/venv/lib/python3.12/site-packages/transformers/models/siglip2/modular_siglip2.pyr-   zSiglip2Tokenizer.__init__7   s     	 		
!		
 		
 4'Jt7G7G,N''(94>>;R;RS$d37#5#5#A!,!5!5{7L7L7NPWPbPb6c!dG $B    )NNz<unk>z<bos>z<eos>z<pad>z<mask>)
r3   
__module____qualname____doc__strr0   intlistr-   __classcell__r2   s   @r;   r   r   2   s     .2)-    "eT#s(^#d*e d3i$&e 	e
 e e e e er<   r   c                       e Zd Zy)Siglip2TextConfigNr3   r=   r>   r+   r<   r;   rF   rF   V       r<   rF   c                   8     e Zd ZdZ	 	 	 	 	 	 	 	 	 	 d fd	Z xZS )Siglip2VisionConfigaO  
    This is the configuration class to store the configuration of a [`Siglip2VisionModel`]. It is used to instantiate a
    Siglip2 vision encoder according to the specified arguments, defining the model architecture. Instantiating a
    configuration with the defaults will yield a similar configuration to that of the vision encoder of the Siglip2
    [google/siglip2-base-patch16-naflex](https://huggingface.co/google/siglip2-base-patch16-naflex) architecture.

    Configuration objects inherit from [`PreTrainedConfig`] and can be used to control the model outputs. Read the
    documentation from [`PreTrainedConfig`] for more information.

    Args:
        hidden_size (`int`, *optional*, defaults to 768):
            Dimensionality of the encoder layers and the pooler layer.
        intermediate_size (`int`, *optional*, defaults to 3072):
            Dimensionality of the "intermediate" (i.e., feed-forward) layer in the Transformer encoder.
        num_hidden_layers (`int`, *optional*, defaults to 12):
            Number of hidden layers in the Transformer encoder.
        num_attention_heads (`int`, *optional*, defaults to 12):
            Number of attention heads for each attention layer in the Transformer encoder.
        num_channels (`int`, *optional*, defaults to 3):
            Number of channels in the input images.
        num_patches (`int`, *optional*, defaults to 256):
            The number of patches in the image with the size of (`patch_size`, `patch_size`).
            The image is resized to fill maximum of this number of patches, and to preserve
            the aspect ratio. In case the resulted number of patches is lower, the image is
            padded in "patch" dimension.
        patch_size (`int`, *optional*, defaults to 16):
            The size (resolution) of each patch.
        hidden_act (`str` or `function`, *optional*, defaults to `"gelu_pytorch_tanh"`):
            The non-linear activation function (function or string) in the encoder and pooler. If string, `"gelu"`,
            `"relu"`, `"selu"` and `"gelu_new"` `"quick_gelu"` are supported.
        layer_norm_eps (`float`, *optional*, defaults to 1e-06):
            The epsilon used by the layer normalization layers.
        attention_dropout (`float`, *optional*, defaults to 0.0):
            The dropout ratio for the attention probabilities.

    Example:

    ```python
    >>> from transformers import Siglip2VisionConfig, Siglip2VisionModel

    >>> # Initializing a Siglip2VisionConfig with google/siglip2-base-patch16-naflex style configuration
    >>> configuration = Siglip2VisionConfig()

    >>> # Initializing a Siglip2VisionModel (with random weights) from the google/siglip2-base-patch16-naflex style configuration
    >>> model = Siglip2VisionModel(configuration)

    >>> # Accessing the model configuration
    >>> configuration = model.config
    ```c                 6    t        |   di | || _        | `y )Nr+   )r,   r-   num_patches
image_size)r8   hidden_sizeintermediate_sizenum_hidden_layersnum_attention_headsnum_channelsrL   
patch_size
hidden_actlayer_norm_epsattention_dropoutr9   r2   s               r;   r-   zSiglip2VisionConfig.__init__   s"     	"6"&Or<   )
i   i      rW   r         gelu_pytorch_tanhgư>        )r3   r=   r>   r?   r-   rC   rD   s   @r;   rJ   rJ   Z   s3    0h & r<   rJ   c                       e Zd Zy)Siglip2ConfigNrG   r+   r<   r;   r]   r]      rH   r<   r]   c                       e Zd Zy)Siglip2VisionOutputNrG   r+   r<   r;   r_   r_      rH   r<   r_   c                       e Zd Zy)Siglip2TextOutputNrG   r+   r<   r;   ra   ra      rH   r<   ra   c                       e Zd Zy)Siglip2OutputNrG   r+   r<   r;   rc   rc      rH   r<   rc   c            	            e Zd Zdef fdZedej                  dej                  de	dej                  fd       Z
dej                  dej                  dej                  fd	Z xZS )
Siglip2VisionEmbeddingsconfigc                    t         |           || _        |j                  | _        |j
                  | _        t        j                  |j                  | j
                  z  | j
                  z  | j                        | _	        |j                  | _
        t        | j                  dz        | _        t        j                  | j                  | j                        | _        y )N)in_featuresout_featuresg      ?)r,   r-   rf   rN   	embed_dimrS   nnLinearrR   patch_embeddingrL   rA   position_embedding_size	Embeddingposition_embeddingr8   rf   r2   s     r;   r-   z Siglip2VisionEmbeddings.__init__   s    ++ ++!yy++doo=O 

 "--'*4+;+;S+@'A$"$,,t/?/?"Pr<   positional_embeddingsspatial_shapes
max_lengthreturnc                    |j                   d   }| j                   d   }| j                  }t        j                  |||f| j                  |      }| j                  ddd      j                  d      } | j                  j                  dk(  r| j                  t        j                        } t        |      D ]  }||   j                         \  }}	t        |	dkD  d       t        |dkD  d       t        ||	z  |k  d	       t        j                  | ||	fd
dd      }
|
j                  |||	z        j!                  dd      }
|
j                  |      }
|
||d||	z  f<   |
d   ||||	z  df<    |S )ac  
        Resize positional embeddings to image-specific size and pad to a fixed size.

        Args:
            positional_embeddings (`torch.Tensor`):
                Position embeddings of shape (height, width, embed_dim)
            spatial_shapes (`torch.LongTensor`):
                Spatial shapes of shape (batch_size, 2) to resize the positional embeddings to
            max_length (`int`):
                Maximum length of the positional embeddings to pad resized positional embeddings to

        Returns:
            `torch.Tensor`: Embeddings of shape (batch_size, max_length, embed_dim)
        r   devicedtype      cpuz8Width of resized positional embeddings must be positive.z9Height of resized positional embeddings must be positive.z0Resized positional embeddings exceed max_length.bilinearFT)sizemodealign_corners	antialiasN)shaperz   torchemptyry   permute	unsqueezetypetofloat32rangetolistr   Finterpolatereshape	transpose)rr   rs   rt   
batch_sizerj   source_dtyperesulted_positional_embeddingsiheightwidthresized_embeddingss              r;   resize_positional_embeddingsz4Siglip2VisionEmbeddings.resize_positional_embeddings   s   ( $))!,
)//3	,22).Y/(//*
& !6 = =aA F P PQR S !'',,5$9$<$<U]]$K!z" 	XA*1-446MFE"EAI0jk"FQJ1lm"FUNz#ACuv!"%e_#" "4!;!;IvPU~!V!`!`abde!f "4!6!6|!DBT*1.>.>+>?BTUVBW*1fun.>+>?+	X. .-r<   pixel_valuesc                 J   | j                   j                  j                  }| j                  |j                  |            }| j                  j                  j                  | j                  | j                  d      }| j                  |||j                  d         }||z   }|S )aH  
        Args:
            pixel_values (`torch.FloatTensor`):
                Pixel values of shape (batch_size, max_num_patches, num_channels * patch_size * patch_size)
            spatial_shapes (`list[tuple[int, int]]`):
                Spatial shapes of shape (batch_size, 2) to resize the positional embeddings to
        )rz   rw   r|   )rt   )	rm   weightrz   r   rp   r   rn   r   r   )r8   r   rs   target_dtypepatch_embedsrr   resized_positional_embeddings
embeddingss           r;   forwardzSiglip2VisionEmbeddings.forward   s     ++2288++LOO,O,OP !% 7 7 > > F F(($*F*F!
 )-(I(I!>l>P>PQR>S )J )
%
 "$AA
r<   )r3   r=   r>   rJ   r-   staticmethodr   Tensor
LongTensorrA   r   FloatTensorr   rC   rD   s   @r;   re   re      s    Q2 Q ;.$||;.((;. ;. 
	;. ;.zE$5$5 uGWGW \a\h\h r<   re   c                       e Zd ZdZdZy)Siglip2PreTrainedModelFN)r3   r=   r>   _supports_flex_attn_supports_flash_attnr+   r<   r;   r   r     s     r<   r   c                        e Zd Zdef fdZ	 	 ddej                  dej                  dej                  de	dz  de	dz  d	e
fd
Z xZS )Siglip2VisionTransformerrf   c                 $    t         |   |       y N)r,   r-   rq   s     r;   r-   z!Siglip2VisionTransformer.__init__  s     r<   Nr   attention_maskrs   output_attentionsoutput_hidden_statesru   c                    ||n| j                   j                  }||n| j                   j                  }| j                  ||      }t	        | j                   ||      }| j                  ||||      }	|	j                  }
| j                  |
      }
| j                  r| j                  |
|      nd}t        |
||	j                  |	j                        S )z
        spatial_shapes (`torch.LongTensor` of shape `(batch_size, 2)`):
            Tensor containing the spatial dimensions (height, width) of the input images.
        N)rf   inputs_embedsr   )r   r   r   r   )last_hidden_statepooler_outputhidden_states
attentions)rf   r   r   r   r   encoderr   post_layernormuse_headheadr	   r   r   )r8   r   r   rs   r   r   r9   r   encoder_attention_maskencoder_outputsr   r   s               r;   r   z Siglip2VisionTransformer.forward#  s     2C1N-TXT_T_TqTq$8$D $++JjJj 	 nE!:;;')"
 ,0<<'1/!5	 ,8 ,
 ,== //0ABHL		"3^D[_)/')77&11	
 	
r<   )NN)r3   r=   r>   rJ   r-   r   r   r   r   boolr	   r   rC   rD   s   @r;   r   r     so    !2 ! *.,0+
''+
 +
 ((	+

  $;+
 #Tk+
 
$+
r<   r   c                       e Zd Zy)Siglip2TextModelNrG   r+   r<   r;   r   r   Q  rH   r<   r   c                   |     e Zd Zdef fdZddej                  dej                  dz  dej                  fdZ xZS )	$Siglip2MultiheadAttentionPoolingHeadrf   c                 T    t         |   |       || _        |j                  | _        y r   )r,   r-   rf   rQ   	num_headsrq   s     r;   r-   z-Siglip2MultiheadAttentionPoolingHead.__init__V  s$     33r<   Nhidden_stater   ru   c                    |j                   d   }| j                  j                  |dd      }||j                   d   |j                   d   }}t        | j                  |||      }||j                  d| j
                  |d      }|j                  d||      }|j                  t        j                  k(  rht        j                  |t        j                  d|j                  |j                        t        j                  |j                        j                        }| j                  ||||      d   }|}| j!                  |      }|| j#                  |      z   }|d d df   S )Nr   r|   )rf   r   r   encoder_hidden_statesrw   r[   rx   )	attn_mask)r   proberepeatr   rf   r   r   rz   r   r   wheretensorry   finfomin	attention	layernormmlp)r8   r   r   r   r   
target_len
source_lenresiduals           r;   r   z,Siglip2MultiheadAttentionPoolingHead.forward\  sF   !''*


!!*a3%%*[[^\5G5G5J
J6{{#-&2	N )!/!6!6q$..*VW!X!/!7!7J
!S "''5::5%*[[&S1F1FekkZEKK044&N ~~e\<Sa~bcde~~l3$((<"88AqD!!r<   r   )	r3   r=   r>   rJ   r-   r   r   r   rC   rD   s   @r;   r   r   U  s?    42 4"ELL "%,,QUBU "afamam "r<   r   c                       e Zd Ze ed      edej                  dej                  dej                  de
e   def
d                     Zy	)
Siglip2VisionModelF)tie_last_hidden_statesr   pixel_attention_maskrs   r9   ru   c                 .     | j                   d|||d|S )a  
        pixel_attention_mask (`torch.Tensor` of shape `(batch_size, image_size, image_size)`, *optional*):
            Mask to avoid performing attention on padding pixel indices.
        spatial_shapes (`torch.LongTensor` of shape `(batch_size, 2)`):
            Tensor containing the spatial dimensions (height, width) of the input images.

        Examples:

        ```python
        >>> from PIL import Image
        >>> import httpx
        >>> from io import BytesIO
        >>> from transformers import AutoProcessor, Siglip2VisionModel

        >>> model = Siglip2VisionModel.from_pretrained("google/siglip2-base-patch16-224")
        >>> processor = AutoProcessor.from_pretrained("google/siglip2-base-patch16-224")

        >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
        >>> with httpx.stream("GET", url) as response:
        ...     image = Image.open(BytesIO(response.read()))

        >>> inputs = processor(images=image, return_tensors="pt")

        >>> outputs = model(**inputs)
        >>> last_hidden_state = outputs.last_hidden_state
        >>> pooled_output = outputs.pooler_output  # pooled features
        ```r   r   rs   r+   vision_modelr8   r   r   rs   r9   s        r;   r   zSiglip2VisionModel.forward  s2    J !t   
%/)
 	
 	
r<   N)r3   r=   r>   r   r   r   r   r   r   r   r   r   r	   r   r+   r<   r;   r   r   }  so    E2'
'''
 $ll'
 ((	'

 +,'
 
$'
  3  '
r<   r   c                      e Zd Zee	 	 	 ddej                  dz  dej                  dz  dej                  dz  de	e
   deez  f
d              Z	 	 	 	 	 	 	 	 	 ddej                  dz  dej                  dz  dej                  dz  dej                  dz  d	ej                  dz  d
ej                  dz  dedz  dedz  dedz  defdZy)Siglip2ModelNr   r   rs   r9   ru   c                 .     | j                   d|||d|S )a  
        pixel_attention_mask (`torch.Tensor` of shape `(batch_size, image_size, image_size)`, *optional*):
            Mask to avoid performing attention on padding pixel indices.
        spatial_shapes (`torch.LongTensor` of shape `(batch_size, 2)`):
            Tensor containing the spatial dimensions (height, width) of the input images.

        Examples:

        ```python
        >>> import torch
        >>> from transformers import AutoProcessor, AutoModel
        >>> from transformers.image_utils import load_image

        >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
        >>> image = load_image(url)

        >>> model = AutoModel.from_pretrained("google/siglip2-base-patch16-224")
        >>> processor = AutoProcessor.from_pretrained("google/siglip2-base-patch16-224")

        >>> inputs = processor(images=image, return_tensors="pt")

        >>> with torch.no_grad():
        ...     image_features = model.get_image_features(**inputs)
        ```
        r   r+   r   r   s        r;   get_image_featureszSiglip2Model.get_image_features  s2    D !t   
%/)
 	
 	
r<   	input_idsr   position_idsreturn_lossr   r   c
           	         ||n| j                   j                  }|	|	n| j                   j                  }	| j                  |||||	      }| j	                  |||||	      }|j
                  }|j
                  }||j                  ddd      z  }||j                  ddd      z  }t        j                  ||j                         j                  |j                              }| j                  j                  |j                        | j                  j                  |j                        }}||j                         z  |z   }|j                         }d}|rt        j                  |j!                  d      |j                  	      }t        j"                  |       d|z  z   }t        j$                  j&                  j)                  ||z        }t        j*                  |d
       }|j-                         }t/        |||||||      S )ae  
        pixel_attention_mask (`torch.Tensor` of shape `(batch_size, image_size, image_size)`, *optional*):
            Mask to avoid performing attention on padding pixel indices.
        spatial_shapes (`torch.LongTensor` of shape `(batch_size, 2)`):
            Tensor containing the spatial dimensions (height, width) of the input images.
        return_loss (`bool`, *optional*):
            Whether or not to return the contrastive loss.

        Examples:

        ```python
        >>> from PIL import Image
        >>> import httpx
        >>> from io import BytesIO
        >>> from transformers import AutoProcessor, AutoModel
        >>> import torch

        >>> model = AutoModel.from_pretrained("google/siglip2-base-patch16-224")
        >>> processor = AutoProcessor.from_pretrained("google/siglip2-base-patch16-224")

        >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
        >>> with httpx.stream("GET", url) as response:
        ...     image = Image.open(BytesIO(response.read()))

        >>> texts = ["a photo of 2 cats", "a photo of 2 dogs"]
        >>> # important: we pass `padding=max_length` since the model was trained with this
        >>> inputs = processor(text=texts, images=image, padding="max_length", return_tensors="pt")

        >>> with torch.no_grad():
        ...     outputs = model(**inputs)

        >>> logits_per_image = outputs.logits_per_image
        >>> probs = torch.sigmoid(logits_per_image) # these are the probabilities
        >>> print(f"{probs[0][0]:.1%} that image 0 is '{texts[0]}'")
        31.9% that image 0 is 'a photo of 2 cats'
        ```
        N)r   r   rs   r   r   )r   r   r   r   r   r{   rw   T)pdimkeepdimr   )ry   r   )losslogits_per_imagelogits_per_texttext_embedsimage_embedstext_model_outputvision_model_output)rf   r   r   r   
text_modelr   normr   matmultr   ry   logit_scale
logit_biasexpeyer   	ones_likerk   
functional
logsigmoidsummeanrc   )r8   r   r   r   rs   r   r   r   r   r   r9   vision_outputstext_outputsr   r   r   r   r   r   r   r   m1_diag1logliknlls                           r;   r   zSiglip2Model.forward  s    f 2C1N-TXT_T_TqTq$8$D $++JjJj 	 6:5F5F%/)/!5 6G 6
 48??)%/!5 4C 4
 &33"00 $l&7&7!T&7&RR!K$4$4qb$$4$OO  ,,{LNN4D4G4GHZHZ4[\"&"2"2"5"5k6H6H"I4??K]K]^i^p^pKqZ)KOO,==
J*,,.))O003O<R<RSC881s7BHXX((33H4NOF99V,,C88:D-+#%* .
 	
r<   )NNN)	NNNNNNNNN)r3   r=   r>   r   r   r   r   r   r   r   r   tupler	   r   r   rc   r   r+   r<   r;   r   r     s\    264826	%
''$.%
 $llT1%
 ((4/	%

 +,%
 
+	+%
  %
T .2154826.204#')-,0h
##d*h
 ''$.h
 $llT1	h

 ((4/h
 t+h
 &&-h
 D[h
  $;h
 #Tkh
 
h
r<   r   c                       e Zd Z	 	 	 	 	 	 d
dej                  dz  dej                  dz  dej
                  dz  dej                  dz  dedz  dedz  defd	Zy)Siglip2ForImageClassificationNr   r   rs   labelsr   r   ru   c                 ,   ||n| j                   j                  }||n| j                   j                  }| j                  |||||      }|j                  }	|Q|d   j                  |	j                        }
t        j                  |	|
z  d      t        j                  |
d      z  }	nt        j                  |	d      }	| j                  |	      }d}|| j                  ||| j                         }t        |||j                  |j                        S )a  
        pixel_attention_mask (`torch.Tensor` of shape `(batch_size, image_size, image_size)`, *optional*):
            Mask to avoid performing attention on padding pixel indices.
        spatial_shapes (`torch.LongTensor` of shape `(batch_size, 2)`):
            Tensor containing the spatial dimensions (height, width) of the input images.
        labels (`torch.LongTensor` of shape `(batch_size,)`, *optional*):
            Labels for computing the image classification/regression loss. Indices should be in `[0, ...,
            config.num_labels - 1]`. If `config.num_labels == 1` a regression loss is computed (Mean-Square loss), If
            `config.num_labels > 1` a classification loss is computed (Cross-Entropy).

        Examples:

        ```python
        >>> from transformers import AutoImageProcessor, Siglip2ForImageClassification
        >>> import torch
        >>> from PIL import Image
        >>> import httpx
        >>> from io import BytesIO

        >>> torch.manual_seed(3)  # doctest: +IGNORE_RESULT
        >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
        >>> with httpx.stream("GET", url) as response:
        ...     image = Image.open(BytesIO(response.read()))

        >>> # note: we are loading a `Siglip2Model` from the hub here,
        >>> # so the head will be randomly initialized, hence the predictions will be random if seed is not set above.
        >>> image_processor = AutoImageProcessor.from_pretrained("google/siglip2-base-patch16-224")
        >>> model = Siglip2ForImageClassification.from_pretrained("google/siglip2-base-patch16-224")

        >>> inputs = image_processor(images=image, return_tensors="pt")
        >>> outputs = model(**inputs)
        >>> logits = outputs.logits
        >>> # model predicts one of the two classes
        >>> predicted_class_idx = logits.argmax(-1).item()
        >>> print("Predicted class:", model.config.id2label[predicted_class_idx])
        Predicted class: LABEL_1
        ```
        N)r   rs   r   r   ).Nr|   r   )r   logitsr   r   )rf   r   r   r   r   r   ry   r   r   r   
classifierloss_functionr
   r   r   )r8   r   r   rs   r  r   r   r9   outputssequence_output	pool_maskr  r   s                r;   r   z%Siglip2ForImageClassification.forwardE  s!   ` 2C1N-TXT_T_TqTq$8$D $++JjJj 	 /3.?.?/)/!5 /@ /
 "33  +,Y7::?;Q;QRI#ii)(CKeiiXaghNiiO#jja@O 1%%ffdkkBD$!//))	
 	
r<   )NNNNNN)	r3   r=   r>   r   r   r   r   r
   r   r+   r<   r;   r  r  C  s     -14826&*)-,0R
llT)R
 $llT1R
 ((4/	R

 t#R
  $;R
 #TkR
 
R
r<   r  )	r]   rF   rJ   r   r   r   r   r  r   ):r   torch.nnrk   torch.nn.functionalr   r   
tokenizersr   ,transformers.models.gemma.tokenization_gemmar   /transformers.models.siglip.configuration_siglipr   r   r   *transformers.models.siglip.modeling_siglipr   r	   r
   r   r   r   r   r   r   r   r   r   r   masking_utilsr   processing_utilsr   utilsr   r   r   r   utils.genericr   utils.output_capturingr   r   rF   rJ   r]   r_   ra   rc   Modulere   r   r   r   r   r   r   r  __all__r+   r<   r;   <module>r     s'       " G n n     7 &  8 5!e~ !eH	( 	C, CL	L 		1 		- 		L 	ebii eP!2 !0
6 0
f	 	%"+N %"P,
* ,
^T
; T
nT
$@ T
n
r<   