code: 
  
  
  
  
  import logging
  
  import torch
  from torch import nn
  from torch.nn import CrossEntropyLoss, MSELoss
  
  from transformers.file_utils import add_start_docstrings, add_start_docstrings_to_model_forward
  from transformers.models.albert.modeling_albert import (
      ALBERT_INPUTS_DOCSTRING,
      ALBERT_START_DOCSTRING,
      AlbertModel,
      AlbertPreTrainedModel,
      AlbertTransformer,
  )
  
  
  lowercase__			=	logging.getLogger(__name__)
  
  
  
  
  
  
  class 						lowercase     (   A_):
  
  
  
  
  
  
        def    A__(self ,  a__ ,  a__ ,  a__=None ,  a__=None					)       ->   Tuple:
  
  
  
           if current_layer == 0:
              SCREAMING_SNAKE_CASE__			:				Optional[int]       						= self.embedding_hidden_mapping_in(a__					)
           else:
              SCREAMING_SNAKE_CASE__			:				Dict       						= hidden_states[0]
  
           SCREAMING_SNAKE_CASE__			:				int       						= int(self.config.num_hidden_layers / self.config.num_hidden_groups					)
  
           # Index of the hidden group
           SCREAMING_SNAKE_CASE__			:				Any       						= int(current_layer / (self.config.num_hidden_layers / self.config.num_hidden_groups)					)
  
           SCREAMING_SNAKE_CASE__			:				int       						= self.albert_layer_groups[group_idx](
               a__ ,  a__ ,  head_mask[group_idx * layers_per_group : (group_idx + 1) * layers_per_group] ,  )
           SCREAMING_SNAKE_CASE__			:				Optional[Any]       						= layer_group_output[0]
  
           return (hidden_states,)
  
  
  
  
  
  
  @add_start_docstrings(
      '''The bare ALBERT Model transformer with PABEE outputting raw hidden-states without any specific head on top.'''				,			A_				,			)
  class 						lowercase     (   A_):
  
  
  
  
  
  
        def __init__(self ,  a__					)       ->   Dict:
           super().__init__(a__					)
  
           SCREAMING_SNAKE_CASE__			:				Any       						= AlbertTransformerWithPabee(a__					)
  
           self.init_weights()
           SCREAMING_SNAKE_CASE__			:				List[str]       						= 0
           SCREAMING_SNAKE_CASE__			:				Optional[int]       						= 0
           SCREAMING_SNAKE_CASE__			:				str       						= 0
  
           SCREAMING_SNAKE_CASE__			:				Dict       						= 0
  
  
  
  
  
  
        def    A__(self ,  a__					)       ->   int:
           SCREAMING_SNAKE_CASE__			:				int       						= threshold
  
  
  
  
  
  
        def    A__(self ,  a__					)       ->   Any:
           SCREAMING_SNAKE_CASE__			:				List[str]       						= patience
  
  
  
  
  
  
        def    A__(self					)       ->   Any:
           SCREAMING_SNAKE_CASE__			:				Dict       						= 0
           SCREAMING_SNAKE_CASE__			:				str       						= 0
  
  
  
  
  
  
        def    A__(self					)       ->   Optional[Any]:
           SCREAMING_SNAKE_CASE__			:				Tuple       						= self.inference_layers_num / self.inference_instances_num
           SCREAMING_SNAKE_CASE__			:				Tuple       						= (
               f"""*** Patience = {self.patience} Avg. Inference Layers = {avg_inf_layers:.2f} Speed Up ="""
               f""" {1 - avg_inf_layers / self.config.num_hidden_layers:.2f} ***"""
           )
           print(a__					)
  
  
  
  
  
  
        @add_start_docstrings_to_model_forward(a__					)
        def    A__(self ,  a__=None ,  a__=None ,  a__=None ,  a__=None ,  a__=None ,  a__=None ,  a__=None ,  a__=None ,  a__=False ,  )       ->   List[str]:
  
  
  
           if input_ids is not None and inputs_embeds is not None:
              raise ValueError('''You cannot specify both input_ids and inputs_embeds at the same time'''					)
           elif input_ids is not None:
              SCREAMING_SNAKE_CASE__			:				Tuple       						= input_ids.size()
           elif inputs_embeds is not None:
              SCREAMING_SNAKE_CASE__			:				Tuple       						= inputs_embeds.size()[:-1]
           else:
              raise ValueError('''You have to specify either input_ids or inputs_embeds'''					)
  
           SCREAMING_SNAKE_CASE__			:				Union[str, Any]       						= input_ids.device if input_ids is not None else inputs_embeds.device
  
           if attention_mask is None:
              SCREAMING_SNAKE_CASE__			:				List[Any]       						= torch.ones(a__ ,  device=a__					)
           if token_type_ids is None:
              SCREAMING_SNAKE_CASE__			:				Dict       						= torch.zeros(a__ ,  dtype=torch.long ,  device=a__					)
  
           SCREAMING_SNAKE_CASE__			:				Optional[Any]       						= attention_mask.unsqueeze(1					).unsqueeze(2					)
           SCREAMING_SNAKE_CASE__			:				int       						= extended_attention_mask.to(dtype=self.dtype					)  # fp16 compatibility
           SCREAMING_SNAKE_CASE__			:				Dict       						= (1.0 - extended_attention_mask) * -1_00_00.0
           SCREAMING_SNAKE_CASE__			:				Union[str, Any]       						= self.get_head_mask(a__ ,  self.config.num_hidden_layers					)
  
           SCREAMING_SNAKE_CASE__			:				Dict       						= self.embeddings(
               a__ ,  position_ids=a__ ,  token_type_ids=a__ ,  inputs_embeds=a__					)
           SCREAMING_SNAKE_CASE__			:				Optional[int]       						= embedding_output
  
           if self.training:
              SCREAMING_SNAKE_CASE__			:				Dict       						= []
              for i in range(self.config.num_hidden_layers					):
                 SCREAMING_SNAKE_CASE__			:				Optional[Any]       						= self.encoder.adaptive_forward(
                     a__ ,  current_layer=a__ ,  attention_mask=a__ ,  head_mask=a__ ,  )
  
                 SCREAMING_SNAKE_CASE__			:				List[str]       						= self.pooler_activation(self.pooler(encoder_outputs[0][:, 0]					)					)
                 SCREAMING_SNAKE_CASE__			:				List[str]       						= output_layers[i](output_dropout(a__					)					)
                 res.append(a__					)
           elif self.patience == 0:  # Use all layers for inference
              SCREAMING_SNAKE_CASE__			:				Any       						= self.encoder(a__ ,  a__ ,  head_mask=a__					)
              SCREAMING_SNAKE_CASE__			:				int       						= self.pooler_activation(self.pooler(encoder_outputs[0][:, 0]					)					)
              SCREAMING_SNAKE_CASE__			:				List[Any]       						= [output_layers[self.config.num_hidden_layers - 1](a__					)]
           else:
              SCREAMING_SNAKE_CASE__			:				Union[str, Any]       						= 0
              SCREAMING_SNAKE_CASE__			:				Optional[int]       						= None
              SCREAMING_SNAKE_CASE__			:				Union[str, Any]       						= 0
              for i in range(self.config.num_hidden_layers					):
                 calculated_layer_num += 1
                 SCREAMING_SNAKE_CASE__			:				Optional[Any]       						= self.encoder.adaptive_forward(
                     a__ ,  current_layer=a__ ,  attention_mask=a__ ,  head_mask=a__ ,  )
  
                 SCREAMING_SNAKE_CASE__			:				int       						= self.pooler_activation(self.pooler(encoder_outputs[0][:, 0]					)					)
                 SCREAMING_SNAKE_CASE__			:				Union[str, Any]       						= output_layers[i](a__					)
                 if regression:
                    SCREAMING_SNAKE_CASE__			:				Optional[int]       						= logits.detach()
                    if patient_result is not None:
                       SCREAMING_SNAKE_CASE__			:				Union[str, Any]       						= patient_result.detach()
                    if (patient_result is not None) and torch.abs(patient_result - labels					) < self.regression_threshold:
                       patient_counter += 1
                    else:
                       SCREAMING_SNAKE_CASE__			:				List[str]       						= 0
                 else:
                    SCREAMING_SNAKE_CASE__			:				Dict       						= logits.detach().argmax(dim=1					)
                    if patient_result is not None:
                       SCREAMING_SNAKE_CASE__			:				List[Any]       						= patient_result.detach().argmax(dim=1					)
                    if (patient_result is not None) and torch.all(labels.eq(a__					)					):
                       patient_counter += 1
                    else:
                       SCREAMING_SNAKE_CASE__			:				int       						= 0
  
                 SCREAMING_SNAKE_CASE__			:				int       						= logits
                 if patient_counter == self.patience:
                    break
              SCREAMING_SNAKE_CASE__			:				Optional[Any]       						= [patient_result]
              self.inference_layers_num += calculated_layer_num
              self.inference_instances_num += 1
  
           return res
  
  
  
  
  
  
  @add_start_docstrings(
      '''Albert Model transformer with PABEE and a sequence classification/regression head on top (a linear layer on top of
      the pooled output) e.g. for GLUE tasks. '''				,			A_				,			)
  class 						lowercase     (   A_):
  
  
  
  
  
  
        def __init__(self ,  a__					)       ->   List[str]:
           super().__init__(a__					)
           SCREAMING_SNAKE_CASE__			:				str       						= config.num_labels
  
           SCREAMING_SNAKE_CASE__			:				Union[str, Any]       						= AlbertModelWithPabee(a__					)
           SCREAMING_SNAKE_CASE__			:				int       						= nn.Dropout(config.classifier_dropout_prob					)
           SCREAMING_SNAKE_CASE__			:				Optional[Any]       						= nn.ModuleList(
               [nn.Linear(config.hidden_size ,  self.config.num_labels					) for _ in range(config.num_hidden_layers					)]					)
  
           self.init_weights()
  
  
  
  
  
  
        @add_start_docstrings_to_model_forward(a__					)
        def    A__(self ,  a__=None ,  a__=None ,  a__=None ,  a__=None ,  a__=None ,  a__=None ,  a__=None ,  )       ->   str:
           SCREAMING_SNAKE_CASE__			:				Tuple       						= self.albert(
               input_ids=a__ ,  attention_mask=a__ ,  token_type_ids=a__ ,  position_ids=a__ ,  head_mask=a__ ,  inputs_embeds=a__ ,  output_dropout=self.dropout ,  output_layers=self.classifiers ,  regression=self.num_labels == 1 ,  )
  
           SCREAMING_SNAKE_CASE__			:				Tuple       						= (logits[-1],)
  
           if labels is not None:
              SCREAMING_SNAKE_CASE__			:				Optional[Any]       						= None
              SCREAMING_SNAKE_CASE__			:				List[Any]       						= 0
              for ix, logits_item in enumerate(a__					):
                 if self.num_labels == 1:
                    #  We are doing regression
                    SCREAMING_SNAKE_CASE__			:				Optional[int]       						= MSELoss()
                    SCREAMING_SNAKE_CASE__			:				Any       						= loss_fct(logits_item.view(-1					) ,  labels.view(-1					)					)
                 else:
                    SCREAMING_SNAKE_CASE__			:				int       						= CrossEntropyLoss()
                    SCREAMING_SNAKE_CASE__			:				List[Any]       						= loss_fct(logits_item.view(-1 ,  self.num_labels					) ,  labels.view(-1					)					)
                 if total_loss is None:
                    SCREAMING_SNAKE_CASE__			:				List[str]       						= loss
                 else:
                    total_loss += loss * (ix + 1)
                 total_weights += ix + 1
              SCREAMING_SNAKE_CASE__			:				Any       						= (total_loss / total_weights,) + outputs
  
           return outputs
  
  
style_context: 
  
  
  
  
  '''simple docstring'''
  
  
  
  
  
  import unittest
  
  import requests
  
  from transformers import MODEL_FOR_VISION_2_SEQ_MAPPING, TF_MODEL_FOR_VISION_2_SEQ_MAPPING, is_vision_available
  from transformers.pipelines import pipeline
  from transformers.testing_utils import (
      is_pipeline_test,
      is_torch_available,
      require_tf,
      require_torch,
      require_vision,
      slow,
  )
  
  from .test_pipelines_common import ANY
  
  
  if is_torch_available():
         from transformers.pytorch_utils import is_torch_greater_or_equal_than_1_11
  else:
         lowercase__			=	False
  
  
  if is_vision_available():
         from PIL import Image
  else:
  
  
  
  
  
  
         class 						lowercase     :
  
  
  
  
  
  
               @staticmethod
               def    A__(*a__ ,  **a__					)       ->   Optional[Any]:
                  pass
  
  
  
  
  
  
  @is_pipeline_test
  @require_vision
  class 						lowercase     (   unittest.TestCase):
        __lowercase 		=  MODEL_FOR_VISION_2_SEQ_MAPPING
        __lowercase 		=  TF_MODEL_FOR_VISION_2_SEQ_MAPPING
  
  
  
  
  
  
        def    A__(self ,  a__ ,  a__ ,  a__					)       ->   Optional[Any]:
           SCREAMING_SNAKE_CASE__			:				Tuple       						= pipeline('''image-to-text''' ,  model=a__ ,  tokenizer=a__ ,  image_processor=a__					)
           SCREAMING_SNAKE_CASE__			:				List[Any]       						= [
               Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''					),
               '''./tests/fixtures/tests_samples/COCO/000000039769.png''',
           ]
           return pipe, examples
  
  
  
  
  
  
        def    A__(self ,  a__ ,  a__					)       ->   Any:
           SCREAMING_SNAKE_CASE__			:				Tuple       						= pipe(a__					)
           self.assertEqual(
               a__ ,  [
                   [{'''generated_text''': ANY(a__					)}],
                   [{'''generated_text''': ANY(a__					)}],
               ] ,  )
  
  
  
  
  
  
        @require_tf
        def    A__(self					)       ->   List[str]:
           SCREAMING_SNAKE_CASE__			:				List[str]       						= pipeline('''image-to-text''' ,  model='''hf-internal-testing/tiny-random-vit-gpt2''' ,  framework='''tf'''					)
           SCREAMING_SNAKE_CASE__			:				Union[str, Any]       						= '''./tests/fixtures/tests_samples/COCO/000000039769.png'''
  
           SCREAMING_SNAKE_CASE__			:				str       						= pipe(a__					)
           self.assertEqual(
               a__ ,  [
                   {
                       '''generated_text''': '''growthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthGOGO'''
                   },
               ] ,  )
  
           SCREAMING_SNAKE_CASE__			:				Optional[Any]       						= pipe([image, image]					)
           self.assertEqual(
               a__ ,  [
                   [
                       {
                           '''generated_text''': '''growthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthGOGO'''
                       }
                   ],
                   [
                       {
                           '''generated_text''': '''growthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthGOGO'''
                       }
                   ],
               ] ,  )
  
           SCREAMING_SNAKE_CASE__			:				Union[str, Any]       						= pipe(a__ ,  max_new_tokens=1					)
           self.assertEqual(
               a__ ,  [{'''generated_text''': '''growth'''}] ,  )
  
  
  
  
  
  
        @require_torch
        def    A__(self					)       ->   Optional[Any]:
           SCREAMING_SNAKE_CASE__			:				Optional[int]       						= pipeline('''image-to-text''' ,  model='''hf-internal-testing/tiny-random-vit-gpt2'''					)
           SCREAMING_SNAKE_CASE__			:				Any       						= '''./tests/fixtures/tests_samples/COCO/000000039769.png'''
  
           SCREAMING_SNAKE_CASE__			:				Optional[Any]       						= pipe(a__					)
           self.assertEqual(
               a__ ,  [
                   {
                       '''generated_text''': '''growthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthGOGO'''
                   },
               ] ,  )
  
           SCREAMING_SNAKE_CASE__			:				Any       						= pipe([image, image]					)
           self.assertEqual(
               a__ ,  [
                   [
                       {
                           '''generated_text''': '''growthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthGOGO'''
                       }
                   ],
                   [
                       {
                           '''generated_text''': '''growthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthGOGO'''
                       }
                   ],
               ] ,  )
  
  
  
  
  
  
        @require_torch
        def    A__(self					)       ->   Any:
           SCREAMING_SNAKE_CASE__			:				Union[str, Any]       						= pipeline('''image-to-text''' ,  model='''hf-internal-testing/tiny-random-BlipForConditionalGeneration'''					)
           SCREAMING_SNAKE_CASE__			:				int       						= '''./tests/fixtures/tests_samples/COCO/000000039769.png'''
           SCREAMING_SNAKE_CASE__			:				Tuple       						= '''a photo of'''
  
           SCREAMING_SNAKE_CASE__			:				List[Any]       						= pipe(a__ ,  prompt=a__					)
           self.assertTrue(outputs[0]['''generated_text'''].startswith(a__					)					)
  
  
  
  
  
  
        @slow
        @require_torch
        def    A__(self					)       ->   List[Any]:
           SCREAMING_SNAKE_CASE__			:				Tuple       						= pipeline('''image-to-text''' ,  model='''ydshieh/vit-gpt2-coco-en'''					)
           SCREAMING_SNAKE_CASE__			:				List[str]       						= '''./tests/fixtures/tests_samples/COCO/000000039769.png'''
  
           SCREAMING_SNAKE_CASE__			:				List[Any]       						= pipe(a__					)
           self.assertEqual(a__ ,  [{'''generated_text''': '''a cat laying on a blanket next to a cat laying on a bed '''}]					)
  
           SCREAMING_SNAKE_CASE__			:				Tuple       						= pipe([image, image]					)
           self.assertEqual(
               a__ ,  [
                   [{'''generated_text''': '''a cat laying on a blanket next to a cat laying on a bed '''}],
                   [{'''generated_text''': '''a cat laying on a blanket next to a cat laying on a bed '''}],
               ] ,  )
  
  
  
  
  
  
        @slow
        @require_torch
        def    A__(self					)       ->   Tuple:
           SCREAMING_SNAKE_CASE__			:				Dict       						= pipeline('''image-to-text''' ,  model='''Salesforce/blip-image-captioning-base'''					)
           SCREAMING_SNAKE_CASE__			:				Optional[Any]       						= '''https://huggingface.co/datasets/sayakpaul/sample-datasets/resolve/main/pokemon.png'''
           SCREAMING_SNAKE_CASE__			:				Optional[int]       						= Image.open(requests.get(a__ ,  stream=a__					).raw					)
  
           SCREAMING_SNAKE_CASE__			:				Optional[int]       						= pipe(a__					)
           self.assertEqual(a__ ,  [{'''generated_text''': '''a pink pokemon pokemon with a blue shirt and a blue shirt'''}]					)
  
  
  
  
  
  
        @slow
        @require_torch
        def    A__(self					)       ->   int:
           SCREAMING_SNAKE_CASE__			:				Optional[Any]       						= pipeline('''image-to-text''' ,  model='''microsoft/git-base-coco'''					)
           SCREAMING_SNAKE_CASE__			:				str       						= '''https://huggingface.co/datasets/sayakpaul/sample-datasets/resolve/main/pokemon.png'''
           SCREAMING_SNAKE_CASE__			:				List[str]       						= Image.open(requests.get(a__ ,  stream=a__					).raw					)
  
           SCREAMING_SNAKE_CASE__			:				str       						= pipe(a__					)
           self.assertEqual(a__ ,  [{'''generated_text''': '''a cartoon of a purple character.'''}]					)
  
  
  
  
  
  
        @slow
        @require_torch
        def    A__(self					)       ->   Dict:
           SCREAMING_SNAKE_CASE__			:				str       						= pipeline('''image-to-text''' ,  model='''Salesforce/blip-image-captioning-base'''					)
           SCREAMING_SNAKE_CASE__			:				List[Any]       						= '''https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/tasks/ai2d-demo.jpg'''
           SCREAMING_SNAKE_CASE__			:				Optional[int]       						= Image.open(requests.get(a__ ,  stream=a__					).raw					)
  
           SCREAMING_SNAKE_CASE__			:				Union[str, Any]       						= '''a photography of'''
  
           SCREAMING_SNAKE_CASE__			:				Union[str, Any]       						= pipe(a__ ,  prompt=a__					)
           self.assertEqual(a__ ,  [{'''generated_text''': '''a photography of a volcano'''}]					)
  
           with self.assertRaises(a__					):
              SCREAMING_SNAKE_CASE__			:				Any       						= pipe([image, image] ,  prompt=[prompt, prompt]					)
  
  
  
  
  
  
        @slow
        @require_torch
        def    A__(self					)       ->   Dict:
           SCREAMING_SNAKE_CASE__			:				Union[str, Any]       						= pipeline('''image-to-text''' ,  model='''microsoft/git-base-coco'''					)
           SCREAMING_SNAKE_CASE__			:				Optional[int]       						= '''https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/tasks/ai2d-demo.jpg'''
           SCREAMING_SNAKE_CASE__			:				Dict       						= Image.open(requests.get(a__ ,  stream=a__					).raw					)
  
           SCREAMING_SNAKE_CASE__			:				Optional[int]       						= '''a photo of a'''
  
           SCREAMING_SNAKE_CASE__			:				str       						= pipe(a__ ,  prompt=a__					)
           self.assertEqual(a__ ,  [{'''generated_text''': '''a photo of a tent with a tent and a tent in the background.'''}]					)
  
           with self.assertRaises(a__					):
              SCREAMING_SNAKE_CASE__			:				Dict       						= pipe([image, image] ,  prompt=[prompt, prompt]					)
  
  
  
  
  
  
        @unittest.skipIf(
            not is_torch_greater_or_equal_than_1_11 ,  reason='''`Pix2StructImageProcessor` requires `torch>=1.11.0`.'''					)
        @slow
        @require_torch
        def    A__(self					)       ->   Union[str, Any]:
           SCREAMING_SNAKE_CASE__			:				List[str]       						= pipeline('''image-to-text''' ,  model='''google/pix2struct-ai2d-base'''					)
           SCREAMING_SNAKE_CASE__			:				int       						= '''https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/tasks/ai2d-demo.jpg'''
           SCREAMING_SNAKE_CASE__			:				Any       						= Image.open(requests.get(a__ ,  stream=a__					).raw					)
  
           SCREAMING_SNAKE_CASE__			:				int       						= '''What does the label 15 represent? (1) lava (2) core (3) tunnel (4) ash cloud'''
  
           SCREAMING_SNAKE_CASE__			:				Union[str, Any]       						= pipe(a__ ,  prompt=a__					)
           self.assertEqual(a__ ,  [{'''generated_text''': '''ash cloud'''}]					)
  
           with self.assertRaises(a__					):
              SCREAMING_SNAKE_CASE__			:				Any       						= pipe([image, image] ,  prompt=[prompt, prompt]					)
  
  
  
  
  
  
        @slow
        @require_tf
        def    A__(self					)       ->   str:
           SCREAMING_SNAKE_CASE__			:				Optional[int]       						= pipeline('''image-to-text''' ,  model='''ydshieh/vit-gpt2-coco-en''' ,  framework='''tf'''					)
           SCREAMING_SNAKE_CASE__			:				Optional[Any]       						= '''./tests/fixtures/tests_samples/COCO/000000039769.png'''
  
           SCREAMING_SNAKE_CASE__			:				Dict       						= pipe(a__					)
           self.assertEqual(a__ ,  [{'''generated_text''': '''a cat laying on a blanket next to a cat laying on a bed '''}]					)
  
           SCREAMING_SNAKE_CASE__			:				Union[str, Any]       						= pipe([image, image]					)
           self.assertEqual(
               a__ ,  [
                   [{'''generated_text''': '''a cat laying on a blanket next to a cat laying on a bed '''}],
                   [{'''generated_text''': '''a cat laying on a blanket next to a cat laying on a bed '''}],
               ] ,  )
  
  