





import copy
import random

from transformers import CLIPTokenizer






class 						UpperCamelCase_  (  snake_case__							):



					def __init__(		self     :     Any       ,      *lowerCamelCase     :     Any       ,      **lowerCamelCase     :     List[str]						):
							super().__init__(*lowerCamelCase       ,      **lowerCamelCase						)
							lowerCamelCase_	:     Optional[Any] 						=      {}



					def   __a     (		self     :     Optional[int]       ,      lowerCamelCase     :     List[str]       ,      *lowerCamelCase     :     Any       ,      **lowerCamelCase     :     Union[str, Any]						):
							lowerCamelCase_	:     int 						=      super().add_tokens(lowerCamelCase       ,      *lowerCamelCase       ,      **lowerCamelCase						)
							if num_added_tokens == 0:
									raise ValueError(
									    F"The tokenizer already contains the token {placeholder_token}. Please pass a different"
									    ' `placeholder_token` that is not already in the tokenizer.'						)



					def   __a     (		self     :     List[Any]       ,      lowerCamelCase     :     Any       ,      *lowerCamelCase     :     Tuple       ,      lowerCamelCase     :     Union[str, Any]=1       ,      **lowerCamelCase     :     Tuple						):
							lowerCamelCase_	:     List[str] 						=      []
							if num_vec_per_token == 1:
									self.try_adding_tokens(lowerCamelCase       ,      *lowerCamelCase       ,      **lowerCamelCase						)
									output.append(lowerCamelCase						)
							else:
									lowerCamelCase_	:     List[str] 						=      []
									for i in range(lowerCamelCase						):
											lowerCamelCase_	:     Optional[Any] 						=      placeholder_token + F"_{i}"
											self.try_adding_tokens(lowerCamelCase       ,      *lowerCamelCase       ,      **lowerCamelCase						)
											output.append(lowerCamelCase						)
        # handle cases where there is a new placeholder token that contains the current placeholder token but is larger
							for token in self.token_map:
									if token in placeholder_token:
											raise ValueError(
											    F"The tokenizer already has placeholder token {token} that can get confused with"
											    F" {placeholder_token}keep placeholder tokens independent"						)
							lowerCamelCase_	:     Union[str, Any] 						=      output



					def   __a     (		self     :     Optional[Any]       ,      lowerCamelCase     :     Tuple       ,      lowerCamelCase     :     Union[str, Any]=False       ,      lowerCamelCase     :     Optional[Any]=1.0						):
							if isinstance(lowerCamelCase       ,      lowerCamelCase						):
									lowerCamelCase_	:     Dict 						=      []
									for i in range(len(lowerCamelCase						)						):
											output.append(self.replace_placeholder_tokens_in_text(text[i]       ,      vector_shuffle=lowerCamelCase						)						)
									return output
							for placeholder_token in self.token_map:
									if placeholder_token in text:
											lowerCamelCase_	:     str 						=      self.token_map[placeholder_token]
											lowerCamelCase_	:     int 						=      tokens[: 1 + int(len(lowerCamelCase						) * prop_tokens_to_load						)]
											if vector_shuffle:
													lowerCamelCase_	:     Dict 						=      copy.copy(lowerCamelCase						)
													random.shuffle(lowerCamelCase						)
											lowerCamelCase_	:     Dict 						=      text.replace(lowerCamelCase       ,      ' '.join(lowerCamelCase						)						)
							return text



					def __call__(		self     :     Optional[Any]       ,      lowerCamelCase     :     Tuple       ,      *lowerCamelCase     :     List[str]       ,      lowerCamelCase     :     Tuple=False       ,      lowerCamelCase     :     List[str]=1.0       ,      **lowerCamelCase     :     str						):
							return super().__call__(
							    self.replace_placeholder_tokens_in_text(
							        lowerCamelCase       ,      vector_shuffle=lowerCamelCase       ,      prop_tokens_to_load=lowerCamelCase						)       ,      *lowerCamelCase       ,      **lowerCamelCase       ,      )





					def   __a     (		self     :     Optional[Any]       ,      lowerCamelCase     :     Optional[int]       ,      *lowerCamelCase     :     str       ,      lowerCamelCase     :     Optional[Any]=False       ,      lowerCamelCase     :     Optional[int]=1.0       ,      **lowerCamelCase     :     Any						):
							return super().encode(
							    self.replace_placeholder_tokens_in_text(
							        lowerCamelCase       ,      vector_shuffle=lowerCamelCase       ,      prop_tokens_to_load=lowerCamelCase						)       ,      *lowerCamelCase       ,      **lowerCamelCase       ,      )







def 		_SCREAMING_SNAKE_CASE     ( lowerCAmelCase__=2_81_23						):
		lowerCamelCase_	:     Any 						=      [1] * (limit + 1)

		for i in range(2							,int(limit**0.5						) + 1						):
				sum_divs[i * i] += i
				for k in range(i + 1							,limit // i + 1						):
						sum_divs[k * i] += k + i

		lowerCamelCase_	:     List[str] 						=      set()
		lowerCamelCase_	:     List[str] 						=      0

		for n in range(1							,limit + 1						):
				if sum_divs[n] > n:
						abundants.add(lowerCAmelCase__						)

				if not any((n - a in abundants) for a in abundants						):
						res += n

		return res


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