





"""simple docstring"""


import warnings
from dataclasses import dataclass, field
from typing import Optional, Tuple

from .training_args import TrainingArguments
from .utils import cached_property, is_tf_available, logging, requires_backends


A_     :      Tuple								=logging.get_logger(__name__)

if is_tf_available():
      import tensorflow as tf







@dataclass
class 	__a   (  lowerCAmelCase__		):
     SCREAMING_SNAKE_CASE__ :      Tuple       		=			"tf"
     SCREAMING_SNAKE_CASE__ :      Optional[str]       		=			field(
         default=lowerCAmelCase__	,						metadata={"help": "Name of TPU"}	,						)

     SCREAMING_SNAKE_CASE__ :      Optional[str]       		=			field(
         default=lowerCAmelCase__	,						metadata={"help": "Zone of TPU"}	,						)

     SCREAMING_SNAKE_CASE__ :      Optional[str]       		=			field(
         default=lowerCAmelCase__	,						metadata={"help": "Name of Cloud TPU-enabled project"}	,						)

     SCREAMING_SNAKE_CASE__ :      float       		=			field(
         default=1.0	,						metadata={"help": "Power for the Polynomial decay LR scheduler."}	,						)

     SCREAMING_SNAKE_CASE__ :      bool       		=			field(default=lowerCAmelCase__	,						metadata={"help": "Whether to activate the XLA compilation or not"}		)



     @cached_property
     def 						snake_case_			(       self   ):
            requires_backends(self					,     ['tf']   )
            logger.info('Tensorflow: setting up strategy'   )

            _lowerCamelCase    	=					tf.config.list_physical_devices('GPU'   )

            # Set to float16 at first
            if self.fpaa:
                   tf.keras.mixed_precision.set_global_policy('mixed_float16'   )

            if self.no_cuda:
                   _lowerCamelCase    	=					tf.distribute.OneDeviceStrategy(device='/cpu:0'   )
            else:
                   try:
                          if self.tpu_name:
                                 _lowerCamelCase    	=					tf.distribute.cluster_resolver.TPUClusterResolver(
                                     self.tpu_name					,     zone=self.tpu_zone					,     project=self.gcp_project   )
                          else:
                                 _lowerCamelCase    	=					tf.distribute.cluster_resolver.TPUClusterResolver()
                   except ValueError:
                          if self.tpu_name:
                                 raise RuntimeError(F'Couldn\'t connect to TPU {self.tpu_name}!'   )
                          else:
                                 _lowerCamelCase    	=					None

                   if tpu:
                          # Set to bfloat16 in case of TPU
                          if self.fpaa:
                                 tf.keras.mixed_precision.set_global_policy('mixed_bfloat16'   )

                          tf.config.experimental_connect_to_cluster(a__   )
                          tf.tpu.experimental.initialize_tpu_system(a__   )

                          _lowerCamelCase    	=					tf.distribute.TPUStrategy(a__   )

                   elif len(a__   ) == 0:
                          _lowerCamelCase    	=					tf.distribute.OneDeviceStrategy(device='/cpu:0'   )
                   elif len(a__   ) == 1:
                          _lowerCamelCase    	=					tf.distribute.OneDeviceStrategy(device='/gpu:0'   )
                   elif len(a__   ) > 1:
                          # If you only want to use a specific subset of GPUs use `CUDA_VISIBLE_DEVICES=0`
                          _lowerCamelCase    	=					tf.distribute.MirroredStrategy()
                   else:
                          raise ValueError('Cannot find the proper strategy, please check your environment properties.'   )

            return strategy



     @property
     def 						snake_case_			(       self   ):
            requires_backends(self					,     ['tf']   )
            return self._setup_strategy



     @property
     def 						snake_case_			(       self   ):
            requires_backends(self					,     ['tf']   )
            return self._setup_strategy.num_replicas_in_sync



     @property
     def 						snake_case_			(       self   ):
            return False  # TF Logging is handled by Keras not the Trainer



     @property
     def 						snake_case_			(       self   ):
            if self.per_gpu_train_batch_size:
                   logger.warning(
                       'Using deprecated `--per_gpu_train_batch_size` argument which will be removed in a future '
                       'version. Using `--per_device_train_batch_size` is preferred.'   )
            _lowerCamelCase    	=					self.per_gpu_train_batch_size or self.per_device_train_batch_size
            return per_device_batch_size * self.n_replicas



     @property
     def 						snake_case_			(       self   ):
            if self.per_gpu_eval_batch_size:
                   logger.warning(
                       'Using deprecated `--per_gpu_eval_batch_size` argument which will be removed in a future '
                       'version. Using `--per_device_eval_batch_size` is preferred.'   )
            _lowerCamelCase    	=					self.per_gpu_eval_batch_size or self.per_device_eval_batch_size
            return per_device_batch_size * self.n_replicas



     @property
     def 						snake_case_			(       self   ):
            requires_backends(self					,     ['tf']   )
            warnings.warn(
                'The n_gpu argument is deprecated and will be removed in a future version, use n_replicas instead.'					,     a__					,     )
            return self._setup_strategy.num_replicas_in_sync













"""simple docstring"""


def SCREAMING_SNAKE_CASE_   (       )->		Tuple:
       _lowerCamelCase    	=					1

       while True:
              if (
                  sorted(str(snake_case		)		)
                  == sorted(str(2 * i		)		)
                  == sorted(str(3 * i		)		)
                  == sorted(str(4 * i		)		)
                  == sorted(str(5 * i		)		)
                  == sorted(str(6 * i		)		)
              ):
                     return i

              i += 1


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






