code: 
  
  
  
  """simple docstring"""
  
  
  
  
  import collections
  import inspect
  import unittest
  
  from transformers import DonutSwinConfig
  from transformers.testing_utils import require_torch, slow, torch_device
  from transformers.utils import is_torch_available
  
  from ...test_configuration_common import ConfigTester
  from ...test_modeling_common import ModelTesterMixin, _config_zero_init, floats_tensor, ids_tensor
  from ...test_pipeline_mixin import PipelineTesterMixin
  
  
  if is_torch_available():
   import torch
   from torch import nn
  
   from transformers import DonutSwinModel
   from transformers.models.donut.modeling_donut_swin import DONUT_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST
  
  
  
  
  
  
  class 			UpperCAmelCase_						:
  
  
  
        def __init__(  self  :			Optional[int]  ,			A  :			Optional[Any]  ,			A  :			Any=1_3  ,			A  :			str=3_2  ,			A  :			Optional[Any]=2  ,			A  :			Any=3  ,			A  :			Dict=1_6  ,			A  :			int=[1, 2, 1]  ,			A  :			int=[2, 2, 4]  ,			A  :			int=2  ,			A  :			Tuple=2.0  ,			A  :			Tuple=True  ,			A  :			List[str]=0.0  ,			A  :			Tuple=0.0  ,			A  :			str=0.1  ,			A  :			Tuple="gelu"  ,			A  :			List[str]=False  ,			A  :			List[str]=True  ,			A  :			str=0.02  ,			A  :			Union[str, Any]=1e-5  ,			A  :			Dict=True  ,			A  :			Any=None  ,			A  :			Dict=True  ,			A  :			str=1_0  ,			A  :			Dict=8  ,			):
             _UpperCAmelCase    :			Dict              =					parent
             _UpperCAmelCase    :			List[Any]              =					batch_size
             _UpperCAmelCase    :			Union[str, Any]              =					image_size
             _UpperCAmelCase    :			Dict              =					patch_size
             _UpperCAmelCase    :			Any              =					num_channels
             _UpperCAmelCase    :			Tuple              =					embed_dim
             _UpperCAmelCase    :			List[str]              =					depths
             _UpperCAmelCase    :			List[str]              =					num_heads
             _UpperCAmelCase    :			Tuple              =					window_size
             _UpperCAmelCase    :			str              =					mlp_ratio
             _UpperCAmelCase    :			List[Any]              =					qkv_bias
             _UpperCAmelCase    :			Optional[int]              =					hidden_dropout_prob
             _UpperCAmelCase    :			Dict              =					attention_probs_dropout_prob
             _UpperCAmelCase    :			Dict              =					drop_path_rate
             _UpperCAmelCase    :			List[Any]              =					hidden_act
             _UpperCAmelCase    :			List[str]              =					use_absolute_embeddings
             _UpperCAmelCase    :			Optional[int]              =					patch_norm
             _UpperCAmelCase    :			List[str]              =					layer_norm_eps
             _UpperCAmelCase    :			Any              =					initializer_range
             _UpperCAmelCase    :			List[Any]              =					is_training
             _UpperCAmelCase    :			str              =					scope
             _UpperCAmelCase    :			Tuple              =					use_labels
             _UpperCAmelCase    :			Any              =					type_sequence_label_size
             _UpperCAmelCase    :			str              =					encoder_stride
  
  
  
        def 		snake_case_      (  self  :			Optional[Any]		):
             _UpperCAmelCase    :			List[str]              =					floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]		)
  
             _UpperCAmelCase    :			Any              =					None
             if self.use_labels:
                  _UpperCAmelCase    :			Any              =					ids_tensor([self.batch_size]  ,			self.type_sequence_label_size		)
  
             _UpperCAmelCase    :			Optional[Any]              =					self.get_config()
  
             return config, pixel_values, labels
  
  
  
        def 		snake_case_      (  self  :			Tuple		):
             return DonutSwinConfig(
                 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 		snake_case_      (  self  :			List[str]  ,			A  :			str  ,			A  :			Any  ,			A  :			Dict		):
             _UpperCAmelCase    :			int              =					DonutSwinModel(config=A		)
             model.to(A		)
             model.eval()
             _UpperCAmelCase    :			Any              =					model(A		)
  
             _UpperCAmelCase    :			Tuple              =					((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths		) - 1))
             _UpperCAmelCase    :			str              =					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 		snake_case_      (  self  :			Union[str, Any]		):
             _UpperCAmelCase    :			Tuple              =					self.prepare_config_and_inputs()
             (
                 (
                 _UpperCAmelCase
             )       , (
                 _UpperCAmelCase
             )       , (
                 _UpperCAmelCase
             )       , 
             )    :			List[Any]              =					config_and_inputs
             _UpperCAmelCase    :			List[str]              =					{"pixel_values": pixel_values}
             return config, inputs_dict
  
  
  
  
  
  
  
  @require_torch
  class 			UpperCAmelCase_						(       _UpperCamelCase ,    _UpperCamelCase ,    unittest.TestCase		):
        __SCREAMING_SNAKE_CASE		:     str				  =				(DonutSwinModel,) if is_torch_available() else ()
        __SCREAMING_SNAKE_CASE		:     Optional[Any]				  =				{'feature-extraction': DonutSwinModel} if is_torch_available() else {}
        __SCREAMING_SNAKE_CASE		:     Any				  =				True
  
        __SCREAMING_SNAKE_CASE		:     Tuple				  =				False
        __SCREAMING_SNAKE_CASE		:     Dict				  =				False
        __SCREAMING_SNAKE_CASE		:     Union[str, Any]				  =				False
  
  
  
        def 		snake_case_      (  self  :			Optional[int]		):
             _UpperCAmelCase    :			Tuple              =					DonutSwinModelTester(self		)
             _UpperCAmelCase    :			Dict              =					ConfigTester(self  ,			config_class=A  ,			embed_dim=3_7		)
  
  
  
        def 		snake_case_      (  self  :			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 		snake_case_      (  self  :			List[Any]		):
             return
  
  
  
        def 		snake_case_      (  self  :			Tuple		):
             _UpperCAmelCase    :			Dict              =					self.model_tester.prepare_config_and_inputs()
             self.model_tester.create_and_check_model(*A		)
  
  
  
        def 		snake_case_      (  self  :			List[str]		):
             # DonutSwin does not use inputs_embeds
             pass
  
  
  
        def 		snake_case_      (  self  :			str		):
             _UpperCAmelCase       , _UpperCAmelCase    :			List[Any]              =					self.model_tester.prepare_config_and_inputs_for_common()
  
             for model_class in self.all_model_classes:
                  _UpperCAmelCase    :			Tuple              =					model_class(A		)
                  self.assertIsInstance(model.get_input_embeddings()  ,			(nn.Module)		)
                  _UpperCAmelCase    :			Dict              =					model.get_output_embeddings()
                  self.assertTrue(x is None or isinstance(A  ,			nn.Linear		)		)
  
  
  
        def 		snake_case_      (  self  :			List[Any]		):
             _UpperCAmelCase       , _UpperCAmelCase    :			Optional[Any]              =					self.model_tester.prepare_config_and_inputs_for_common()
  
             for model_class in self.all_model_classes:
                  _UpperCAmelCase    :			List[str]              =					model_class(A		)
                  _UpperCAmelCase    :			Optional[Any]              =					inspect.signature(model.forward		)
                  # signature.parameters is an OrderedDict => so arg_names order is deterministic
                  _UpperCAmelCase    :			str              =					[*signature.parameters.keys()]
  
                  _UpperCAmelCase    :			int              =					["pixel_values"]
                  self.assertListEqual(arg_names[:1]  ,			A		)
  
  
  
        def 		snake_case_      (  self  :			Optional[int]		):
             _UpperCAmelCase       , _UpperCAmelCase    :			Dict              =					self.model_tester.prepare_config_and_inputs_for_common()
             _UpperCAmelCase    :			Union[str, Any]              =					True
  
             for model_class in self.all_model_classes:
                  _UpperCAmelCase    :			Any              =					True
                  _UpperCAmelCase    :			Dict              =					False
                  _UpperCAmelCase    :			List[str]              =					True
                  _UpperCAmelCase    :			Optional[Any]              =					model_class(A		)
                  model.to(A		)
                  model.eval()
                  with torch.no_grad():
                       _UpperCAmelCase    :			Optional[Any]              =					model(**self._prepare_for_class(A  ,			A		)		)
                  _UpperCAmelCase    :			str              =					outputs.attentions
                  _UpperCAmelCase    :			Tuple              =					len(self.model_tester.depths		)
                  self.assertEqual(len(A		)  ,			A		)
  
                  # check that output_attentions also work using config
                  del inputs_dict["output_attentions"]
                  _UpperCAmelCase    :			List[Any]              =					True
                  _UpperCAmelCase    :			List[str]              =					config.window_size**2
                  _UpperCAmelCase    :			Dict              =					model_class(A		)
                  model.to(A		)
                  model.eval()
                  with torch.no_grad():
                       _UpperCAmelCase    :			int              =					model(**self._prepare_for_class(A  ,			A		)		)
                  _UpperCAmelCase    :			int              =					outputs.attentions
                  self.assertEqual(len(A		)  ,			A		)
  
                  self.assertListEqual(
                      list(attentions[0].shape[-3:]		)  ,			[self.model_tester.num_heads[0], window_size_squared, window_size_squared]  ,			)
                  _UpperCAmelCase    :			Any              =					len(A		)
  
                  # Check attention is always last and order is fine
                  _UpperCAmelCase    :			Optional[int]              =					True
                  _UpperCAmelCase    :			Any              =					True
                  _UpperCAmelCase    :			List[Any]              =					model_class(A		)
                  model.to(A		)
                  model.eval()
                  with torch.no_grad():
                       _UpperCAmelCase    :			int              =					model(**self._prepare_for_class(A  ,			A		)		)
  
                  if hasattr(self.model_tester  ,			"num_hidden_states_types"		):
                       _UpperCAmelCase    :			Tuple              =					self.model_tester.num_hidden_states_types
                  else:
                       # also another +1 for reshaped_hidden_states
                       _UpperCAmelCase    :			Any              =					2
                  self.assertEqual(out_len + added_hidden_states  ,			len(A		)		)
  
                  _UpperCAmelCase    :			Optional[Any]              =					outputs.attentions
  
                  self.assertEqual(len(A		)  ,			A		)
  
                  self.assertListEqual(
                      list(self_attentions[0].shape[-3:]		)  ,			[self.model_tester.num_heads[0], window_size_squared, window_size_squared]  ,			)
  
  
  
        def 		snake_case_      (  self  :			Tuple  ,			A  :			int  ,			A  :			Optional[Any]  ,			A  :			Dict  ,			A  :			Optional[Any]		):
             _UpperCAmelCase    :			Any              =					model_class(A		)
             model.to(A		)
             model.eval()
  
             with torch.no_grad():
                  _UpperCAmelCase    :			int              =					model(**self._prepare_for_class(A  ,			A		)		)
  
             _UpperCAmelCase    :			str              =					outputs.hidden_states
  
             _UpperCAmelCase    :			int              =					getattr(
                 self.model_tester  ,			"expected_num_hidden_layers"  ,			len(self.model_tester.depths		) + 1		)
             self.assertEqual(len(A		)  ,			A		)
  
             # DonutSwin has a different seq_length
             _UpperCAmelCase    :			Dict              =					(
                 config.patch_size
                 if isinstance(config.patch_size  ,			collections.abc.Iterable		)
                 else (config.patch_size, config.patch_size)
             )
  
             _UpperCAmelCase    :			Any              =					(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]  ,			)
  
             _UpperCAmelCase    :			int              =					outputs.reshaped_hidden_states
             self.assertEqual(len(A		)  ,			A		)
  
             _UpperCAmelCase       , _UpperCAmelCase       , _UpperCAmelCase       , _UpperCAmelCase    :			Optional[Any]              =					reshaped_hidden_states[0].shape
             _UpperCAmelCase    :			List[str]              =					(
                 reshaped_hidden_states[0].view(A  ,			A  ,			height * width		).permute(0  ,			2  ,			1		)
             )
             self.assertListEqual(
                 list(reshaped_hidden_states.shape[-2:]		)  ,			[num_patches, self.model_tester.embed_dim]  ,			)
  
  
  
        def 		snake_case_      (  self  :			Optional[Any]		):
             _UpperCAmelCase       , _UpperCAmelCase    :			Optional[Any]              =					self.model_tester.prepare_config_and_inputs_for_common()
  
             _UpperCAmelCase    :			Optional[int]              =					(
                 self.model_tester.image_size
                 if isinstance(self.model_tester.image_size  ,			collections.abc.Iterable		)
                 else (self.model_tester.image_size, self.model_tester.image_size)
             )
  
             for model_class in self.all_model_classes:
                  _UpperCAmelCase    :			Tuple              =					True
                  self.check_hidden_states_output(A  ,			A  ,			A  ,			A		)
  
                  # check that output_hidden_states also work using config
                  del inputs_dict["output_hidden_states"]
                  _UpperCAmelCase    :			List[str]              =					True
  
                  self.check_hidden_states_output(A  ,			A  ,			A  ,			A		)
  
  
  
        def 		snake_case_      (  self  :			Optional[int]		):
             _UpperCAmelCase       , _UpperCAmelCase    :			Union[str, Any]              =					self.model_tester.prepare_config_and_inputs_for_common()
             _UpperCAmelCase    :			Tuple              =					3
  
             _UpperCAmelCase    :			int              =					(
                 self.model_tester.image_size
                 if isinstance(self.model_tester.image_size  ,			collections.abc.Iterable		)
                 else (self.model_tester.image_size, self.model_tester.image_size)
             )
             _UpperCAmelCase    :			Optional[int]              =					(
                 config.patch_size
                 if isinstance(config.patch_size  ,			collections.abc.Iterable		)
                 else (config.patch_size, config.patch_size)
             )
  
             _UpperCAmelCase    :			Optional[int]              =					image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
             _UpperCAmelCase    :			Union[str, Any]              =					image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])
  
             for model_class in self.all_model_classes:
                  _UpperCAmelCase    :			List[str]              =					True
                  self.check_hidden_states_output(A  ,			A  ,			A  ,			(padded_height, padded_width)		)
  
                  # check that output_hidden_states also work using config
                  del inputs_dict["output_hidden_states"]
                  _UpperCAmelCase    :			int              =					True
                  self.check_hidden_states_output(A  ,			A  ,			A  ,			(padded_height, padded_width)		)
  
  
  
        @slow
        def 		snake_case_      (  self  :			Tuple		):
             for model_name in DONUT_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                  _UpperCAmelCase    :			List[Any]              =					DonutSwinModel.from_pretrained(A		)
                  self.assertIsNotNone(A		)
  
  
  
        def 		snake_case_      (  self  :			List[str]		):
             _UpperCAmelCase       , _UpperCAmelCase    :			Optional[int]              =					self.model_tester.prepare_config_and_inputs_for_common()
  
             _UpperCAmelCase    :			Tuple              =					_config_zero_init(A		)
             for model_class in self.all_model_classes:
                  _UpperCAmelCase    :			Union[str, Any]              =					model_class(config=A		)
                  for name, param in model.named_parameters():
                       if "embeddings" not in name and param.requires_grad:
                            self.assertIn(
                                ((param.data.mean() * 1e9).round() / 1e9).item()  ,			[0.0, 1.0]  ,			msg=f'Parameter {name} of model {model_class} seems not properly initialized'  ,			)
  
style_context: 
  
  
  
  """simple docstring"""
  
  
  
  
  _lowerCAmelCase       :      str							=							{
      "0": 1,
      "1": 1,
      "2": 2,
      "3": 6,
      "4": 24,
      "5": 1_20,
      "6": 7_20,
      "7": 50_40,
      "8": 4_03_20,
      "9": 36_28_80,
  }
  
  _lowerCAmelCase       :      Optional[int]							=							{1_45: 1_45}
  
  _lowerCAmelCase       :      int							=							{
      1_45: 0,
      1_69: 3,
      3_63_01: 3,
      14_54: 3,
      8_71: 2,
      4_53_61: 2,
      8_72: 2,
  }
  
  def 		__snake_case		(   SCREAMING_SNAKE_CASE__			:		int       )						->     int:
  
  
  
  
  
       '''simple docstring'''
  
       if n in CACHE_SUM_DIGIT_FACTORIALS:
            return CACHE_SUM_DIGIT_FACTORIALS[n]
       _UpperCAmelCase    :			Dict              =					sum(DIGIT_FACTORIALS[let] for let in str(SCREAMING_SNAKE_CASE__       )       )
       _UpperCAmelCase    :			Any              =					ret
       return ret
  
  def 		__snake_case		(   SCREAMING_SNAKE_CASE__			:		int		,						SCREAMING_SNAKE_CASE__			:		set | None = None       )						->     int:
  
  
  
  
  
       '''simple docstring'''
  
       _UpperCAmelCase    :			Dict              =					previous or set()
       if n in CHAIN_LENGTH_CACHE:
            return CHAIN_LENGTH_CACHE[n]
       _UpperCAmelCase    :			Dict              =					sum_digit_factorials(SCREAMING_SNAKE_CASE__       )
       if next_number in previous:
            _UpperCAmelCase    :			List[str]              =					0
            return 0
       else:
            previous.add(SCREAMING_SNAKE_CASE__       )
            _UpperCAmelCase    :			str              =					1 + chain_length(SCREAMING_SNAKE_CASE__		,						SCREAMING_SNAKE_CASE__       )
            _UpperCAmelCase    :			str              =					ret
            return ret
  
  def 		__snake_case		(   SCREAMING_SNAKE_CASE__			:		int = 60		,						SCREAMING_SNAKE_CASE__			:		int = 1_000_000       )						->     int:
  
  
  
  
  
       '''simple docstring'''
  
       return sum(1 for i in range(1		,						SCREAMING_SNAKE_CASE__       ) if chain_length(SCREAMING_SNAKE_CASE__       ) == num_terms       )
  
  
  if __name__ == "__main__":
   print(F"{solution() = }")
  