


"""simple docstring"""


from math import sqrt


def _lowerCamelCase      (						_UpperCamelCase ):

			'''simple docstring'''




			assert isinstance(_UpperCamelCase       ,					_UpperCamelCase ) and (
			    number >= 0
			), "'number' must been an int and positive"

			__lowerCAmelCase							       =     True

			# 0 and 1 are none primes.
			if number <= 1:
						__lowerCAmelCase							       =     False

			for divisor in range(2       ,					int(round(sqrt(_UpperCamelCase ) ) ) + 1 ):
						# if 'number' divisible by 'divisor' then sets 'status'
						# of false and break up the loop.
						if number % divisor == 0:
									__lowerCAmelCase							       =     False
									break

    # precondition
			assert isinstance(_UpperCamelCase       ,					_UpperCamelCase ), "'status' must been from type bool"

			return status


def _lowerCamelCase      (						_UpperCamelCase ):

			'''simple docstring'''




			assert isinstance(_UpperCamelCase       ,					_UpperCamelCase ) and (n > 2), "'N' must been an int and > 2"

			# beginList: contains all natural numbers from 2 up to N
			__lowerCAmelCase							       =     list(range(2       ,					n + 1 ) )

			__lowerCAmelCase							       =     []  # this list will be returns.

			# actual sieve of erathostenes
			for i in range(len(_UpperCamelCase ) ):
						for j in range(i + 1       ,					len(_UpperCamelCase ) ):
									if (begin_list[i] != 0) and (begin_list[j] % begin_list[i] == 0):
												__lowerCAmelCase							       =     0

    # filters actual prime numbers.
			__lowerCAmelCase							       =     [x for x in begin_list if x != 0]

			# precondition
			assert isinstance(_UpperCamelCase       ,					_UpperCamelCase ), "'ans' must been from type list"

			return ans


def _lowerCamelCase      (						_UpperCamelCase ):

			'''simple docstring'''




			assert isinstance(_UpperCamelCase       ,					_UpperCamelCase ) and (n > 2), "'N' must been an int and > 2"

			__lowerCAmelCase							       =     []

			# iterates over all numbers between 2 up to N+1
			# if a number is prime then appends to list 'ans'
			for number in range(2       ,					n + 1 ):
						if is_prime(_UpperCamelCase ):
									ans.append(_UpperCamelCase )

    # precondition
			assert isinstance(_UpperCamelCase       ,					_UpperCamelCase ), "'ans' must been from type list"

			return ans


def _lowerCamelCase      (						_UpperCamelCase ):

			'''simple docstring'''




			assert isinstance(_UpperCamelCase       ,					_UpperCamelCase ) and number >= 0, "'number' must been an int and >= 0"

			__lowerCAmelCase							       =     []  # this list will be returns of the function.

			# potential prime number factors.

			__lowerCAmelCase							       =     2

			__lowerCAmelCase							       =     number

			if number == 0 or number == 1:
						ans.append(_UpperCamelCase )

			# if 'number' not prime then builds the prime factorization of 'number'
			elif not is_prime(_UpperCamelCase ):
						while quotient != 1:
									if is_prime(_UpperCamelCase ) and (quotient % factor == 0):
												ans.append(_UpperCamelCase )
												quotient /= factor
									else:
												factor += 1

			else:
						ans.append(_UpperCamelCase )

			# precondition
			assert isinstance(_UpperCamelCase       ,					_UpperCamelCase ), "'ans' must been from type list"

			return ans


def _lowerCamelCase      (						_UpperCamelCase ):

			'''simple docstring'''




			assert isinstance(_UpperCamelCase       ,					_UpperCamelCase ) and (
			    number >= 0
			), "'number' bust been an int and >= 0"

			__lowerCAmelCase							       =     0

			# prime factorization of 'number'
			__lowerCAmelCase							       =     prime_factorization(_UpperCamelCase )

			__lowerCAmelCase							       =     max(_UpperCamelCase )

			# precondition
			assert isinstance(_UpperCamelCase       ,					_UpperCamelCase ), "'ans' must been from type int"

			return ans


def _lowerCamelCase      (						_UpperCamelCase ):

			'''simple docstring'''




			assert isinstance(_UpperCamelCase       ,					_UpperCamelCase ) and (
			    number >= 0
			), "'number' bust been an int and >= 0"

			__lowerCAmelCase							       =     0

			# prime factorization of 'number'
			__lowerCAmelCase							       =     prime_factorization(_UpperCamelCase )

			__lowerCAmelCase							       =     min(_UpperCamelCase )

			# precondition
			assert isinstance(_UpperCamelCase       ,					_UpperCamelCase ), "'ans' must been from type int"

			return ans


def _lowerCamelCase      (						_UpperCamelCase ):

			'''simple docstring'''




			assert isinstance(_UpperCamelCase       ,					_UpperCamelCase ), "'number' must been an int"
			assert isinstance(number % 2 == 0       ,					_UpperCamelCase ), "compare bust been from type bool"

			return number % 2 == 0


def _lowerCamelCase      (						_UpperCamelCase ):

			'''simple docstring'''




			assert isinstance(_UpperCamelCase       ,					_UpperCamelCase ), "'number' must been an int"
			assert isinstance(number % 2 != 0       ,					_UpperCamelCase ), "compare bust been from type bool"

			return number % 2 != 0


def _lowerCamelCase      (						_UpperCamelCase ):

			'''simple docstring'''




			assert (
			    isinstance(_UpperCamelCase       ,					_UpperCamelCase ) and (number > 2) and is_even(_UpperCamelCase )
			), "'number' must been an int, even and > 2"

			__lowerCAmelCase							       =     []  # this list will returned

			# creates a list of prime numbers between 2 up to 'number'
			__lowerCAmelCase							       =     get_prime_numbers(_UpperCamelCase )
			__lowerCAmelCase							       =     len(_UpperCamelCase )

			# run variable for while-loops.
			__lowerCAmelCase							       =     0
			__lowerCAmelCase							       =     None

			# exit variable. for break up the loops
			__lowerCAmelCase							       =     True

			while i < len_pn and loop:
						__lowerCAmelCase							       =     i + 1

						while j < len_pn and loop:
									if prime_numbers[i] + prime_numbers[j] == number:
												__lowerCAmelCase							       =     False
												ans.append(prime_numbers[i] )
												ans.append(prime_numbers[j] )

									j += 1

						i += 1

			# precondition
			assert (
			    isinstance(_UpperCamelCase       ,					_UpperCamelCase )
			    and (len(_UpperCamelCase ) == 2)
			    and (ans[0] + ans[1] == number)
			    and is_prime(ans[0] )
			    and is_prime(ans[1] )
			), "'ans' must contains two primes. And sum of elements must been eq 'number'"

			return ans


def _lowerCamelCase      (						_UpperCamelCase       ,					_UpperCamelCase ):

			'''simple docstring'''




			assert (
			    isinstance(_UpperCamelCase       ,					_UpperCamelCase )
			    and isinstance(_UpperCamelCase       ,					_UpperCamelCase )
			    and (numbera >= 0)
			    and (numbera >= 0)
			), "'number1' and 'number2' must been positive integer."

			__lowerCAmelCase							       =     0

			while numbera != 0:
						__lowerCAmelCase							       =     numbera % numbera
						__lowerCAmelCase							       =     numbera
						__lowerCAmelCase							       =     rest

			# precondition
			assert isinstance(_UpperCamelCase       ,					_UpperCamelCase ) and (
			    numbera >= 0
			), "'number' must been from type int and positive"

			return numbera


def _lowerCamelCase      (						_UpperCamelCase       ,					_UpperCamelCase ):

			'''simple docstring'''




			assert (
			    isinstance(_UpperCamelCase       ,					_UpperCamelCase )
			    and isinstance(_UpperCamelCase       ,					_UpperCamelCase )
			    and (numbera >= 1)
			    and (numbera >= 1)
			), "'number1' and 'number2' must been positive integer."

			__lowerCAmelCase							       =     1  # actual answer that will be return.

			# for kgV (x,1)
			if numbera > 1 and numbera > 1:
						# builds the prime factorization of 'number1' and 'number2'
						__lowerCAmelCase							       =     prime_factorization(_UpperCamelCase )
						__lowerCAmelCase							       =     prime_factorization(_UpperCamelCase )

			elif numbera == 1 or numbera == 1:
						__lowerCAmelCase							       =     []
						__lowerCAmelCase							       =     []
						__lowerCAmelCase							       =     max(_UpperCamelCase       ,					_UpperCamelCase )

			__lowerCAmelCase							       =     0
			__lowerCAmelCase							       =     0

			__lowerCAmelCase							       =     []  # captured numbers int both 'primeFac1' and 'primeFac2'

			# iterates through primeFac1
			for n in prime_fac_a:
						if n not in done:
									if n in prime_fac_a:
												__lowerCAmelCase							       =     prime_fac_a.count(_UpperCamelCase )
												__lowerCAmelCase							       =     prime_fac_a.count(_UpperCamelCase )

												for _ in range(max(_UpperCamelCase       ,					_UpperCamelCase ) ):
															ans *= n

									else:
												__lowerCAmelCase							       =     prime_fac_a.count(_UpperCamelCase )

												for _ in range(_UpperCamelCase ):
															ans *= n

									done.append(_UpperCamelCase )

    # iterates through primeFac2
			for n in prime_fac_a:
						if n not in done:
									__lowerCAmelCase							       =     prime_fac_a.count(_UpperCamelCase )

									for _ in range(_UpperCamelCase ):
												ans *= n

									done.append(_UpperCamelCase )

    # precondition
			assert isinstance(_UpperCamelCase       ,					_UpperCamelCase ) and (
			    ans >= 0
			), "'ans' must been from type int and positive"

			return ans


def _lowerCamelCase      (						_UpperCamelCase ):

			'''simple docstring'''




			assert isinstance(_UpperCamelCase       ,					_UpperCamelCase ) and (n >= 0), "'number' must been a positive int"

			__lowerCAmelCase							       =     0
			__lowerCAmelCase							       =     2  # this variable holds the answer

			while index < n:
						index += 1

						ans += 1  # counts to the next number

						# if ans not prime then
						# runs to the next prime number.
						while not is_prime(_UpperCamelCase ):
									ans += 1

    # precondition
			assert isinstance(_UpperCamelCase       ,					_UpperCamelCase ) and is_prime(
			    _UpperCamelCase ), "'ans' must been a prime number and from type int"

			return ans


def _lowerCamelCase      (						_UpperCamelCase       ,					_UpperCamelCase ):

			'''simple docstring'''




			assert (
			    is_prime(_UpperCamelCase ) and is_prime(_UpperCamelCase ) and (p_number_a < p_number_a)
			), "The arguments must been prime numbers and 'pNumber1' < 'pNumber2'"

			__lowerCAmelCase							       =     p_number_a + 1  # jump to the next number

			__lowerCAmelCase							       =     []  # this list will be returns.

			# if number is not prime then
			# fetch the next prime number.
			while not is_prime(_UpperCamelCase ):
						number += 1

			while number < p_number_a:
						ans.append(_UpperCamelCase )

						number += 1

						# fetch the next prime number.
						while not is_prime(_UpperCamelCase ):
									number += 1

    # precondition
			assert (
			    isinstance(_UpperCamelCase       ,					_UpperCamelCase )
			    and ans[0] != p_number_a
			    and ans[len(_UpperCamelCase ) - 1] != p_number_a
			), "'ans' must been a list without the arguments"

			# 'ans' contains not 'pNumber1' and 'pNumber2' !
			return ans


def _lowerCamelCase      (						_UpperCamelCase ):

			'''simple docstring'''




			assert isinstance(_UpperCamelCase       ,					_UpperCamelCase ) and (n >= 1), "'n' must been int and >= 1"

			__lowerCAmelCase							       =     []  # will be returned.

			for divisor in range(1       ,					n + 1 ):
						if n % divisor == 0:
									ans.append(_UpperCamelCase )

    # precondition
			assert ans[0] == 1 and ans[len(_UpperCamelCase ) - 1] == n, "Error in function getDivisiors(...)"

			return ans


def _lowerCamelCase      (						_UpperCamelCase ):

			'''simple docstring'''




			assert isinstance(_UpperCamelCase       ,					_UpperCamelCase ) and (
			    number > 1
			), "'number' must been an int and >= 1"

			__lowerCAmelCase							       =     get_divisors(_UpperCamelCase )

			# precondition
			assert (
			    isinstance(_UpperCamelCase       ,					_UpperCamelCase )
			    and (divisors[0] == 1)
			    and (divisors[len(_UpperCamelCase ) - 1] == number)
			), "Error in help-function getDivisiors(...)"

			# summed all divisors up to 'number' (exclusive), hence [:-1]
			return sum(divisors[:-1] ) == number


def _lowerCamelCase      (						_UpperCamelCase       ,					_UpperCamelCase ):

			'''simple docstring'''




			assert (
			    isinstance(_UpperCamelCase       ,					_UpperCamelCase )
			    and isinstance(_UpperCamelCase       ,					_UpperCamelCase )
			    and (denominator != 0)
			), "The arguments must been from type int and 'denominator' != 0"

			# build the greatest common divisor of numerator and denominator.
			__lowerCAmelCase							       =     gcd(abs(_UpperCamelCase )       ,					abs(_UpperCamelCase ) )

			# precondition
			assert (
			    isinstance(_UpperCamelCase       ,					_UpperCamelCase )
			    and (numerator % gcd_of_fraction == 0)
			    and (denominator % gcd_of_fraction == 0)
			), "Error in function gcd(...,...)"

			return (numerator // gcd_of_fraction, denominator // gcd_of_fraction)


def _lowerCamelCase      (						_UpperCamelCase ):

			'''simple docstring'''




			assert isinstance(_UpperCamelCase       ,					_UpperCamelCase ) and (n >= 0), "'n' must been a int and >= 0"

			__lowerCAmelCase							       =     1  # this will be return.

			for factor in range(1       ,					n + 1 ):
						ans *= factor

			return ans


def _lowerCamelCase      (						_UpperCamelCase ):

			'''simple docstring'''




			assert isinstance(_UpperCamelCase       ,					_UpperCamelCase ) and (n >= 0), "'n' must been an int and >= 0"

			__lowerCAmelCase							       =     0
			__lowerCAmelCase							       =     1
			__lowerCAmelCase							       =     1  # this will be return

			for _ in range(n - 1 ):
						__lowerCAmelCase							       =     ans
						ans += fiba
						__lowerCAmelCase							       =     tmp

			return ans








"""simple docstring"""


import os
from shutil import copyfile
from typing import List, Optional, Tuple

from ...tokenization_utils import AddedToken
from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import is_sentencepiece_available, logging


if is_sentencepiece_available():
	from .tokenization_xlnet import XLNetTokenizer
else:
	A	:  Optional[Any]            =     None


A	:  Any            =     logging.get_logger(__name__)

A	:  Union[str, Any]            =     {"vocab_file": "spiece.model", "tokenizer_file": "tokenizer.json"}

A	:  List[Any]            =     {
    "vocab_file": {
        "xlnet-base-cased": "https://huggingface.co/xlnet-base-cased/resolve/main/spiece.model",
        "xlnet-large-cased": "https://huggingface.co/xlnet-large-cased/resolve/main/spiece.model",
    },
    "tokenizer_file": {
        "xlnet-base-cased": "https://huggingface.co/xlnet-base-cased/resolve/main/tokenizer.json",
        "xlnet-large-cased": "https://huggingface.co/xlnet-large-cased/resolve/main/tokenizer.json",
    },
}

A	:  Union[str, Any]            =     {
    "xlnet-base-cased": None,
    "xlnet-large-cased": None,
}

A	:  Optional[int]            =     "▁"

# Segments (not really needed)
A	:  str            =     0
A	:  Dict            =     1
A	:  List[str]            =     2
A	:  Tuple            =     3
A	:  Tuple            =     4
class     _UpperCamelCase    (  lowerCAmelCase__						):
							'''simple docstring'''







							__UpperCAmelCase		:       Optional[Any]							 =VOCAB_FILES_NAMES
							__UpperCAmelCase		:       Optional[int]							 =PRETRAINED_VOCAB_FILES_MAP
							__UpperCAmelCase		:       Dict							 =PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
							__UpperCAmelCase		:       List[Any]							 ="""left"""
							__UpperCAmelCase		:       List[str]							 =XLNetTokenizer

							def __init__(	self       ,  __a=None       ,  __a=None       ,  __a=False       ,  __a=True       ,  __a=False       ,  __a="<s>"       ,  __a="</s>"       ,  __a="<unk>"       ,  __a="<sep>"       ,  __a="<pad>"       ,  __a="<cls>"       ,  __a="<mask>"       ,  __a=["<eop>", "<eod>"]       ,  **__a       ,  ):
										# Mask token behave like a normal word, i.e. include the space before it
										__lowerCAmelCase							       =     AddedToken(__a       ,  lstrip=__a       ,  rstrip=__a      ) if isinstance(__a       ,  __a      ) else mask_token

										super().__init__(
										    vocab_file=__a       ,  tokenizer_file=__a       ,  do_lower_case=__a       ,  remove_space=__a       ,  keep_accents=__a       ,  bos_token=__a       ,  eos_token=__a       ,  unk_token=__a       ,  sep_token=__a       ,  pad_token=__a       ,  cls_token=__a       ,  mask_token=__a       ,  additional_special_tokens=__a       ,  **__a       ,  )

										__lowerCAmelCase							       =     3
										__lowerCAmelCase							       =     do_lower_case
										__lowerCAmelCase							       =     remove_space
										__lowerCAmelCase							       =     keep_accents
										__lowerCAmelCase							       =     vocab_file
										__lowerCAmelCase							       =     False if not self.vocab_file else True

							def      snake_case							(	self       ,  __a       ,  __a = None      ):
										__lowerCAmelCase							       =     [self.sep_token_id]
										__lowerCAmelCase							       =     [self.cls_token_id]
										if token_ids_a is None:
													return token_ids_a + sep + cls
										return token_ids_a + sep + token_ids_a + sep + cls

							def      snake_case							(	self       ,  __a       ,  __a = None      ):
										__lowerCAmelCase							       =     [self.sep_token_id]
										__lowerCAmelCase							       =     [2]

										if token_ids_a is None:
													return len(token_ids_a + sep      ) * [0] + cls_segment_id
										return len(token_ids_a + sep      ) * [0] + len(token_ids_a + sep      ) * [1] + cls_segment_id



							def      snake_case							(	self       ,  __a       ,  __a = None      ):
										if not self.can_save_slow_tokenizer:
													raise ValueError(
													    "Your fast tokenizer does not have the necessary information to save the vocabulary for a slow "
													    "tokenizer."      )

										if not os.path.isdir(__a      ):
													logger.error(f"Vocabulary path ({save_directory}) should be a directory"      )
													return
										__lowerCAmelCase							       =     os.path.join(
										    __a       ,  (filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["vocab_file"]      )

										if os.path.abspath(self.vocab_file      ) != os.path.abspath(__a      ):
													copyfile(self.vocab_file       ,  __a      )

										return (out_vocab_file,)




