





import inspect
import os

import torch
from transformers import AutoModel
from transformers.testing_utils import mockenv_context
from transformers.trainer_utils import set_seed

import accelerate
from accelerate.accelerator import Accelerator
from accelerate.state import AcceleratorState
from accelerate.test_utils.testing import (
    AccelerateTestCase,
    TempDirTestCase,
    execute_subprocess_async,
    require_cuda,
    require_fsdp,
    require_multi_gpu,
    slow,
)
from accelerate.utils.constants import (
    FSDP_AUTO_WRAP_POLICY,
    FSDP_BACKWARD_PREFETCH,
    FSDP_SHARDING_STRATEGY,
    FSDP_STATE_DICT_TYPE,
)
from accelerate.utils.dataclasses import FullyShardedDataParallelPlugin
from accelerate.utils.other import patch_environment


set_seed(42)

__lowerCamelCase	:					Any			  =					"""bert-base-cased"""
__lowerCamelCase	:					int			  =					"""fp16"""
__lowerCamelCase	:					List[str]			  =					"""bf16"""
__lowerCamelCase	:					List[Any]			  =					[FPaa, BFaa]



@require_fsdp
@require_cuda
class  A__       (	__snake_case      ):





      def 	__UpperCamelCase(			self       ):
       '''simple docstring'''




       super().setUp()

       UpperCamelCase     : Optional[int]	     =       dict(
           ACCELERATE_USE_FSDP="true"	,							MASTER_ADDR="localhost"	,							MASTER_PORT="10999"	,							RANK="0"	,							LOCAL_RANK="0"	,							WORLD_SIZE="1"	,							)





      def 	__UpperCamelCase(			self       ):
       '''simple docstring'''




       from torch.distributed.fsdp.fully_sharded_data_parallel import ShardingStrategy

       for i, strategy in enumerate(A_       ):
        UpperCamelCase     : Dict	     =       self.dist_env.copy()
        UpperCamelCase     : int	     =       F"""{i + 1}"""
        UpperCamelCase     : Optional[int]	     =       strategy
        with mockenv_context(**A_       ):
         UpperCamelCase     : Tuple	     =       FullyShardedDataParallelPlugin()
         self.assertEqual(fsdp_plugin.sharding_strategy	,							ShardingStrategy(i + 1       )       )





      def 	__UpperCamelCase(			self       ):
       '''simple docstring'''




       from torch.distributed.fsdp.fully_sharded_data_parallel import BackwardPrefetch

       for i, prefetch_policy in enumerate(A_       ):
        UpperCamelCase     : int	     =       self.dist_env.copy()
        UpperCamelCase     : Any	     =       prefetch_policy
        with mockenv_context(**A_       ):
         UpperCamelCase     : List[Any]	     =       FullyShardedDataParallelPlugin()
         if prefetch_policy == "NO_PREFETCH":
          self.assertIsNone(fsdp_plugin.backward_prefetch       )
         else:
          self.assertEqual(fsdp_plugin.backward_prefetch	,							BackwardPrefetch(i + 1       )       )





      def 	__UpperCamelCase(			self       ):
       '''simple docstring'''




       from torch.distributed.fsdp.fully_sharded_data_parallel import StateDictType

       for i, state_dict_type in enumerate(A_       ):
        UpperCamelCase     : List[str]	     =       self.dist_env.copy()
        UpperCamelCase     : Optional[Any]	     =       state_dict_type
        with mockenv_context(**A_       ):
         UpperCamelCase     : Dict	     =       FullyShardedDataParallelPlugin()
         self.assertEqual(fsdp_plugin.state_dict_type	,							StateDictType(i + 1       )       )
         if state_dict_type == "FULL_STATE_DICT":
          self.assertTrue(fsdp_plugin.state_dict_config.offload_to_cpu       )
          self.assertTrue(fsdp_plugin.state_dict_config.ranka_only       )





      def 	__UpperCamelCase(			self       ):
       '''simple docstring'''




       UpperCamelCase     : str	     =       AutoModel.from_pretrained(A_       )
       for policy in FSDP_AUTO_WRAP_POLICY:
        UpperCamelCase     : Tuple	     =       self.dist_env.copy()
        UpperCamelCase     : Tuple	     =       policy
        if policy == "TRANSFORMER_BASED_WRAP":
         UpperCamelCase     : Any	     =       "BertLayer"
        elif policy == "SIZE_BASED_WRAP":
         UpperCamelCase     : Optional[int]	     =       "2000"
        with mockenv_context(**A_       ):
         UpperCamelCase     : List[Any]	     =       FullyShardedDataParallelPlugin()
         fsdp_plugin.set_auto_wrap_policy(A_       )
         if policy == "NO_WRAP":
          self.assertIsNone(fsdp_plugin.auto_wrap_policy       )
         else:
          self.assertIsNotNone(fsdp_plugin.auto_wrap_policy       )

       UpperCamelCase     : List[Any]	     =       self.dist_env.copy()
       UpperCamelCase     : str	     =       "TRANSFORMER_BASED_WRAP"
       UpperCamelCase     : Union[str, Any]	     =       "T5Layer"
       with mockenv_context(**A_       ):
        UpperCamelCase     : Tuple	     =       FullyShardedDataParallelPlugin()
        with self.assertRaises(A_       ) as cm:
         fsdp_plugin.set_auto_wrap_policy(A_       )
        self.assertTrue("Could not find the transformer layer class to wrap in the model." in str(cm.exception       )       )

       UpperCamelCase     : int	     =       self.dist_env.copy()
       UpperCamelCase     : Optional[int]	     =       "SIZE_BASED_WRAP"
       UpperCamelCase     : List[Any]	     =       "0"
       with mockenv_context(**A_       ):
        UpperCamelCase     : Tuple	     =       FullyShardedDataParallelPlugin()
        fsdp_plugin.set_auto_wrap_policy(A_       )
        self.assertIsNone(fsdp_plugin.auto_wrap_policy       )





      def 	__UpperCamelCase(			self       ):
       '''simple docstring'''




       from torch.distributed.fsdp.fully_sharded_data_parallel import MixedPrecision
       from torch.distributed.fsdp.sharded_grad_scaler import ShardedGradScaler

       for mp_dtype in dtypes:
        UpperCamelCase     : Optional[Any]	     =       self.dist_env.copy()
        UpperCamelCase     : Dict	     =       mp_dtype
        with mockenv_context(**A_       ):
         UpperCamelCase     : Optional[int]	     =       Accelerator()
         if mp_dtype == "fp16":
          UpperCamelCase     : Tuple	     =       torch.floataa
         elif mp_dtype == "bf16":
          UpperCamelCase     : Dict	     =       torch.bfloataa
         UpperCamelCase     : List[Any]	     =       MixedPrecision(param_dtype=A_	,							reduce_dtype=A_	,							buffer_dtype=A_       )
         self.assertEqual(accelerator.state.fsdp_plugin.mixed_precision_policy	,							A_       )
         if mp_dtype == FPaa:
          self.assertTrue(isinstance(accelerator.scaler	,							A_       )       )
         elif mp_dtype == BFaa:
          self.assertIsNone(accelerator.scaler       )
         AcceleratorState._reset_state(A_       )





      def 	__UpperCamelCase(			self       ):
       '''simple docstring'''




       from torch.distributed.fsdp.fully_sharded_data_parallel import CPUOffload

       for flag in [True, False]:
        UpperCamelCase     : Optional[Any]	     =       self.dist_env.copy()
        UpperCamelCase     : List[str]	     =       str(A_       ).lower()
        with mockenv_context(**A_       ):
         UpperCamelCase     : int	     =       FullyShardedDataParallelPlugin()
         self.assertEqual(fsdp_plugin.cpu_offload	,							CPUOffload(offload_params=A_       )       )



@require_fsdp
@require_multi_gpu
@slow
class  A__       (	__snake_case      ):





      def 	__UpperCamelCase(			self       ):
       '''simple docstring'''




       super().setUp()
       UpperCamelCase     : Any	     =       0.82
       UpperCamelCase     : Any	     =       [
           "fsdp_shard_grad_op_transformer_based_wrap",
           "fsdp_full_shard_transformer_based_wrap",
       ]
       UpperCamelCase     : int	     =       {
           "multi_gpu_fp16": 3200,
           "fsdp_shard_grad_op_transformer_based_wrap_fp16": 2000,
           "fsdp_full_shard_transformer_based_wrap_fp16": 1900,
           # Disabling below test as it overwhelms the RAM memory usage
           # on CI self-hosted runner leading to tests getting killed.
           # "fsdp_full_shard_cpu_offload_transformer_based_wrap_fp32": 1500,  # fp16 was leading to indefinite hang
       }
       UpperCamelCase     : Any	     =       160
       UpperCamelCase     : Optional[int]	     =       160

       UpperCamelCase     : List[str]	     =       inspect.getfile(accelerate.test_utils       )
       UpperCamelCase     : Optional[Any]	     =       os.path.sep.join(mod_file.split(os.path.sep       )[:-1] + ["scripts", "external_deps"]       )





      def 	__UpperCamelCase(			self       ):
       '''simple docstring'''




       UpperCamelCase     : Optional[int]	     =       os.path.join(self.test_scripts_folder	,							"test_performance.py"       )
       UpperCamelCase     : Tuple	     =       ["accelerate", "launch", "--num_processes=2", "--num_machines=1", "--machine_rank=0", "--use_fsdp"]
       for config in self.performance_configs:
        UpperCamelCase     : Dict	     =       cmd.copy()
        for i, strategy in enumerate(A_       ):
         if strategy.lower() in config:
          cmd_config.append(F"""--fsdp_sharding_strategy={i+1}"""       )
          break

        if "fp32" in config:
         cmd_config.append("--mixed_precision=no"       )
        else:
         cmd_config.append("--mixed_precision=fp16"       )

        if "cpu_offload" in config:
         cmd_config.append("--fsdp_offload_params=True"       )

        for policy in FSDP_AUTO_WRAP_POLICY:
         if policy.lower() in config:
          cmd_config.append(F"""--fsdp_auto_wrap_policy={policy}"""       )
          break

        if policy == "TRANSFORMER_BASED_WRAP":
         cmd_config.append("--fsdp_transformer_layer_cls_to_wrap=BertLayer"       )
        elif policy == "SIZE_BASED_WRAP":
         cmd_config.append("--fsdp_min_num_params=2000"       )

        cmd_config.extend(
            [
                self.test_file_path,
                F"""--output_dir={self.tmpdir}""",
                F"""--performance_lower_bound={self.performance_lower_bound}""",
            ]       )
        with patch_environment(omp_num_threads=1       ):
         execute_subprocess_async(A_	,							env=os.environ.copy()       )





      def 	__UpperCamelCase(			self       ):
       '''simple docstring'''




       UpperCamelCase     : List[Any]	     =       os.path.join(self.test_scripts_folder	,							"test_checkpointing.py"       )
       UpperCamelCase     : List[str]	     =       [
           "accelerate",
           "launch",
           "--num_processes=2",
           "--num_machines=1",
           "--machine_rank=0",
           "--use_fsdp",
           "--mixed_precision=fp16",
           "--fsdp_transformer_layer_cls_to_wrap=BertLayer",
       ]

       for i, strategy in enumerate(A_       ):
        UpperCamelCase     : int	     =       cmd.copy()
        cmd_config.append(F"""--fsdp_sharding_strategy={i+1}"""       )
        if strategy != "FULL_SHARD":
         continue
        UpperCamelCase     : Optional[int]	     =       len(A_       )
        for state_dict_type in FSDP_STATE_DICT_TYPE:
         UpperCamelCase     : Optional[int]	     =       cmd_config[:state_dict_config_index]
         cmd_config.append(F"""--fsdp_state_dict_type={state_dict_type}"""       )
         cmd_config.extend(
             [
                 self.test_file_path,
                 F"""--output_dir={self.tmpdir}""",
                 "--partial_train_epoch=1",
             ]       )
         with patch_environment(omp_num_threads=1       ):
          execute_subprocess_async(A_	,							env=os.environ.copy()       )

         UpperCamelCase     : Any	     =       cmd_config[:-1]
         UpperCamelCase     : Tuple	     =       os.path.join(self.tmpdir	,							"epoch_0"       )
         cmd_config.extend(
             [
                 F"""--resume_from_checkpoint={resume_from_checkpoint}""",
             ]       )
         with patch_environment(omp_num_threads=1       ):
          execute_subprocess_async(A_	,							env=os.environ.copy()       )





      def 	__UpperCamelCase(			self       ):
       '''simple docstring'''




       UpperCamelCase     : int	     =       os.path.join(self.test_scripts_folder	,							"test_peak_memory_usage.py"       )
       UpperCamelCase     : Dict	     =       [
           "accelerate",
           "launch",
           "--num_processes=2",
           "--num_machines=1",
           "--machine_rank=0",
       ]
       for spec, peak_mem_upper_bound in self.peak_memory_usage_upper_bound.items():
        UpperCamelCase     : Union[str, Any]	     =       cmd.copy()
        if "fp16" in spec:
         cmd_config.extend(["--mixed_precision=fp16"]       )
        else:
         cmd_config.extend(["--mixed_precision=no"]       )

        if "multi_gpu" in spec:
         continue
        else:
         cmd_config.extend(["--use_fsdp"]       )
         for i, strategy in enumerate(A_       ):
          if strategy.lower() in spec:
           cmd_config.append(F"""--fsdp_sharding_strategy={i+1}"""       )
           break

         if "cpu_offload" in spec:
          cmd_config.append("--fsdp_offload_params=True"       )

         for policy in FSDP_AUTO_WRAP_POLICY:
          if policy.lower() in spec:
           cmd_config.append(F"""--fsdp_auto_wrap_policy={policy}"""       )
           break

         if policy == "TRANSFORMER_BASED_WRAP":
          cmd_config.append("--fsdp_transformer_layer_cls_to_wrap=BertLayer"       )
         elif policy == "SIZE_BASED_WRAP":
          cmd_config.append("--fsdp_min_num_params=2000"       )

        cmd_config.extend(
            [
                self.test_file_path,
                F"""--output_dir={self.tmpdir}""",
                F"""--peak_memory_upper_bound={peak_mem_upper_bound}""",
                F"""--n_train={self.n_train}""",
                F"""--n_val={self.n_val}""",
            ]       )
        with patch_environment(omp_num_threads=1       ):
         execute_subprocess_async(A_	,							env=os.environ.copy()       )







import math



def 		A_    (					_lowerCAmelCase					)						->			list:
 UpperCamelCase     : str	     =       [True] * n
 UpperCamelCase     : Optional[int]	     =       False
 UpperCamelCase     : str	     =       False
 UpperCamelCase     : List[Any]	     =       True

 for i in range(3							,       int(n**0.5 + 1					)							,       2					):
  UpperCamelCase     : int	     =       i * 2
  while index < n:
   UpperCamelCase     : Optional[Any]	     =       False
   UpperCamelCase     : Optional[Any]	     =       index + i

 UpperCamelCase     : Optional[Any]	     =       [2]

 for i in range(3							,       _lowerCAmelCase							,       2					):
  if is_prime[i]:
   primes.append(_lowerCAmelCase					)

 return primes



def 		A_    (					_lowerCAmelCase = 9999_6666_3333					)						->			int:
 UpperCamelCase     : Tuple	     =       math.floor(math.sqrt(_lowerCAmelCase					)					) + 100
 UpperCamelCase     : Dict	     =       prime_sieve(_lowerCAmelCase					)

 UpperCamelCase     : Optional[Any]	     =       0
 UpperCamelCase     : Tuple	     =       0
 UpperCamelCase     : List[str]	     =       primes[prime_index]

 while (last_prime**2) <= limit:
  UpperCamelCase     : Dict	     =       primes[prime_index + 1]

  UpperCamelCase     : Any	     =       last_prime**2
  UpperCamelCase     : Union[str, Any]	     =       next_prime**2

  # Get numbers divisible by lps(current)
  UpperCamelCase     : Dict	     =       lower_bound + last_prime
  while upper_bound > current <= limit:
   matches_sum += current
   current += last_prime

  # Reset the upper_bound
  while (upper_bound - next_prime) > limit:
   upper_bound -= next_prime

  # Add the numbers divisible by ups(current)
  UpperCamelCase     : List[str]	     =       upper_bound - next_prime
  while current > lower_bound:
   matches_sum += current
   current -= next_prime

  # Remove the numbers divisible by both ups and lps
  UpperCamelCase     : Dict	     =       0
  while upper_bound > current <= limit:
   if current <= lower_bound:
    # Increment the current number
    current += last_prime * next_prime
    continue

   if current > limit:
    break

   # Remove twice since it was added by both ups and lps
   matches_sum -= current * 2

   # Increment the current number
   current += last_prime * next_prime

  # Setup for next pair
  UpperCamelCase     : str	     =       next_prime
  prime_index += 1

 return matches_sum


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