
"""simple docstring"""





import inspect
import unittest

from transformers import DecisionTransformerConfig, is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device

from ...generation.test_utils import GenerationTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
							import torch

							from transformers import DecisionTransformerModel
							from transformers.models.decision_transformer.modeling_decision_transformer import (
							    DECISION_TRANSFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
							)
class 						SCREAMING_SNAKE_CASE_ :




		"""simple docstring"""





		def __init__(     self							,  lowerCAmelCase__							,  lowerCAmelCase__=1_3							,  lowerCAmelCase__=7							,  lowerCAmelCase__=6							,  lowerCAmelCase__=1_7							,  lowerCAmelCase__=2_3							,  lowerCAmelCase__=1_1							,  lowerCAmelCase__=True							,  ):
				__SCREAMING_SNAKE_CASE            = parent
				__SCREAMING_SNAKE_CASE            = batch_size
				__SCREAMING_SNAKE_CASE            = seq_length
				__SCREAMING_SNAKE_CASE            = act_dim
				__SCREAMING_SNAKE_CASE            = state_dim
				__SCREAMING_SNAKE_CASE            = hidden_size
				__SCREAMING_SNAKE_CASE            = max_length
				__SCREAMING_SNAKE_CASE            = is_training




		def 	snake_case_     (     self):
				__SCREAMING_SNAKE_CASE            = floats_tensor((self.batch_size, self.seq_length, self.state_dim))
				__SCREAMING_SNAKE_CASE            = floats_tensor((self.batch_size, self.seq_length, self.act_dim))
				__SCREAMING_SNAKE_CASE            = floats_tensor((self.batch_size, self.seq_length, 1))
				__SCREAMING_SNAKE_CASE            = floats_tensor((self.batch_size, self.seq_length, 1))
				__SCREAMING_SNAKE_CASE            = ids_tensor((self.batch_size, self.seq_length)							,  vocab_size=1_0_0_0)
				__SCREAMING_SNAKE_CASE            = random_attention_mask((self.batch_size, self.seq_length))

				__SCREAMING_SNAKE_CASE            = self.get_config()

				return (
				    config,
				    states,
				    actions,
				    rewards,
				    returns_to_go,
				    timesteps,
				    attention_mask,
				)




		def 	snake_case_     (     self):
				return DecisionTransformerConfig(
				    batch_size=self.batch_size							,  seq_length=self.seq_length							,  act_dim=self.act_dim							,  state_dim=self.state_dim							,  hidden_size=self.hidden_size							,  max_length=self.max_length							,  )




		def 	snake_case_     (     self							,  lowerCAmelCase__							,  lowerCAmelCase__							,  lowerCAmelCase__							,  lowerCAmelCase__							,  lowerCAmelCase__							,  lowerCAmelCase__							,  lowerCAmelCase__							,  ):
				__SCREAMING_SNAKE_CASE            = DecisionTransformerModel(config=lowerCAmelCase__)
				model.to(lowerCAmelCase__)
				model.eval()
				__SCREAMING_SNAKE_CASE            = model(lowerCAmelCase__							,  lowerCAmelCase__							,  lowerCAmelCase__							,  lowerCAmelCase__							,  lowerCAmelCase__							,  lowerCAmelCase__)

				self.parent.assertEqual(result.state_preds.shape							,  states.shape)
				self.parent.assertEqual(result.action_preds.shape							,  actions.shape)
				self.parent.assertEqual(result.return_preds.shape							,  returns_to_go.shape)
				self.parent.assertEqual(
				    result.last_hidden_state.shape							,  (self.batch_size, self.seq_length * 3, self.hidden_size))  # seq length *3 as there are 3 modelities: states, returns and actions




		def 	snake_case_     (     self):
				__SCREAMING_SNAKE_CASE            = self.prepare_config_and_inputs()
				(
				    (
				    __SCREAMING_SNAKE_CASE
				)       ,(
				    __SCREAMING_SNAKE_CASE
				)       ,(
				    __SCREAMING_SNAKE_CASE
				)       ,(
				    __SCREAMING_SNAKE_CASE
				)       ,(
				    __SCREAMING_SNAKE_CASE
				)       ,(
				    __SCREAMING_SNAKE_CASE
				)       ,(
				    __SCREAMING_SNAKE_CASE
				)       ,
				)            = config_and_inputs
				__SCREAMING_SNAKE_CASE            = {
				    """states""": states,
				    """actions""": actions,
				    """rewards""": rewards,
				    """returns_to_go""": returns_to_go,
				    """timesteps""": timesteps,
				    """attention_mask""": attention_mask,
				}
				return config, inputs_dict



@require_torch
class 						SCREAMING_SNAKE_CASE_ (						__a     ,				__a     ,				__a     ,				unittest.TestCase ):




		"""simple docstring"""





		__lowercase							:  Any						   =		(DecisionTransformerModel,) if is_torch_available() else ()
		__lowercase							:  List[str]						   =		()
		__lowercase							:  str						   =		{'''feature-extraction''': DecisionTransformerModel} if is_torch_available() else {}

		# Ignoring of a failing test from GenerationTesterMixin, as the model does not use inputs_ids
		__lowercase							:  Dict						   =		False

		# Ignoring of a failing tests from ModelTesterMixin, as the model does not implement these features
		__lowercase							:  Tuple						   =		False
		__lowercase							:  Optional[int]						   =		False
		__lowercase							:  str						   =		False
		__lowercase							:  str						   =		False
		__lowercase							:  Any						   =		False
		__lowercase							:  Union[str, Any]						   =		False
		__lowercase							:  str						   =		False
		__lowercase							:  Union[str, Any]						   =		False
		__lowercase							:  int						   =		False




		def 	snake_case_     (     self):
				__SCREAMING_SNAKE_CASE            = DecisionTransformerModelTester(self)
				__SCREAMING_SNAKE_CASE            = ConfigTester(self							,  config_class=lowerCAmelCase__							,  hidden_size=3_7)




		def 	snake_case_     (     self):
				self.config_tester.run_common_tests()




		def 	snake_case_     (     self):
				__SCREAMING_SNAKE_CASE            = self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_model(*lowerCAmelCase__)




		@slow
		def 	snake_case_     (     self):
				for model_name in DECISION_TRANSFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
						__SCREAMING_SNAKE_CASE            = DecisionTransformerModel.from_pretrained(lowerCAmelCase__)
						self.assertIsNotNone(lowerCAmelCase__)




		def 	snake_case_     (     self):
				__SCREAMING_SNAKE_CASE       ,__SCREAMING_SNAKE_CASE            = self.model_tester.prepare_config_and_inputs_for_common()

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

						__SCREAMING_SNAKE_CASE            = [
						    """states""",
						    """actions""",
						    """rewards""",
						    """returns_to_go""",
						    """timesteps""",
						    """attention_mask""",
						]

						self.assertListEqual(arg_names[: len(lowerCAmelCase__)]							,  lowerCAmelCase__)



@require_torch
class 						SCREAMING_SNAKE_CASE_ (						unittest.TestCase ):




		"""simple docstring"""





		@slow
		def 	snake_case_     (     self):
				__SCREAMING_SNAKE_CASE            = 2  # number of steps of autoregressive prediction we will perform
				__SCREAMING_SNAKE_CASE            = 1_0  # defined by the RL environment, may be normalized
				__SCREAMING_SNAKE_CASE            = DecisionTransformerModel.from_pretrained("""edbeeching/decision-transformer-gym-hopper-expert""")
				__SCREAMING_SNAKE_CASE            = model.to(lowerCAmelCase__)
				__SCREAMING_SNAKE_CASE            = model.config
				torch.manual_seed(0)
				__SCREAMING_SNAKE_CASE            = torch.randn(1							,  1							,  config.state_dim).to(device=lowerCAmelCase__							,  dtype=torch.floataa)  # env.reset()

				__SCREAMING_SNAKE_CASE            = torch.tensor(
				    [[0.24_27_93, -0.28_69_30_74, 0.8_74_26_13], [0.67_81_52_74, -0.08_10_10_85, -0.12_95_21_47]]							,  device=lowerCAmelCase__)

				__SCREAMING_SNAKE_CASE            = torch.tensor(lowerCAmelCase__							,  device=lowerCAmelCase__							,  dtype=torch.floataa).reshape(1							,  1							,  1)
				__SCREAMING_SNAKE_CASE            = state
				__SCREAMING_SNAKE_CASE            = torch.zeros(1							,  0							,  config.act_dim							,  device=lowerCAmelCase__							,  dtype=torch.floataa)
				__SCREAMING_SNAKE_CASE            = torch.zeros(1							,  0							,  device=lowerCAmelCase__							,  dtype=torch.floataa)
				__SCREAMING_SNAKE_CASE            = torch.tensor(0							,  device=lowerCAmelCase__							,  dtype=torch.long).reshape(1							,  1)

				for step in range(lowerCAmelCase__):
						__SCREAMING_SNAKE_CASE            = torch.cat([actions, torch.zeros(1							,  1							,  config.act_dim							,  device=lowerCAmelCase__)]							,  dim=1)
						__SCREAMING_SNAKE_CASE            = torch.cat([rewards, torch.zeros(1							,  1							,  device=lowerCAmelCase__)]							,  dim=1)

						__SCREAMING_SNAKE_CASE            = torch.ones(1							,  states.shape[1]).to(dtype=torch.long							,  device=states.device)

						with torch.no_grad():
								__SCREAMING_SNAKE_CASE       ,__SCREAMING_SNAKE_CASE       ,__SCREAMING_SNAKE_CASE            = model(
								    states=lowerCAmelCase__							,  actions=lowerCAmelCase__							,  rewards=lowerCAmelCase__							,  returns_to_go=lowerCAmelCase__							,  timesteps=lowerCAmelCase__							,  attention_mask=lowerCAmelCase__							,  return_dict=lowerCAmelCase__							,  )

						self.assertEqual(action_pred.shape							,  actions.shape)
						self.assertTrue(torch.allclose(action_pred[0, -1]							,  expected_outputs[step]							,  atol=1E-4))
						__SCREAMING_SNAKE_CASE       ,__SCREAMING_SNAKE_CASE       ,__SCREAMING_SNAKE_CASE       ,__SCREAMING_SNAKE_CASE            = (  # env.step(action)
						    torch.randn(1							,  1							,  config.state_dim).to(device=lowerCAmelCase__							,  dtype=torch.floataa),
						    1.0,
						    False,
						    {},
						)

						__SCREAMING_SNAKE_CASE            = action_pred[0, -1]
						__SCREAMING_SNAKE_CASE            = torch.cat([states, state]							,  dim=1)
						__SCREAMING_SNAKE_CASE            = returns_to_go[0, -1] - reward
						__SCREAMING_SNAKE_CASE            = torch.cat([returns_to_go, pred_return.reshape(1							,  1							,  1)]							,  dim=1)
						__SCREAMING_SNAKE_CASE            = torch.cat(
						    [timesteps, torch.ones((1, 1)							,  device=lowerCAmelCase__							,  dtype=torch.long) * (step + 1)]							,  dim=1)












"""simple docstring"""



def 						lowercase    (				__snake_case				: int	):
		if n == 1 or not isinstance(__snake_case		,					__snake_case	):
				return 0
		elif n == 2:
				return 1
		else:
				lowercase_ : Dict							       =   [0, 1]
				for i in range(2		,					n + 1	):
						sequence.append(sequence[i - 1] + sequence[i - 2]	)

				return sequence[n]



def 						lowercase    (				__snake_case				: int	):
		lowercase_ : str							       =   0
		lowercase_ : List[str]							       =   2

		while digits < n:
				index += 1
				lowercase_ : Any							       =   len(str(fibonacci(__snake_case	)	)	)

		return index



def 						lowercase    (				__snake_case				: int = 1_0_0_0	):
		return fibonacci_digits_index(__snake_case	)


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



