






'''simple docstring'''

import argparse
import gc
import json
import os

import torch
from datasets import load_dataset
from torch.optim import AdamW
from torch.utils.data import DataLoader
from transformers import AutoModelForSequenceClassification, AutoTokenizer, get_linear_schedule_with_warmup, set_seed

from accelerate import Accelerator, DistributedType
from accelerate.utils.deepspeed import DummyOptim, DummyScheduler


SCREAMING_SNAKE_CASE__											=     1_6
SCREAMING_SNAKE_CASE__											=     3_2







def 					lowercase__				(   __UpperCamelCase					)->				str:
      return int(x / 2**20					)






class        a_		:

  def __enter__(   self   )						->   List[str]:



        """simple docstring"""






        gc.collect()
        torch.cuda.empty_cache()
        torch.cuda.reset_max_memory_allocated()  # reset the peak gauge to zero
        UpperCamelCase       						=      torch.cuda.memory_allocated()
        return self


  def __exit__(   self    ,	*_SCREAMING_SNAKE_CASE   )						->   int:



        """simple docstring"""






        gc.collect()
        torch.cuda.empty_cache()
        UpperCamelCase       						=      torch.cuda.memory_allocated()
        UpperCamelCase       						=      torch.cuda.max_memory_allocated()
        UpperCamelCase       						=      bamb(self.end - self.begin   )
        UpperCamelCase       						=      bamb(self.peak - self.begin   )
        # print(f"delta used/peak {self.used:4d}/{self.peaked:4d}")







def 					lowercase__				(   __UpperCamelCase	,		__UpperCamelCase = 16	,		__UpperCamelCase = "bert-base-cased"	,		__UpperCamelCase = 320	,		__UpperCamelCase = 160	,		)->				Dict:
      UpperCamelCase       						=      AutoTokenizer.from_pretrained(__UpperCamelCase					)
      UpperCamelCase       						=      load_dataset(
          """glue"""	,		"""mrpc"""	,		split={"""train""": F"train[:{n_train}]", """validation""": F"validation[:{n_val}]"}					)

      def tokenize_function(__UpperCamelCase					):
            # max_length=None => use the model max length (it's actually the default)
            UpperCamelCase       						=      tokenizer(examples["""sentence1"""]	,		examples["""sentence2"""]	,		truncation=__UpperCamelCase	,		max_length=__UpperCamelCase					)
            return outputs

      # Apply the method we just defined to all the examples in all the splits of the dataset
      UpperCamelCase       						=      datasets.map(
          __UpperCamelCase	,		batched=__UpperCamelCase	,		remove_columns=["""idx""", """sentence1""", """sentence2"""]	,		load_from_cache_file=__UpperCamelCase					)

      # We also rename the 'label' column to 'labels' which is the expected name for labels by the models of the
      # transformers library
      UpperCamelCase       						=      tokenized_datasets.rename_column("""label"""	,		"""labels"""					)

      def collate_fn(__UpperCamelCase					):
            # On TPU it's best to pad everything to the same length or training will be very slow.
            if accelerator.distributed_type == DistributedType.TPU:
                  return tokenizer.pad(__UpperCamelCase	,		padding="""max_length"""	,		max_length=128	,		return_tensors="""pt"""					)
            return tokenizer.pad(__UpperCamelCase	,		padding="""longest"""	,		return_tensors="""pt"""					)

      # Instantiate dataloaders.
      UpperCamelCase       						=      DataLoader(
          tokenized_datasets["""train"""]	,		shuffle=__UpperCamelCase	,		collate_fn=__UpperCamelCase	,		batch_size=__UpperCamelCase					)
      UpperCamelCase       						=      DataLoader(
          tokenized_datasets["""validation"""]	,		shuffle=__UpperCamelCase	,		collate_fn=__UpperCamelCase	,		batch_size=__UpperCamelCase					)

      return train_dataloader, eval_dataloader







def 					lowercase__				(   __UpperCamelCase	,		__UpperCamelCase					)->				List[str]:
      # Initialize accelerator
      UpperCamelCase       						=      Accelerator()

      # Sample hyper-parameters for learning rate, batch size, seed and a few other HPs
      UpperCamelCase       						=      config["""lr"""]
      UpperCamelCase       						=      int(config["""num_epochs"""]					)
      UpperCamelCase       						=      int(config["""seed"""]					)
      UpperCamelCase       						=      int(config["""batch_size"""]					)
      UpperCamelCase       						=      args.model_name_or_path

      set_seed(__UpperCamelCase					)
      UpperCamelCase						,UpperCamelCase       						=      get_dataloaders(__UpperCamelCase	,		__UpperCamelCase	,		__UpperCamelCase	,		args.n_train	,		args.n_val					)

      # Instantiate the model (we build the model here so that the seed also control new weights initialization)
      UpperCamelCase       						=      AutoModelForSequenceClassification.from_pretrained(__UpperCamelCase	,		return_dict=__UpperCamelCase					)

      # Instantiate optimizer
      UpperCamelCase       						=      (
          AdamW
          if accelerator.state.deepspeed_plugin is None
          or """optimizer""" not in accelerator.state.deepspeed_plugin.deepspeed_config
          else DummyOptim
      )
      UpperCamelCase       						=      optimizer_cls(params=model.parameters()	,		lr=__UpperCamelCase					)

      if accelerator.state.deepspeed_plugin is not None:
            UpperCamelCase       						=      accelerator.state.deepspeed_plugin.deepspeed_config[
                """gradient_accumulation_steps"""
            ]
      else:
            UpperCamelCase       						=      1
      UpperCamelCase       						=      (len(__UpperCamelCase					) * num_epochs) // gradient_accumulation_steps

      # Instantiate scheduler
      if (
          accelerator.state.deepspeed_plugin is None
          or "scheduler" not in accelerator.state.deepspeed_plugin.deepspeed_config
      ):
            UpperCamelCase       						=      get_linear_schedule_with_warmup(
                optimizer=__UpperCamelCase	,		num_warmup_steps=0	,		num_training_steps=__UpperCamelCase	,		)
      else:
            UpperCamelCase       						=      DummyScheduler(__UpperCamelCase	,		total_num_steps=__UpperCamelCase	,		warmup_num_steps=0					)

      # Prepare everything
      # There is no specific order to remember, we just need to unpack the objects in the same order we gave them to the
      # prepare method.
      UpperCamelCase						,UpperCamelCase						,UpperCamelCase						,UpperCamelCase						,UpperCamelCase       						=      accelerator.prepare(
          __UpperCamelCase	,		__UpperCamelCase	,		__UpperCamelCase	,		__UpperCamelCase	,		__UpperCamelCase					)

      # We need to keep track of how many total steps we have iterated over
      UpperCamelCase       						=      0
      # We also need to keep track of the stating epoch so files are named properly
      UpperCamelCase       						=      0

      # Now we train the model
      UpperCamelCase       						=      {}
      for epoch in range(__UpperCamelCase	,		__UpperCamelCase					):
            with TorchTracemalloc() as tracemalloc:
                  model.train()
                  for step, batch in enumerate(__UpperCamelCase					):
                        UpperCamelCase       						=      model(**__UpperCamelCase					)
                        UpperCamelCase       						=      outputs.loss
                        UpperCamelCase       						=      loss / gradient_accumulation_steps
                        accelerator.backward(__UpperCamelCase					)
                        if step % gradient_accumulation_steps == 0:
                              optimizer.step()
                              lr_scheduler.step()
                              optimizer.zero_grad()

                        overall_step += 1

        # Printing the GPU memory usage details such as allocated memory, peak memory, and total memory usage
            accelerator.print("""Memory before entering the train : {}""".format(bamb(tracemalloc.begin					)					)					)
            accelerator.print("""Memory consumed at the end of the train (end-begin): {}""".format(tracemalloc.used					)					)
            accelerator.print("""Peak Memory consumed during the train (max-begin): {}""".format(tracemalloc.peaked					)					)
            accelerator.print(
                """Total Peak Memory consumed during the train (max): {}""".format(
                    tracemalloc.peaked + bamb(tracemalloc.begin					)					)					)
            UpperCamelCase       						=      tracemalloc.peaked + bamb(tracemalloc.begin					)
            if args.peak_memory_upper_bound is not None:
                  assert (
                      train_total_peak_memory[F"epoch-{epoch}"] <= args.peak_memory_upper_bound
                  ), "Peak memory usage exceeded the upper bound"

      accelerator.wait_for_everyone()
      if accelerator.is_main_process:
            with open(os.path.join(args.output_dir	,		"""peak_memory_utilization.json"""					)	,		"""w"""					) as f:
                  json.dump(__UpperCamelCase	,		__UpperCamelCase					)







def 					lowercase__				(   )->				str:
      UpperCamelCase       						=      argparse.ArgumentParser(description="""Simple example of training script tracking peak GPU memory usage."""					)
      parser.add_argument(
          """--model_name_or_path"""	,		type=__UpperCamelCase	,		default="""bert-base-cased"""	,		help="""Path to pretrained model or model identifier from huggingface.co/models."""	,		required=__UpperCamelCase	,		)
      parser.add_argument(
          """--output_dir"""	,		type=__UpperCamelCase	,		default="""."""	,		help="""Optional save directory where all checkpoint folders will be stored. Default is the current working directory."""	,		)
      parser.add_argument(
          """--peak_memory_upper_bound"""	,		type=__UpperCamelCase	,		default=__UpperCamelCase	,		help="""The upper bound of peak memory usage in MB. If set, the training will throw an error if the peak memory usage exceeds this value."""	,		)
      parser.add_argument(
          """--n_train"""	,		type=__UpperCamelCase	,		default=320	,		help="""Number of training examples to use."""	,		)
      parser.add_argument(
          """--n_val"""	,		type=__UpperCamelCase	,		default=160	,		help="""Number of validation examples to use."""	,		)
      parser.add_argument(
          """--num_epochs"""	,		type=__UpperCamelCase	,		default=1	,		help="""Number of train epochs."""	,		)
      UpperCamelCase       						=      parser.parse_args()
      UpperCamelCase       						=      {"""lr""": 2E-5, """num_epochs""": args.num_epochs, """seed""": 42, """batch_size""": 16}
      training_function(__UpperCamelCase	,		__UpperCamelCase					)


if __name__ == "__main__":
     main()








'''simple docstring'''

from math import sqrt







def 					lowercase__				(   __UpperCamelCase					)->				int:
      UpperCamelCase       						=      0
      for i in range(1	,		int(sqrt(__UpperCamelCase					) + 1					)					):
            if n % i == 0 and i != sqrt(__UpperCamelCase					):
                  total += i + n // i
            elif i == sqrt(__UpperCamelCase					):
                  total += i
      return total - n







def 					lowercase__				(   __UpperCamelCase = 10000					)->				int:
      UpperCamelCase       						=      sum(
          i
          for i in range(1	,		__UpperCamelCase					)
          if sum_of_divisors(sum_of_divisors(__UpperCamelCase					)					) == i and sum_of_divisors(__UpperCamelCase					) != i					)
      return total


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