



"""simple docstring"""
from math import sqrt





def        __magic_name__			(							lowercase	):
   SCREAMING_SNAKE_CASE_:	Union[str, Any]            =[1]
   for i in range(2							,     int(sqrt(lowercase	)	) + 1							,     1	):
      if number % i == 0:
         values.append(lowercase	)
         if int(number // i	) != i:
            values.append(int(number // i	)	)
   return sorted(lowercase	)





def        __magic_name__			(							lowercase	):
   return sum(factors(lowercase	)	) > n





def        __magic_name__			(							lowercase	):
   SCREAMING_SNAKE_CASE_:	Tuple            =factors(lowercase	)
   SCREAMING_SNAKE_CASE_:	List[Any]            =len(lowercase	)
   SCREAMING_SNAKE_CASE_:	Any            =[[0 for i in range(number + 1	)] for j in range(r + 1	)]
   for i in range(r + 1	):
      SCREAMING_SNAKE_CASE_:	Union[str, Any]            =True

   for i in range(1							,     number + 1	):
      SCREAMING_SNAKE_CASE_:	Dict            =False

   for i in range(1							,     r + 1	):
      for j in range(1							,     number + 1	):
         if j < values[i - 1]:
            SCREAMING_SNAKE_CASE_:	str            =subset[i - 1][j]
         else:
            SCREAMING_SNAKE_CASE_:	Union[str, Any]            =subset[i - 1][j] or subset[i - 1][j - values[i - 1]]

   return subset[r][number] != 0





def        __magic_name__			(							lowercase	):
   return abundant(lowercase	) and not semi_perfect(lowercase	)


if __name__ == "__main__":
   import doctest

   doctest.testmod(verbose=True)
   for number in (6_9, 7_0, 7_1):
      print(f"""{number} is {'' if weird(number) else 'not '}weird.""")








"""simple docstring"""
from typing import List

from tokenizers import NormalizedString, PreTokenizedString, normalizers
class    a		:



  def __init__(  self	:   Optional[Any]    ,						lowerCAmelCase	:   List[str]						)       ->   None:


     '''simple docstring'''




     SCREAMING_SNAKE_CASE_:	int            =vocab
     SCREAMING_SNAKE_CASE_:	Union[str, Any]            =normalizers.BertNormalizer(
         clean_text=lowerCAmelCase    ,						handle_chinese_chars=lowerCAmelCase    ,						strip_accents=lowerCAmelCase    ,						lowercase=lowerCAmelCase    ,						)
     try:
        import rjieba
     except ImportError:
        raise ImportError(
            """You need to install rjieba to use RoFormerTokenizer. """
            """See https://pypi.org/project/rjieba/ for installation."""						)
     SCREAMING_SNAKE_CASE_:	Dict            =rjieba



  def 		lowerCamelCase__    (  self	:   Tuple    ,						lowerCAmelCase	:   int    ,						lowerCAmelCase	:   NormalizedString						)       ->   List[NormalizedString]:


     '''simple docstring'''




     SCREAMING_SNAKE_CASE_:	Optional[int]            =[]

     # this code slice normalized_string is too slow (6s) but test_alignement_methods can pass
     for token, start, end in self.jieba.tokenize(str(lowerCAmelCase						)    ,						hmm=lowerCAmelCase						):
        if token in self.vocab:
           splits.append(normalized_string[start:end]						)
        else:
           SCREAMING_SNAKE_CASE_:	List[Any]            =self.normalizers.normalize_str(lowerCAmelCase						).split()
           for token in token_list:
              if token:
                 SCREAMING_SNAKE_CASE_:	Dict            =start + len(lowerCAmelCase						)
                 splits.append(normalized_string[start:end]						)
                 SCREAMING_SNAKE_CASE_:	Optional[Any]            =end

        # this code test_alignement_methods can't pass but fast (300ms)
        # for token in self.jieba.cut(str(normalized_string), False):
        #     if token in self.vocab:
        #         splits.append(NormalizedString(token))
        #     else:
        #         token_list = self.normalizers.normalize_str(token).split()
        #         for token in token_list:
        #             if token:
        #                 splits.append(NormalizedString(token))

     return splits





  def 		lowerCamelCase__    (  self	:   Union[str, Any]    ,						lowerCAmelCase	:   PreTokenizedString						)       ->   Tuple:


     '''simple docstring'''




     pretok.split(self.jieba_split						)



