

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   UpperCamelCase			(  SCREAMING_SNAKE_CASE ):

    def __init__(      self			:   Optional[Any]				,     *snake_case__			:   List[Any]				,     snake_case__			:   Tuple=None				,     snake_case__			:   List[Any]=None				,     **snake_case__			:   Any     ):

     """simple docstring"""






     super().__init__(*snake_case__				,     **snake_case__     )
     SCREAMING_SNAKE_CASE		    =      eval_examples
     SCREAMING_SNAKE_CASE		    =      post_process_function

    def UpperCamelCase      (      self			:   Union[str, Any]				,     snake_case__			:   Optional[Dataset] = None				,     snake_case__			:   List[str]=None				,     snake_case__			:   Optional[List[str]] = None				,     snake_case__			:   str = "eval"				,     **snake_case__			:   str				,     ):

     """simple docstring"""






     SCREAMING_SNAKE_CASE		    =      gen_kwargs.copy()
     SCREAMING_SNAKE_CASE		    =      (
         gen_kwargs['max_length'] if gen_kwargs.get('max_length'     ) is not None else self.args.generation_max_length
     )
     SCREAMING_SNAKE_CASE		    =      (
         gen_kwargs['num_beams'] if gen_kwargs.get('num_beams'     ) is not None else self.args.generation_num_beams
     )
     SCREAMING_SNAKE_CASE		    =      gen_kwargs

     SCREAMING_SNAKE_CASE		    =      self.eval_dataset if eval_dataset is None else eval_dataset
     SCREAMING_SNAKE_CASE		    =      self.get_eval_dataloader(snake_case__     )
     SCREAMING_SNAKE_CASE		    =      self.eval_examples if eval_examples is None else eval_examples

     # Temporarily disable metric computation, we will do it in the loop here.
     SCREAMING_SNAKE_CASE		    =      self.compute_metrics
     SCREAMING_SNAKE_CASE		    =      None
     SCREAMING_SNAKE_CASE		    =      time.time()
     SCREAMING_SNAKE_CASE		    =      self.prediction_loop if self.args.use_legacy_prediction_loop else self.evaluation_loop
     try:
      SCREAMING_SNAKE_CASE		    =      eval_loop(
          snake_case__				,     description='Evaluation'				,     prediction_loss_only=True if compute_metrics is None else None				,     ignore_keys=snake_case__				,     metric_key_prefix=snake_case__				,     )
     finally:
      SCREAMING_SNAKE_CASE		    =      compute_metrics
     SCREAMING_SNAKE_CASE		    =      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(
             snake_case__				,     snake_case__				,     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
      SCREAMING_SNAKE_CASE		    =      self.post_process_function(snake_case__				,     snake_case__				,     snake_case__     )
      SCREAMING_SNAKE_CASE		    =      self.compute_metrics(snake_case__     )

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

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

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

     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()     )

     SCREAMING_SNAKE_CASE		    =      self.callback_handler.on_evaluate(self.args				,     self.state				,     self.control				,     snake_case__     )
     return metrics




    def UpperCamelCase      (      self			:   Union[str, Any]				,     snake_case__			:   int				,     snake_case__			:   List[Any]				,     snake_case__			:   Union[str, Any]=None				,     snake_case__			:   str = "test"				,     **snake_case__			:   Union[str, Any]     ):

     """simple docstring"""






     SCREAMING_SNAKE_CASE		    =      gen_kwargs.copy()

     SCREAMING_SNAKE_CASE		    =      self.get_test_dataloader(snake_case__     )

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

     SCREAMING_SNAKE_CASE		    =      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(
             snake_case__				,     snake_case__				,     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

     SCREAMING_SNAKE_CASE		    =      self.post_process_function(snake_case__				,     snake_case__				,     snake_case__				,     'predict'     )
     SCREAMING_SNAKE_CASE		    =      self.compute_metrics(snake_case__     )

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




def 							__lowerCAmelCase     (							_UpperCamelCase		:	List[str]=2_81_23						)		->				str:
 '''simple docstring'''


 SCREAMING_SNAKE_CASE		    =      [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

 SCREAMING_SNAKE_CASE		    =      set()
 SCREAMING_SNAKE_CASE		    =      0

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

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

 return res


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

