import argparse
import logging
import math
import time

import torch

from transformers import TransfoXLCorpus, TransfoXLLMHeadModel


logging.basicConfig(
    format="%(asctime)s - %(levelname)s - %(name)s - %(message)s", datefmt="%m/%d/%Y %H:%M:%S", level=logging.INFO
)
lowercase_   				=       logging.getLogger(__name__)







def  __lowerCAmelCase							(						):







    '''simple docstring'''
    __snake_case    :							int             =  argparse.ArgumentParser(description="""PyTorch Transformer Language Model"""					)
    parser.add_argument("""--model_name"""						,				type=SCREAMING_SNAKE_CASE__						,				default="""transfo-xl-wt103"""						,				help="""pretrained model name"""					)
    parser.add_argument(
        """--split"""						,				type=SCREAMING_SNAKE_CASE__						,				default="""test"""						,				choices=["""all""", """valid""", """test"""]						,				help="""which split to evaluate"""					)
    parser.add_argument("""--batch_size"""						,				type=SCREAMING_SNAKE_CASE__						,				default=1_0						,				help="""batch size"""					)
    parser.add_argument("""--tgt_len"""						,				type=SCREAMING_SNAKE_CASE__						,				default=1_2_8						,				help="""number of tokens to predict"""					)
    parser.add_argument("""--ext_len"""						,				type=SCREAMING_SNAKE_CASE__						,				default=0						,				help="""length of the extended context"""					)
    parser.add_argument("""--mem_len"""						,				type=SCREAMING_SNAKE_CASE__						,				default=1_6_0_0						,				help="""length of the retained previous heads"""					)
    parser.add_argument("""--clamp_len"""						,				type=SCREAMING_SNAKE_CASE__						,				default=1_0_0_0						,				help="""max positional embedding index"""					)
    parser.add_argument("""--no_cuda"""						,				action="""store_true"""						,				help="""Do not use CUDA even though CUA is available"""					)
    parser.add_argument("""--work_dir"""						,				type=SCREAMING_SNAKE_CASE__						,				required=SCREAMING_SNAKE_CASE__						,				help="""path to the work_dir"""					)
    parser.add_argument("""--no_log"""						,				action="""store_true"""						,				help="""do not log the eval result"""					)
    parser.add_argument("""--same_length"""						,				action="""store_true"""						,				help="""set same length attention with masking"""					)
    parser.add_argument("""--server_ip"""						,				type=SCREAMING_SNAKE_CASE__						,				default=""""""						,				help="""Can be used for distant debugging."""					)
    parser.add_argument("""--server_port"""						,				type=SCREAMING_SNAKE_CASE__						,				default=""""""						,				help="""Can be used for distant debugging."""					)
    __snake_case    :							List[Any]             =  parser.parse_args()
    assert args.ext_len >= 0, "extended context length must be non-negative"

    if args.server_ip and args.server_port:
        # Distant debugging - see https://code.visualstudio.com/docs/python/debugging#_attach-to-a-local-script
        import ptvsd

        print("""Waiting for debugger attach"""					)
        ptvsd.enable_attach(address=(args.server_ip, args.server_port)						,				redirect_output=SCREAMING_SNAKE_CASE__					)
        ptvsd.wait_for_attach()

    __snake_case    :							Union[str, Any]             =  torch.device("""cuda""" if torch.cuda.is_available() and not args.no_cuda else """cpu"""					)
    logger.info("""device: {}""".format(SCREAMING_SNAKE_CASE__					)					)

    # Load a pre-processed dataset
    # You can also build the corpus yourself using TransfoXLCorpus methods
    # The pre-processing involve computing word frequencies to prepare the Adaptive input and SoftMax
    # and tokenizing the dataset
    # The pre-processed corpus is a convertion (using the conversion script )
    __snake_case    :							List[str]             =  TransfoXLCorpus.from_pretrained(args.model_name					)

    __snake_case    :							Union[str, Any]             =  corpus.get_iterator("""valid"""						,				args.batch_size						,				args.tgt_len						,				device=SCREAMING_SNAKE_CASE__						,				ext_len=args.ext_len					)
    __snake_case    :							int             =  corpus.get_iterator("""test"""						,				args.batch_size						,				args.tgt_len						,				device=SCREAMING_SNAKE_CASE__						,				ext_len=args.ext_len					)

    # Load a pre-trained model
    __snake_case    :							Dict             =  TransfoXLLMHeadModel.from_pretrained(args.model_name					)
    model.to(SCREAMING_SNAKE_CASE__					)

    logger.info(
        """Evaluating with bsz {} tgt_len {} ext_len {} mem_len {} clamp_len {}""".format(
            args.batch_size						,				args.tgt_len						,				args.ext_len						,				args.mem_len						,				args.clamp_len					)					)

    model.reset_memory_length(args.mem_len					)
    if args.clamp_len > 0:
        __snake_case    :							Any             =  args.clamp_len
    if args.same_length:
        __snake_case    :							Any             =  True

    ###############################################################################
    # Evaluation code
    ###############################################################################
    def evaluate(__SCREAMING_SNAKE_CASE    : str					):
        # Turn on evaluation mode which disables dropout.
        model.eval()
        __snake_case    :							List[Any]             =  0, 0.0
        __snake_case    :							Any             =  time.time()
        with torch.no_grad():
            __snake_case    :							List[str]             =  None
            for idx, (data, target, seq_len) in enumerate(SCREAMING_SNAKE_CASE__					):
                __snake_case    :							str             =  model(SCREAMING_SNAKE_CASE__						,				lm_labels=SCREAMING_SNAKE_CASE__						,				mems=SCREAMING_SNAKE_CASE__					)
                __snake_case    :							Optional[Any]             =  ret
                __snake_case    :							List[str]             =  loss.mean()
                total_loss += seq_len * loss.item()
                total_len += seq_len
            __snake_case    :							Tuple             =  time.time() - start_time
        logger.info("""Time : {:.2f}s, {:.2f}ms/segment""".format(SCREAMING_SNAKE_CASE__						,				1_0_0_0 * total_time / (idx + 1)					)					)
        return total_loss / total_len

    # Run on test data.
    if args.split == "all":
        __snake_case    :							List[Any]             =  evaluate(SCREAMING_SNAKE_CASE__					)
        __snake_case    :							str             =  evaluate(SCREAMING_SNAKE_CASE__					)
    elif args.split == "valid":
        __snake_case    :							Optional[Any]             =  evaluate(SCREAMING_SNAKE_CASE__					)
        __snake_case    :							Dict             =  None
    elif args.split == "test":
        __snake_case    :							List[str]             =  evaluate(SCREAMING_SNAKE_CASE__					)
        __snake_case    :							Union[str, Any]             =  None

    def format_log(__SCREAMING_SNAKE_CASE    : int						,				__SCREAMING_SNAKE_CASE    : str					):
        __snake_case    :							List[str]             =  '| {0} loss {1:5.2f} | {0} ppl {2:9.3f} '.format(SCREAMING_SNAKE_CASE__						,				SCREAMING_SNAKE_CASE__						,				math.exp(SCREAMING_SNAKE_CASE__					)					)
        return log_str

    __snake_case    :							List[Any]             =  ''
    if valid_loss is not None:
        log_str += format_log(SCREAMING_SNAKE_CASE__						,				"""valid"""					)
    if test_loss is not None:
        log_str += format_log(SCREAMING_SNAKE_CASE__						,				"""test"""					)

    logger.info("""=""" * 1_0_0					)
    logger.info(SCREAMING_SNAKE_CASE__					)
    logger.info("""=""" * 1_0_0					)


if __name__ == "__main__":
     main()







def       UpperCamelCase__     (  SCREAMING_SNAKE_CASE__ = 100						):
 __lowerCamelCase		:							List[Any]							=						[[0 for _ in range(SCREAMING_SNAKE_CASE__						)] for _ in range(m + 1						)]
 for i in range(m + 1						):
  __lowerCamelCase		:							Any							=						1

 for n in range(m + 1						):
  for k in range(1			,       SCREAMING_SNAKE_CASE__						):
   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())))

