




'''simple docstring'''

from pathlib import Path
from typing import List

from transformers import is_torch_available, is_vision_available
from transformers.testing_utils import get_tests_dir, is_tool_test
from transformers.tools.agent_types import AGENT_TYPE_MAPPING, AgentAudio, AgentImage, AgentText


if is_torch_available():
							import torch

if is_vision_available():
							from PIL import Image


a    :							Union[str, Any]										=    ['text', 'image', 'audio']


def 						__magic_name__       (      __UpperCAmelCase      )						->   Dict:

					'''simple docstring'''

					snake_case_		     =							[]

					for input_type in input_types:
										if input_type == "text":
															inputs.append('''Text input'''      )
										elif input_type == "image":
															inputs.append(
															    Image.open(Path(get_tests_dir('''fixtures/tests_samples/COCO'''      )      ) / '''000000039769.png'''      ).resize((512, 512)      )      )
										elif input_type == "audio":
															inputs.append(torch.ones(3000      )      )
										elif isinstance(__UpperCAmelCase, __UpperCAmelCase      ):
															inputs.append(create_inputs(__UpperCAmelCase      )      )
										else:
															raise ValueError(F"Invalid type requested: {input_type}"      )

					return inputs


def 						__magic_name__       (      __UpperCAmelCase      )						->   Tuple:

					'''simple docstring'''

					snake_case_		     =							[]

					for output in outputs:
										if isinstance(__UpperCAmelCase, (str, AgentText)      ):
															output_types.append('''text'''      )
										elif isinstance(__UpperCAmelCase, (Image.Image, AgentImage)      ):
															output_types.append('''image'''      )
										elif isinstance(__UpperCAmelCase, (torch.Tensor, AgentAudio)      ):
															output_types.append('''audio'''      )
										else:
															raise ValueError(F"Invalid output: {output}"      )

					return output_types






@is_tool_test
class 		a							:


				def     A_					(						self       :   List[Any]   ):
									self.assertTrue(hasattr(self.tool			,							'''inputs'''   )   )
									self.assertTrue(hasattr(self.tool			,							'''outputs'''   )   )

									snake_case_		     =							self.tool.inputs
									for _input in inputs:
														if isinstance(_input			,							lowercase_   ):
																			for __input in _input:
																								self.assertTrue(__input in authorized_types   )
														else:
																			self.assertTrue(_input in authorized_types   )

									snake_case_		     =							self.tool.outputs
									for _output in outputs:
														self.assertTrue(_output in authorized_types   )


				def     A_					(						self       :   int   ):
									snake_case_		     =							create_inputs(self.tool.inputs   )
									snake_case_		     =							self.tool(*lowercase_   )

									# There is a single output
									if len(self.tool.outputs   ) == 1:
														snake_case_		     =							[outputs]

									self.assertListEqual(output_types(lowercase_   )			,							self.tool.outputs   )


				def     A_					(						self       :   Tuple   ):
									self.assertTrue(hasattr(self.tool			,							'''description'''   )   )
									self.assertTrue(hasattr(self.tool			,							'''default_checkpoint'''   )   )
									self.assertTrue(self.tool.description.startswith('''This is a tool that'''   )   )


				def     A_					(						self       :   List[Any]   ):
									snake_case_		     =							create_inputs(self.tool.inputs   )
									snake_case_		     =							self.tool(*lowercase_   )

									if not isinstance(lowercase_			,							lowercase_   ):
														snake_case_		     =							[outputs]

									self.assertEqual(len(lowercase_   )			,							len(self.tool.outputs   )   )

									for output, output_type in zip(lowercase_			,							self.tool.outputs   ):
														snake_case_		     =							AGENT_TYPE_MAPPING[output_type]
														self.assertTrue(isinstance(lowercase_			,							lowercase_   )   )


				def     A_					(						self       :   int   ):
									snake_case_		     =							create_inputs(self.tool.inputs   )

									snake_case_		     =							[]

									for _input, input_type in zip(lowercase_			,							self.tool.inputs   ):
														if isinstance(lowercase_			,							lowercase_   ):
																			_inputs.append([AGENT_TYPE_MAPPING[_input_type](_input   ) for _input_type in input_type]   )
														else:
																			_inputs.append(AGENT_TYPE_MAPPING[input_type](_input   )   )

        # Should not raise an error
									snake_case_		     =							self.tool(*lowercase_   )

									if not isinstance(lowercase_			,							lowercase_   ):
														snake_case_		     =							[outputs]

									self.assertEqual(len(lowercase_   )			,							len(self.tool.outputs   )   )







'''simple docstring'''

from collections.abc import Generator


def 						__magic_name__       (      )						->   Generator[int, None, None]:

					'''simple docstring'''

					snake_case_     ,snake_case_		     =							0, 1
					while True:
										snake_case_     ,snake_case_		     =							b, a + b
										yield b


def 						__magic_name__       (      __UpperCAmelCase = 1000      )						->   int:

					'''simple docstring'''

					snake_case_		     =							1
					snake_case_		     =							fibonacci_generator()
					while len(str(next(__UpperCAmelCase      )      )      ) < n:
										answer += 1
					return answer + 1


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

