






__UpperCAmelCase      =				{
    "0": 1,
    "1": 1,
    "2": 2,
    "3": 6,
    "4": 2_4,
    "5": 1_2_0,
    "6": 7_2_0,
    "7": 5_0_4_0,
    "8": 4_0_3_2_0,
    "9": 3_6_2_8_8_0,
}

__UpperCAmelCase      =				{1_4_5: 1_4_5}

__UpperCAmelCase      =				{
    1_4_5: 0,
    1_6_9: 3,
    3_6_3_0_1: 3,
    1_4_5_4: 3,
    8_7_1: 2,
    4_5_3_6_1: 2,
    8_7_2: 2,
}





def 						A_					(						lowercase_			)				->int:







 """simple docstring"""

 if n in CACHE_SUM_DIGIT_FACTORIALS:
  return CACHE_SUM_DIGIT_FACTORIALS[n]
 SCREAMING_SNAKE_CASE				    =		sum(DIGIT_FACTORIALS[let] for let in str(lowercase_			)			)
 SCREAMING_SNAKE_CASE				    =		ret
 return ret





def 						A_					(						lowercase_	,  lowercase_ = None			)				->int:







 """simple docstring"""

 SCREAMING_SNAKE_CASE				    =		previous or set()
 if n in CHAIN_LENGTH_CACHE:
  return CHAIN_LENGTH_CACHE[n]
 SCREAMING_SNAKE_CASE				    =		sum_digit_factorials(lowercase_			)
 if next_number in previous:
  SCREAMING_SNAKE_CASE				    =		0
  return 0
 else:
  previous.add(lowercase_			)
  SCREAMING_SNAKE_CASE				    =		1 + chain_length(lowercase_	,  lowercase_			)
  SCREAMING_SNAKE_CASE				    =		ret
  return ret





def 						A_					(						lowercase_ = 6_0	,  lowercase_ = 1_0_0_0_0_0_0			)				->int:







 """simple docstring"""

 return sum(1 for i in range(1	,  lowercase_			) if chain_length(lowercase_			) == num_terms			)


if __name__ == "__main__":
      print(f'{solution() = }')









"""simple docstring"""







import argparse
import logging

import datasets
from tokenizers import Tokenizer, decoders, normalizers, pre_tokenizers, processors
from tokenizers.models import Unigram
from tokenizers.trainers import UnigramTrainer

from transformers import AlbertTokenizerFast


UpperCAmelCase:  List[str]			     =				logging.getLogger(__name__)


def  __SCREAMING_SNAKE_CASE (  ):
		_lowercase				: List[Any]     =   argparse.ArgumentParser(description="""Train a unigram tokenizer on the wikitext dataset."""      )
		parser.add_argument(
		    """--dataset_name"""   ,				type=__UpperCAmelCase   ,				default="""wikitext"""   ,				help="""Name of the training. Explore datasets at: hf.co/datasets."""   ,				)
		parser.add_argument(
		    """--dataset_config"""   ,				type=__UpperCAmelCase   ,				default="""wikitext-103-raw-v1"""   ,				help="""Configuration name of the dataset."""      )
		parser.add_argument(
		    """--batch_size"""   ,				type=__UpperCAmelCase   ,				default=1000   ,				help="""Batch size during training."""   ,				)
		parser.add_argument(
		    """--vocab_size"""   ,				type=__UpperCAmelCase   ,				default=10048   ,				help="""Size of the desired vocabulary."""   ,				)
		parser.add_argument(
		    """--limit"""   ,				default=__UpperCAmelCase   ,				type=__UpperCAmelCase   ,				help="""Limit the number of shards (used for debugging)."""   ,				)
		parser.add_argument(
		    """--export_to_hub"""   ,				action="""store_true"""   ,				)

		_lowercase				: Any     =   parser.parse_args()
		return args


def  __SCREAMING_SNAKE_CASE (  __UpperCAmelCase      ):
		_lowercase				: List[Any]     =   datasets.load_dataset(args.dataset_name   ,				args.dataset_config   ,				split="""train"""      )

		if args.limit is not None:
				_lowercase				: Tuple     =   min(len(__UpperCAmelCase      )   ,				args.limit      )
				_lowercase				: Optional[Any]     =   dataset.select(range(__UpperCAmelCase      )      )
				logger.info(F"""Limiting the dataset to {args.limit} entries."""      )

		def batch_iterator():
				for i in range(0   ,				len(__UpperCAmelCase      )   ,				args.batch_size      ):
						yield dataset[i : i + args.batch_size]["text"]

    # Prepare the tokenizer.
		_lowercase				: Optional[int]     =   Tokenizer(Unigram()      )
		_lowercase				: List[str]     =   normalizers.Sequence([normalizers.Replace("""``"""   ,				"""\""""      ), normalizers.Replace("""''"""   ,				"""\""""      )]      )
		_lowercase				: str     =   pre_tokenizers.Metaspace()

		# Prepare the trainer.
		_lowercase				: int     =   UnigramTrainer(
		    unk_token="""<unk>"""   ,				special_tokens=["""[CLS]""", """[SEP]""", """<unk>""", """<pad>""", """[MASK]"""]   ,				vocab_size=args.vocab_size   ,				)

		logger.info("""Training the tokenizer."""      )
		tokenizer.train_from_iterator(batch_iterator()   ,				trainer=__UpperCAmelCase      )
		logger.info("""Tokenizer training complete!"""      )

		_lowercase				: int     =   tokenizer.token_to_id("""[CLS]"""      )
		_lowercase				: Optional[Any]     =   tokenizer.token_to_id("""[SEP]"""      )
		_lowercase				: Optional[int]     =   processors.TemplateProcessing(
		    single="""[CLS]:0 $A:0 [SEP]:0"""   ,				pair="""[CLS]:0 $A:0 [SEP]:0 $B:1 [SEP]:1"""   ,				special_tokens=[
		        ("""[CLS]""", cls_token_id),
		        ("""[SEP]""", sep_token_id),
		    ]   ,				)
		_lowercase				: Union[str, Any]     =   decoders.Metaspace()

		if args.export_to_hub:
				logger.info("""Exporting the trained tokenzier to Hub."""      )
				_lowercase				: List[Any]     =   AlbertTokenizerFast(tokenizer_object=__UpperCAmelCase      )
				new_tokenizer.push_to_hub("""unigram-tokenizer-dataset"""      )


if __name__ == "__main__":
		UpperCAmelCase:  List[Any]			     =				parse_args()
		main(args)



