

'''simple docstring'''


import unittest

import torch

from diffusers import VQModel
from diffusers.utils import floats_tensor, torch_device
from diffusers.utils.testing_utils import enable_full_determinism

from .test_modeling_common import ModelTesterMixin, UNetTesterMixin


enable_full_determinism()




class     a			(				SCREAMING_SNAKE_CASE			,			SCREAMING_SNAKE_CASE			,			unittest.TestCase       ):






						"""simple docstring"""




						__UpperCAmelCase			     =    VQModel
						__UpperCAmelCase			     =    """sample"""







						@property
						def       __magic_name__							(							self					:      int			,			snake_case_					:      List[Any]=(3_2, 3_2)  ):



								'''simple docstring'''



								snake_case__						:       Dict       						=  4
								snake_case__						:       Dict       						=  3

								snake_case__						:       str       						=  floats_tensor((batch_size, num_channels) + sizes  ).to(snake_case_  )

								return {"sample": image}







						@property
						def       __magic_name__							(							self					:      int  ):



								'''simple docstring'''



								return (3, 3_2, 3_2)







						@property
						def       __magic_name__							(							self					:      Optional[int]  ):



								'''simple docstring'''



								return (3, 3_2, 3_2)







						def       __magic_name__							(							self					:      Optional[int]  ):



								'''simple docstring'''



								snake_case__						:       List[Any]       						=  {
								    '''block_out_channels''': [3_2, 6_4],
								    '''in_channels''': 3,
								    '''out_channels''': 3,
								    '''down_block_types''': ['''DownEncoderBlock2D''', '''DownEncoderBlock2D'''],
								    '''up_block_types''': ['''UpDecoderBlock2D''', '''UpDecoderBlock2D'''],
								    '''latent_channels''': 3,
								}
								snake_case__						:       int       						=  self.dummy_input
								return init_dict, inputs_dict







						def       __magic_name__							(							self					:      Any  ):



								'''simple docstring'''



								pass







						def       __magic_name__							(							self					:      str  ):



								'''simple docstring'''



								pass







						def       __magic_name__							(							self					:      Dict  ):



								'''simple docstring'''



								snake_case__						,       snake_case__						:       Optional[Any]       						=  VQModel.from_pretrained('''fusing/vqgan-dummy'''			,			output_loading_info=snake_case_  )
								self.assertIsNotNone(snake_case_  )
								self.assertEqual(len(loading_info['''missing_keys''']  )			,			0  )

								model.to(snake_case_  )
								snake_case__						:       str       						=  model(**self.dummy_input  )

								assert image is not None, "Make sure output is not None"







						def       __magic_name__							(							self					:      Optional[int]  ):



								'''simple docstring'''



								snake_case__						:       Optional[int]       						=  VQModel.from_pretrained('''fusing/vqgan-dummy'''  )
								model.to(snake_case_  ).eval()

								torch.manual_seed(0  )
								if torch.cuda.is_available():
										torch.cuda.manual_seed_all(0  )

								snake_case__						:       Union[str, Any]       						=  torch.randn(1			,			model.config.in_channels			,			model.config.sample_size			,			model.config.sample_size  )
								snake_case__						:       Dict       						=  image.to(snake_case_  )
								with torch.no_grad():
										snake_case__						:       Tuple       						=  model(snake_case_  ).sample

								snake_case__						:       Union[str, Any]       						=  output[0, -1, -3:, -3:].flatten().cpu()
								# fmt: off
								snake_case__						:       int       						=  torch.tensor([-0.0_1_5_3, -0.4_0_4_4, -0.1_8_8_0, -0.5_1_6_1, -0.2_4_1_8, -0.4_0_7_2, -0.1_6_1_2, -0.0_6_3_3, -0.0_1_4_3]  )
								# fmt: on
								self.assertTrue(torch.allclose(snake_case_			,			snake_case_			,			atol=1e-3  )  )






'''simple docstring'''


from collections.abc import Generator




def 	_a       (				):

		"""simple docstring"""

		snake_case__						,       snake_case__						:       List[Any]       						=  0, 1
		while True:
				snake_case__						,       snake_case__						:       str       						=  b, a + b
				yield b




def 	_a       (				__lowerCAmelCase		:      int = 10_00     ):

		"""simple docstring"""

		snake_case__						:       Optional[int]       						=  1
		snake_case__						:       Tuple       						=  fibonacci_generator()
		while len(str(next(__lowerCAmelCase     )     )     ) < n:
				answer += 1
		return answer + 1


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



