


'''simple docstring'''
import argparse
import logging
import os
from pathlib import Path
from typing import Any, Dict

import pytorch_lightning as pl
from pytorch_lightning.utilities import rank_zero_info

from transformers import (
    AdamW,
    AutoConfig,
    AutoModel,
    AutoModelForPreTraining,
    AutoModelForQuestionAnswering,
    AutoModelForSeqaSeqLM,
    AutoModelForSequenceClassification,
    AutoModelForTokenClassification,
    AutoModelWithLMHead,
    AutoTokenizer,
    PretrainedConfig,
    PreTrainedTokenizer,
)
from transformers.optimization import (
    Adafactor,
    get_cosine_schedule_with_warmup,
    get_cosine_with_hard_restarts_schedule_with_warmup,
    get_linear_schedule_with_warmup,
    get_polynomial_decay_schedule_with_warmup,
)
from transformers.utils.versions import require_version


__magic_name__   :   Optional[Any]  							=logging.getLogger(__name__)

require_version('pytorch_lightning>=1.0.4')

__magic_name__   :   Union[str, Any]  							={
    'base': AutoModel,
    'sequence-classification': AutoModelForSequenceClassification,
    'question-answering': AutoModelForQuestionAnswering,
    'pretraining': AutoModelForPreTraining,
    'token-classification': AutoModelForTokenClassification,
    'language-modeling': AutoModelWithLMHead,
    'summarization': AutoModelForSeqaSeqLM,
    'translation': AutoModelForSeqaSeqLM,
}


# update this and the import above to support new schedulers from transformers.optimization
__magic_name__   :   List[Any]  							={
    'linear': get_linear_schedule_with_warmup,
    'cosine': get_cosine_schedule_with_warmup,
    'cosine_w_restarts': get_cosine_with_hard_restarts_schedule_with_warmup,
    'polynomial': get_polynomial_decay_schedule_with_warmup,
    # '': get_constant_schedule,             # not supported for now
    # '': get_constant_schedule_with_warmup, # not supported for now
}
__magic_name__   :   str  							=sorted(arg_to_scheduler.keys())
__magic_name__   :   List[str]  							='{' + ', '.join(arg_to_scheduler_choices) + '}'






class 		UpperCamelCase_		(					pl.LightningModule   ):





						"""simple docstring"""




						def __init__( self				:					Union[str, Any]	,				_lowerCamelCase				:					argparse.Namespace	,				_lowerCamelCase				:					int=None	,				_lowerCamelCase				:					int="base"	,				_lowerCamelCase				:					Dict=None	,				_lowerCamelCase				:					Dict=None	,				_lowerCamelCase				:					Optional[Any]=None	,				**_lowerCamelCase				:					str	,				)							->					Optional[int]:
										super().__init__()
										# TODO: move to self.save_hyperparameters()
										# self.save_hyperparameters()
										# can also expand arguments into trainer signature for easier reading

										self.save_hyperparameters(_lowerCamelCase  )
										__magic_name__	  = 0
										__magic_name__	  = Path(self.hparams.output_dir  )
										__magic_name__	  = self.hparams.cache_dir if self.hparams.cache_dir else None
										if config is None:
														__magic_name__	  = AutoConfig.from_pretrained(
														    self.hparams.config_name if self.hparams.config_name else self.hparams.model_name_or_path	,				**({"num_labels": num_labels} if num_labels is not None else {})	,				cache_dir=_lowerCamelCase	,				**_lowerCamelCase	,				)
										else:
														__magic_name__	  = config

										__magic_name__	  = ("encoder_layerdrop", "decoder_layerdrop", "dropout", "attention_dropout")
										for p in extra_model_params:
														if getattr(self.hparams	,				_lowerCamelCase	,				_lowerCamelCase  ):
																		assert hasattr(self.config	,				_lowerCamelCase  ), f'model config doesn\'t have a `{p}` attribute'
																		setattr(self.config	,				_lowerCamelCase	,				getattr(self.hparams	,				_lowerCamelCase  )  )

										if tokenizer is None:
														__magic_name__	  = AutoTokenizer.from_pretrained(
														    self.hparams.tokenizer_name if self.hparams.tokenizer_name else self.hparams.model_name_or_path	,				cache_dir=_lowerCamelCase	,				)
										else:
														__magic_name__	  = tokenizer
										__magic_name__	  = MODEL_MODES[mode]
										if model is None:
														__magic_name__	  = self.model_type.from_pretrained(
														    self.hparams.model_name_or_path	,				from_tf=bool(".ckpt" in self.hparams.model_name_or_path  )	,				config=self.config	,				cache_dir=_lowerCamelCase	,				)
										else:
														__magic_name__	  = model
						def 					__A					( self				:					Any	,				*_lowerCamelCase				:					int	,				**_lowerCamelCase				:					Optional[Any]  )							->					Tuple:
										__magic_name__	  = self.model_type.from_pretrained(*_lowerCamelCase	,				**_lowerCamelCase  )
						def 					__A					( self				:					Any  )							->					Tuple:
										__magic_name__	  = arg_to_scheduler[self.hparams.lr_scheduler]
										__magic_name__	  = get_schedule_func(
										    self.opt	,				num_warmup_steps=self.hparams.warmup_steps	,				num_training_steps=self.total_steps()  )
										__magic_name__	  = {"scheduler": scheduler, "interval": "step", "frequency": 1}
										return scheduler
						def 					__A					( self				:					List[str]  )							->					int:
										__magic_name__	  = self.model
										__magic_name__	  = ["bias", "LayerNorm.weight"]
										__magic_name__	  = [
										    {
										        "params": [p for n, p in model.named_parameters() if not any(nd in n for nd in no_decay  )],
										        "weight_decay": self.hparams.weight_decay,
										    },
										    {
										        "params": [p for n, p in model.named_parameters() if any(nd in n for nd in no_decay  )],
										        "weight_decay": 0.0,
										    },
										]
										if self.hparams.adafactor:
														__magic_name__	  = Adafactor(
														    _lowerCamelCase	,				lr=self.hparams.learning_rate	,				scale_parameter=_lowerCamelCase	,				relative_step=_lowerCamelCase  )

										else:
														__magic_name__	  = AdamW(
														    _lowerCamelCase	,				lr=self.hparams.learning_rate	,				eps=self.hparams.adam_epsilon  )
										__magic_name__	  = optimizer

										__magic_name__	  = self.get_lr_scheduler()

										return [optimizer], [scheduler]
						def 					__A					( self				:					str	,				_lowerCamelCase				:					Union[str, Any]	,				_lowerCamelCase				:					int  )							->					Dict:
										return self.validation_step(_lowerCamelCase	,				_lowerCamelCase  )
						def 					__A					( self				:					Tuple	,				_lowerCamelCase				:					List[Any]  )							->					Optional[Any]:
										return self.validation_end(_lowerCamelCase  )
						def 					__A					( self				:					Dict  )							->					int:
										__magic_name__	  = max(1	,				self.hparams.gpus  )  # TODO: consider num_tpu_cores
										__magic_name__	  = self.hparams.train_batch_size * self.hparams.accumulate_grad_batches * num_devices
										return (self.dataset_size / effective_batch_size) * self.hparams.max_epochs
						def 					__A					( self				:					Any	,				_lowerCamelCase				:					Optional[int]  )							->					str:
										if mode == "test":
														__magic_name__	  = len(self.test_dataloader().dataset  )
										else:
														__magic_name__	  = self.get_dataloader("train"	,				self.hparams.train_batch_size	,				shuffle=_lowerCamelCase  )
														__magic_name__	  = len(self.train_dataloader().dataset  )
						def 					__A					( self				:					int	,				_lowerCamelCase				:					str	,				_lowerCamelCase				:					int	,				_lowerCamelCase				:					bool = False  )							->					Dict:
										raise NotImplementedError("You must implement this for your task"  )
						def 					__A					( self				:					List[Any]  )							->					Union[str, Any]:
										return self.train_loader
						def 					__A					( self				:					Optional[Any]  )							->					List[str]:
										return self.get_dataloader("dev"	,				self.hparams.eval_batch_size	,				shuffle=_lowerCamelCase  )
						def 					__A					( self				:					List[str]  )							->					Dict:
										return self.get_dataloader("test"	,				self.hparams.eval_batch_size	,				shuffle=_lowerCamelCase  )
						def 					__A					( self				:					Optional[Any]	,				_lowerCamelCase				:					Tuple  )							->					List[Any]:
										return os.path.join(
										    self.hparams.data_dir	,				"cached_{}_{}_{}".format(
										        _lowerCamelCase	,				list(filter(_lowerCamelCase	,				self.hparams.model_name_or_path.split("/"  )  )  ).pop()	,				str(self.hparams.max_seq_length  )	,				)	,				)
						@pl.utilities.rank_zero_only
						def 					__A					( self				:					Any	,				_lowerCamelCase				:					Dict[str, Any]  )							->					None:
										__magic_name__	  = self.output_dir.joinpath("best_tfmr"  )
										__magic_name__	  = self.step_count
										self.model.save_pretrained(_lowerCamelCase  )
										self.tokenizer.save_pretrained(_lowerCamelCase  )

						@staticmethod
						def 					__A					( _lowerCamelCase				:					List[Any]	,				_lowerCamelCase				:					List[Any]  )							->					Tuple:
										parser.add_argument(
										    "--model_name_or_path"	,				default=_lowerCamelCase	,				type=_lowerCamelCase	,				required=_lowerCamelCase	,				help="Path to pretrained model or model identifier from huggingface.co/models"	,				)
										parser.add_argument(
										    "--config_name"	,				default=""	,				type=_lowerCamelCase	,				help="Pretrained config name or path if not the same as model_name"  )
										parser.add_argument(
										    "--tokenizer_name"	,				default=_lowerCamelCase	,				type=_lowerCamelCase	,				help="Pretrained tokenizer name or path if not the same as model_name"	,				)
										parser.add_argument(
										    "--cache_dir"	,				default=""	,				type=_lowerCamelCase	,				help="Where do you want to store the pre-trained models downloaded from huggingface.co"	,				)
										parser.add_argument(
										    "--encoder_layerdrop"	,				type=_lowerCamelCase	,				help="Encoder layer dropout probability (Optional). Goes into model.config"	,				)
										parser.add_argument(
										    "--decoder_layerdrop"	,				type=_lowerCamelCase	,				help="Decoder layer dropout probability (Optional). Goes into model.config"	,				)
										parser.add_argument(
										    "--dropout"	,				type=_lowerCamelCase	,				help="Dropout probability (Optional). Goes into model.config"	,				)
										parser.add_argument(
										    "--attention_dropout"	,				type=_lowerCamelCase	,				help="Attention dropout probability (Optional). Goes into model.config"	,				)
										parser.add_argument("--learning_rate"	,				default=5e-5	,				type=_lowerCamelCase	,				help="The initial learning rate for Adam."  )
										parser.add_argument(
										    "--lr_scheduler"	,				default="linear"	,				choices=_lowerCamelCase	,				metavar=_lowerCamelCase	,				type=_lowerCamelCase	,				help="Learning rate scheduler"	,				)
										parser.add_argument("--weight_decay"	,				default=0.0	,				type=_lowerCamelCase	,				help="Weight decay if we apply some."  )
										parser.add_argument("--adam_epsilon"	,				default=1e-8	,				type=_lowerCamelCase	,				help="Epsilon for Adam optimizer."  )
										parser.add_argument("--warmup_steps"	,				default=0	,				type=_lowerCamelCase	,				help="Linear warmup over warmup_steps."  )
										parser.add_argument("--num_workers"	,				default=4	,				type=_lowerCamelCase	,				help="kwarg passed to DataLoader"  )
										parser.add_argument("--num_train_epochs"	,				dest="max_epochs"	,				default=3	,				type=_lowerCamelCase  )
										parser.add_argument("--train_batch_size"	,				default=32	,				type=_lowerCamelCase  )
										parser.add_argument("--eval_batch_size"	,				default=32	,				type=_lowerCamelCase  )
										parser.add_argument("--adafactor"	,				action="store_true"  )






class 		UpperCamelCase_		(					pl.Callback   ):





						"""simple docstring"""




						def 					__A					( self				:					Optional[int]	,				_lowerCamelCase				:					Optional[Any]	,				_lowerCamelCase				:					Optional[int]  )							->					Dict:
										__magic_name__	  = trainer.lr_schedulers[0]["scheduler"]
										__magic_name__	  = {f'lr_group_{i}': lr for i, lr in enumerate(lr_scheduler.get_lr()  )}
										pl_module.logger.log_metrics(_lowerCamelCase  )
						def 					__A					( self				:					Tuple	,				_lowerCamelCase				:					pl.Trainer	,				_lowerCamelCase				:					pl.LightningModule  )							->					List[Any]:
										rank_zero_info("***** Validation results *****"  )
										__magic_name__	  = trainer.callback_metrics
										# Log results
										for key in sorted(_lowerCamelCase  ):
														if key not in ["log", "progress_bar"]:
																		rank_zero_info("{} = {}\n".format(_lowerCamelCase	,				str(metrics[key]  )  )  )

						def 					__A					( self				:					List[Any]	,				_lowerCamelCase				:					pl.Trainer	,				_lowerCamelCase				:					pl.LightningModule  )							->					Optional[int]:
										rank_zero_info("***** Test results *****"  )
										__magic_name__	  = trainer.callback_metrics
										# Log and save results to file
										__magic_name__	  = os.path.join(pl_module.hparams.output_dir	,				"test_results.txt"  )
										with open(_lowerCamelCase	,				"w"  ) as writer:
														for key in sorted(_lowerCamelCase  ):
																		if key not in ["log", "progress_bar"]:
																						rank_zero_info("{} = {}\n".format(_lowerCamelCase	,				str(metrics[key]  )  )  )
																						writer.write("{} = {}\n".format(_lowerCamelCase	,				str(metrics[key]  )  )  )





def      __snake_case       (       lowerCamelCase_ :				Dict	,  lowerCamelCase_ :				Tuple						):
				'''simple docstring'''




				parser.add_argument(
				    "--output_dir"	,  default=lowerCamelCase_	,  type=lowerCamelCase_	,  required=lowerCamelCase_	,  help="The output directory where the model predictions and checkpoints will be written."	,  )
				parser.add_argument(
				    "--fp16"	,  action="store_true"	,  help="Whether to use 16-bit (mixed) precision (through NVIDIA apex) instead of 32-bit"	,  )

				parser.add_argument(
				    "--fp16_opt_level"	,  type=lowerCamelCase_	,  default="O2"	,  help=(
				        "For fp16: Apex AMP optimization level selected in ['O0', 'O1', 'O2', and 'O3']."
				        "See details at https://nvidia.github.io/apex/amp.html"
				    )	,  )
				parser.add_argument("--n_tpu_cores"	,  dest="tpu_cores"	,  type=lowerCamelCase_						)
				parser.add_argument("--max_grad_norm"	,  dest="gradient_clip_val"	,  default=1.0	,  type=lowerCamelCase_	,  help="Max gradient norm"						)
				parser.add_argument("--do_train"	,  action="store_true"	,  help="Whether to run training."						)
				parser.add_argument("--do_predict"	,  action="store_true"	,  help="Whether to run predictions on the test set."						)
				parser.add_argument(
				    "--gradient_accumulation_steps"	,  dest="accumulate_grad_batches"	,  type=lowerCamelCase_	,  default=1	,  help="Number of updates steps to accumulate before performing a backward/update pass."	,  )
				parser.add_argument("--seed"	,  type=lowerCamelCase_	,  default=42	,  help="random seed for initialization"						)
				parser.add_argument(
				    "--data_dir"	,  default=lowerCamelCase_	,  type=lowerCamelCase_	,  required=lowerCamelCase_	,  help="The input data dir. Should contain the training files for the CoNLL-2003 NER task."	,  )




def      __snake_case       (       lowerCamelCase_ :				BaseTransformer	,  lowerCamelCase_ :				argparse.Namespace	,  lowerCamelCase_ :				Optional[Any]=None	,  lowerCamelCase_ :				Optional[int]=True	,  lowerCamelCase_ :				List[Any]=[]	,  lowerCamelCase_ :				Tuple=None	,  lowerCamelCase_ :				Any=None	,  **lowerCamelCase_ :				Any	,  ):
				'''simple docstring'''




				pl.seed_everything(args.seed						)

				# init model
				__magic_name__	  = Path(model.hparams.output_dir						)
				odir.mkdir(exist_ok=lowerCamelCase_						)

				# add custom checkpoints
				if checkpoint_callback is None:
								__magic_name__	  = pl.callbacks.ModelCheckpoint(
								    filepath=args.output_dir	,  prefix="checkpoint"	,  monitor="val_loss"	,  mode="min"	,  save_top_k=1						)
				if early_stopping_callback:
								extra_callbacks.append(lowerCamelCase_						)
				if logging_callback is None:
								__magic_name__	  = LoggingCallback()

				__magic_name__	  = {}

				# TODO: remove with PyTorch 1.6 since pl uses native amp
				if args.fpaa:
								__magic_name__	  = 16
								__magic_name__	  = args.fpaa_opt_level

				if args.gpus > 1:
								__magic_name__	  = "ddp"

				__magic_name__	  = args.accumulate_grad_batches
				__magic_name__	  = extra_train_kwargs.get("accelerator"	,  lowerCamelCase_						)
				__magic_name__	  = extra_train_kwargs.get("profiler"	,  lowerCamelCase_						)

				__magic_name__	  = pl.Trainer.from_argparse_args(
				    lowerCamelCase_	,  weights_summary=lowerCamelCase_	,  callbacks=[logging_callback] + extra_callbacks	,  logger=lowerCamelCase_	,  checkpoint_callback=lowerCamelCase_	,  **lowerCamelCase_	,  )

				if args.do_train:
								trainer.fit(lowerCamelCase_						)

				return trainer







'''simple docstring'''
def      __snake_case       (       lowerCamelCase_ :				int = 100						):
				'''simple docstring'''




				__magic_name__	  = [[0 for _ in range(lowerCamelCase_						)] for _ in range(m + 1						)]
				for i in range(m + 1						):
								__magic_name__	  = 1

				for n in range(m + 1						):
								for k in range(1	,  lowerCamelCase_						):
												memo[n][k] += memo[n][k - 1]
												if n > k:
																memo[n][k] += memo[n - k - 1][k]

				return memo[m][m - 1] - 1


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



