



'''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


__a  			=						logging.get_logger(__name__)







@dataclass
class        UpperCAmelCase_			(			_a      ):
    """simple docstring"""







    lowercase   =						[
        "no_inference",
        "no_cuda",
        "no_tpu",
        "no_speed",
        "no_memory",
        "no_env_print",
        "no_multi_process",
    ]




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

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




    @cached_property
    def lowerCamelCase			(       self   :	Optional[Any]		):
          requires_backends(self					,	["""tf"""]		)
          snake_case__    :       Optional[Any]       		= None
          if self.tpu:
                try:
                      if self.tpu_name:
                            snake_case__    :       Union[str, Any]       		= tf.distribute.cluster_resolver.TPUClusterResolver(self.tpu_name		)
                      else:
                            snake_case__    :       Optional[int]       		= tf.distribute.cluster_resolver.TPUClusterResolver()
                except ValueError:
                      snake_case__    :       str       		= None
          return tpu




    @cached_property
    def lowerCamelCase			(       self   :	Any		):
          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		)

                snake_case__    :       List[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"""		)
                      snake_case__    :       int       		= tf.distribute.OneDeviceStrategy(device=f"/gpu:{self.device_idx}"		)
                else:
                      tf.config.set_visible_devices([]					,	"""GPU"""		)  # disable GPU
                      snake_case__    :       str       		= tf.distribute.OneDeviceStrategy(device=f"/cpu:{self.device_idx}"		)

          return strategy




    @property
    def lowerCamelCase			(       self   :	Optional[int]		):
          requires_backends(self					,	["""tf"""]		)
          return self._setup_tpu is not None




    @property
    def lowerCamelCase			(       self   :	str		):
          requires_backends(self					,	["""tf"""]		)
          return self._setup_strategy




    @property
    def lowerCamelCase			(       self   :	List[Any]		):
          requires_backends(self					,	["""tf"""]		)
          return tf.config.list_physical_devices("""GPU"""		)




    @property
    def lowerCamelCase			(       self   :	Optional[int]		):
          requires_backends(self					,	["""tf"""]		)
          if self.cuda:
                return len(self.gpu_list		)
          return 0




    @property
    def lowerCamelCase			(       self   :	Optional[int]		):
          return self.n_gpu > 0





'''simple docstring'''





def 		__snake_case(							)						->					Optional[Any]:
      for n in range(1	,  1_000_000						):
            yield n * (n + 1) // 2





def 		__snake_case(							_lowerCAmelCase						)						->					str:
      snake_case__    :       Optional[int]       		= 1
      snake_case__    :       List[Any]       		= 2
      while i * i <= n:
            snake_case__    :       Dict       		= 0
            while n % i == 0:
                  n //= i
                  multiplicity += 1
            divisors_count *= multiplicity + 1
            i += 1
      if n > 1:
            divisors_count *= 2
      return divisors_count





def 		__snake_case(							)						->					List[str]:
      return next(i for i in triangle_number_generator() if count_divisors(_lowerCAmelCase						) > 500						)


if __name__ == "__main__":
       print(solution())
