





import argparse
import logging
import os
import sys
import tempfile
from pathlib import Path

import lightning_base
import pytest
import pytorch_lightning as pl
import torch
from convert_pl_checkpoint_to_hf import convert_pl_to_hf
from distillation import distill_main
from finetune import SummarizationModule, main
from huggingface_hub import list_models
from parameterized import parameterized
from run_eval import generate_summaries_or_translations
from torch import nn

from transformers import AutoConfig, AutoModelForSeqaSeqLM
from transformers.testing_utils import CaptureStderr, CaptureStdout, TestCasePlus, require_torch_gpu, slow
from utils import label_smoothed_nll_loss, lmap, load_json


logging.basicConfig(level=logging.DEBUG)

A__:  Union[str, Any]       					=					logging.getLogger()
A__:  Any       					=					torch.cuda.is_available()
A__:  Tuple       					=					{
    '''max_tokens_per_batch''': None,
    '''supervise_forward''': True,
    '''normalize_hidden''': True,
    '''label_smoothing''': 0.2,
    '''eval_max_gen_length''': None,
    '''eval_beams''': 1,
    '''val_metric''': '''loss''',
    '''save_top_k''': 1,
    '''adafactor''': True,
    '''early_stopping_patience''': 2,
    '''logger_name''': '''default''',
    '''length_penalty''': 0.5,
    '''cache_dir''': '''''',
    '''task''': '''summarization''',
    '''num_workers''': 2,
    '''alpha_hid''': 0,
    '''freeze_embeds''': True,
    '''enc_only''': False,
    '''tgt_suffix''': '''''',
    '''resume_from_checkpoint''': None,
    '''sortish_sampler''': True,
    '''student_decoder_layers''': 1,
    '''val_check_interval''': 1.0,
    '''output_dir''': '''''',
    '''fp16''': False,  # TODO(SS): set this to CUDA_AVAILABLE if ci installs apex or start using native amp
    '''no_teacher''': False,
    '''fp16_opt_level''': '''O1''',
    '''gpus''': 1 if CUDA_AVAILABLE else 0,
    '''n_tpu_cores''': 0,
    '''max_grad_norm''': 1.0,
    '''do_train''': True,
    '''do_predict''': True,
    '''accumulate_grad_batches''': 1,
    '''server_ip''': '''''',
    '''server_port''': '''''',
    '''seed''': 42,
    '''model_name_or_path''': '''sshleifer/bart-tiny-random''',
    '''config_name''': '''''',
    '''tokenizer_name''': '''facebook/bart-large''',
    '''do_lower_case''': False,
    '''learning_rate''': 0.3,
    '''lr_scheduler''': '''linear''',
    '''weight_decay''': 0.0,
    '''adam_epsilon''': 1e-08,
    '''warmup_steps''': 0,
    '''max_epochs''': 1,
    '''train_batch_size''': 2,
    '''eval_batch_size''': 2,
    '''max_source_length''': 12,
    '''max_target_length''': 12,
    '''val_max_target_length''': 12,
    '''test_max_target_length''': 12,
    '''fast_dev_run''': False,
    '''no_cache''': False,
    '''n_train''': -1,
    '''n_val''': -1,
    '''n_test''': -1,
    '''student_encoder_layers''': 1,
    '''freeze_encoder''': False,
    '''auto_scale_batch_size''': False,
    '''overwrite_output_dir''': False,
    '''student''': None,
}



def 							lowerCAmelCase_				(    A_  ,A_):
    UpperCamelCase__:					List[Any]												=      "\n".join(A_)
    Path(A_).open("w").writelines(A_)


A__:  Any       					=					[''' Sam ate lunch today.''', '''Sams lunch ingredients.''']
A__:  str       					=					['''A very interesting story about what I ate for lunch.''', '''Avocado, celery, turkey, coffee''']
A__:  Union[str, Any]       					=					'''patrickvonplaten/t5-tiny-random'''
A__:  Optional[int]       					=					'''sshleifer/t5-tinier-random'''
A__:  Optional[Any]       					=					'''sshleifer/bart-tiny-random'''
A__:  str       					=					'''sshleifer/tiny-mbart'''
A__:  Any       					=					'''sshleifer/tiny-marian-en-de'''
A__:  Optional[int]       					=					'''stas/tiny-wmt19-en-de'''


A__:  List[Any]       					=					logging.StreamHandler(sys.stdout)
logger.addHandler(stream_handler)
logging.disable(logging.CRITICAL)  # remove noisy download output from tracebacks



def 							lowerCAmelCase_				(    A_):
    for split in ["train", "val", "test"]:
        _dump_articles(os.path.join(A_  ,F"{split}.source")  ,A_)
        _dump_articles(os.path.join(A_  ,F"{split}.target")  ,A_)
    return tmp_dir




class    _a  (  UpperCamelCase__):

  """simple docstring"""


  @classmethod
  def 	UpperCAmelCase_   (						cls:	str			):
      '''simple docstring'''


      logging.disable(logging.CRITICAL			)  # remove noisy download output from tracebacks
      return cls






  @slow
  @require_torch_gpu
  def 	UpperCAmelCase_   (						self:	Any			):
      '''simple docstring'''


      UpperCamelCase__:					Optional[Any]												=      list_models()
      UpperCamelCase__:					Any												=      "sshleifer"
      UpperCamelCase__:					Dict												=      [x.modelId for x in model_list if x.modelId.startswith(__lowerCamelCase			)]
      UpperCamelCase__:					Union[str, Any]												=      ["sshleifer/blenderbot-3B", "sshleifer/blenderbot-90M"]
      UpperCamelCase__:					List[Any]												=      []
      for m in model_ids:
          if m in allowed_to_be_broken:
              continue
          try:
              AutoConfig.from_pretrained(__lowerCamelCase			)
          except Exception:
              failures.append(__lowerCamelCase			)
      assert not failures, F"The following models could not be loaded through AutoConfig: {failures}"






  def 	UpperCAmelCase_   (						self:	Tuple			):
      '''simple docstring'''


      UpperCamelCase__:					Union[str, Any]												=      {"student_encoder_layers": 2, "student_decoder_layers": 1, "no_teacher": True}
      self._test_distiller_cli(__lowerCamelCase			)






  def 	UpperCAmelCase_   (						self:	Tuple			):
      '''simple docstring'''


      UpperCamelCase__:					str												=      {
          "student_encoder_layers": 2,
          "student_decoder_layers": 1,
          "max_epochs": 4,
          "val_check_interval": 0.25,
          "alpha_hid": 2.0,
          "model_name_or_path": "IGNORE_THIS_IT_DOESNT_GET_USED",
      }
      UpperCamelCase__:					List[str]												=      self._test_distiller_cli(__lowerCamelCase					,  check_contents=__lowerCamelCase			)

      UpperCamelCase__:					Tuple												=      list(Path(model.output_dir			).glob("*.ckpt"			)			)
      self.assertEqual(1					,  len(__lowerCamelCase			)			)
      UpperCamelCase__:					Optional[Any]												=      list(Path(model.output_dir			).glob("**/*.bin"			)			)
      self.assertEqual(len(__lowerCamelCase			)					,  2			)
      UpperCamelCase__:					str												=      lmap(str.strip					,  Path(model.hparams.data_dir			).joinpath("test.source"			).open().readlines()			)
      UpperCamelCase__:					Any												=      tempfile.mktemp()  # XXX: not being cleaned up
      generate_summaries_or_translations(__lowerCamelCase					,  __lowerCamelCase					,  str(model.output_dir / "best_tfmr"			)			)
      self.assertTrue(Path(__lowerCamelCase			).exists()			)

      UpperCamelCase__:					List[str]												=      self.get_auto_remove_tmp_dir()
      convert_pl_to_hf(ckpts[0]					,  transformer_ckpts[0].parent					,  __lowerCamelCase			)
      assert os.path.exists(os.path.join(__lowerCamelCase					,  "pytorch_model.bin"			)			)






  def 	UpperCAmelCase_   (						self:	Tuple			):
      '''simple docstring'''


      UpperCamelCase__:					Optional[Any]												=      AutoModelForSeqaSeqLM.from_pretrained(__lowerCamelCase			)
      UpperCamelCase__:					Tuple												=      model.dummy_inputs["input_ids"], model.dummy_inputs["attention_mask"]
      UpperCamelCase__:					Tuple												=      torch.tensor([[0, 4, 8, 2], [0, 8, 2, 1]]					,  dtype=torch.long					,  device=model.device			)
      UpperCamelCase__:					Any												=      target_ids[:, :-1].contiguous()  # Why this line?
      UpperCamelCase__:					Optional[Any]												=      target_ids[:, 1:].clone()  # why clone?
      UpperCamelCase__:					Any												=      model(
          __lowerCamelCase					,  attention_mask=__lowerCamelCase					,  decoder_input_ids=__lowerCamelCase					,  labels=__lowerCamelCase					,  use_cache=__lowerCamelCase			).loss

      UpperCamelCase__:					Optional[int]												=      model(__lowerCamelCase					,  attention_mask=__lowerCamelCase					,  decoder_input_ids=__lowerCamelCase					,  use_cache=__lowerCamelCase			).logits

      UpperCamelCase__:					Optional[Any]												=      nn.functional.log_softmax(__lowerCamelCase					,  dim=-1			)
      UpperCamelCase__:					int												=      label_smoothed_nll_loss(
          __lowerCamelCase					,  __lowerCamelCase					,  0.1					,  ignore_index=model.config.pad_token_id			)
      with self.assertRaises(__lowerCamelCase			):
          # TODO: understand why this breaks
          self.assertEqual(__lowerCamelCase					,  __lowerCamelCase			)






  def 	UpperCAmelCase_   (						self:	List[Any]			):
      '''simple docstring'''


      UpperCamelCase__:					List[Any]												=      {
          "student_encoder_layers": 2,
          "student_decoder_layers": 1,
          "num_train_epochs": 4,
          "val_check_interval": 0.25,
          "alpha_hid": 2.0,
          "task": "translation",
          "model_name_or_path": "IGNORE_THIS_IT_DOESNT_GET_USED",
          "tokenizer_name": MBART_TINY,
          "teacher": MBART_TINY,
          "src_lang": "en_XX",
          "tgt_lang": "ro_RO",
      }
      UpperCamelCase__:					Optional[int]												=      self._test_distiller_cli(__lowerCamelCase					,  check_contents=__lowerCamelCase			)
      assert model.model.config.model_type == "mbart"

      UpperCamelCase__:					Tuple												=      list(Path(model.output_dir			).glob("*.ckpt"			)			)
      self.assertEqual(1					,  len(__lowerCamelCase			)			)
      UpperCamelCase__:					Tuple												=      list(Path(model.output_dir			).glob("**/*.bin"			)			)
      UpperCamelCase__:					Dict												=      list(Path(model.output_dir			).glob("best_tfmr/*"			)			)
      assert len(__lowerCamelCase			) > 2
      self.assertEqual(len(__lowerCamelCase			)					,  2			)






  def 	UpperCAmelCase_   (						self:	str			):
      '''simple docstring'''


      UpperCamelCase__:					Any												=      {
          "student_encoder_layers": 1,
          "student_decoder_layers": 1,
          "alpha_hid": 2.0,
          "teacher": T5_TINY,
          "model_name_or_path": T5_TINY,
          "tokenizer_name": T5_TINY,
      }
      self._test_distiller_cli(__lowerCamelCase			)






  def 	UpperCAmelCase_   (						self:	str			):
      '''simple docstring'''


      UpperCamelCase__:					Optional[Any]												=      {
          "teacher": T5_TINY,
          "student": T5_TINIER,
          "model_name_or_path": T5_TINIER,
          "tokenizer_name": T5_TINIER,
      }
      self._test_distiller_cli(__lowerCamelCase			)






  def 	UpperCAmelCase_   (						self:	Union[str, Any]					,  __lowerCamelCase:	Optional[Any]					,  __lowerCamelCase:	List[str]=True			):
      '''simple docstring'''


      UpperCamelCase__:					str												=      {
          "label_smoothing": 0.0,
          "early_stopping_patience": -1,
          "train_batch_size": 1,
          "eval_batch_size": 2,
          "max_epochs": 2,
          "alpha_mlm": 0.2,
          "alpha_ce": 0.8,
          "do_predict": True,
          "model_name_or_path": "sshleifer/tinier_bart",
          "teacher": CHEAP_ARGS["model_name_or_path"],
          "val_check_interval": 0.5,
      }
      default_updates.update(__lowerCamelCase			)
      UpperCamelCase__:					dict												=      CHEAP_ARGS.copy()
      UpperCamelCase__:					int												=      make_test_data_dir(tmp_dir=self.get_auto_remove_tmp_dir()			)
      UpperCamelCase__:					Any												=      self.get_auto_remove_tmp_dir()

      args_d.update(data_dir=__lowerCamelCase					,  output_dir=__lowerCamelCase					,  **__lowerCamelCase			)
      UpperCamelCase__:					Dict												=      distill_main(argparse.Namespace(**__lowerCamelCase			)			)
      if not check_contents:
          return model
      UpperCamelCase__:					Optional[int]												=      os.listdir(__lowerCamelCase			)
      UpperCamelCase__:					Any												=      {os.path.basename(__lowerCamelCase			) for p in contents}
      UpperCamelCase__:					Union[str, Any]												=      [p for p in contents if p.endswith("ckpt"			)]
      assert len(__lowerCamelCase			) > 0

      self.assertIn("test_generations.txt"					,  __lowerCamelCase			)
      self.assertIn("test_results.txt"					,  __lowerCamelCase			)

      UpperCamelCase__:					Any												=      load_json(model.metrics_save_path			)
      UpperCamelCase__:					List[Any]												=      metrics["val"][-1]
      self.assertGreaterEqual(last_step_stats["val_avg_gen_time"]					,  0.01			)
      self.assertGreaterEqual(1.0					,  last_step_stats["val_avg_gen_time"]			)
      self.assertIsInstance(last_step_stats[F"val_avg_{model.val_metric}"]					,  __lowerCamelCase			)
      UpperCamelCase__:					Any												=      int(args_d["max_epochs"] * (1 / args_d["val_check_interval"]) + 1			)
      self.assertEqual(len(metrics["val"]			)					,  __lowerCamelCase			)
      self.assertEqual(len(metrics["test"]			)					,  1			)
      return model




class    _a  (  UpperCamelCase__):

  """simple docstring"""


  @parameterized.expand(
      [T5_TINY, BART_TINY, MBART_TINY, MARIAN_TINY, FSMT_TINY]					,  )
  def 	UpperCAmelCase_   (						self:	List[str]					,  __lowerCamelCase:	Optional[Any]			):
      '''simple docstring'''


      UpperCamelCase__:					dict												=      CHEAP_ARGS.copy()
      UpperCamelCase__:					List[Any]												=      "translation" if model in [MBART_TINY, MARIAN_TINY, FSMT_TINY] else "summarization"
      UpperCamelCase__:					int												=      0.1 if task == "translation" else 0

      UpperCamelCase__:					Any												=      make_test_data_dir(tmp_dir=self.get_auto_remove_tmp_dir()			)
      UpperCamelCase__:					Optional[int]												=      self.get_auto_remove_tmp_dir()
      args_d.update(
          data_dir=__lowerCamelCase					,  model_name_or_path=__lowerCamelCase					,  tokenizer_name=__lowerCamelCase					,  train_batch_size=2					,  eval_batch_size=2					,  output_dir=__lowerCamelCase					,  do_predict=__lowerCamelCase					,  task=__lowerCamelCase					,  src_lang="en_XX"					,  tgt_lang="ro_RO"					,  freeze_encoder=__lowerCamelCase					,  freeze_embeds=__lowerCamelCase					,  )
      assert "n_train" in args_d
      UpperCamelCase__:					Dict												=      argparse.Namespace(**__lowerCamelCase			)
      UpperCamelCase__:					List[Any]												=      main(__lowerCamelCase			)

      UpperCamelCase__:					Any												=      module.model.get_input_embeddings()
      assert not input_embeds.weight.requires_grad
      if model == T5_TINY:
          UpperCamelCase__:					Tuple												=      module.model.lm_head
          assert not lm_head.weight.requires_grad
          assert (lm_head.weight == input_embeds.weight).all().item()
      elif model == FSMT_TINY:
          UpperCamelCase__:					Tuple												=      module.model.model
          UpperCamelCase__:					Dict												=      fsmt.decoder.embed_positions
          assert not embed_pos.weight.requires_grad
          assert not fsmt.decoder.embed_tokens.weight.requires_grad
          # check that embeds are not the same
          assert fsmt.decoder.embed_tokens != fsmt.encoder.embed_tokens
      else:
          UpperCamelCase__:					Any												=      module.model.model
          UpperCamelCase__:					Union[str, Any]												=      bart.decoder.embed_positions
          assert not embed_pos.weight.requires_grad
          assert not bart.shared.weight.requires_grad
          # check that embeds are the same
          assert bart.decoder.embed_tokens == bart.encoder.embed_tokens
          assert bart.decoder.embed_tokens == bart.shared

      UpperCamelCase__:					Tuple												=      load_json(module.output_dir / "text_batch.json"			)
      assert isinstance(__lowerCamelCase					,  __lowerCamelCase			)
      assert len(__lowerCamelCase			) >= 4






  def 	UpperCAmelCase_   (						self:	List[Any]			):
      '''simple docstring'''


      UpperCamelCase__:					dict												=      CHEAP_ARGS.copy()

      UpperCamelCase__:					Tuple												=      "summarization"
      UpperCamelCase__:					Tuple												=      make_test_data_dir(tmp_dir=self.get_auto_remove_tmp_dir()			)

      args_d.update(
          data_dir=__lowerCamelCase					,  tokenizer_name=__lowerCamelCase					,  train_batch_size=2					,  eval_batch_size=2					,  do_predict=__lowerCamelCase					,  task=__lowerCamelCase					,  src_lang="en_XX"					,  tgt_lang="ro_RO"					,  freeze_encoder=__lowerCamelCase					,  freeze_embeds=__lowerCamelCase					,  )

      # test models whose config includes the extra_model_args
      UpperCamelCase__:					Any												=      BART_TINY
      UpperCamelCase__:					Dict												=      self.get_auto_remove_tmp_dir()
      UpperCamelCase__:					int												=      args_d.copy()
      args_da.update(
          model_name_or_path=__lowerCamelCase					,  output_dir=__lowerCamelCase					,  )
      UpperCamelCase__:					Union[str, Any]												=      ("encoder_layerdrop", "decoder_layerdrop", "dropout", "attention_dropout")
      for p in extra_model_params:
          UpperCamelCase__:					Any												=      0.5
      UpperCamelCase__:					int												=      argparse.Namespace(**__lowerCamelCase			)
      UpperCamelCase__:					Optional[int]												=      main(__lowerCamelCase			)
      for p in extra_model_params:
          assert getattr(model.config					,  __lowerCamelCase			) == 0.5, F"failed to override the model config for param {p}"

      # test models whose config doesn't include the extra_model_args
      UpperCamelCase__:					Dict												=      T5_TINY
      UpperCamelCase__:					str												=      self.get_auto_remove_tmp_dir()
      UpperCamelCase__:					Dict												=      args_d.copy()
      args_da.update(
          model_name_or_path=__lowerCamelCase					,  output_dir=__lowerCamelCase					,  )
      UpperCamelCase__:					List[Any]												=      "encoder_layerdrop"
      UpperCamelCase__:					str												=      0.5
      UpperCamelCase__:					Union[str, Any]												=      argparse.Namespace(**__lowerCamelCase			)
      with pytest.raises(__lowerCamelCase			) as excinfo:
          UpperCamelCase__:					List[str]												=      main(__lowerCamelCase			)
      assert str(excinfo.value			) == F"model config doesn't have a `{unsupported_param}` attribute"






  def 	UpperCAmelCase_   (						self:	List[Any]			):
      '''simple docstring'''


      UpperCamelCase__:					dict												=      CHEAP_ARGS.copy()

      UpperCamelCase__:					str												=      "summarization"
      UpperCamelCase__:					Any												=      make_test_data_dir(tmp_dir=self.get_auto_remove_tmp_dir()			)

      UpperCamelCase__:					Dict												=      BART_TINY
      UpperCamelCase__:					Union[str, Any]												=      self.get_auto_remove_tmp_dir()

      args_d.update(
          data_dir=__lowerCamelCase					,  model_name_or_path=__lowerCamelCase					,  output_dir=__lowerCamelCase					,  tokenizer_name=__lowerCamelCase					,  train_batch_size=2					,  eval_batch_size=2					,  do_predict=__lowerCamelCase					,  task=__lowerCamelCase					,  src_lang="en_XX"					,  tgt_lang="ro_RO"					,  freeze_encoder=__lowerCamelCase					,  freeze_embeds=__lowerCamelCase					,  )

      # emulate finetune.py
      UpperCamelCase__:					Dict												=      argparse.ArgumentParser()
      UpperCamelCase__:					str												=      pl.Trainer.add_argparse_args(__lowerCamelCase			)
      UpperCamelCase__:					Dict												=      SummarizationModule.add_model_specific_args(__lowerCamelCase					,  os.getcwd()			)
      UpperCamelCase__:					List[Any]												=      {"--help": True}

      # --help test
      with pytest.raises(__lowerCamelCase			) as excinfo:
          with CaptureStdout() as cs:
              UpperCamelCase__:					Tuple												=      parser.parse_args(__lowerCamelCase			)
          assert False, "--help is expected to sys.exit"
      assert excinfo.type == SystemExit
      UpperCamelCase__:					Optional[Any]												=      lightning_base.arg_to_scheduler_metavar
      assert expected in cs.out, "--help is expected to list the supported schedulers"

      # --lr_scheduler=non_existing_scheduler test
      UpperCamelCase__:					Any												=      "non_existing_scheduler"
      UpperCamelCase__:					str												=      {F"--lr_scheduler={unsupported_param}"}
      with pytest.raises(__lowerCamelCase			) as excinfo:
          with CaptureStderr() as cs:
              UpperCamelCase__:					Dict												=      parser.parse_args(__lowerCamelCase			)
          assert False, "invalid argument is expected to sys.exit"
      assert excinfo.type == SystemExit
      UpperCamelCase__:					str												=      F"invalid choice: '{unsupported_param}'"
      assert expected in cs.err, F"should have bailed on invalid choice of scheduler {unsupported_param}"

      # --lr_scheduler=existing_scheduler test
      UpperCamelCase__:					int												=      "cosine"
      UpperCamelCase__:					Any												=      args_d.copy()
      UpperCamelCase__:					List[str]												=      supported_param
      UpperCamelCase__:					Dict												=      argparse.Namespace(**__lowerCamelCase			)
      UpperCamelCase__:					List[Any]												=      main(__lowerCamelCase			)
      assert (
          getattr(model.hparams					,  "lr_scheduler"			) == supported_param
      ), F"lr_scheduler={supported_param} shouldn't fail"








from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


A__:  List[str]       					=					{
    '''configuration_wav2vec2_conformer''': [
        '''WAV2VEC2_CONFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP''',
        '''Wav2Vec2ConformerConfig''',
    ],
}


try:
   if not is_torch_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   A__:  int       					=					[
       '''WAV2VEC2_CONFORMER_PRETRAINED_MODEL_ARCHIVE_LIST''',
       '''Wav2Vec2ConformerForAudioFrameClassification''',
       '''Wav2Vec2ConformerForCTC''',
       '''Wav2Vec2ConformerForPreTraining''',
       '''Wav2Vec2ConformerForSequenceClassification''',
       '''Wav2Vec2ConformerForXVector''',
       '''Wav2Vec2ConformerModel''',
       '''Wav2Vec2ConformerPreTrainedModel''',
   ]

if TYPE_CHECKING:
   from .configuration_wavaveca_conformer import (
       WAV2VEC2_CONFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP,
       WavaVecaConformerConfig,
   )

   try:
      if not is_torch_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_wavaveca_conformer import (
          WAV2VEC2_CONFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
          WavaVecaConformerForAudioFrameClassification,
          WavaVecaConformerForCTC,
          WavaVecaConformerForPreTraining,
          WavaVecaConformerForSequenceClassification,
          WavaVecaConformerForXVector,
          WavaVecaConformerModel,
          WavaVecaConformerPreTrainedModel,
      )

else:
   import sys

   A__:  Dict       					=					_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)

