"""simple docstring"""





from dataclasses import dataclass, field
from typing import Tuple

from ..utils import cached_property, is_tf_available, logging, requires_backends
from .benchmark_args_utils import BenchmarkArguments


if is_tf_available():
       import tensorflow as tf


_UpperCamelCase   :						Optional[int]      =    logging.get_logger(__name__)


@dataclass
class      UpperCAmelCase_	(    _a):
      lowerCamelCase__		:    Tuple   =  [
          "no_inference",
          "no_cuda",
          "no_tpu",
          "no_speed",
          "no_memory",
          "no_env_print",
          "no_multi_process",
      ]


      def __init__(   self		,			**a							)       ->					List[Any]:
             for deprecated_arg in self.deprecated_args:
                    if deprecated_arg in kwargs:
                           lowercase__			:		Optional[Any]       =	deprecated_arg[3:]
                           lowercase__			:		Dict       =	not kwargs.pop(a							)
                           logger.warning(
                               f"""{deprecated_arg} is depreciated. Please use --no-{positive_arg} or"""
                               f""" {positive_arg}={kwargs[positive_arg]}"""							)
             lowercase__			:		Dict       =	kwargs.pop('tpu_name'		,			self.tpu_name							)
             lowercase__			:		Optional[int]       =	kwargs.pop('device_idx'		,			self.device_idx							)
             lowercase__			:		List[Any]       =	kwargs.pop('eager_mode'		,			self.eager_mode							)
             lowercase__			:		Union[str, Any]       =	kwargs.pop('use_xla'		,			self.use_xla							)
             super().__init__(**a							)

      lowerCamelCase__		:    str   =  field(
          default=_a ,							metadata={"help": "Name of TPU"} ,							)
      lowerCamelCase__		:    int   =  field(
          default=0 ,							metadata={"help": "CPU / GPU device index. Defaults to 0."} ,							)
      lowerCamelCase__		:    bool   =  field(default=_a ,							metadata={"help": "Benchmark models in eager model."})
      lowerCamelCase__		:    bool   =  field(
          default=_a ,							metadata={
              "help": "Benchmark models using XLA JIT compilation. Note that `eager_model` has to be set to `False`."
          } ,							)


      @cached_property
      def 		_UpperCAmelCase       (   self							)       ->					Tuple["tf.distribute.cluster_resolver.TPUClusterResolver"]:
             requires_backends(self		,			['tf']							)
             lowercase__			:		Dict       =	None
             if self.tpu:
                    try:
                           if self.tpu_name:
                                  lowercase__			:		Tuple       =	tf.distribute.cluster_resolver.TPUClusterResolver(self.tpu_name							)
                           else:
                                  lowercase__			:		Optional[int]       =	tf.distribute.cluster_resolver.TPUClusterResolver()
                    except ValueError:
                           lowercase__			:		str       =	None
             return tpu


      @cached_property
      def 		_UpperCAmelCase       (   self							)       ->					Tuple["tf.distribute.Strategy", "tf.distribute.cluster_resolver.TPUClusterResolver"]:
             requires_backends(self		,			['tf']							)
             if self.is_tpu:
                    tf.config.experimental_connect_to_cluster(self._setup_tpu							)
                    tf.tpu.experimental.initialize_tpu_system(self._setup_tpu							)

                    lowercase__			:		Union[str, Any]       =	tf.distribute.TPUStrategy(self._setup_tpu							)
             else:
                    # currently no multi gpu is allowed
                    if self.is_gpu:
                           # TODO: Currently only single GPU is supported
                           tf.config.set_visible_devices(self.gpu_list[self.device_idx]		,			'GPU'							)
                           lowercase__			:		str       =	tf.distribute.OneDeviceStrategy(device=f"""/gpu:{self.device_idx}"""							)
                    else:
                           tf.config.set_visible_devices([]		,			'GPU'							)  # disable GPU
                           lowercase__			:		Dict       =	tf.distribute.OneDeviceStrategy(device=f"""/cpu:{self.device_idx}"""							)

             return strategy


      @property
      def 		_UpperCAmelCase       (   self							)       ->					bool:
             requires_backends(self		,			['tf']							)
             return self._setup_tpu is not None


      @property
      def 		_UpperCAmelCase       (   self							)       ->					"tf.distribute.Strategy":
             requires_backends(self		,			['tf']							)
             return self._setup_strategy


      @property
      def 		_UpperCAmelCase       (   self							)       ->					Tuple:
             requires_backends(self		,			['tf']							)
             return tf.config.list_physical_devices('GPU'							)


      @property
      def 		_UpperCAmelCase       (   self							)       ->					int:
             requires_backends(self		,			['tf']							)
             if self.cuda:
                    return len(self.gpu_list							)
             return 0


      @property
      def 		_UpperCAmelCase       (   self							)       ->					bool:
             return self.n_gpu > 0








'''simple docstring'''


def 							UpperCAmelCase_  (						__lowerCamelCase					:					int = 10_00 ):
   lowercase_			,							lowercase_			:str    			= 1, 1
   lowercase_			:Any    			= 2
   while True:
      lowercase_			:str    			= 0
      lowercase_			:Tuple    			= fa + fa
      lowercase_			,							lowercase_			:Tuple    			= fa, f
      index += 1
      for _ in str(__lowerCamelCase ):
         i += 1
      if i == n:
         break
   return index


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


