




import random
import timeit
from functools import wraps
from typing import Callable, Optional

from ..configuration_utils import PretrainedConfig
from ..models.auto.modeling_tf_auto import TF_MODEL_MAPPING, TF_MODEL_WITH_LM_HEAD_MAPPING
from ..utils import is_pyanvml_available, is_tf_available, logging
from .benchmark_utils import (
    Benchmark,
    Memory,
    MemorySummary,
    measure_peak_memory_cpu,
    start_memory_tracing,
    stop_memory_tracing,
)


if is_tf_available():
    import tensorflow as tf
    from tensorflow.python.framework.errors_impl import ResourceExhaustedError

    from .benchmark_args_tf import TensorFlowBenchmarkArguments

if is_pyanvml_available():
    import pyanvml.pyanvml as nvml

snake_case_ : Tuple    		=       logging.get_logger(__name__)


def    A						(__A   :    bool   ,				__A   :    bool       )   ->      Optional[Any]:







     """simple docstring"""


     def run_func(__A   :    Optional[Any]       ):
          @wraps(__A       )
          def run_in_eager_mode(*__A   :    Dict   ,				**__A   :    List[Any]       ):
               return func(*__A   ,				**__A       )

          @wraps(__A       )
          @tf.function(experimental_compile=__A       )
          def run_in_graph_mode(*__A   :    Optional[Any]   ,				**__A   :    Any       ):
               return func(*__A   ,				**__A       )

          if do_eager_mode is True:
               if use_xla is not False:
                    raise ValueError(
                        '''Cannot run model in XLA, if `args.eager_mode` is set to `True`. Please set `args.eager_mode=False`.'''       )
               return run_in_eager_mode
          else:
               return run_in_graph_mode

     return run_func


def    A						(__A   :    int   ,				__A   :    int   ,				__A   :    int       )   ->      ["tf.Tensor"]:







     """simple docstring"""


     UpperCAmelCase_          =							random.Random()
     UpperCAmelCase_          =							[rng.randint(0   ,				vocab_size - 1       ) for i in range(batch_size * sequence_length       )]
     return tf.constant(__A   ,				shape=(batch_size, sequence_length)   ,				dtype=tf.intaa       )







class __snake_case			(			a		):
   UpperCAmelCase__  :    TensorFlowBenchmarkArguments
   UpperCAmelCase__  :    PretrainedConfig
   UpperCAmelCase__  :    str          =  "TensorFlow"







   @property
   def lowerCamelCase						(      self		:						List[str]):

        """simple docstring"""


        return tf.__version__







   def lowerCamelCase						(      self		:						Dict					,						_snake_case		:						str					,						_snake_case		:						int					,						_snake_case		:						int):

        """simple docstring"""


        UpperCAmelCase_          =							self.args.strategy
        if strategy is None:
             raise ValueError('''A device strategy has to be initialized before using TensorFlow.''')
        UpperCAmelCase_          =							self._prepare_inference_func(_snake_case					,						_snake_case					,						_snake_case)
        return self._measure_speed(_inference)







   def lowerCamelCase						(      self		:						Any					,						_snake_case		:						str					,						_snake_case		:						int					,						_snake_case		:						int):

        """simple docstring"""


        UpperCAmelCase_          =							self.args.strategy
        if strategy is None:
             raise ValueError('''A device strategy has to be initialized before using TensorFlow.''')
        UpperCAmelCase_          =							self._prepare_train_func(_snake_case					,						_snake_case					,						_snake_case)
        return self._measure_speed(_train)







   def lowerCamelCase						(      self		:						Any					,						_snake_case		:						str					,						_snake_case		:						int					,						_snake_case		:						int):

        """simple docstring"""


        if self.args.is_gpu:
             tf.config.experimental.set_memory_growth(self.args.gpu_list[self.args.device_idx]					,						_snake_case)
        UpperCAmelCase_          =							self.args.strategy
        if strategy is None:
             raise ValueError('''A device strategy has to be initialized before using TensorFlow.''')
        UpperCAmelCase_          =							self._prepare_inference_func(_snake_case					,						_snake_case					,						_snake_case)
        return self._measure_memory(_inference)







   def lowerCamelCase						(      self		:						Optional[Any]					,						_snake_case		:						str					,						_snake_case		:						int					,						_snake_case		:						int):

        """simple docstring"""


        if self.args.is_gpu:
             tf.config.experimental.set_memory_growth(self.args.gpu_list[self.args.device_idx]					,						_snake_case)
        UpperCAmelCase_          =							self.args.strategy
        if strategy is None:
             raise ValueError('''A device strategy has to be initialized before using TensorFlow.''')

        UpperCAmelCase_          =							self._prepare_train_func(_snake_case					,						_snake_case					,						_snake_case)
        return self._measure_memory(_train)







   def lowerCamelCase						(      self		:						Optional[int]					,						_snake_case		:						str					,						_snake_case		:						int					,						_snake_case		:						int):

        """simple docstring"""


        UpperCAmelCase_          =							self.config_dict[model_name]

        if self.args.fpaa:
             raise NotImplementedError('''Mixed precision is currently not supported.''')

        UpperCAmelCase_          =							(
            hasattr(_snake_case					,						'''architectures''')
            and isinstance(config.architectures					,						_snake_case)
            and len(config.architectures) > 0
        )
        if not self.args.only_pretrain_model and has_model_class_in_config:
             try:
                  UpperCAmelCase_          =							'''TF''' + config.architectures[0]  # prepend 'TF' for tensorflow model
                  UpperCAmelCase_          =							__import__('''transformers'''					,						fromlist=[model_class])
                  UpperCAmelCase_          =							getattr(_snake_case					,						_snake_case)
                  UpperCAmelCase_          =							model_cls(_snake_case)
             except ImportError:
                  raise ImportError(
                      F"""{model_class} does not exist. If you just want to test the pretrained model, you might want to"""
                      ''' set `--only_pretrain_model` or `args.only_pretrain_model=True`.''')
        else:
             UpperCAmelCase_          =							TF_MODEL_MAPPING[config.__class__](_snake_case)

        # encoder-decoder has vocab size saved differently
        UpperCAmelCase_          =							config.vocab_size if hasattr(_snake_case					,						'''vocab_size''') else config.encoder.vocab_size
        UpperCAmelCase_          =							random_input_ids(_snake_case					,						_snake_case					,						_snake_case)

        @run_with_tf_optimizations(self.args.eager_mode					,						self.args.use_xla)
        def encoder_decoder_forward():
             return model(_snake_case					,						decoder_input_ids=_snake_case					,						training=_snake_case)

        @run_with_tf_optimizations(self.args.eager_mode					,						self.args.use_xla)
        def encoder_forward():
             return model(_snake_case					,						training=_snake_case)

        UpperCAmelCase_          =							encoder_decoder_forward if config.is_encoder_decoder else encoder_forward

        return _inference







   def lowerCamelCase						(      self		:						Optional[Any]					,						_snake_case		:						str					,						_snake_case		:						int					,						_snake_case		:						int):

        """simple docstring"""


        UpperCAmelCase_          =							self.config_dict[model_name]

        if self.args.eager_mode is not False:
             raise ValueError('''Training cannot be done in eager mode. Please make sure that `args.eager_mode = False`.''')

        if self.args.fpaa:
             raise NotImplementedError('''Mixed precision is currently not supported.''')

        UpperCAmelCase_          =							(
            hasattr(_snake_case					,						'''architectures''')
            and isinstance(config.architectures					,						_snake_case)
            and len(config.architectures) > 0
        )
        if not self.args.only_pretrain_model and has_model_class_in_config:
             try:
                  UpperCAmelCase_          =							'''TF''' + config.architectures[0]  # prepend 'TF' for tensorflow model
                  UpperCAmelCase_          =							__import__('''transformers'''					,						fromlist=[model_class])
                  UpperCAmelCase_          =							getattr(_snake_case					,						_snake_case)
                  UpperCAmelCase_          =							model_cls(_snake_case)
             except ImportError:
                  raise ImportError(
                      F"""{model_class} does not exist. If you just want to test the pretrained model, you might want to"""
                      ''' set `--only_pretrain_model` or `args.only_pretrain_model=True`.''')
        else:
             UpperCAmelCase_          =							TF_MODEL_WITH_LM_HEAD_MAPPING[config.__class__](_snake_case)

        # encoder-decoder has vocab size saved differently
        UpperCAmelCase_          =							config.vocab_size if hasattr(_snake_case					,						'''vocab_size''') else config.encoder.vocab_size
        UpperCAmelCase_          =							random_input_ids(_snake_case					,						_snake_case					,						_snake_case)

        @run_with_tf_optimizations(self.args.eager_mode					,						self.args.use_xla)
        def encoder_decoder_train():
             UpperCAmelCase_          =							model(_snake_case					,						decoder_input_ids=_snake_case					,						labels=_snake_case					,						training=_snake_case)[0]
             UpperCAmelCase_          =							tf.gradients(_snake_case					,						model.trainable_variables)
             return gradients

        @run_with_tf_optimizations(self.args.eager_mode					,						self.args.use_xla)
        def encoder_train():
             UpperCAmelCase_          =							model(_snake_case					,						labels=_snake_case					,						training=_snake_case)[0]
             UpperCAmelCase_          =							tf.gradients(_snake_case					,						model.trainable_variables)
             return gradients

        UpperCAmelCase_          =							encoder_decoder_train if config.is_encoder_decoder else encoder_train

        return _train







   def lowerCamelCase						(      self		:						Any					,						_snake_case		:						Optional[Any]):

        """simple docstring"""


        with self.args.strategy.scope():
             try:
                  if self.args.is_tpu or self.args.use_xla:
                       # run additional 10 times to stabilize compilation for tpu
                       logger.info('''Do inference on TPU. Running model 5 times to stabilize compilation''')
                       timeit.repeat(_snake_case					,						repeat=1					,						number=5)

                  # as written in https://docs.python.org/2/library/timeit.html#timeit.Timer.repeat, min should be taken rather than the average
                  UpperCAmelCase_          =							timeit.repeat(
                      _snake_case					,						repeat=self.args.repeat					,						number=10					,						)

                  return min(_snake_case) / 1_0.0
             except ResourceExhaustedError as e:
                  self.print_fn(F"""Doesn't fit on GPU. {e}""")







   def lowerCamelCase						(      self		:						Dict					,						_snake_case		:						Callable[[], None]):

        """simple docstring"""


        logger.info(
            '''Note that TensorFlow allocates more memory than '''
            '''it might need to speed up computation. '''
            '''The memory reported here corresponds to the memory '''
            '''reported by `nvidia-smi`, which can vary depending '''
            '''on total available memory on the GPU that is used.''')
        with self.args.strategy.scope():
             try:
                  if self.args.trace_memory_line_by_line:
                       if not self.args.eager_mode:
                            raise ValueError(
                                '''`args.eager_mode` is set to `False`. Make sure to run model in eager mode to measure memory'''
                                ''' consumption line by line.''')
                       UpperCAmelCase_          =							start_memory_tracing('''transformers''')

                  if self.args.is_tpu:
                       # tpu
                       raise NotImplementedError(
                           '''Memory Benchmarking is currently not implemented for TPU. Please disable memory benchmarking'''
                           ''' with `args.memory=False`''')
                  elif self.args.is_gpu:
                       # gpu
                       if not is_pyanvml_available():
                            logger.warning(
                                '''py3nvml not installed, we won\'t log GPU memory usage. '''
                                '''Install py3nvml (pip install py3nvml) to log information about GPU.''')
                            UpperCAmelCase_          =							'''N/A'''
                       else:
                            logger.info(
                                '''Measuring total GPU usage on GPU device. Make sure to not have additional processes'''
                                ''' running on the same GPU.''')
                            # init nvml
                            nvml.nvmlInit()
                            func()
                            UpperCAmelCase_          =							nvml.nvmlDeviceGetHandleByIndex(self.args.device_idx)
                            UpperCAmelCase_          =							nvml.nvmlDeviceGetMemoryInfo(_snake_case)
                            UpperCAmelCase_          =							meminfo.used
                            UpperCAmelCase_          =							Memory(_snake_case)
                            # shutdown nvml
                            nvml.nvmlShutdown()
                  else:
                       # cpu
                       if self.args.trace_memory_line_by_line:
                            logger.info(
                                '''When enabling line by line tracing, the max peak memory for CPU is inaccurate in'''
                                ''' TensorFlow.''')
                            UpperCAmelCase_          =							None
                       else:
                            UpperCAmelCase_          =							measure_peak_memory_cpu(_snake_case)
                            UpperCAmelCase_          =							Memory(_snake_case) if isinstance(_snake_case					,						_snake_case) else memory_bytes
                  if self.args.trace_memory_line_by_line:
                       UpperCAmelCase_          =							stop_memory_tracing(_snake_case)
                       if memory is None:
                            UpperCAmelCase_          =							summary.total
                  else:
                       UpperCAmelCase_          =							None

                  return memory, summary
             except ResourceExhaustedError as e:
                  self.print_fn(F"""Doesn't fit on GPU. {e}""")
                  return "N/A", None








import json
import os
import unittest

from transformers.models.gptsan_japanese.tokenization_gptsan_japanese import (
    VOCAB_FILES_NAMES,
    GPTSanJapaneseTokenizer,
)
from transformers.testing_utils import require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin




@require_tokenizers
class 						lowercase__  (						_UpperCAmelCase     ,       unittest.TestCase  ):
	A__    :   Any				       =GPTSanJapaneseTokenizer
	A__    :   str				       =False
	A__    :   int				       ={"""do_clean_text""": False, """add_prefix_space""": False}
	def      A_				(			self							:   Any							):
						super().setUp()

						# fmt: off
						SCREAMING_SNAKE_CASE__													= ['こん', 'こんに', 'にちは', 'ばんは', '世界,㔺界', '、', '。', '<BR>', '<SP>', '<TAB>', '<URL>', '<EMAIL>', '<TEL>', '<DATE>', '<PRICE>', '<BLOCK>', '<KIGOU>', '<U2000U2BFF>', '<|emoji1|>', '<unk>', '<|bagoftoken|>', '<|endoftext|>']
						# fmt: on
						SCREAMING_SNAKE_CASE__													= {'emoji': {'\ud83d\ude00': '<|emoji1|>'}, 'emoji_inv': {'<|emoji1|>': '\ud83d\ude00'}}  # 😀
						SCREAMING_SNAKE_CASE__													= {'unk_token': '<unk>'}

						SCREAMING_SNAKE_CASE__													= os.path.join(self.tmpdirname       ,   VOCAB_FILES_NAMES['vocab_file']							)
						SCREAMING_SNAKE_CASE__													= os.path.join(self.tmpdirname       ,   VOCAB_FILES_NAMES['emoji_file']							)
						with open(self.vocab_file       ,   'w'       ,   encoding='utf-8'							) as vocab_writer:
											vocab_writer.write(''.join([x + '\n' for x in vocab_tokens]							)							)
						with open(self.emoji_file       ,   'w'							) as emoji_writer:
											emoji_writer.write(json.dumps(UpperCAmelCase_							)							)
	def      A_				(			self							:   str       ,   **UpperCAmelCase_							:   Optional[Any]							):
						kwargs.update(self.special_tokens_map							)
						return GPTSanJapaneseTokenizer.from_pretrained(self.tmpdirname       ,   **UpperCAmelCase_							)
	def      A_				(			self							:   int       ,   UpperCAmelCase_							:   List[str]							):
						SCREAMING_SNAKE_CASE__													= 'こんにちは、世界。 \nこんばんは、㔺界。😀'
						SCREAMING_SNAKE_CASE__													= 'こんにちは、世界。 \nこんばんは、世界。😀'
						return input_text, output_text
	def      A_				(			self							:   Any       ,   UpperCAmelCase_							:   str							):
						SCREAMING_SNAKE_CASE__						, SCREAMING_SNAKE_CASE__													= self.get_input_output_texts(UpperCAmelCase_							)
						SCREAMING_SNAKE_CASE__													= tokenizer.encode(UpperCAmelCase_       ,   add_special_tokens=UpperCAmelCase_							)
						SCREAMING_SNAKE_CASE__													= tokenizer.decode(UpperCAmelCase_       ,   clean_up_tokenization_spaces=UpperCAmelCase_							)
						return text, ids
	def      A_				(			self							:   str							):
						pass  # TODO add if relevant
	def      A_				(			self							:   Tuple							):
						pass  # TODO add if relevant
	def      A_				(			self							:   int							):
						pass  # TODO add if relevant
	def      A_				(			self							:   Optional[int]							):
						SCREAMING_SNAKE_CASE__													= self.get_tokenizer()

						# Testing tokenization
						SCREAMING_SNAKE_CASE__													= 'こんにちは、世界。　こんばんは、㔺界。'
						SCREAMING_SNAKE_CASE__													= ['こん', 'にちは', '、', '世界', '。', '<SP>', 'こん', 'ばんは', '、', '㔺界', '。']
						SCREAMING_SNAKE_CASE__													= tokenizer.tokenize(UpperCAmelCase_							)
						self.assertListEqual(UpperCAmelCase_       ,   UpperCAmelCase_							)

						# Testing conversion to ids without special tokens
						SCREAMING_SNAKE_CASE__													= [0, 2, 5, 4, 6, 8, 0, 3, 5, 4, 6]
						SCREAMING_SNAKE_CASE__													= tokenizer.convert_tokens_to_ids(UpperCAmelCase_							)
						self.assertListEqual(UpperCAmelCase_       ,   UpperCAmelCase_							)

						# Testing conversion to ids with special tokens
						SCREAMING_SNAKE_CASE__													= tokens + [tokenizer.unk_token]
						SCREAMING_SNAKE_CASE__													= [0, 2, 5, 4, 6, 8, 0, 3, 5, 4, 6, 19]
						SCREAMING_SNAKE_CASE__													= tokenizer.convert_tokens_to_ids(UpperCAmelCase_							)
						self.assertListEqual(UpperCAmelCase_       ,   UpperCAmelCase_							)
	def      A_				(			self							:   Union[str, Any]							):
						SCREAMING_SNAKE_CASE__													= self.get_tokenizer()

						# Testing tokenization
						SCREAMING_SNAKE_CASE__													= 'こんにちは、<|bagoftoken|>世界。こんばんは、<|bagoftoken|>㔺界。'
						SCREAMING_SNAKE_CASE__													= 'こんにちは、、、、世界。こんばんは、、、、世界。'
						SCREAMING_SNAKE_CASE__													= tokenizer.encode(UpperCAmelCase_							)
						SCREAMING_SNAKE_CASE__													= tokenizer.decode(UpperCAmelCase_							)
						self.assertEqual(UpperCAmelCase_       ,   UpperCAmelCase_							)
	@slow
	def      A_				(			self							:   str							):
						SCREAMING_SNAKE_CASE__													= self.tokenizer_class.from_pretrained('Tanrei/GPTSAN-japanese'							)

						# Testing tokenization
						SCREAMING_SNAKE_CASE__													= 'こんにちは、世界。'
						SCREAMING_SNAKE_CASE__													= 'こんばんは、㔺界。😀'
						SCREAMING_SNAKE_CASE__													= 'こんにちは、世界。こんばんは、世界。😀'
						SCREAMING_SNAKE_CASE__													= tokenizer.encode(prefix_text + input_text							)
						SCREAMING_SNAKE_CASE__													= tokenizer.encode(''       ,   prefix_text=prefix_text + input_text							)
						SCREAMING_SNAKE_CASE__													= tokenizer.encode(UpperCAmelCase_       ,   prefix_text=UpperCAmelCase_							)
						SCREAMING_SNAKE_CASE__													= tokenizer.decode(UpperCAmelCase_							)
						SCREAMING_SNAKE_CASE__													= tokenizer.decode(UpperCAmelCase_							)
						SCREAMING_SNAKE_CASE__													= tokenizer.decode(UpperCAmelCase_							)
						self.assertEqual(UpperCAmelCase_       ,   UpperCAmelCase_							)
						self.assertEqual(UpperCAmelCase_       ,   UpperCAmelCase_							)
						self.assertEqual(UpperCAmelCase_       ,   UpperCAmelCase_							)
	@slow
	def      A_				(			self							:   Union[str, Any]							):
						SCREAMING_SNAKE_CASE__													= self.tokenizer_class.from_pretrained('Tanrei/GPTSAN-japanese'							)

						# Testing tokenization
						SCREAMING_SNAKE_CASE__													= 'こんにちは、世界。'
						SCREAMING_SNAKE_CASE__													= 'こんばんは、㔺界。😀'

						SCREAMING_SNAKE_CASE__													= len(tokenizer.encode(UpperCAmelCase_							)							) - 2
						SCREAMING_SNAKE_CASE__													= len(tokenizer.encode(UpperCAmelCase_							)							) - 2

						SCREAMING_SNAKE_CASE__													= [1] + [0] * (len_prefix + len_text + 1)
						SCREAMING_SNAKE_CASE__													= [1] * (len_prefix + len_text + 1) + [0]
						SCREAMING_SNAKE_CASE__													= [1] + [1] * (len_prefix) + [0] * (len_text + 1)

						SCREAMING_SNAKE_CASE__													= tokenizer(prefix_text + input_text							).token_type_ids
						SCREAMING_SNAKE_CASE__													= tokenizer(''       ,   prefix_text=prefix_text + input_text							).token_type_ids
						SCREAMING_SNAKE_CASE__													= tokenizer(UpperCAmelCase_       ,   prefix_text=UpperCAmelCase_							).token_type_ids
						self.assertListEqual(UpperCAmelCase_       ,   UpperCAmelCase_							)
						self.assertListEqual(UpperCAmelCase_       ,   UpperCAmelCase_							)
						self.assertListEqual(UpperCAmelCase_       ,   UpperCAmelCase_							)
	@slow
	def      A_				(			self							:   Tuple							):
						SCREAMING_SNAKE_CASE__													= self.tokenizer_class.from_pretrained('Tanrei/GPTSAN-japanese'							)

						SCREAMING_SNAKE_CASE__													= tokenizer.encode('あンいワ'							)
						SCREAMING_SNAKE_CASE__													= tokenizer.encode(''       ,   prefix_text='あンいワ'							)
						SCREAMING_SNAKE_CASE__													= tokenizer.encode('いワ'       ,   prefix_text='あン'							)

						self.assertEqual(tokenizer.decode(UpperCAmelCase_							)       ,   tokenizer.decode(UpperCAmelCase_							)							)
						self.assertEqual(tokenizer.decode(UpperCAmelCase_							)       ,   tokenizer.decode(UpperCAmelCase_							)							)
						self.assertNotEqual(UpperCAmelCase_       ,   UpperCAmelCase_							)
						self.assertNotEqual(UpperCAmelCase_       ,   UpperCAmelCase_							)
						self.assertEqual(x_token_a[1]       ,   x_token_a[-1]							)  # SEG token
						self.assertEqual(x_token_a[1]       ,   x_token_a[3]							)  # SEG token
	@slow
	def      A_				(			self							:   Union[str, Any]							):
						SCREAMING_SNAKE_CASE__													= self.tokenizer_class.from_pretrained('Tanrei/GPTSAN-japanese'							)

						SCREAMING_SNAKE_CASE__													= [['武田信玄', 'は、'], ['織田信長', 'の配下の、']]
						SCREAMING_SNAKE_CASE__													= tokenizer(UpperCAmelCase_       ,   padding=UpperCAmelCase_							)
						SCREAMING_SNAKE_CASE__													= tokenizer.batch_encode_plus(UpperCAmelCase_       ,   padding=UpperCAmelCase_							)

						# fmt: off
						SCREAMING_SNAKE_CASE__													= [[35993, 8640, 25948, 35998, 30647, 35675, 35999, 35999], [35993, 10382, 9868, 35998, 30646, 9459, 30646, 35675]]
						SCREAMING_SNAKE_CASE__													= [[1, 1, 1, 0, 0, 0, 0, 0], [1, 1, 1, 0, 0, 0, 0, 0]]
						SCREAMING_SNAKE_CASE__													= [[1, 1, 1, 1, 1, 1, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1]]
						# fmt: on
						self.assertListEqual(x_token.input_ids       ,   UpperCAmelCase_							)
						self.assertListEqual(x_token.token_type_ids       ,   UpperCAmelCase_							)
						self.assertListEqual(x_token.attention_mask       ,   UpperCAmelCase_							)
						self.assertListEqual(x_token_a.input_ids       ,   UpperCAmelCase_							)
						self.assertListEqual(x_token_a.token_type_ids       ,   UpperCAmelCase_							)
						self.assertListEqual(x_token_a.attention_mask       ,   UpperCAmelCase_							)
	def      A_				(			self							:   Tuple							):
						# Intentionally convert some words to accommodate character fluctuations unique to Japanese
						pass





	def      A_				(			self							:   List[str]							):
						# tokenizer has no padding token
						pass





