





from __future__ import annotations

import inspect
import unittest

import numpy as np

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

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
					import tensorflow as tf

					from transformers.models.swin.modeling_tf_swin import (
					    TF_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST,
					    TFSwinForImageClassification,
					    TFSwinForMaskedImageModeling,
					    TFSwinModel,
					)


if is_vision_available():
					from PIL import Image

					from transformers import AutoImageProcessor
class       UpperCamelCase_		:




					def __init__(		self					,    lowerCAmelCase_					,    lowerCAmelCase_=13					,    lowerCAmelCase_=32					,    lowerCAmelCase_=2					,    lowerCAmelCase_=3					,    lowerCAmelCase_=16					,    lowerCAmelCase_=[1, 2, 1]					,    lowerCAmelCase_=[2, 2, 4]					,    lowerCAmelCase_=2					,    lowerCAmelCase_=2.0					,    lowerCAmelCase_=True					,    lowerCAmelCase_=0.0					,    lowerCAmelCase_=0.0					,    lowerCAmelCase_=0.1					,    lowerCAmelCase_="gelu"					,    lowerCAmelCase_=False					,    lowerCAmelCase_=True					,    lowerCAmelCase_=0.02					,    lowerCAmelCase_=1E-5					,    lowerCAmelCase_=True					,    lowerCAmelCase_=None					,    lowerCAmelCase_=True					,    lowerCAmelCase_=10					,    lowerCAmelCase_=8					,    )		->				None:
										_snake_case						=					parent
										_snake_case						=					batch_size
										_snake_case						=					image_size
										_snake_case						=					patch_size
										_snake_case						=					num_channels
										_snake_case						=					embed_dim
										_snake_case						=					depths
										_snake_case						=					num_heads
										_snake_case						=					window_size
										_snake_case						=					mlp_ratio
										_snake_case						=					qkv_bias
										_snake_case						=					hidden_dropout_prob
										_snake_case						=					attention_probs_dropout_prob
										_snake_case						=					drop_path_rate
										_snake_case						=					hidden_act
										_snake_case						=					use_absolute_embeddings
										_snake_case						=					patch_norm
										_snake_case						=					layer_norm_eps
										_snake_case						=					initializer_range
										_snake_case						=					is_training
										_snake_case						=					scope
										_snake_case						=					use_labels
										_snake_case						=					type_sequence_label_size
										_snake_case						=					encoder_stride




					def 						lowerCAmelCase      (		self	)		->				Tuple:
										_snake_case						=					floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]	)

										_snake_case						=					None
										if self.use_labels:
															_snake_case						=					ids_tensor([self.batch_size]					,    self.type_sequence_label_size	)

										_snake_case						=					self.get_config()

										return config, pixel_values, labels




					def 						lowerCAmelCase      (		self	)		->				List[str]:
										return SwinConfig(
										    image_size=self.image_size					,    patch_size=self.patch_size					,    num_channels=self.num_channels					,    embed_dim=self.embed_dim					,    depths=self.depths					,    num_heads=self.num_heads					,    window_size=self.window_size					,    mlp_ratio=self.mlp_ratio					,    qkv_bias=self.qkv_bias					,    hidden_dropout_prob=self.hidden_dropout_prob					,    attention_probs_dropout_prob=self.attention_probs_dropout_prob					,    drop_path_rate=self.drop_path_rate					,    hidden_act=self.hidden_act					,    use_absolute_embeddings=self.use_absolute_embeddings					,    path_norm=self.patch_norm					,    layer_norm_eps=self.layer_norm_eps					,    initializer_range=self.initializer_range					,    encoder_stride=self.encoder_stride					,    )




					def 						lowerCAmelCase      (		self					,    lowerCAmelCase_					,    lowerCAmelCase_					,    lowerCAmelCase_	)		->				List[str]:
										_snake_case						=					TFSwinModel(config=lowerCAmelCase_	)
										_snake_case						=					model(lowerCAmelCase_	)

										_snake_case						=					((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths	) - 1))
										_snake_case						=					int(config.embed_dim * 2 ** (len(config.depths	) - 1)	)

										self.parent.assertEqual(result.last_hidden_state.shape					,    (self.batch_size, expected_seq_len, expected_dim)	)




					def 						lowerCAmelCase      (		self					,    lowerCAmelCase_					,    lowerCAmelCase_					,    lowerCAmelCase_	)		->				int:
										_snake_case						=					TFSwinForMaskedImageModeling(config=lowerCAmelCase_	)
										_snake_case						=					model(lowerCAmelCase_	)
										self.parent.assertEqual(
										    result.logits.shape					,    (self.batch_size, self.num_channels, self.image_size, self.image_size)	)

										# test greyscale images
										_snake_case						=					1
										_snake_case						=					TFSwinForMaskedImageModeling(lowerCAmelCase_	)

										_snake_case						=					floats_tensor([self.batch_size, 1, self.image_size, self.image_size]	)
										_snake_case						=					model(lowerCAmelCase_	)
										self.parent.assertEqual(result.logits.shape					,    (self.batch_size, 1, self.image_size, self.image_size)	)




					def 						lowerCAmelCase      (		self					,    lowerCAmelCase_					,    lowerCAmelCase_					,    lowerCAmelCase_	)		->				Tuple:
										_snake_case						=					self.type_sequence_label_size
										_snake_case						=					TFSwinForImageClassification(lowerCAmelCase_	)
										_snake_case						=					model(lowerCAmelCase_					,    labels=lowerCAmelCase_	)
										self.parent.assertEqual(result.logits.shape					,    (self.batch_size, self.type_sequence_label_size)	)

										# test greyscale images
										_snake_case						=					1
										_snake_case						=					TFSwinForImageClassification(lowerCAmelCase_	)
										_snake_case						=					floats_tensor([self.batch_size, 1, self.image_size, self.image_size]	)
										_snake_case						=					model(lowerCAmelCase_	)
										self.parent.assertEqual(result.logits.shape					,    (self.batch_size, self.type_sequence_label_size)	)






					def 						lowerCAmelCase      (		self	)		->				int:
										_snake_case						=					self.prepare_config_and_inputs()
										_snake_case				,  _snake_case				,  _snake_case						=					config_and_inputs
										_snake_case						=					{'pixel_values': pixel_values}
										return config, inputs_dict





@require_tf
class       UpperCamelCase_		(	_lowerCamelCase				,	_lowerCamelCase				,	unittest.TestCase       ):
					lowerCAmelCase_				=						(
					    (
					        TFSwinModel,
					        TFSwinForImageClassification,
					        TFSwinForMaskedImageModeling,
					    )
					    if is_tf_available()
					    else ()
					)
					lowerCAmelCase_				=						(
					    {'''feature-extraction''': TFSwinModel, '''image-classification''': TFSwinForImageClassification}
					    if is_tf_available()
					    else {}
					)

					lowerCAmelCase_				=						False
					lowerCAmelCase_				=						False
					lowerCAmelCase_				=						False
					lowerCAmelCase_				=						False




					def 						lowerCAmelCase      (		self	)		->				Tuple:
										_snake_case						=					TFSwinModelTester(self	)
										_snake_case						=					ConfigTester(self					,    config_class=lowerCAmelCase_					,    embed_dim=37	)




					def 						lowerCAmelCase      (		self	)		->				List[Any]:
										self.create_and_test_config_common_properties()
										self.config_tester.create_and_test_config_to_json_string()
										self.config_tester.create_and_test_config_to_json_file()
										self.config_tester.create_and_test_config_from_and_save_pretrained()
										self.config_tester.create_and_test_config_with_num_labels()
										self.config_tester.check_config_can_be_init_without_params()
										self.config_tester.check_config_arguments_init()




					def 						lowerCAmelCase      (		self	)		->				Any:
										return




					def 						lowerCAmelCase      (		self	)		->				Union[str, Any]:
										_snake_case						=					self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_model(*lowerCAmelCase_	)




					def 						lowerCAmelCase      (		self	)		->				List[Any]:
										_snake_case						=					self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_masked_image_modeling(*lowerCAmelCase_	)




					def 						lowerCAmelCase      (		self	)		->				Tuple:
										_snake_case						=					self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_image_classification(*lowerCAmelCase_	)




					@unittest.skip(reason='Swin does not use inputs_embeds'	)
					def 						lowerCAmelCase      (		self	)		->				Union[str, Any]:
										pass




					def 						lowerCAmelCase      (		self	)		->				Optional[int]:
										_snake_case				,  _snake_case						=					self.model_tester.prepare_config_and_inputs_for_common()

										for model_class in self.all_model_classes:
															_snake_case						=					model_class(lowerCAmelCase_	)
															self.assertIsInstance(model.get_input_embeddings()					,    tf.keras.layers.Layer	)
															_snake_case						=					model.get_output_embeddings()
															self.assertTrue(x is None or isinstance(lowerCAmelCase_					,    tf.keras.layers.Dense	)	)




					def 						lowerCAmelCase      (		self	)		->				Any:
										_snake_case				,  _snake_case						=					self.model_tester.prepare_config_and_inputs_for_common()

										for model_class in self.all_model_classes:
															_snake_case						=					model_class(lowerCAmelCase_	)
															_snake_case						=					inspect.signature(model.call	)
															# signature.parameters is an OrderedDict => so arg_names order is deterministic
															_snake_case						=					[*signature.parameters.keys()]

															_snake_case						=					['pixel_values']
															self.assertListEqual(arg_names[:1]					,    lowerCAmelCase_	)




					def 						lowerCAmelCase      (		self	)		->				Optional[Any]:
										_snake_case				,  _snake_case						=					self.model_tester.prepare_config_and_inputs_for_common()
										_snake_case						=					True

										for model_class in self.all_model_classes:
															_snake_case						=					True
															_snake_case						=					False
															_snake_case						=					True
															_snake_case						=					model_class(lowerCAmelCase_	)
															_snake_case						=					model(**self._prepare_for_class(lowerCAmelCase_					,    lowerCAmelCase_	)	)
															_snake_case						=					outputs.attentions
															_snake_case						=					len(self.model_tester.depths	)
															self.assertEqual(len(lowerCAmelCase_	)					,    lowerCAmelCase_	)

															# check that output_attentions also work using config
															del inputs_dict["output_attentions"]
															_snake_case						=					True
															_snake_case						=					config.window_size**2
															_snake_case						=					model_class(lowerCAmelCase_	)
															_snake_case						=					model(**self._prepare_for_class(lowerCAmelCase_					,    lowerCAmelCase_	)	)
															_snake_case						=					outputs.attentions
															self.assertEqual(len(lowerCAmelCase_	)					,    lowerCAmelCase_	)

															self.assertListEqual(
															    list(attentions[0].shape[-3:]	)					,    [self.model_tester.num_heads[0], window_size_squared, window_size_squared]					,    )
															_snake_case						=					len(lowerCAmelCase_	)

															# Check attention is always last and order is fine
															_snake_case						=					True
															_snake_case						=					True
															_snake_case						=					model_class(lowerCAmelCase_	)
															_snake_case						=					model(**self._prepare_for_class(lowerCAmelCase_					,    lowerCAmelCase_	)	)

															if hasattr(self.model_tester					,    'num_hidden_states_types'	):
																				_snake_case						=					self.model_tester.num_hidden_states_types
															else:
																				# also another +1 for reshaped_hidden_states
																				_snake_case						=					2
															self.assertEqual(out_len + added_hidden_states					,    len(lowerCAmelCase_	)	)

															_snake_case						=					outputs.attentions

															self.assertEqual(len(lowerCAmelCase_	)					,    lowerCAmelCase_	)

															self.assertListEqual(
															    list(self_attentions[0].shape[-3:]	)					,    [self.model_tester.num_heads[0], window_size_squared, window_size_squared]					,    )




					def 						lowerCAmelCase      (		self					,    lowerCAmelCase_					,    lowerCAmelCase_					,    lowerCAmelCase_					,    lowerCAmelCase_	)		->				Optional[int]:
										_snake_case						=					model_class(lowerCAmelCase_	)
										_snake_case						=					model(**self._prepare_for_class(lowerCAmelCase_					,    lowerCAmelCase_	)	)
										_snake_case						=					outputs.hidden_states

										_snake_case						=					getattr(
										    self.model_tester					,    'expected_num_hidden_layers'					,    len(self.model_tester.depths	) + 1	)
										self.assertEqual(len(lowerCAmelCase_	)					,    lowerCAmelCase_	)

										# Swin has a different seq_length
										_snake_case						=					to_atuple(config.patch_size	)

										_snake_case						=					(image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])

										self.assertListEqual(
										    list(hidden_states[0].shape[-2:]	)					,    [num_patches, self.model_tester.embed_dim]					,    )

										_snake_case						=					outputs.reshaped_hidden_states
										self.assertEqual(len(lowerCAmelCase_	)					,    lowerCAmelCase_	)

										_snake_case				,  _snake_case				,  _snake_case				,  _snake_case						=					reshaped_hidden_states[0].shape

										_snake_case						=					tf.reshape(reshaped_hidden_states[0]					,    (batch_size, num_channels, height * width)	)
										_snake_case						=					tf.transpose(lowerCAmelCase_					,    (0, 2, 1)	)

										self.assertListEqual(
										    list(reshaped_hidden_states.shape[-2:]	)					,    [num_patches, self.model_tester.embed_dim]					,    )




					def 						lowerCAmelCase      (		self	)		->				List[str]:
										_snake_case				,  _snake_case						=					self.model_tester.prepare_config_and_inputs_for_common()

										_snake_case						=					to_atuple(self.model_tester.image_size	)

										for model_class in self.all_model_classes:
															_snake_case						=					True
															self.check_hidden_states_output(lowerCAmelCase_					,    lowerCAmelCase_					,    lowerCAmelCase_					,    lowerCAmelCase_	)

															# check that output_hidden_states also work using config
															del inputs_dict["output_hidden_states"]
															_snake_case						=					True

															self.check_hidden_states_output(lowerCAmelCase_					,    lowerCAmelCase_					,    lowerCAmelCase_					,    lowerCAmelCase_	)




					def 						lowerCAmelCase      (		self	)		->				Optional[Any]:
										_snake_case				,  _snake_case						=					self.model_tester.prepare_config_and_inputs_for_common()
										_snake_case						=					3

										_snake_case						=					to_atuple(self.model_tester.image_size	)
										_snake_case						=					to_atuple(config.patch_size	)

										_snake_case						=					image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
										_snake_case						=					image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

										for model_class in self.all_model_classes:
															_snake_case						=					True
															self.check_hidden_states_output(lowerCAmelCase_					,    lowerCAmelCase_					,    lowerCAmelCase_					,    (padded_height, padded_width)	)

															# check that output_hidden_states also work using config
															del inputs_dict["output_hidden_states"]
															_snake_case						=					True
															self.check_hidden_states_output(lowerCAmelCase_					,    lowerCAmelCase_					,    lowerCAmelCase_					,    (padded_height, padded_width)	)






					@slow
					def 						lowerCAmelCase      (		self	)		->				str:
										for model_name in TF_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
															_snake_case						=					TFSwinModel.from_pretrained(lowerCAmelCase_	)
															self.assertIsNotNone(lowerCAmelCase_	)





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




					@cached_property
					def 						lowerCAmelCase      (		self	)		->				Tuple:
										return (
										    AutoImageProcessor.from_pretrained('microsoft/swin-tiny-patch4-window7-224'	)
										    if is_vision_available()
										    else None
										)






					@slow
					def 						lowerCAmelCase      (		self	)		->				Union[str, Any]:
										_snake_case						=					TFSwinForImageClassification.from_pretrained('microsoft/swin-tiny-patch4-window7-224'	)
										_snake_case						=					self.default_image_processor

										_snake_case						=					Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'	)
										_snake_case						=					image_processor(images=lowerCAmelCase_					,    return_tensors='tf'	)

										# forward pass
										_snake_case						=					model(lowerCAmelCase_	)

										# verify the logits
										_snake_case						=					tf.TensorShape((1, 1000)	)
										self.assertEqual(outputs.logits.shape					,    lowerCAmelCase_	)
										_snake_case						=					tf.constant([-0.09_48, -0.64_54, -0.09_21]	)
										self.assertTrue(np.allclose(outputs.logits[0, :3]					,    lowerCAmelCase_					,    atol=1E-4	)	)










def     lowerCamelCase__  (  UpperCamelCase__      :							int = 100    )      ->			int:



					'''simple docstring'''




					_snake_case						=					1
					_snake_case						=					0
					for i in range(1							,     num + 1    ):
										fact *= i

					for j in str(UpperCamelCase__    ):
										result += int(UpperCamelCase__    )

					return result


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



