
from math import isqrt



def 							a__ (				lowerCAmelCase	:       int		):






     '''simple docstring'''
     return all(number % divisor != 0 for divisor in range(2       ,    isqrt(snake_case__		) + 1		)		)



def 							a__ (				lowerCAmelCase	:       int = 10**6		):






     '''simple docstring'''
     UpperCAmelCase__							: Optional[int] 							=						0
     UpperCAmelCase__							: List[Any] 							=						1
     UpperCAmelCase__							: str 							=						7
     while prime_candidate < max_prime:
          primes_count += is_prime(snake_case__		)

          cube_index += 1
          prime_candidate += 6 * cube_index

     return primes_count


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





"""simple docstring"""




from pathlib import PurePosixPath
from typing import Optional

import fsspec
from fsspec import AbstractFileSystem
from huggingface_hub.hf_api import DatasetInfo

from ..utils.file_utils import get_authentication_headers_for_url
from ..utils.hub import hf_hub_url







class   _lowercase						(       lowerCAmelCase_				):


     '''simple docstring'''





     _A								=							''
     _A								=							'hf-legacy'  # "hf://"" is reserved for hffs



     def __init__(      self ,			__UpperCamelCase = None ,			__UpperCamelCase = None ,			**__UpperCamelCase ,			)->					str:
          super().__init__(self ,			**__UpperCamelCase  )
          UpperCAmelCase__							: int 							=						repo_info
          UpperCAmelCase__							: Optional[int] 							=						token
          UpperCAmelCase__							: Optional[Any] 							=						None



     def  lowerCAmelCase__       (      self  )->					Optional[Any]:
          if self.dir_cache is None:
               UpperCAmelCase__							: str 							=						{}
               for hf_file in self.repo_info.siblings:
                    # TODO(QL): add sizes
                    UpperCAmelCase__							: str 							=						{
                        "name": hf_file.rfilename,
                        "size": None,
                        "type": "file",
                    }
                    self.dir_cache.update(
                        {
                            str(__UpperCamelCase  ): {"name": str(__UpperCamelCase  ), "size": None, "type": "directory"}
                            for d in list(PurePosixPath(hf_file.rfilename  ).parents  )[:-1]
                        }  )



     def  lowerCAmelCase__       (      self ,			__UpperCamelCase ,			__UpperCamelCase = "rb" ,			**__UpperCamelCase ,			)->					List[Any]:
          if not isinstance(self.repo_info ,			__UpperCamelCase  ):
               raise NotImplementedError(F"Open is only implemented for dataset repositories, but got {self.repo_info}"  )
          UpperCAmelCase__							: Union[str, Any] 							=						hf_hub_url(self.repo_info.id ,			__UpperCamelCase ,			revision=self.repo_info.sha  )
          return fsspec.open(
              __UpperCamelCase ,			mode=__UpperCamelCase ,			headers=get_authentication_headers_for_url(__UpperCamelCase ,			use_auth_token=self.token  ) ,			client_kwargs={"trust_env": True} ,			).open()



     def  lowerCAmelCase__       (      self ,			__UpperCamelCase ,			**__UpperCamelCase  )->					List[str]:
          self._get_dirs()
          UpperCAmelCase__							: Union[str, Any] 							=						self._strip_protocol(__UpperCamelCase  )
          if path in self.dir_cache:
               return self.dir_cache[path]
          else:
               raise FileNotFoundError(__UpperCamelCase  )



     def  lowerCAmelCase__       (      self ,			__UpperCamelCase ,			__UpperCamelCase=False ,			**__UpperCamelCase  )->					str:
          self._get_dirs()
          UpperCAmelCase__							: str 							=						PurePosixPath(path.strip("/"  )  )
          UpperCAmelCase__							: Optional[Any] 							=						{}
          for p, f in self.dir_cache.items():
               UpperCAmelCase__							: Optional[int] 							=						PurePosixPath(p.strip("/"  )  )
               UpperCAmelCase__							: Dict 							=						p.parent
               if root == path:
                    UpperCAmelCase__							: Tuple 							=						f
          UpperCAmelCase__							: List[Any] 							=						list(paths.values()  )
          if detail:
               return out
          else:
               return sorted(f["name"] for f in out  )



