'''simple docstring'''

import random
from typing import List, Optional, Union

import numpy as np
import torch

from ..state import AcceleratorState
from .constants import CUDA_DISTRIBUTED_TYPES
from .dataclasses import DistributedType, RNGType
from .imports import is_npu_available, is_tpu_available, is_xpu_available


if is_tpu_available(check_device=False):
						import torch_xla.core.xla_model as xm


def 					UpperCAmelCase__      (							_lowerCAmelCase						: int,			_lowerCAmelCase						: bool = False)						->		List[Any]:



						"""simple docstring"""

						if device_specific:
												seed += AcceleratorState().process_index
						random.seed(_lowerCAmelCase)
						np.random.seed(_lowerCAmelCase)
						torch.manual_seed(_lowerCAmelCase)
						if is_xpu_available():
												torch.xpu.manual_seed_all(_lowerCAmelCase)
						elif is_npu_available():
												torch.npu.manual_seed_all(_lowerCAmelCase)
						else:
												torch.cuda.manual_seed_all(_lowerCAmelCase)
						# ^^ safe to call this function even if cuda is not available
						if is_tpu_available():
												xm.set_rng_state(_lowerCAmelCase)


def 					UpperCAmelCase__      (							_lowerCAmelCase						: Optional[RNGType] = None,			_lowerCAmelCase						: Optional[torch.Generator] = None)						->		Tuple:



						"""simple docstring"""

						if rng_type == RNGType.TORCH:
												snake_case   :					Dict							=						torch.get_rng_state()
						elif rng_type == RNGType.CUDA:
												snake_case   :					Dict							=						torch.cuda.get_rng_state()
						elif rng_type == RNGType.XLA:
												assert is_tpu_available(), "Can't synchronize XLA seeds on an environment without TPUs."
												snake_case   :					Tuple							=						torch.tensor(xm.get_rng_state())
						elif rng_type == RNGType.NPU:
												assert is_npu_available(), "Can't synchronize NPU seeds on an environment without NPUs."
												snake_case   :					List[Any]							=						torch.npu.get_rng_state()
						elif rng_type == RNGType.XPU:
												assert is_xpu_available(), "Can't synchronize XPU seeds on an environment without XPUs."
												snake_case   :					str							=						torch.xpu.get_rng_state()
						elif rng_type == RNGType.GENERATOR:
												assert generator is not None, "Need a generator to synchronize its seed."
												snake_case   :					Union[str, Any]							=						generator.get_state()

						# Broadcast the rng state from device 0 to other devices
						snake_case   :					List[Any]							=						AcceleratorState()
						if state.distributed_type == DistributedType.TPU:
												snake_case   :					List[Any]							=						rng_state.to(xm.xla_device())
												xm.collective_broadcast([rng_state])
												xm.mark_step()
												snake_case   :					Any							=						rng_state.cpu()
						elif (
						    state.distributed_type in CUDA_DISTRIBUTED_TYPES
						    or state.distributed_type == DistributedType.MULTI_NPU
						    or state.distributed_type == DistributedType.MULTI_XPU
						):
												snake_case   :					List[str]							=						rng_state.to(state.device)
												torch.distributed.broadcast(_lowerCAmelCase,			0)
												snake_case   :					Any							=						rng_state.cpu()
						elif state.distributed_type == DistributedType.MULTI_CPU:
												torch.distributed.broadcast(_lowerCAmelCase,			0)

						# Set the broadcast rng state
						if rng_type == RNGType.TORCH:
												torch.set_rng_state(_lowerCAmelCase)
						elif rng_type == RNGType.CUDA:
												torch.cuda.set_rng_state(_lowerCAmelCase)
						elif rng_type == RNGType.NPU:
												torch.npu.set_rng_state(_lowerCAmelCase)
						elif rng_type == RNGType.XPU:
												torch.xpu.set_rng_state(_lowerCAmelCase)
						elif rng_type == RNGType.XLA:
												xm.set_rng_state(rng_state.item())
						elif rng_type == RNGType.GENERATOR:
												generator.set_state(_lowerCAmelCase)



def 					UpperCAmelCase__      (							_lowerCAmelCase						: List[Union[str, RNGType]],			_lowerCAmelCase						: Optional[torch.Generator] = None)						->		Any:



						"""simple docstring"""

						for rng_type in rng_types:
												synchronize_rng_state(RNGType(_lowerCAmelCase),			generator=_lowerCAmelCase)






'''simple docstring'''

from math import sqrt


def 					UpperCAmelCase__      (							_lowerCAmelCase						: int)						->		list[int]:



						"""simple docstring"""

						snake_case   :					Dict							=						[1]
						for i in range(2,			int(sqrt(_lowerCAmelCase)) + 1,			1):
												if number % i == 0:
																		values.append(_lowerCAmelCase)
																		if int(number // i) != i:
																								values.append(int(number // i))
						return sorted(_lowerCAmelCase)


def 					UpperCAmelCase__      (							_lowerCAmelCase						: int)						->		bool:



						"""simple docstring"""

						return sum(factors(_lowerCAmelCase)) > n


def 					UpperCAmelCase__      (							_lowerCAmelCase						: int)						->		bool:



						"""simple docstring"""

						snake_case   :					Dict							=						factors(_lowerCAmelCase)
						snake_case   :					List[str]							=						len(_lowerCAmelCase)
						snake_case   :					Optional[Any]							=						[[0 for i in range(number + 1)] for j in range(r + 1)]
						for i in range(r + 1):
												snake_case   :					int							=						True

						for i in range(1,			number + 1):
												snake_case   :					List[Any]							=						False

						for i in range(1,			r + 1):
												for j in range(1,			number + 1):
																		if j < values[i - 1]:
																								snake_case   :					Union[str, Any]							=						subset[i - 1][j]
																		else:
																								snake_case   :					Tuple							=						subset[i - 1][j] or subset[i - 1][j - values[i - 1]]

						return subset[r][number] != 0


def 					UpperCAmelCase__      (							_lowerCAmelCase						: int)						->		bool:



						"""simple docstring"""

						return abundant(_lowerCAmelCase) and not semi_perfect(_lowerCAmelCase)


if __name__ == "__main__":
						import doctest

						doctest.testmod(verbose=True)
						for number in (69, 70, 71):
												print(f"{number} is {'' if weird(number) else 'not '}weird.")





