


# Lint as: python3
import dataclasses
import re
from dataclasses import dataclass
from functools import total_ordering
from typing import Optional, Union


__a     =			re.compile(R"""^(?P<major>\d+)""" R"""\.(?P<minor>\d+)""" R"""\.(?P<patch>\d+)$""")






@total_ordering
@dataclass
class   __lowercase				:
  UpperCamelCase								=       42
  UpperCamelCase								=       None
  UpperCamelCase								=       None
  UpperCamelCase								=       None
  UpperCamelCase								=       None





  def        _lowercase				(		self						:					List[Any]       )    ->   List[str]:






     """simple docstring"""







     UpperCAmelCase				,  UpperCAmelCase				,  UpperCAmelCase							=     _str_to_version_tuple(self.version_str       )





  def __repr__(		self						:					Optional[int]       )    ->   Dict:






     """simple docstring"""







     return F"""{self.tuple[0]}.{self.tuple[1]}.{self.tuple[2]}"""





  @property
  def        _lowercase				(		self						:					Any       )    ->   Union[str, Any]:






     """simple docstring"""







     return self.major, self.minor, self.patch





  def        _lowercase				(		self						:					Dict					,       __lowerCamelCase						:					int       )    ->   Dict:






     """simple docstring"""







     if isinstance(__lowerCamelCase					,       __lowerCamelCase       ):
        return Version(__lowerCamelCase       )
     elif isinstance(__lowerCamelCase					,       __lowerCamelCase       ):
        return other
     raise TypeError(F"""{other} (type {type(__lowerCamelCase       )}) cannot be compared to version."""       )





  def __eq__(		self						:					int					,       __lowerCamelCase						:					List[Any]       )    ->   Optional[Any]:






     """simple docstring"""







     try:
        UpperCAmelCase							=     self._validate_operand(__lowerCamelCase       )
     except (TypeError, ValueError):
        return False
     else:
        return self.tuple == other.tuple





  def __lt__(		self						:					Union[str, Any]					,       __lowerCamelCase						:					Dict       )    ->   Optional[int]:






     """simple docstring"""







     UpperCAmelCase							=     self._validate_operand(__lowerCamelCase       )
     return self.tuple < other.tuple





  def __hash__(		self						:					Optional[Any]       )    ->   Any:






     """simple docstring"""







     return hash(_version_tuple_to_str(self.tuple       )       )





  @classmethod
  def        _lowercase				(		cls						:					List[str]					,       __lowerCamelCase						:					str       )    ->   List[str]:






     """simple docstring"""







     UpperCAmelCase							=     {f.name for f in dataclasses.fields(cls       )}
     return cls(**{k: v for k, v in dic.items() if k in field_names}       )





  def        _lowercase				(		self						:					Optional[Any]       )    ->   str:






     """simple docstring"""







     return self.version_str

def   _UpperCamelCase				(						lowerCAmelCase_   )						->Any:
   UpperCAmelCase							=     _VERSION_REG.match(lowerCAmelCase_   )
   if not res:
      raise ValueError(F"""Invalid version '{version_str}'. Format should be x.y.z with {{x,y,z}} being digits."""   )
   return tuple(int(lowerCAmelCase_   ) for v in [res.group("""major"""   ), res.group("""minor"""   ), res.group("""patch"""   )]   )







def   _UpperCamelCase				(						lowerCAmelCase_   )						->List[Any]:
   return ".".join(str(lowerCAmelCase_   ) for v in version_tuple   )







from math import isqrt
def   _UpperCamelCase				(						lowerCAmelCase_   )						->bool:
   return all(number % divisor != 0 for divisor in range(2  ,						isqrt(lowerCAmelCase_   ) + 1   )   )
def   _UpperCamelCase				(						lowerCAmelCase_ = 1_0**6   )						->int:
   UpperCAmelCase							=     0
   UpperCAmelCase							=     1
   UpperCAmelCase							=     7
   while prime_candidate < max_prime:
      primes_count += is_prime(lowerCAmelCase_   )

      cube_index += 1
      prime_candidate += 6 * cube_index

   return primes_count


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



