

from __future__ import annotations

import collections
import tempfile
import unittest

import numpy as np

from transformers.testing_utils import require_tf, require_vision, slow
from transformers.utils import is_tf_available, is_vision_available

from ...test_modeling_tf_common import floats_tensor, ids_tensor, random_attention_mask
from ..bert.test_modeling_tf_bert import TFBertModelTester
from ..clip.test_modeling_tf_clip import TFCLIPVisionModelTester
from ..deit.test_modeling_tf_deit import TFDeiTModelTester
from ..roberta.test_modeling_tf_roberta import TFRobertaModelTester
from ..vit.test_modeling_tf_vit import TFViTModelTester


if is_tf_available():
					from transformers import (
					    TFBertModel,
					    TFCLIPVisionModel,
					    TFDeiTModel,
					    TFRobertaModel,
					    TFVisionTextDualEncoderModel,
					    TFViTModel,
					    VisionTextDualEncoderConfig,
					)

if is_vision_available():
					from PIL import Image

					from transformers import VisionTextDualEncoderProcessor





def    __lowerCamelCase      (					UpperCamelCase__ ):







							'''simple docstring'''






							if isinstance(UpperCamelCase__  ,				collections.abc.Iterable ):
														return x
							return (x, x)







@require_tf
class 					lowercase							:




				def        a				(   self ,  snake_case ,  snake_case			):
											pass




				def        a				(   self			):
											pass




				def        a				(   self			):
											pass




				def        a				(   self ,  snake_case ,  snake_case ,  snake_case ,  snake_case ,  snake_case=None ,  **snake_case			):
											snake_case_     							=       VisionTextDualEncoderConfig.from_vision_text_configs(snake_case ,  snake_case			)

											snake_case_     							=       TFVisionTextDualEncoderModel(snake_case			)

											snake_case_     							=       model(input_ids=snake_case ,  pixel_values=snake_case ,  attention_mask=snake_case			)

											self.assertEqual(output['text_embeds'].shape ,  (input_ids.shape[0], config.projection_dim)			)
											self.assertEqual(output['image_embeds'].shape ,  (pixel_values.shape[0], config.projection_dim)			)




				def        a				(   self ,  snake_case ,  snake_case ,  snake_case ,  snake_case ,  snake_case=None ,  **snake_case			):
											snake_case_							,       snake_case_     							=       self.get_vision_text_model(snake_case ,  snake_case			)
											snake_case_     							=       TFVisionTextDualEncoderModel(vision_model=snake_case ,  text_model=snake_case			)

											snake_case_     							=       model(input_ids=snake_case ,  pixel_values=snake_case ,  attention_mask=snake_case			)

											self.assertEqual(output['text_embeds'].shape ,  (input_ids.shape[0], model.config.projection_dim)			)
											self.assertEqual(output['image_embeds'].shape ,  (pixel_values.shape[0], model.config.projection_dim)			)




				def        a				(   self ,  snake_case ,  snake_case ,  snake_case ,  snake_case ,  snake_case=None ,  **snake_case			):
											snake_case_							,       snake_case_     							=       self.get_vision_text_model(snake_case ,  snake_case			)
											snake_case_     							=       {'vision_model': vision_model, 'text_model': text_model}
											snake_case_     							=       TFVisionTextDualEncoderModel.from_vision_text_pretrained(**snake_case			)

											snake_case_     							=       model(input_ids=snake_case ,  pixel_values=snake_case ,  attention_mask=snake_case			)

											self.assertEqual(output['text_embeds'].shape ,  (input_ids.shape[0], model.config.projection_dim)			)
											self.assertEqual(output['image_embeds'].shape ,  (pixel_values.shape[0], model.config.projection_dim)			)




				def        a				(   self ,  snake_case ,  snake_case ,  snake_case ,  snake_case ,  snake_case=None ,  **snake_case			):
											snake_case_							,       snake_case_     							=       self.get_vision_text_model(snake_case ,  snake_case			)
											snake_case_     							=       TFVisionTextDualEncoderModel(vision_model=snake_case ,  text_model=snake_case			)

											snake_case_     							=       model(input_ids=snake_case ,  pixel_values=snake_case ,  attention_mask=snake_case			)
											snake_case_     							=       output[0].numpy()

											with tempfile.TemporaryDirectory() as tmpdirname:
																		model.save_pretrained(snake_case			)
																		snake_case_     							=       TFVisionTextDualEncoderModel.from_pretrained(snake_case			)

																		snake_case_     							=       model(input_ids=snake_case ,  pixel_values=snake_case ,  attention_mask=snake_case			)
																		snake_case_     							=       after_output[0].numpy()
																		snake_case_     							=       np.amax(np.abs(out_a - out_a			)			)
																		self.assertLessEqual(snake_case ,  1e-5			)




				def        a				(   self ,  snake_case ,  snake_case ,  snake_case ,  snake_case ,  snake_case=None ,  **snake_case			):
											snake_case_							,       snake_case_     							=       self.get_vision_text_model(snake_case ,  snake_case			)
											snake_case_     							=       TFVisionTextDualEncoderModel(vision_model=snake_case ,  text_model=snake_case			)

											snake_case_     							=       model(
											    input_ids=snake_case ,  pixel_values=snake_case ,  attention_mask=snake_case ,  output_attentions=snake_case			)

											snake_case_     							=       output.vision_model_output.attentions
											self.assertEqual(len(snake_case			) ,  vision_config.num_hidden_layers			)

											# in ViT, the seq_len equals the number of patches + 1 (we add 1 for the [CLS] token)
											snake_case_     							=       to_atuple(vision_model.config.image_size			)
											snake_case_     							=       to_atuple(vision_model.config.patch_size			)
											snake_case_     							=       (image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])
											snake_case_     							=       num_patches + 1
											self.assertEqual(vision_attentions[0].shape[-3:] ,  (vision_config.num_attention_heads, seq_len, seq_len)			)

											snake_case_     							=       output.text_model_output.attentions
											self.assertEqual(len(snake_case			) ,  text_config.num_hidden_layers			)

											self.assertEqual(
											    text_attentions[0].shape[-3:] ,  (text_config.num_attention_heads, input_ids.shape[-1], input_ids.shape[-1]) ,  )




				def        a				(   self ,  snake_case ,  snake_case ,  snake_case			):
											snake_case_     							=       np.abs((a - b)			).max()
											self.assertLessEqual(snake_case ,  snake_case ,  F'''Difference between torch and flax is {diff} (>= {tol}).'''			)




				def        a				(   self			):
											snake_case_     							=       self.prepare_config_and_inputs()
											self.check_vision_text_dual_encoder_model(**snake_case			)




				def        a				(   self			):
											snake_case_     							=       self.prepare_config_and_inputs()
											self.check_model_from_pretrained_configs(**snake_case			)




				def        a				(   self			):
											snake_case_     							=       self.prepare_config_and_inputs()
											self.check_vision_text_dual_encoder_from_pretrained(**snake_case			)




				def        a				(   self			):
											snake_case_     							=       self.prepare_config_and_inputs()
											self.check_save_load(**snake_case			)




				def        a				(   self			):
											snake_case_     							=       self.prepare_config_and_inputs()
											self.check_vision_text_output_attention(**snake_case			)




				@slow
				def        a				(   self			):
											snake_case_							,       snake_case_     							=       self.get_pretrained_model_and_inputs()

											snake_case_     							=       model_a(**snake_case			)
											snake_case_     							=       outputs[0].numpy()

											with tempfile.TemporaryDirectory() as tmp_dirname:
																		model_a.save_pretrained(snake_case			)
																		snake_case_     							=       TFVisionTextDualEncoderModel.from_pretrained(snake_case			)

																		snake_case_     							=       model_a(**snake_case			)
																		snake_case_     							=       after_outputs[0].numpy()
																		snake_case_     							=       np.amax(np.abs(out_a - out_a			)			)
																		self.assertLessEqual(snake_case ,  1e-5			)







@require_tf
class 					lowercase							(			lowercase_      ,    unittest.TestCase     ):




				def        a				(   self			):
											snake_case_     							=       TFVisionTextDualEncoderModel.from_vision_text_pretrained(
											    'hf-internal-testing/tiny-random-vit' ,  'hf-internal-testing/tiny-random-bert'			)
											snake_case_     							=       13
											snake_case_     							=       floats_tensor(
											    [
											        batch_size,
											        model.vision_model.config.num_channels,
											        model.vision_model.config.image_size,
											        model.vision_model.config.image_size,
											    ]			)
											snake_case_     							=       ids_tensor([batch_size, 4] ,  model.text_model.config.vocab_size			)
											snake_case_     							=       random_attention_mask([batch_size, 4]			)
											snake_case_     							=       {'pixel_values': pixel_values, 'input_ids': input_ids, 'attention_mask': attention_mask}

											return model, inputs




				def        a				(   self ,  snake_case ,  snake_case			):
											snake_case_     							=       TFViTModel(snake_case ,  name='vision_model'			)
											snake_case_     							=       TFBertModel(snake_case ,  name='text_model'			)
											return vision_model, text_model




				def        a				(   self			):
											snake_case_     							=       TFViTModelTester(self			)
											snake_case_     							=       TFBertModelTester(self			)
											snake_case_     							=       vit_model_tester.prepare_config_and_inputs()
											snake_case_     							=       bert_model_tester.prepare_config_and_inputs()

											snake_case_							,       snake_case_							,       snake_case_     							=       vision_config_and_inputs

											(
											    (
											    snake_case_
											)							,       (
											    snake_case_
											)							,       (
											    snake_case_
											)							,       (
											    snake_case_
											)							,       (
											    snake_case_
											)							,       (
											    snake_case_
											)							,       (
											    snake_case_
											)							,       
											)     							=       text_config_and_inputs

											return {
											    "text_config": text_config,
											    "vision_config": vision_config,
											    "pixel_values": pixel_values,
											    "attention_mask": input_mask,
											    "input_ids": input_ids,
											    "text_token_type_ids": token_type_ids,
											    "text_sequence_labels": sequence_labels,
											    "text_token_labels": token_labels,
											    "text_choice_labels": choice_labels,
											}







@require_tf
class 					lowercase							(			lowercase_      ,    unittest.TestCase     ):




				def        a				(   self			):
											# DeiT repo doesn't have TF weights, but we don't actually use the weights at all so let's
											# just reinitialize it.
											snake_case_     							=       TFVisionTextDualEncoderModel.from_vision_text_pretrained(
											    'Rocketknight1/tiny-random-deit-tf' ,  'hf-internal-testing/tiny-random-roberta'			)
											snake_case_     							=       13
											snake_case_     							=       floats_tensor(
											    [
											        batch_size,
											        model.vision_model.config.num_channels,
											        model.vision_model.config.image_size,
											        model.vision_model.config.image_size,
											    ]			)
											snake_case_     							=       ids_tensor([batch_size, 4] ,  model.text_model.config.vocab_size			)
											snake_case_     							=       random_attention_mask([batch_size, 4]			)
											snake_case_     							=       {'pixel_values': pixel_values, 'input_ids': input_ids, 'attention_mask': attention_mask}

											return model, inputs




				def        a				(   self ,  snake_case ,  snake_case ,  snake_case ,  snake_case ,  snake_case=None ,  **snake_case			):
											snake_case_							,       snake_case_     							=       self.get_vision_text_model(snake_case ,  snake_case			)
											snake_case_     							=       TFVisionTextDualEncoderModel(vision_model=snake_case ,  text_model=snake_case			)

											snake_case_     							=       model(
											    input_ids=snake_case ,  pixel_values=snake_case ,  attention_mask=snake_case ,  output_attentions=snake_case			)

											snake_case_     							=       output.vision_model_output.attentions
											self.assertEqual(len(snake_case			) ,  vision_config.num_hidden_layers			)

											# in DEiT, the seq_len equals the number of patches + 2 (we add 2 for the [CLS] and distillation tokens)
											snake_case_     							=       to_atuple(vision_model.config.image_size			)
											snake_case_     							=       to_atuple(vision_model.config.patch_size			)
											snake_case_     							=       (image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])
											snake_case_     							=       num_patches + 2
											self.assertEqual(vision_attentions[0].shape[-3:] ,  (vision_config.num_attention_heads, seq_len, seq_len)			)

											snake_case_     							=       output.text_model_output.attentions
											self.assertEqual(len(snake_case			) ,  text_config.num_hidden_layers			)

											self.assertEqual(
											    text_attentions[0].shape[-3:] ,  (text_config.num_attention_heads, input_ids.shape[-1], input_ids.shape[-1]) ,  )




				def        a				(   self ,  snake_case ,  snake_case			):
											snake_case_     							=       TFDeiTModel(snake_case ,  name='vision_model'			)
											snake_case_     							=       TFRobertaModel(snake_case ,  name='text_model'			)
											return vision_model, text_model




				def        a				(   self			):
											snake_case_     							=       TFDeiTModelTester(self			)
											snake_case_     							=       TFRobertaModelTester(self			)
											snake_case_     							=       vit_model_tester.prepare_config_and_inputs()
											snake_case_     							=       bert_model_tester.prepare_config_and_inputs()

											snake_case_							,       snake_case_							,       snake_case_     							=       vision_config_and_inputs

											(
											    (
											    snake_case_
											)							,       (
											    snake_case_
											)							,       (
											    snake_case_
											)							,       (
											    snake_case_
											)							,       (
											    snake_case_
											)							,       (
											    snake_case_
											)							,       (
											    snake_case_
											)							,       
											)     							=       text_config_and_inputs

											return {
											    "text_config": text_config,
											    "vision_config": vision_config,
											    "pixel_values": pixel_values,
											    "attention_mask": input_mask,
											    "input_ids": input_ids,
											    "text_token_type_ids": token_type_ids,
											    "text_sequence_labels": sequence_labels,
											    "text_token_labels": token_labels,
											    "text_choice_labels": choice_labels,
											}







@require_tf
class 					lowercase							(			lowercase_      ,    unittest.TestCase     ):




				def        a				(   self			):
											snake_case_     							=       TFVisionTextDualEncoderModel.from_vision_text_pretrained(
											    'Rocketknight1/tiny-random-clip-tf' ,  'hf-internal-testing/tiny-random-bert'			)
											snake_case_     							=       13
											snake_case_     							=       floats_tensor(
											    [
											        batch_size,
											        model.vision_model.config.num_channels,
											        model.vision_model.config.image_size,
											        model.vision_model.config.image_size,
											    ]			)
											snake_case_     							=       ids_tensor([batch_size, 4] ,  model.text_model.config.vocab_size			)
											snake_case_     							=       random_attention_mask([batch_size, 4]			)
											snake_case_     							=       {'pixel_values': pixel_values, 'input_ids': input_ids, 'attention_mask': attention_mask}

											return model, inputs




				def        a				(   self ,  snake_case ,  snake_case			):
											snake_case_     							=       TFCLIPVisionModel(snake_case ,  name='vision_model'			)
											snake_case_     							=       TFBertModel(snake_case ,  name='text_model'			)
											return vision_model, text_model




				def        a				(   self			):
											snake_case_     							=       TFCLIPVisionModelTester(self			)
											snake_case_     							=       TFBertModelTester(self			)
											snake_case_     							=       clip_model_tester.prepare_config_and_inputs()
											snake_case_     							=       bert_model_tester.prepare_config_and_inputs()

											snake_case_							,       snake_case_     							=       vision_config_and_inputs

											(
											    (
											    snake_case_
											)							,       (
											    snake_case_
											)							,       (
											    snake_case_
											)							,       (
											    snake_case_
											)							,       (
											    snake_case_
											)							,       (
											    snake_case_
											)							,       (
											    snake_case_
											)							,       
											)     							=       text_config_and_inputs

											return {
											    "text_config": text_config,
											    "vision_config": vision_config,
											    "pixel_values": pixel_values,
											    "attention_mask": input_mask,
											    "input_ids": input_ids,
											    "text_token_type_ids": token_type_ids,
											    "text_sequence_labels": sequence_labels,
											    "text_token_labels": token_labels,
											    "text_choice_labels": choice_labels,
											}







@require_vision
@require_tf
class 					lowercase							(			unittest.TestCase     ):




				@slow
				def        a				(   self			):
											snake_case_     							=       TFVisionTextDualEncoderModel.from_pretrained(
											    'clip-italian/clip-italian' ,  logit_scale_init_value=1.0 ,  from_pt=snake_case			)
											snake_case_     							=       VisionTextDualEncoderProcessor.from_pretrained('clip-italian/clip-italian'			)

											snake_case_     							=       Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'			)
											snake_case_     							=       processor(
											    text=['una foto di un gatto', 'una foto di un cane'] ,  images=snake_case ,  padding=snake_case ,  return_tensors='np'			)

											snake_case_     							=       model(**snake_case			)

											# verify the logits
											self.assertEqual(outputs.logits_per_image.shape ,  (inputs.pixel_values.shape[0], inputs.input_ids.shape[0])			)
											self.assertEqual(
											    outputs.logits_per_text.shape ,  (inputs.input_ids.shape[0], inputs.pixel_values.shape[0]) ,  )

											snake_case_     							=       np.array([[1.2_28_47_27, 0.3_10_41_22]]			)

											self.assertTrue(np.allclose(outputs.logits_per_image.numpy() ,  snake_case ,  atol=1e-3			)			)







def    __lowerCamelCase      (					UpperCamelCase__ = 1000 ):







							'''simple docstring'''






							snake_case_     							=       2**power
							snake_case_     							=       0
							while n:
														snake_case_							,       snake_case_     							=       r + n % 10, n // 10
							return r


if __name__ == "__main__":
					print(solution(int(str(input()).strip())))




