


"""simple docstring"""






import math
import time
from typing import Dict, List, Optional

from torch.utils.data import Dataset

from transformers import SeqaSeqTrainer, is_torch_tpu_available
from transformers.trainer_utils import PredictionOutput, speed_metrics


if is_torch_tpu_available(check_device=False):
   import torch_xla.core.xla_model as xm
   import torch_xla.debug.metrics as met


class     __lowerCamelCase  (					a__				):

     '''simple docstring'''


     def __init__(      self    ,				*__UpperCAmelCase    ,				__UpperCAmelCase=None    ,				__UpperCAmelCase=None    ,				**__UpperCAmelCase							)       ->							Optional[int]:
          super().__init__(*__UpperCAmelCase    ,				**__UpperCAmelCase							)
          _a    	=				eval_examples
          _a    	=				post_process_function


     def 							_UpperCAmelCase      (      self    ,				__UpperCAmelCase = None    ,				__UpperCAmelCase=None    ,				__UpperCAmelCase = None    ,				__UpperCAmelCase = "eval"    ,				**__UpperCAmelCase    ,				)       ->							Dict[str, float]:
          _a    	=				gen_kwargs.copy()
          _a    	=				(
              gen_kwargs['''max_length'''] if gen_kwargs.get('''max_length'''							) is not None else self.args.generation_max_length
          )
          _a    	=				(
              gen_kwargs['''num_beams'''] if gen_kwargs.get('''num_beams'''							) is not None else self.args.generation_num_beams
          )
          _a    	=				gen_kwargs

          _a    	=				self.eval_dataset if eval_dataset is None else eval_dataset
          _a    	=				self.get_eval_dataloader(__UpperCAmelCase							)
          _a    	=				self.eval_examples if eval_examples is None else eval_examples

          # Temporarily disable metric computation, we will do it in the loop here.
          _a    	=				self.compute_metrics
          _a    	=				None
          _a    	=				time.time()
          _a    	=				self.prediction_loop if self.args.use_legacy_prediction_loop else self.evaluation_loop
          try:
               _a    	=				eval_loop(
                   __UpperCAmelCase    ,				description='''Evaluation'''    ,				prediction_loss_only=True if compute_metrics is None else None    ,				ignore_keys=__UpperCAmelCase    ,				metric_key_prefix=__UpperCAmelCase    ,				)
          finally:
               _a    	=				compute_metrics
          _a    	=				self.args.eval_batch_size * self.args.world_size
          if F'{metric_key_prefix}_jit_compilation_time' in output.metrics:
               start_time += output.metrics[F'{metric_key_prefix}_jit_compilation_time']
          output.metrics.update(
              speed_metrics(
                  __UpperCAmelCase    ,				__UpperCAmelCase    ,				num_samples=output.num_samples    ,				num_steps=math.ceil(output.num_samples / total_batch_size							)    ,				)							)

          if self.post_process_function is not None and self.compute_metrics is not None and self.args.should_save:
               # Only the main node write the results by default
               _a    	=				self.post_process_function(__UpperCAmelCase    ,				__UpperCAmelCase    ,				__UpperCAmelCase							)
               _a    	=				self.compute_metrics(__UpperCAmelCase							)

               # Prefix all keys with metric_key_prefix + '_'
               for key in list(metrics.keys()							):
                    if not key.startswith(F'{metric_key_prefix}_'							):
                         _a    	=				metrics.pop(__UpperCAmelCase							)

               metrics.update(output.metrics							)
          else:
               _a    	=				output.metrics

          if self.args.should_log:
               # Only the main node log the results by default
               self.log(__UpperCAmelCase							)

          if self.args.tpu_metrics_debug or self.args.debug:
               # tpu-comment: Logging debug metrics for PyTorch/XLA (compile, execute times, ops, etc.)
               xm.master_print(met.metrics_report()							)

          _a    	=				self.callback_handler.on_evaluate(self.args    ,				self.state    ,				self.control    ,				__UpperCAmelCase							)
          return metrics





     def 							_UpperCAmelCase      (      self    ,				__UpperCAmelCase    ,				__UpperCAmelCase    ,				__UpperCAmelCase=None    ,				__UpperCAmelCase = "test"    ,				**__UpperCAmelCase							)       ->							List[Any]:
          _a    	=				gen_kwargs.copy()

          _a    	=				self.get_test_dataloader(__UpperCAmelCase							)

          # Temporarily disable metric computation, we will do it in the loop here.
          _a    	=				self.compute_metrics
          _a    	=				None
          _a    	=				time.time()
          _a    	=				self.prediction_loop if self.args.use_legacy_prediction_loop else self.evaluation_loop
          try:
               _a    	=				eval_loop(
                   __UpperCAmelCase    ,				description='''Prediction'''    ,				prediction_loss_only=True if compute_metrics is None else None    ,				ignore_keys=__UpperCAmelCase    ,				metric_key_prefix=__UpperCAmelCase    ,				)
          finally:
               _a    	=				compute_metrics

          _a    	=				self.args.eval_batch_size * self.args.world_size
          if F'{metric_key_prefix}_jit_compilation_time' in output.metrics:
               start_time += output.metrics[F'{metric_key_prefix}_jit_compilation_time']
          output.metrics.update(
              speed_metrics(
                  __UpperCAmelCase    ,				__UpperCAmelCase    ,				num_samples=output.num_samples    ,				num_steps=math.ceil(output.num_samples / total_batch_size							)    ,				)							)
          if self.post_process_function is None or self.compute_metrics is None:
               return output

          _a    	=				self.post_process_function(__UpperCAmelCase    ,				__UpperCAmelCase    ,				__UpperCAmelCase    ,				'''predict'''							)
          _a    	=				self.compute_metrics(__UpperCAmelCase							)

          # Prefix all keys with metric_key_prefix + '_'
          for key in list(metrics.keys()							):
               if not key.startswith(F'{metric_key_prefix}_'							):
                    _a    	=				metrics.pop(__UpperCAmelCase							)
          metrics.update(output.metrics							)
          return PredictionOutput(predictions=predictions.predictions    ,				label_ids=predictions.label_ids    ,				metrics=__UpperCAmelCase							)



"""simple docstring"""






def       A_   (   _lowerCAmelCase     :					Dict=2_81_23       ):






     """simple docstring"""

     _a    	=				[1] * (limit + 1)

     for i in range(2,     int(limit**0.5       ) + 1       ):
          sum_divs[i * i] += i
          for k in range(i + 1,     limit // i + 1       ):
               sum_divs[k * i] += k + i

     _a    	=				set()
     _a    	=				0

     for n in range(1,     limit + 1       ):
          if sum_divs[n] > n:
               abundants.add(_lowerCAmelCase       )

          if not any((n - a in abundants) for a in abundants       ):
               res += n

     return res


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