



'''simple docstring'''

import unittest

from transformers import EsmConfig, is_torch_available
from transformers.testing_utils import TestCasePlus, require_torch, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
	import torch

	from transformers import EsmForMaskedLM, EsmForSequenceClassification, EsmForTokenClassification, EsmModel
	from transformers.models.esm.modeling_esm import (
	    ESM_PRETRAINED_MODEL_ARCHIVE_LIST,
	    EsmEmbeddings,
	    create_position_ids_from_input_ids,
	)


class 						a__  :


	def __init__(self			:			Optional[Any],       __UpperCAmelCase			:			Tuple,       __UpperCAmelCase			:			Optional[int]=13,       __UpperCAmelCase			:			Any=7,       __UpperCAmelCase			:			Optional[Any]=False,       __UpperCAmelCase			:			str=True,       __UpperCAmelCase			:			int=False,       __UpperCAmelCase			:			Optional[int]=True,       __UpperCAmelCase			:			str=33,       __UpperCAmelCase			:			Any=32,       __UpperCAmelCase			:			Union[str, Any]=5,       __UpperCAmelCase			:			Tuple=4,       __UpperCAmelCase			:			List[str]=37,       __UpperCAmelCase			:			Union[str, Any]="gelu",       __UpperCAmelCase			:			List[Any]=0.1,       __UpperCAmelCase			:			Tuple=0.1,       __UpperCAmelCase			:			Any=512,       __UpperCAmelCase			:			List[str]=16,       __UpperCAmelCase			:			Dict=2,       __UpperCAmelCase			:			List[str]=0.02,       __UpperCAmelCase			:			Optional[Any]=3,       __UpperCAmelCase			:			Optional[Any]=4,       __UpperCAmelCase			:			Optional[int]=None,       )  ->      List[str]:

					"""simple docstring"""

					SCREAMING_SNAKE_CASE	:    Optional[Any]          =			parent
					SCREAMING_SNAKE_CASE	:    Dict          =			batch_size
					SCREAMING_SNAKE_CASE	:    Dict          =			seq_length
					SCREAMING_SNAKE_CASE	:    Dict          =			is_training
					SCREAMING_SNAKE_CASE	:    List[str]          =			use_input_mask
					SCREAMING_SNAKE_CASE	:    Optional[Any]          =			use_token_type_ids
					SCREAMING_SNAKE_CASE	:    List[Any]          =			use_labels
					SCREAMING_SNAKE_CASE	:    Any          =			vocab_size
					SCREAMING_SNAKE_CASE	:    List[str]          =			hidden_size
					SCREAMING_SNAKE_CASE	:    Tuple          =			num_hidden_layers
					SCREAMING_SNAKE_CASE	:    Dict          =			num_attention_heads
					SCREAMING_SNAKE_CASE	:    Union[str, Any]          =			intermediate_size
					SCREAMING_SNAKE_CASE	:    Optional[int]          =			hidden_act
					SCREAMING_SNAKE_CASE	:    Union[str, Any]          =			hidden_dropout_prob
					SCREAMING_SNAKE_CASE	:    List[Any]          =			attention_probs_dropout_prob
					SCREAMING_SNAKE_CASE	:    List[Any]          =			max_position_embeddings
					SCREAMING_SNAKE_CASE	:    Tuple          =			type_vocab_size
					SCREAMING_SNAKE_CASE	:    List[str]          =			type_sequence_label_size
					SCREAMING_SNAKE_CASE	:    Dict          =			initializer_range
					SCREAMING_SNAKE_CASE	:    Any          =			num_labels
					SCREAMING_SNAKE_CASE	:    Any          =			num_choices
					SCREAMING_SNAKE_CASE	:    List[str]          =			scope


	def 					lowercase__	(self			:			Any   )  ->      Tuple:

					"""simple docstring"""

					SCREAMING_SNAKE_CASE	:    Optional[Any]          =			ids_tensor([self.batch_size, self.seq_length],       self.vocab_size   )

					SCREAMING_SNAKE_CASE	:    Union[str, Any]          =			None
					if self.use_input_mask:
									SCREAMING_SNAKE_CASE	:    int          =			random_attention_mask([self.batch_size, self.seq_length]   )

					SCREAMING_SNAKE_CASE	:    Any          =			None
					SCREAMING_SNAKE_CASE	:    List[Any]          =			None
					SCREAMING_SNAKE_CASE	:    Optional[int]          =			None
					if self.use_labels:
									SCREAMING_SNAKE_CASE	:    Optional[int]          =			ids_tensor([self.batch_size],       self.type_sequence_label_size   )
									SCREAMING_SNAKE_CASE	:    Any          =			ids_tensor([self.batch_size, self.seq_length],       self.num_labels   )
									SCREAMING_SNAKE_CASE	:    str          =			ids_tensor([self.batch_size],       self.num_choices   )

					SCREAMING_SNAKE_CASE	:    Optional[int]          =			self.get_config()

					return config, input_ids, input_mask, sequence_labels, token_labels, choice_labels


	def 					lowercase__	(self			:			Union[str, Any]   )  ->      Dict:

					"""simple docstring"""

					return EsmConfig(
					    vocab_size=self.vocab_size,       hidden_size=self.hidden_size,       pad_token_id=1,       num_hidden_layers=self.num_hidden_layers,       num_attention_heads=self.num_attention_heads,       intermediate_size=self.intermediate_size,       hidden_act=self.hidden_act,       hidden_dropout_prob=self.hidden_dropout_prob,       attention_probs_dropout_prob=self.attention_probs_dropout_prob,       max_position_embeddings=self.max_position_embeddings,       type_vocab_size=self.type_vocab_size,       initializer_range=self.initializer_range,       )


	def 					lowercase__	(self			:			str,       __UpperCAmelCase			:			Any,       __UpperCAmelCase			:			str,       __UpperCAmelCase			:			Optional[Any],       __UpperCAmelCase			:			Optional[int],       __UpperCAmelCase			:			Tuple,       __UpperCAmelCase			:			Tuple   )  ->      Optional[int]:

					"""simple docstring"""

					SCREAMING_SNAKE_CASE	:    Dict          =			EsmModel(config=lowerCamelCase_   )
					model.to(lowerCamelCase_   )
					model.eval()
					SCREAMING_SNAKE_CASE	:    str          =			model(lowerCamelCase_,       attention_mask=lowerCamelCase_   )
					SCREAMING_SNAKE_CASE	:    Union[str, Any]          =			model(lowerCamelCase_   )
					SCREAMING_SNAKE_CASE	:    Any          =			model(lowerCamelCase_   )

					self.parent.assertEqual(result.last_hidden_state.shape,       (self.batch_size, self.seq_length, self.hidden_size)   )
					self.parent.assertEqual(result.pooler_output.shape,       (self.batch_size, self.hidden_size)   )


	def 					lowercase__	(self			:			Tuple,       __UpperCAmelCase			:			Union[str, Any],       __UpperCAmelCase			:			Dict,       __UpperCAmelCase			:			Union[str, Any],       __UpperCAmelCase			:			Tuple,       __UpperCAmelCase			:			List[str],       __UpperCAmelCase			:			Optional[Any]   )  ->      Any:

					"""simple docstring"""

					SCREAMING_SNAKE_CASE	:    Tuple          =			EsmForMaskedLM(config=lowerCamelCase_   )
					model.to(lowerCamelCase_   )
					model.eval()
					SCREAMING_SNAKE_CASE	:    Optional[Any]          =			model(lowerCamelCase_,       attention_mask=lowerCamelCase_,       labels=lowerCamelCase_   )
					self.parent.assertEqual(result.logits.shape,       (self.batch_size, self.seq_length, self.vocab_size)   )


	def 					lowercase__	(self			:			Dict,       __UpperCAmelCase			:			Any,       __UpperCAmelCase			:			Optional[int],       __UpperCAmelCase			:			Dict,       __UpperCAmelCase			:			Any,       __UpperCAmelCase			:			Any,       __UpperCAmelCase			:			Any   )  ->      Union[str, Any]:

					"""simple docstring"""

					SCREAMING_SNAKE_CASE	:    Tuple          =			self.num_labels
					SCREAMING_SNAKE_CASE	:    Optional[Any]          =			EsmForTokenClassification(config=lowerCamelCase_   )
					model.to(lowerCamelCase_   )
					model.eval()
					SCREAMING_SNAKE_CASE	:    Optional[Any]          =			model(lowerCamelCase_,       attention_mask=lowerCamelCase_,       labels=lowerCamelCase_   )
					self.parent.assertEqual(result.logits.shape,       (self.batch_size, self.seq_length, self.num_labels)   )






	def 					lowercase__	(self			:			List[str]   )  ->      Dict:

					"""simple docstring"""

					SCREAMING_SNAKE_CASE	:    Optional[int]          =			self.prepare_config_and_inputs()
					(
					    (
					    SCREAMING_SNAKE_CASE   
					)       ,       (
					    SCREAMING_SNAKE_CASE   
					)       ,       (
					    SCREAMING_SNAKE_CASE   
					)       ,       (
					    SCREAMING_SNAKE_CASE   
					)       ,       (
					    SCREAMING_SNAKE_CASE   
					)       ,       (
					    SCREAMING_SNAKE_CASE   
					)       ,          
					)	:    Tuple          =			config_and_inputs
					SCREAMING_SNAKE_CASE	:    Optional[Any]          =			{'''input_ids''': input_ids, '''attention_mask''': input_mask}
					return config, inputs_dict



@require_torch
class 						a__  (					a__,      a__,      unittest.TestCase						):
	__magic_name__		:     Optional[Any]						     =  False

	__magic_name__		:     Optional[Any]						     =  (
	    (
	        EsmForMaskedLM,
	        EsmModel,
	        EsmForSequenceClassification,
	        EsmForTokenClassification,
	    )
	    if is_torch_available()
	    else ()
	)
	__magic_name__		:     int						     =  ()
	__magic_name__		:     Optional[int]						     =  (
	    {
	        "feature-extraction": EsmModel,
	        "fill-mask": EsmForMaskedLM,
	        "text-classification": EsmForSequenceClassification,
	        "token-classification": EsmForTokenClassification,
	        "zero-shot": EsmForSequenceClassification,
	    }
	    if is_torch_available()
	    else {}
	)
	__magic_name__		:     Tuple						     =  True


	def 					lowercase__	(self			:			Optional[Any]   )  ->      Any:

					"""simple docstring"""

					SCREAMING_SNAKE_CASE	:    Any          =			EsmModelTester(self   )
					SCREAMING_SNAKE_CASE	:    List[Any]          =			ConfigTester(self,       config_class=lowerCamelCase_,       hidden_size=37   )


	def 					lowercase__	(self			:			int   )  ->      Dict:

					"""simple docstring"""

					self.config_tester.run_common_tests()


	def 					lowercase__	(self			:			Dict   )  ->      Optional[Any]:

					"""simple docstring"""

					SCREAMING_SNAKE_CASE	:    int          =			self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_model(*lowerCamelCase_   )


	def 					lowercase__	(self			:			int   )  ->      Dict:

					"""simple docstring"""

					SCREAMING_SNAKE_CASE	:    Union[str, Any]          =			self.model_tester.prepare_config_and_inputs()
					for type in ["absolute", "relative_key", "relative_key_query"]:
									SCREAMING_SNAKE_CASE	:    Union[str, Any]          =			type
									self.model_tester.create_and_check_model(*lowerCamelCase_   )


	def 					lowercase__	(self			:			Dict   )  ->      Optional[int]:

					"""simple docstring"""

					SCREAMING_SNAKE_CASE	:    List[Any]          =			self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_for_masked_lm(*lowerCamelCase_   )


	def 					lowercase__	(self			:			Optional[int]   )  ->      Tuple:

					"""simple docstring"""

					SCREAMING_SNAKE_CASE	:    Tuple          =			self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_for_token_classification(*lowerCamelCase_   )


	@slow
	def 					lowercase__	(self			:			int   )  ->      Dict:

					"""simple docstring"""

					for model_name in ESM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
									SCREAMING_SNAKE_CASE	:    str          =			EsmModel.from_pretrained(lowerCamelCase_   )
									self.assertIsNotNone(lowerCamelCase_   )


	def 					lowercase__	(self			:			Optional[int]   )  ->      Optional[Any]:

					"""simple docstring"""

					SCREAMING_SNAKE_CASE	:    Tuple          =			self.model_tester.prepare_config_and_inputs()[0]
					SCREAMING_SNAKE_CASE	:    Optional[Any]          =			EsmEmbeddings(config=lowerCamelCase_   )

					SCREAMING_SNAKE_CASE	:    Optional[Any]          =			torch.as_tensor([[12, 31, 13, model.padding_idx]]   )
					SCREAMING_SNAKE_CASE	:    Optional[int]          =			torch.as_tensor(
					    [
					        [
					            0 + model.padding_idx + 1,
					            1 + model.padding_idx + 1,
					            2 + model.padding_idx + 1,
					            model.padding_idx,
					        ]
					    ]   )
					SCREAMING_SNAKE_CASE	:    Optional[int]          =			create_position_ids_from_input_ids(lowerCamelCase_,       model.padding_idx   )
					self.assertEqual(position_ids.shape,       expected_positions.shape   )
					self.assertTrue(torch.all(torch.eq(lowerCamelCase_,       lowerCamelCase_   )   )   )


	def 					lowercase__	(self			:			int   )  ->      List[str]:

					"""simple docstring"""

					SCREAMING_SNAKE_CASE	:    Tuple          =			self.model_tester.prepare_config_and_inputs()[0]
					SCREAMING_SNAKE_CASE	:    Dict          =			EsmEmbeddings(config=lowerCamelCase_   )

					SCREAMING_SNAKE_CASE	:    Optional[Any]          =			torch.empty(2,       4,       30   )
					SCREAMING_SNAKE_CASE	:    Optional[int]          =			[
					    0 + embeddings.padding_idx + 1,
					    1 + embeddings.padding_idx + 1,
					    2 + embeddings.padding_idx + 1,
					    3 + embeddings.padding_idx + 1,
					]
					SCREAMING_SNAKE_CASE	:    int          =			torch.as_tensor([expected_single_positions, expected_single_positions]   )
					SCREAMING_SNAKE_CASE	:    Union[str, Any]          =			embeddings.create_position_ids_from_inputs_embeds(lowerCamelCase_   )
					self.assertEqual(position_ids.shape,       expected_positions.shape   )
					self.assertTrue(torch.all(torch.eq(lowerCamelCase_,       lowerCamelCase_   )   )   )


	@unittest.skip('''Esm does not support embedding resizing'''   )
	def 					lowercase__	(self			:			int   )  ->      Optional[Any]:

					"""simple docstring"""

					pass


	@unittest.skip('''Esm does not support embedding resizing'''   )
	def 					lowercase__	(self			:			List[Any]   )  ->      List[Any]:

					"""simple docstring"""

					pass






	@unittest.skip('''Will be fixed soon by reducing the size of the model used for common tests.'''   )
	def 					lowercase__	(self			:			Any   )  ->      List[Any]:

					"""simple docstring"""

					pass



@require_torch
class 						a__  (					a__						):


	@slow
	def 					lowercase__	(self			:			Any   )  ->      Any:

					"""simple docstring"""

					with torch.no_grad():
									SCREAMING_SNAKE_CASE	:    Any          =			EsmForMaskedLM.from_pretrained('''facebook/esm2_t6_8M_UR50D'''   )
									model.eval()
									SCREAMING_SNAKE_CASE	:    List[str]          =			torch.tensor([[0, 1, 2, 3, 4, 5]]   )
									SCREAMING_SNAKE_CASE	:    Union[str, Any]          =			model(lowerCamelCase_   )[0]

									SCREAMING_SNAKE_CASE	:    Optional[int]          =			33

									SCREAMING_SNAKE_CASE	:    str          =			torch.Size((1, 6, vocab_size)   )
									self.assertEqual(output.shape,       lowerCamelCase_   )

									SCREAMING_SNAKE_CASE	:    Dict          =			torch.tensor(
									    [[[8.9215, -10.5898, -6.4671], [-6.3967, -13.9114, -1.1212], [-7.7812, -13.9516, -3.7406]]]   )
									self.assertTrue(torch.allclose(output[:, :3, :3],       lowerCamelCase_,       atol=1e-4   )   )






	@slow
	def 					lowercase__	(self			:			List[str]   )  ->      List[str]:

					"""simple docstring"""

					with torch.no_grad():
									SCREAMING_SNAKE_CASE	:    Any          =			EsmModel.from_pretrained('''facebook/esm2_t6_8M_UR50D'''   )
									model.eval()

									SCREAMING_SNAKE_CASE	:    Tuple          =			torch.tensor([[0, 6, 4, 13, 5, 4, 16, 12, 11, 7, 2]]   )
									SCREAMING_SNAKE_CASE	:    List[str]          =			model(lowerCamelCase_   )[0]
									# compare the actual values for a slice.
									SCREAMING_SNAKE_CASE	:    Optional[Any]          =			torch.tensor(
									    [[[0.1444, 0.5413, 0.3248], [0.3034, 0.0053, 0.3108], [0.3228, -0.2499, 0.3415]]]   )
									self.assertTrue(torch.allclose(output[:, :3, :3],       lowerCamelCase_,       atol=1e-4   )   )








'''simple docstring'''






def    _snake_case  (	A			)		->       int:
							if n == 1 or not isinstance(A					,       A			):
														return 0
							elif n == 2:
														return 1
							else:
														lowerCAmelCase__			  =      [0, 1]
														for i in range(2					,       n + 1			):
																					sequence.append(sequence[i - 1] + sequence[i - 2]			)

														return sequence[n]


def    _snake_case  (	A			)		->       int:
							lowerCAmelCase__			  =      0
							lowerCAmelCase__			  =      2

							while digits < n:
														index += 1
														lowerCAmelCase__			  =      len(str(fibonacci(A			)			)			)

							return index


def    _snake_case  (	A = 1000			)		->       int:
							return fibonacci_digits_index(A			)


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