






import copy
import re






class      __SCREAMING_SNAKE_CASE      :
 snake_case_  							=							'''hp'''
 snake_case_  							=							{}
 snake_case_  							=							None




 @classmethod
 def      __magic_name__	(      cls	:							List[str]					,      __lowercase	:							Union[str, Any]					,      __lowercase	:							Dict      )	->						Union[str, Any]:
       SCREAMING_SNAKE_CASE__     :				str									=prefix
       SCREAMING_SNAKE_CASE__     :				List[str]									=defaults
       cls.build_naming_info()




 @staticmethod
 def      __magic_name__	(      __lowercase	:							Optional[Any]					,      __lowercase	:							Optional[int]      )	->						List[Any]:
       if len(A_      ) == 0:
             return ""
       SCREAMING_SNAKE_CASE__     :				Dict									=None
       if any(char.isdigit() for char in word      ):
             raise Exception(F"Parameters should not contain numbers: \'{word}\' contains a number"      )
       if word in info["short_word"]:
             return info["short_word"][word]
       for prefix_len in range(1					,      len(A_      ) + 1      ):
             SCREAMING_SNAKE_CASE__     :				Union[str, Any]									=word[:prefix_len]
             if prefix in info["reverse_short_word"]:
                   continue
             else:
                   SCREAMING_SNAKE_CASE__     :				Optional[int]									=prefix
                   break

       if short_word is None:
             # Paranoid fallback
             def int_to_alphabetic(__lowercase	:							int      ):
                   SCREAMING_SNAKE_CASE__     :				Any									=''''''
                   while integer != 0:
                         SCREAMING_SNAKE_CASE__     :				str									=chr(ord('''A'''      ) + integer % 10      ) + s
                         integer //= 10
                   return s

             SCREAMING_SNAKE_CASE__     :				List[Any]									=0
             while True:
                   SCREAMING_SNAKE_CASE__     :				List[str]									=word + '''#''' + int_to_alphabetic(A_      )
                   if sword in info["reverse_short_word"]:
                         continue
                   else:
                         SCREAMING_SNAKE_CASE__     :				int									=sword
                         break

       SCREAMING_SNAKE_CASE__     :				str									=short_word
       SCREAMING_SNAKE_CASE__     :				Optional[Any]									=word
       return short_word




 @staticmethod
 def      __magic_name__	(      __lowercase	:							Any					,      __lowercase	:							Any      )	->						List[str]:
       SCREAMING_SNAKE_CASE__     :				int									=param_name.split('''_'''      )

       SCREAMING_SNAKE_CASE__     :				int									=[TrialShortNamer.shortname_for_word(A_					,      A_      ) for word in words]

       # We try to create a separatorless short name, but if there is a collision we have to fallback
       # to a separated short name
       SCREAMING_SNAKE_CASE__     :				Tuple									=['''''', '''_''']

       for separator in separators:
             SCREAMING_SNAKE_CASE__     :				Optional[int]									=separator.join(A_      )
             if shortname not in info["reverse_short_param"]:
                   SCREAMING_SNAKE_CASE__     :				Tuple									=shortname
                   SCREAMING_SNAKE_CASE__     :				str									=param_name
                   return shortname

       return param_name




 @staticmethod
 def      __magic_name__	(      __lowercase	:							List[Any]					,      __lowercase	:							List[Any]      )	->						Dict:
       SCREAMING_SNAKE_CASE__     :				Tuple									=TrialShortNamer.shortname_for_key(A_					,      A_      )
       SCREAMING_SNAKE_CASE__     :				Tuple									=short_name
       SCREAMING_SNAKE_CASE__     :				Tuple									=param_name




 @classmethod
 def      __magic_name__	(      cls	:							Any      )	->						Union[str, Any]:
       if cls.NAMING_INFO is not None:
             return

       SCREAMING_SNAKE_CASE__     :				Dict									={
           '''short_word''': {},
           '''reverse_short_word''': {},
           '''short_param''': {},
           '''reverse_short_param''': {},
       }

       SCREAMING_SNAKE_CASE__     :				Union[str, Any]									=list(cls.DEFAULTS.keys()      )

       for k in field_keys:
             cls.add_new_param_name(A_					,      A_      )

       SCREAMING_SNAKE_CASE__     :				List[Any]									=info




 @classmethod
 def      __magic_name__	(      cls	:							Any					,      __lowercase	:							List[str]      )	->						Optional[int]:
       cls.build_naming_info()
       assert cls.PREFIX is not None
       SCREAMING_SNAKE_CASE__     :				Tuple									=[copy.copy(cls.PREFIX      )]

       for k, v in params.items():
             if k not in cls.DEFAULTS:
                   raise Exception(F"You should provide a default value for the param name {k} with value {v}"      )
             if v == cls.DEFAULTS[k]:
                   # The default value is not added to the name
                   continue

             SCREAMING_SNAKE_CASE__     :				Tuple									=cls.NAMING_INFO['''short_param'''][k]

             if isinstance(A_					,      A_      ):
                   SCREAMING_SNAKE_CASE__     :				List[str]									=1 if v else 0

             SCREAMING_SNAKE_CASE__     :				str									='''''' if isinstance(A_					,      (int, float)      ) else '''-'''
             SCREAMING_SNAKE_CASE__     :				List[str]									=F"{key}{sep}{v}"
             name.append(A_      )

       return "_".join(A_      )




 @classmethod
 def      __magic_name__	(      cls	:							Any					,      __lowercase	:							List[Any]      )	->						Tuple:
       SCREAMING_SNAKE_CASE__     :				List[str]									=repr[len(cls.PREFIX      ) + 1 :]
       if repr == "":
             SCREAMING_SNAKE_CASE__     :				Optional[Any]									=[]
       else:
             SCREAMING_SNAKE_CASE__     :				List[Any]									=repr.split('''_'''      )

       SCREAMING_SNAKE_CASE__     :				Optional[int]									={}

       for value in values:
             if "-" in value:
                   SCREAMING_SNAKE_CASE__		,	SCREAMING_SNAKE_CASE__     :				List[Any]									=value.split('''-'''      )
             else:
                   SCREAMING_SNAKE_CASE__     :				Any									=re.sub('''[0-9.]'''					,      ''''''					,      A_      )
                   SCREAMING_SNAKE_CASE__     :				Tuple									=float(re.sub('''[^0-9.]'''					,      ''''''					,      A_      )      )

             SCREAMING_SNAKE_CASE__     :				int									=cls.NAMING_INFO['''reverse_short_param'''][p_k]

             SCREAMING_SNAKE_CASE__     :				Union[str, Any]									=p_v

       for k in cls.DEFAULTS:
             if k not in parameters:
                   SCREAMING_SNAKE_CASE__     :				Union[str, Any]									=cls.DEFAULTS[k]

       return parameters







'''simple docstring'''
from math import isqrt





def  _a(  UpperCamelCase__				:						int							):




      '''simple docstring'''






      SCREAMING_SNAKE_CASE__     :				int									=[True] * max_number
      for i in range(2,	isqrt(max_number - 1							) + 1							):
            if is_prime[i]:
                  for j in range(i**2,	UpperCamelCase__,	UpperCamelCase__							):
                        SCREAMING_SNAKE_CASE__     :				Any									=False

      return [i for i in range(2,	UpperCamelCase__							) if is_prime[i]]





def  _a(  UpperCamelCase__				:						int = 1_0**8							):




      '''simple docstring'''






      SCREAMING_SNAKE_CASE__     :				Tuple									=calculate_prime_numbers(max_number // 2							)

      SCREAMING_SNAKE_CASE__     :				int									=0
      SCREAMING_SNAKE_CASE__     :				int									=0
      SCREAMING_SNAKE_CASE__     :				Optional[int]									=len(UpperCamelCase__							) - 1
      while left <= right:
            while prime_numbers[left] * prime_numbers[right] >= max_number:
                  right -= 1
            semiprimes_count += right - left + 1
            left += 1

      return semiprimes_count


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