"""simple docstring"""





import json
import os
import unittest

from transformers.models.ctrl.tokenization_ctrl import VOCAB_FILES_NAMES, CTRLTokenizer

from ...test_tokenization_common import TokenizerTesterMixin
class  _snake_case     (					a__				, unittest.TestCase		):
						snake_case__			  =			CTRLTokenizer
						snake_case__			  =			False
						snake_case__			  =			False






						def       lowerCamelCase__     (       self      :			Optional[Any]    ):
													super().setUp()

													# Adapted from Sennrich et al. 2015 and https://github.com/rsennrich/subword-nmt
													__lowerCamelCase					:		Dict		   =     ["adapt", "re@@", "a@@", "apt", "c@@", "t", "<unk>"]
													__lowerCamelCase					:		Tuple		   =     dict(zip(UpperCAmelCase							,					range(len(UpperCAmelCase    )    )    )    )
													__lowerCamelCase					:		List[Any]		   =     ["#version: 0.2", "a p", "ap t</w>", "r e", "a d", "ad apt</w>", ""]
													__lowerCamelCase					:		Dict		   =     {"unk_token": "<unk>"}

													__lowerCamelCase					:		str		   =     os.path.join(self.tmpdirname							,					VOCAB_FILES_NAMES["vocab_file"]    )
													__lowerCamelCase					:		str		   =     os.path.join(self.tmpdirname							,					VOCAB_FILES_NAMES["merges_file"]    )
													with open(self.vocab_file							,					"w"							,					encoding="utf-8"    ) as fp:
																				fp.write(json.dumps(UpperCAmelCase    ) + "\n"    )
													with open(self.merges_file							,					"w"							,					encoding="utf-8"    ) as fp:
																				fp.write("\n".join(UpperCAmelCase    )    )






						def       lowerCamelCase__     (       self      :			int							,					**UpperCAmelCase      :			Dict    ):
													kwargs.update(self.special_tokens_map    )
													return CTRLTokenizer.from_pretrained(self.tmpdirname							,					**UpperCAmelCase    )






						def       lowerCamelCase__     (       self      :			Optional[int]							,					UpperCAmelCase      :			Any    ):
													__lowerCamelCase					:		Optional[Any]		   =     "adapt react readapt apt"
													__lowerCamelCase					:		Dict		   =     "adapt react readapt apt"
													return input_text, output_text







						def       lowerCamelCase__     (       self      :			Optional[Any]    ):
													__lowerCamelCase					:		Optional[Any]		   =     CTRLTokenizer(self.vocab_file							,					self.merges_file							,					**self.special_tokens_map    )
													__lowerCamelCase					:		int		   =     "adapt react readapt apt"
													__lowerCamelCase					:		Union[str, Any]		   =     "adapt re@@ a@@ c@@ t re@@ adapt apt".split()
													__lowerCamelCase					:		List[Any]		   =     tokenizer.tokenize(UpperCAmelCase    )
													self.assertListEqual(UpperCAmelCase							,					UpperCAmelCase    )

													__lowerCamelCase					:		Optional[int]		   =     tokens + [tokenizer.unk_token]

													__lowerCamelCase					:		Tuple		   =     [0, 1, 2, 4, 5, 1, 0, 3, 6]
													self.assertListEqual(tokenizer.convert_tokens_to_ids(UpperCAmelCase    )							,					UpperCAmelCase    )
"""simple docstring"""





from functools import lru_cache


def    lowercase_   (   _lowerCamelCase:	int      ) ->      set:



							'''simple docstring'''

							__lowerCamelCase					:		Optional[Any]		   =     2
							__lowerCamelCase					:		Tuple		   =     set()
							while i * i <= n:
														if n % i:
																					i += 1
														else:
																					n //= i
																					factors.add(_lowerCamelCase      )
							if n > 1:
														factors.add(_lowerCamelCase      )
							return factors


@lru_cache
def    lowercase_   (   _lowerCamelCase:	int      ) ->      int:



							'''simple docstring'''

							return len(unique_prime_factors(_lowerCamelCase      )      )


def    lowercase_   (   _lowerCamelCase:	list      ) ->      bool:



							'''simple docstring'''

							return len(set(_lowerCamelCase      )      ) in (0, 1)


def    lowercase_   (   _lowerCamelCase:	int      ) ->      list:



							'''simple docstring'''

							__lowerCamelCase					:		str		   =     2

							while True:
														# Increment each value of a generated range
														__lowerCamelCase					:		int		   =     [base + i for i in range(_lowerCamelCase      )]

														# Run elements through out unique_prime_factors function
														# Append our target number to the end.
														__lowerCamelCase					:		Dict		   =     [upf_len(_lowerCamelCase      ) for x in group]
														checker.append(_lowerCamelCase      )

														# If all numbers in the list are equal, return the group variable.
														if equality(_lowerCamelCase      ):
																					return group

														# Increment our base variable by 1
														base += 1


def    lowercase_   (   _lowerCamelCase:	int = 4      ) ->      int:



							'''simple docstring'''

							__lowerCamelCase					:		Any		   =     run(_lowerCamelCase      )
							return results[0] if len(_lowerCamelCase      ) else None


if __name__ == "__main__":
				print(solution())