




def 						lowercase		(     _lowerCAmelCase = 100      ):
  UpperCAmelCase__    						=   1
  UpperCAmelCase__    						=   0
  for i in range(1   ,     num + 1      ):
    fact *= i

  for j in str(_lowerCAmelCase      ):
    result += int(_lowerCAmelCase      )

  return result


if __name__ == "__main__":
   print(solution(int(input('''Enter the Number: ''').strip())))










import argparse
import os

import evaluate
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


########################################################################
# This is a fully working simple example to use Accelerate
#
# This example trains a Bert base model on GLUE MRPC
# in any of the following settings (with the same script):
#   - single CPU or single GPU
#   - multi GPUS (using PyTorch distributed mode)
#   - (multi) TPUs
#   - fp16 (mixed-precision) or fp32 (normal precision)
#
# This example also demonstrates the checkpointing and sharding capabilities
#
# To run it in each of these various modes, follow the instructions
# in the readme for examples:
# https://github.com/huggingface/accelerate/tree/main/examples
#
########################################################################


snake_case__ :						Dict     =			1_6
snake_case__ :						Tuple     =			3_2


def 						lowercase		(     _lowerCAmelCase   ,     _lowerCAmelCase      ):
  # Initialize accelerator
  if args.with_tracking:
    UpperCAmelCase__    						=   Accelerator(
        cpu=args.cpu   ,     mixed_precision=args.mixed_precision   ,     log_with="""all"""   ,     project_dir=args.project_dir      )
  else:
    UpperCAmelCase__    						=   Accelerator(cpu=args.cpu   ,     mixed_precision=args.mixed_precision      )

  if hasattr(args.checkpointing_steps   ,     """isdigit"""      ):
    if args.checkpointing_steps == "epoch":
      UpperCAmelCase__    						=   args.checkpointing_steps
    elif args.checkpointing_steps.isdigit():
      UpperCAmelCase__    						=   int(args.checkpointing_steps      )
    else:
      raise ValueError(
          F'''Argument `checkpointing_steps` must be either a number or `epoch`. `{args.checkpointing_steps}` passed.'''      )
  else:
    UpperCAmelCase__    						=   None
  # 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"""]      )

  # We need to initialize the trackers we use, and also store our configuration
  if args.with_tracking:
    UpperCAmelCase__    						=   os.path.split(_lowerCAmelCase      )[-1].split("""."""      )[0]
    accelerator.init_trackers(_lowerCAmelCase   ,     _lowerCAmelCase      )

  UpperCAmelCase__    						=   AutoTokenizer.from_pretrained("""bert-base-cased"""      )
  UpperCAmelCase__    						=   load_dataset("""glue"""   ,     """mrpc"""      )
  UpperCAmelCase__    						=   evaluate.load("""glue"""   ,     """mrpc"""      )

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

  # Apply the method we just defined to all the examples in all the splits of the dataset
  # starting with the main process first:
  with accelerator.main_process_first():
    UpperCAmelCase__    						=   datasets.map(
        _lowerCAmelCase   ,     batched=_lowerCAmelCase   ,     remove_columns=["""idx""", """sentence1""", """sentence2"""]   ,     )

  # 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"""      )

  # If the batch size is too big we use gradient accumulation
  UpperCAmelCase__    						=   1
  if batch_size > MAX_GPU_BATCH_SIZE and accelerator.distributed_type != DistributedType.TPU:
    UpperCAmelCase__    						=   batch_size // MAX_GPU_BATCH_SIZE
    UpperCAmelCase__    						=   MAX_GPU_BATCH_SIZE

  def collate_fn(_lowerCAmelCase      ):
    # On TPU it's best to pad everything to the same length or training will be very slow.
    UpperCAmelCase__    						=   128 if accelerator.distributed_type == DistributedType.TPU else None
    # When using mixed precision we want round multiples of 8/16
    if accelerator.mixed_precision == "fp8":
      UpperCAmelCase__    						=   16
    elif accelerator.mixed_precision != "no":
      UpperCAmelCase__    						=   8
    else:
      UpperCAmelCase__    						=   None

    return tokenizer.pad(
        _lowerCAmelCase   ,     padding="""longest"""   ,     max_length=_lowerCAmelCase   ,     pad_to_multiple_of=_lowerCAmelCase   ,     return_tensors="""pt"""   ,     )

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

  set_seed(_lowerCAmelCase      )

  # Instantiate the model (we build the model here so that the seed also control new weights initialization)
  UpperCAmelCase__    						=   AutoModelForSequenceClassification.from_pretrained("""bert-base-cased"""   ,     return_dict=_lowerCAmelCase      )

  # We could avoid this line since the accelerator is set with `device_placement=True` (default value).
  # Note that if you are placing tensors on devices manually, this line absolutely needs to be before the optimizer
  # creation otherwise training will not work on TPU (`accelerate` will kindly throw an error to make us aware of that).
  UpperCAmelCase__    						=   model.to(accelerator.device      )

  # Instantiate optimizer
  UpperCAmelCase__    						=   AdamW(params=model.parameters()   ,     lr=_lowerCAmelCase      )

  # Instantiate scheduler
  UpperCAmelCase__    						=   get_linear_schedule_with_warmup(
      optimizer=_lowerCAmelCase   ,     num_warmup_steps=100   ,     num_training_steps=(len(_lowerCAmelCase      ) * num_epochs) // gradient_accumulation_steps   ,     )

  # 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(
      _lowerCAmelCase   ,     _lowerCAmelCase   ,     _lowerCAmelCase   ,     _lowerCAmelCase   ,     _lowerCAmelCase      )

  # 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

  # Potentially load in the weights and states from a previous save
  if args.resume_from_checkpoint:
    if args.resume_from_checkpoint is not None or args.resume_from_checkpoint != "":
      accelerator.print(F'''Resumed from checkpoint: {args.resume_from_checkpoint}'''      )
      accelerator.load_state(args.resume_from_checkpoint      )
      UpperCAmelCase__    						=   os.path.basename(args.resume_from_checkpoint      )
    else:
      # Get the most recent checkpoint
      UpperCAmelCase__    						=   [f.name for f in os.scandir(os.getcwd()      ) if f.is_dir()]
      dirs.sort(key=os.path.getctime      )
      UpperCAmelCase__    						=   dirs[-1]  # Sorts folders by date modified, most recent checkpoint is the last
    # Extract `epoch_{i}` or `step_{i}`
    UpperCAmelCase__    						=   os.path.splitext(_lowerCAmelCase      )[0]

    if "epoch" in training_difference:
      UpperCAmelCase__    						=   int(training_difference.replace("""epoch_"""   ,     """"""      )      ) + 1
      UpperCAmelCase__    						=   None
    else:
      UpperCAmelCase__    						=   int(training_difference.replace("""step_"""   ,     """"""      )      )
      UpperCAmelCase__    						=   resume_step // len(_lowerCAmelCase      )
      resume_step -= starting_epoch * len(_lowerCAmelCase      )

    # Now we train the model
  for epoch in range(_lowerCAmelCase   ,     _lowerCAmelCase      ):
    model.train()
    if args.with_tracking:
      UpperCAmelCase__    						=   0
    if args.resume_from_checkpoint and epoch == starting_epoch and resume_step is not None:
      # We need to skip steps until we reach the resumed step
      UpperCAmelCase__    						=   accelerator.skip_first_batches(_lowerCAmelCase   ,     _lowerCAmelCase      )
      overall_step += resume_step
    else:
      # After the first iteration though, we need to go back to the original dataloader
      UpperCAmelCase__    						=   train_dataloader
    for step, batch in enumerate(_lowerCAmelCase      ):
      # We could avoid this line since we set the accelerator with `device_placement=True`.
      batch.to(accelerator.device      )
      UpperCAmelCase__    						=   model(**_lowerCAmelCase      )
      UpperCAmelCase__    						=   outputs.loss
      UpperCAmelCase__    						=   loss / gradient_accumulation_steps
      # We keep track of the loss at each epoch
      if args.with_tracking:
        total_loss += loss.detach().float()
      accelerator.backward(_lowerCAmelCase      )
      if step % gradient_accumulation_steps == 0:
        optimizer.step()
        lr_scheduler.step()
        optimizer.zero_grad()

      overall_step += 1

      if isinstance(_lowerCAmelCase   ,     _lowerCAmelCase      ):
        UpperCAmelCase__    						=   F'''step_{overall_step}'''
        if overall_step % checkpointing_steps == 0:
          if args.output_dir is not None:
            UpperCAmelCase__    						=   os.path.join(args.output_dir   ,     _lowerCAmelCase      )
          accelerator.save_state(_lowerCAmelCase      )

    model.eval()
    for step, batch in enumerate(_lowerCAmelCase      ):
      # We could avoid this line since we set the accelerator with `device_placement=True`.
      batch.to(accelerator.device      )
      with torch.no_grad():
        UpperCAmelCase__    						=   model(**_lowerCAmelCase      )
      UpperCAmelCase__    						=   outputs.logits.argmax(dim=-1      )
      UpperCAmelCase__						,					UpperCAmelCase__    						=   accelerator.gather_for_metrics((predictions, batch["""labels"""])      )
      metric.add_batch(
          predictions=_lowerCAmelCase   ,     references=_lowerCAmelCase   ,     )

    UpperCAmelCase__    						=   metric.compute()
    # Use accelerator.print to print only on the main process.
    accelerator.print(F'''epoch {epoch}:'''   ,     _lowerCAmelCase      )
    if args.with_tracking:
      accelerator.log(
          {
              """accuracy""": eval_metric["""accuracy"""],
              """f1""": eval_metric["""f1"""],
              """train_loss""": total_loss.item() / len(_lowerCAmelCase      ),
              """epoch""": epoch,
          }   ,     step=_lowerCAmelCase   ,     )

    if checkpointing_steps == "epoch":
      UpperCAmelCase__    						=   F'''epoch_{epoch}'''
      if args.output_dir is not None:
        UpperCAmelCase__    						=   os.path.join(args.output_dir   ,     _lowerCAmelCase      )
      accelerator.save_state(_lowerCAmelCase      )

  if args.with_tracking:
    accelerator.end_training()


def 						lowercase		(     ):
  UpperCAmelCase__    						=   argparse.ArgumentParser(description="""Simple example of training script."""      )
  parser.add_argument(
      """--mixed_precision"""   ,     type=_lowerCAmelCase   ,     default=_lowerCAmelCase   ,     choices=["""no""", """fp16""", """bf16""", """fp8"""]   ,     help="""Whether to use mixed precision. Choose"""
      """between fp16 and bf16 (bfloat16). Bf16 requires PyTorch >= 1.10."""
      """and an Nvidia Ampere GPU."""   ,     )
  parser.add_argument("""--cpu"""   ,     action="""store_true"""   ,     help="""If passed, will train on the CPU."""      )
  parser.add_argument(
      """--checkpointing_steps"""   ,     type=_lowerCAmelCase   ,     default=_lowerCAmelCase   ,     help="""Whether the various states should be saved at the end of every n steps, or 'epoch' for each epoch."""   ,     )
  parser.add_argument(
      """--resume_from_checkpoint"""   ,     type=_lowerCAmelCase   ,     default=_lowerCAmelCase   ,     help="""If the training should continue from a checkpoint folder."""   ,     )
  parser.add_argument(
      """--with_tracking"""   ,     action="""store_true"""   ,     help="""Whether to load in all available experiment trackers from the environment and use them for logging."""   ,     )
  parser.add_argument(
      """--output_dir"""   ,     type=_lowerCAmelCase   ,     default="""."""   ,     help="""Optional save directory where all checkpoint folders will be stored. Default is the current working directory."""   ,     )
  parser.add_argument(
      """--project_dir"""   ,     type=_lowerCAmelCase   ,     default="""logs"""   ,     help="""Location on where to store experiment tracking logs` and relevent project information"""   ,     )
  UpperCAmelCase__    						=   parser.parse_args()
  UpperCAmelCase__    						=   {"""lr""": 2e-5, """num_epochs""": 3, """seed""": 42, """batch_size""": 16}
  training_function(_lowerCAmelCase   ,     _lowerCAmelCase      )


if __name__ == "__main__":
   main()




