





import random
import timeit
from functools import wraps
from typing import Callable, Optional

from ..configuration_utils import PretrainedConfig
from ..models.auto.modeling_tf_auto import TF_MODEL_MAPPING, TF_MODEL_WITH_LM_HEAD_MAPPING
from ..utils import is_pyanvml_available, is_tf_available, logging
from .benchmark_utils import (
    Benchmark,
    Memory,
    MemorySummary,
    measure_peak_memory_cpu,
    start_memory_tracing,
    stop_memory_tracing,
)


if is_tf_available():
							import tensorflow as tf
							from tensorflow.python.framework.errors_impl import ResourceExhaustedError

							from .benchmark_args_tf import TensorFlowBenchmarkArguments

if is_pyanvml_available():
							import pyanvml.pyanvml as nvml

UpperCAmelCase_							=				logging.get_logger(__name__)





def  __magic_name__  (				lowercase				,       lowercase				)				-> int:

							"""simple docstring"""



							def run_func(lowercase				):
														@wraps(lowercase				)
														def run_in_eager_mode(*lowercase				,       **lowercase				):
																					return func(*lowercase				,       **lowercase				)

														@wraps(lowercase				)
														@tf.function(experimental_compile=lowercase				)
														def run_in_graph_mode(*lowercase				,       **lowercase				):
																					return func(*lowercase				,       **lowercase				)

														if do_eager_mode is True:
																					if use_xla is not False:
																												raise ValueError(
																												    """Cannot run model in XLA, if `args.eager_mode` is set to `True`. Please set `args.eager_mode=False`."""				)
																					return run_in_eager_mode
														else:
																					return run_in_graph_mode

							return run_func





def  __magic_name__  (				lowercase				,       lowercase				,       lowercase				)				-> ["tf.Tensor"]:

							"""simple docstring"""



							lowercase_	:   Optional[int]  				=     random.Random()
							lowercase_	:   Optional[Any]  				=     [rng.randint(0				,       vocab_size - 1				) for i in range(batch_size * sequence_length				)]
							return tf.constant(lowercase				,       shape=(batch_size, sequence_length)				,       dtype=tf.intaa				)




class     UpperCamelCase__					(     lowerCamelCase__				):






		'''simple docstring'''






		__a       :       TensorFlowBenchmarkArguments
		__a       :       PretrainedConfig
		__a       :       str       =	"TensorFlow"






		@property
		def 						snake_case__				(							self  )       -> Union[str, Any]:






									"""simple docstring"""
									return tf.__version__






		def 						snake_case__				(							self,   snake_case__,   snake_case__,   snake_case__  )       -> float:






									"""simple docstring"""
									# initialize GPU on separate process
									lowercase_	:   Dict  				=     self.args.strategy
									if strategy is None:
																raise ValueError("""A device strategy has to be initialized before using TensorFlow."""  )
									lowercase_	:   Optional[Any]  				=     self._prepare_inference_func(snake_case__,   snake_case__,   snake_case__  )
									return self._measure_speed(_inference  )






		def 						snake_case__				(							self,   snake_case__,   snake_case__,   snake_case__  )       -> float:






									"""simple docstring"""
									lowercase_	:   str  				=     self.args.strategy
									if strategy is None:
																raise ValueError("""A device strategy has to be initialized before using TensorFlow."""  )
									lowercase_	:   str  				=     self._prepare_train_func(snake_case__,   snake_case__,   snake_case__  )
									return self._measure_speed(_train  )






		def 						snake_case__				(							self,   snake_case__,   snake_case__,   snake_case__  )       -> [Memory, Optional[MemorySummary]]:






									"""simple docstring"""
									# initialize GPU on separate process
									if self.args.is_gpu:
																tf.config.experimental.set_memory_growth(self.args.gpu_list[self.args.device_idx],   snake_case__  )
									lowercase_	:   Optional[int]  				=     self.args.strategy
									if strategy is None:
																raise ValueError("""A device strategy has to be initialized before using TensorFlow."""  )
									lowercase_	:   List[Any]  				=     self._prepare_inference_func(snake_case__,   snake_case__,   snake_case__  )
									return self._measure_memory(_inference  )






		def 						snake_case__				(							self,   snake_case__,   snake_case__,   snake_case__  )       -> [Memory, Optional[MemorySummary]]:






									"""simple docstring"""
									if self.args.is_gpu:
																tf.config.experimental.set_memory_growth(self.args.gpu_list[self.args.device_idx],   snake_case__  )
									lowercase_	:   List[Any]  				=     self.args.strategy
									if strategy is None:
																raise ValueError("""A device strategy has to be initialized before using TensorFlow."""  )

									lowercase_	:   Optional[int]  				=     self._prepare_train_func(snake_case__,   snake_case__,   snake_case__  )
									return self._measure_memory(_train  )






		def 						snake_case__				(							self,   snake_case__,   snake_case__,   snake_case__  )       -> Callable[[], None]:






									"""simple docstring"""
									lowercase_	:   Dict  				=     self.config_dict[model_name]

									if self.args.fpaa:
																raise NotImplementedError("""Mixed precision is currently not supported."""  )

									lowercase_	:   str  				=     (
									    hasattr(snake_case__,   """architectures"""  )
									    and isinstance(config.architectures,   snake_case__  )
									    and len(config.architectures  ) > 0
									)
									if not self.args.only_pretrain_model and has_model_class_in_config:
																try:
																							lowercase_	:   List[str]  				=     """TF""" + config.architectures[0]  # prepend 'TF' for tensorflow model
																							lowercase_	:   Any  				=     __import__("""transformers""",   fromlist=[model_class]  )
																							lowercase_	:   Union[str, Any]  				=     getattr(snake_case__,   snake_case__  )
																							lowercase_	:   Union[str, Any]  				=     model_cls(snake_case__  )
																except ImportError:
																							raise ImportError(
																							    f"""{model_class} does not exist. If you just want to test the pretrained model, you might want to"""
																							    """ set `--only_pretrain_model` or `args.only_pretrain_model=True`."""  )
									else:
																lowercase_	:   Union[str, Any]  				=     TF_MODEL_MAPPING[config.__class__](snake_case__  )

									# encoder-decoder has vocab size saved differently
									lowercase_	:   Tuple  				=     config.vocab_size if hasattr(snake_case__,   """vocab_size"""  ) else config.encoder.vocab_size
									lowercase_	:   List[str]  				=     random_input_ids(snake_case__,   snake_case__,   snake_case__  )

									@run_with_tf_optimizations(self.args.eager_mode,   self.args.use_xla  )
									def encoder_decoder_forward():
																return model(snake_case__,   decoder_input_ids=snake_case__,   training=snake_case__  )

									@run_with_tf_optimizations(self.args.eager_mode,   self.args.use_xla  )
									def encoder_forward():
																return model(snake_case__,   training=snake_case__  )

									lowercase_	:   Union[str, Any]  				=     encoder_decoder_forward if config.is_encoder_decoder else encoder_forward

									return _inference






		def 						snake_case__				(							self,   snake_case__,   snake_case__,   snake_case__  )       -> Callable[[], None]:






									"""simple docstring"""
									lowercase_	:   Optional[int]  				=     self.config_dict[model_name]

									if self.args.eager_mode is not False:
																raise ValueError("""Training cannot be done in eager mode. Please make sure that `args.eager_mode = False`."""  )

									if self.args.fpaa:
																raise NotImplementedError("""Mixed precision is currently not supported."""  )

									lowercase_	:   Optional[Any]  				=     (
									    hasattr(snake_case__,   """architectures"""  )
									    and isinstance(config.architectures,   snake_case__  )
									    and len(config.architectures  ) > 0
									)
									if not self.args.only_pretrain_model and has_model_class_in_config:
																try:
																							lowercase_	:   List[str]  				=     """TF""" + config.architectures[0]  # prepend 'TF' for tensorflow model
																							lowercase_	:   Optional[Any]  				=     __import__("""transformers""",   fromlist=[model_class]  )
																							lowercase_	:   List[Any]  				=     getattr(snake_case__,   snake_case__  )
																							lowercase_	:   Dict  				=     model_cls(snake_case__  )
																except ImportError:
																							raise ImportError(
																							    f"""{model_class} does not exist. If you just want to test the pretrained model, you might want to"""
																							    """ set `--only_pretrain_model` or `args.only_pretrain_model=True`."""  )
									else:
																lowercase_	:   Tuple  				=     TF_MODEL_WITH_LM_HEAD_MAPPING[config.__class__](snake_case__  )

									# encoder-decoder has vocab size saved differently
									lowercase_	:   str  				=     config.vocab_size if hasattr(snake_case__,   """vocab_size"""  ) else config.encoder.vocab_size
									lowercase_	:   List[Any]  				=     random_input_ids(snake_case__,   snake_case__,   snake_case__  )

									@run_with_tf_optimizations(self.args.eager_mode,   self.args.use_xla  )
									def encoder_decoder_train():
																lowercase_	:   Any  				=     model(snake_case__,   decoder_input_ids=snake_case__,   labels=snake_case__,   training=snake_case__  )[0]
																lowercase_	:   List[Any]  				=     tf.gradients(snake_case__,   model.trainable_variables  )
																return gradients

									@run_with_tf_optimizations(self.args.eager_mode,   self.args.use_xla  )
									def encoder_train():
																lowercase_	:   Union[str, Any]  				=     model(snake_case__,   labels=snake_case__,   training=snake_case__  )[0]
																lowercase_	:   Any  				=     tf.gradients(snake_case__,   model.trainable_variables  )
																return gradients

									lowercase_	:   str  				=     encoder_decoder_train if config.is_encoder_decoder else encoder_train

									return _train






		def 						snake_case__				(							self,   snake_case__  )       -> float:






									"""simple docstring"""
									with self.args.strategy.scope():
																try:
																							if self.args.is_tpu or self.args.use_xla:
																														# run additional 10 times to stabilize compilation for tpu
																														logger.info("""Do inference on TPU. Running model 5 times to stabilize compilation"""  )
																														timeit.repeat(snake_case__,   repeat=1,   number=5  )

																							# as written in https://docs.python.org/2/library/timeit.html#timeit.Timer.repeat, min should be taken rather than the average
																							lowercase_	:   Optional[int]  				=     timeit.repeat(
																							    snake_case__,   repeat=self.args.repeat,   number=10,   )

																							return min(snake_case__  ) / 10.0
																except ResourceExhaustedError as e:
																							self.print_fn(f"""Doesn't fit on GPU. {e}"""  )






		def 						snake_case__				(							self,   snake_case__  )       -> [Memory, MemorySummary]:






									"""simple docstring"""
									logger.info(
									    """Note that TensorFlow allocates more memory than """
									    """it might need to speed up computation. """
									    """The memory reported here corresponds to the memory """
									    """reported by `nvidia-smi`, which can vary depending """
									    """on total available memory on the GPU that is used."""  )
									with self.args.strategy.scope():
																try:
																							if self.args.trace_memory_line_by_line:
																														if not self.args.eager_mode:
																																					raise ValueError(
																																					    """`args.eager_mode` is set to `False`. Make sure to run model in eager mode to measure memory"""
																																					    """ consumption line by line."""  )
																														lowercase_	:   Union[str, Any]  				=     start_memory_tracing("""transformers"""  )

																							if self.args.is_tpu:
																														# tpu
																														raise NotImplementedError(
																														    """Memory Benchmarking is currently not implemented for TPU. Please disable memory benchmarking"""
																														    """ with `args.memory=False`"""  )
																							elif self.args.is_gpu:
																														# gpu
																														if not is_pyanvml_available():
																																					logger.warning(
																																					    """py3nvml not installed, we won't log GPU memory usage. """
																																					    """Install py3nvml (pip install py3nvml) to log information about GPU."""  )
																																					lowercase_	:   int  				=     """N/A"""
																														else:
																																					logger.info(
																																					    """Measuring total GPU usage on GPU device. Make sure to not have additional processes"""
																																					    """ running on the same GPU."""  )
																																					# init nvml
																																					nvml.nvmlInit()
																																					func()
																																					lowercase_	:   Dict  				=     nvml.nvmlDeviceGetHandleByIndex(self.args.device_idx  )
																																					lowercase_	:   Optional[Any]  				=     nvml.nvmlDeviceGetMemoryInfo(snake_case__  )
																																					lowercase_	:   List[str]  				=     meminfo.used
																																					lowercase_	:   List[Any]  				=     Memory(snake_case__  )
																																					# shutdown nvml
																																					nvml.nvmlShutdown()
																							else:
																														# cpu
																														if self.args.trace_memory_line_by_line:
																																					logger.info(
																																					    """When enabling line by line tracing, the max peak memory for CPU is inaccurate in"""
																																					    """ TensorFlow."""  )
																																					lowercase_	:   List[str]  				=     None
																														else:
																																					lowercase_	:   Dict  				=     measure_peak_memory_cpu(snake_case__  )
																																					lowercase_	:   List[Any]  				=     Memory(snake_case__  ) if isinstance(snake_case__,   snake_case__  ) else memory_bytes
																							if self.args.trace_memory_line_by_line:
																														lowercase_	:   Any  				=     stop_memory_tracing(snake_case__  )
																														if memory is None:
																																					lowercase_	:   str  				=     summary.total
																							else:
																														lowercase_	:   Any  				=     None

																							return memory, summary
																except ResourceExhaustedError as e:
																							self.print_fn(f"""Doesn't fit on GPU. {e}"""  )
																							return "N/A", None






def  __magic_name__  (				lowercase = 1000				)				-> int:

							"""simple docstring"""



							lowercase_				,		lowercase_	:   Optional[Any]  				=     1, 1
							lowercase_	:   Tuple  				=     2
							while True:
														lowercase_	:   Dict  				=     0
														lowercase_	:   List[Any]  				=     fa + fa
														lowercase_				,		lowercase_	:   List[str]  				=     fa, f
														index += 1
														for _ in str(lowercase				):
																					i += 1
														if i == n:
																					break
							return index


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