






from __future__ import annotations

import unittest

import numpy as np

from transformers import BlipTextConfig
from transformers.testing_utils import require_tf, slow
from transformers.utils import is_tf_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask


if is_tf_available():
 import tensorflow as tf

 from transformers import TFBlipTextModel
 from transformers.models.blip.modeling_tf_blip import TF_BLIP_PRETRAINED_MODEL_ARCHIVE_LIST


class     _a							:






  """simple docstring"""





  def __init__(  self		,		_UpperCAmelCase		,		_UpperCAmelCase=12		,		_UpperCAmelCase=7		,		_UpperCAmelCase=True		,		_UpperCAmelCase=True		,		_UpperCAmelCase=True		,		_UpperCAmelCase=99		,		_UpperCAmelCase=32		,		_UpperCAmelCase=32		,		_UpperCAmelCase=2		,		_UpperCAmelCase=4		,		_UpperCAmelCase=37		,		_UpperCAmelCase=0.1		,		_UpperCAmelCase=0.1		,		_UpperCAmelCase=512		,		_UpperCAmelCase=0.0_2		,		_UpperCAmelCase=0		,		_UpperCAmelCase=None		,		)      ->			Dict:
     UpperCamelCase_						=  parent
     UpperCamelCase_						=  batch_size
     UpperCamelCase_						=  seq_length
     UpperCamelCase_						=  is_training
     UpperCamelCase_						=  use_input_mask
     UpperCamelCase_						=  use_labels
     UpperCamelCase_						=  vocab_size
     UpperCamelCase_						=  hidden_size
     UpperCamelCase_						=  projection_dim
     UpperCamelCase_						=  num_hidden_layers
     UpperCamelCase_						=  num_attention_heads
     UpperCamelCase_						=  intermediate_size
     UpperCamelCase_						=  dropout
     UpperCamelCase_						=  attention_dropout
     UpperCamelCase_						=  max_position_embeddings
     UpperCamelCase_						=  initializer_range
     UpperCamelCase_						=  scope
     UpperCamelCase_						=  bos_token_id




  def  _UpperCAmelCase  (  self			)      ->			Dict:
     UpperCamelCase_						=  ids_tensor([self.batch_size, self.seq_length]		,		self.vocab_size			)

     UpperCamelCase_						=  None
     if self.use_input_mask:
        UpperCamelCase_						=  random_attention_mask([self.batch_size, self.seq_length]			)

     if input_mask is not None:
        UpperCamelCase_						=  input_mask.numpy()
        UpperCamelCase_		,   UpperCamelCase_						=  input_mask.shape
        UpperCamelCase_						=  np.random.randint(1		,		seq_length - 1		,		size=(batch_size,)			)
        for batch_idx, start_index in enumerate(_UpperCAmelCase			):
           UpperCamelCase_						=  1
           UpperCamelCase_						=  0

     UpperCamelCase_						=  self.get_config()

     return config, input_ids, tf.convert_to_tensor(_UpperCAmelCase			)




  def  _UpperCAmelCase  (  self			)      ->			Union[str, Any]:
     return BlipTextConfig(
         vocab_size=self.vocab_size		,		hidden_size=self.hidden_size		,		projection_dim=self.projection_dim		,		num_hidden_layers=self.num_hidden_layers		,		num_attention_heads=self.num_attention_heads		,		intermediate_size=self.intermediate_size		,		dropout=self.dropout		,		attention_dropout=self.attention_dropout		,		max_position_embeddings=self.max_position_embeddings		,		initializer_range=self.initializer_range		,		bos_token_id=self.bos_token_id		,		)




  def  _UpperCAmelCase  (  self		,		_UpperCAmelCase		,		_UpperCAmelCase		,		_UpperCAmelCase			)      ->			List[str]:
     UpperCamelCase_						=  TFBlipTextModel(config=_UpperCAmelCase			)
     UpperCamelCase_						=  model(_UpperCAmelCase		,		attention_mask=_UpperCAmelCase		,		training=_UpperCAmelCase			)
     UpperCamelCase_						=  model(_UpperCAmelCase		,		training=_UpperCAmelCase			)
     self.parent.assertEqual(result.last_hidden_state.shape		,		(self.batch_size, self.seq_length, self.hidden_size)			)
     self.parent.assertEqual(result.pooler_output.shape		,		(self.batch_size, self.hidden_size)			)




  def  _UpperCAmelCase  (  self			)      ->			Union[str, Any]:
     UpperCamelCase_						=  self.prepare_config_and_inputs()
     UpperCamelCase_		,   UpperCamelCase_		,   UpperCamelCase_						=  config_and_inputs
     UpperCamelCase_						=  {'input_ids': input_ids, 'attention_mask': input_mask}
     return config, inputs_dict




@require_tf
class     _a							(	UpperCAmelCase__    ,							unittest.TestCase     ):






  """simple docstring"""





  A_						       = (TFBlipTextModel,) if is_tf_available() else ()
  A_						       = False
  A_						       = False
  A_						       = False




  def  _UpperCAmelCase  (  self			)      ->			List[str]:
     UpperCamelCase_						=  BlipTextModelTester(self			)
     UpperCamelCase_						=  ConfigTester(self		,		config_class=_UpperCAmelCase		,		hidden_size=37			)




  def  _UpperCAmelCase  (  self			)      ->			List[str]:
     self.config_tester.run_common_tests()




  def  _UpperCAmelCase  (  self			)      ->			Optional[Any]:
     UpperCamelCase_						=  self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_model(*_UpperCAmelCase			)




  def  _UpperCAmelCase  (  self			)      ->			Optional[Any]:
     pass




  def  _UpperCAmelCase  (  self			)      ->			List[Any]:
     pass




  @unittest.skip(reason='Blip does not use inputs_embeds'			)
  def  _UpperCAmelCase  (  self			)      ->			List[str]:
     pass




  @unittest.skip(reason='BlipTextModel has no base class and is not available in MODEL_MAPPING'			)
  def  _UpperCAmelCase  (  self			)      ->			Optional[Any]:
     pass




  @unittest.skip(reason='BlipTextModel has no base class and is not available in MODEL_MAPPING'			)
  def  _UpperCAmelCase  (  self			)      ->			Dict:
     pass




  @slow
  def  _UpperCAmelCase  (  self			)      ->			int:
     for model_name in TF_BLIP_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
        UpperCamelCase_						=  TFBlipTextModel.from_pretrained(_UpperCAmelCase			)
        self.assertIsNotNone(_UpperCAmelCase			)




  def  _UpperCAmelCase  (  self		,		_UpperCAmelCase=True			)      ->			List[Any]:
     super().test_pt_tf_model_equivalence(allow_missing_keys=_UpperCAmelCase			)













def      _snake_case     (__lowercase):
   UpperCamelCase_						=  1
   for i in range(1     ,   num + 1):
      fact *= i
   return fact






def      _snake_case     (__lowercase):
   UpperCamelCase_						=  0
   while number > 0:
      UpperCamelCase_						=  number % 10
      sum_of_digits += last_digit
      UpperCamelCase_						=  number // 10  # Removing the last_digit from the given number
   return sum_of_digits






def      _snake_case     (__lowercase = 100):
   UpperCamelCase_						=  factorial(__lowercase)
   UpperCamelCase_						=  split_and_add(__lowercase)
   return result


if __name__ == "__main__":
 print(solution(int(input("""Enter the Number: """).strip())))





