


'''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       lowerCAmelCase__       (				lowerCamelCase     :			int  ,lowerCamelCase     :			bool = False   ):
       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       lowerCAmelCase__       (				lowerCamelCase     :			Optional[RNGType] = None  ,lowerCamelCase     :			Optional[torch.Generator] = None   ):
       # Get the proper rng state
       if rng_type == RNGType.TORCH:
              _A     :	Tuple      =					torch.get_rng_state()
       elif rng_type == RNGType.CUDA:
              _A     :	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."
              _A     :	Any      =					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."
              _A     :	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."
              _A     :	Any      =					torch.xpu.get_rng_state()
       elif rng_type == RNGType.GENERATOR:
              assert generator is not None, "Need a generator to synchronize its seed."
              _A     :	str      =					generator.get_state()

       # Broadcast the rng state from device 0 to other devices
       _A     :	Union[str, Any]      =					AcceleratorState()
       if state.distributed_type == DistributedType.TPU:
              _A     :	Optional[Any]      =					rng_state.to(xm.xla_device()   )
              xm.collective_broadcast([rng_state]   )
              xm.mark_step()
              _A     :	Optional[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
       ):
              _A     :	Optional[Any]      =					rng_state.to(state.device   )
              torch.distributed.broadcast(lowerCamelCase  ,0   )
              _A     :	Tuple      =					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       lowerCAmelCase__       (				lowerCamelCase     :			List[Union[str, RNGType]]  ,lowerCamelCase     :			Optional[torch.Generator] = None   ):
       for rng_type in rng_types:
              synchronize_rng_state(RNGType(lowerCamelCase   )  ,generator=lowerCamelCase   )










'''simple docstring'''







import sys

sys.set_int_max_str_digits(0)  # type: ignore






def       lowerCAmelCase__       (				lowerCamelCase     :			int   ):
       _A     :	Optional[Any]      =					[0] * 11
       _A     :	str      =					[0] * 11

       # mark last 9 numbers
       for _ in range(9   ):
              _A     :	int      =					1
              _A     :	Optional[int]      =					number // 10
       # flag
       _A     :	List[Any]      =					True

       # check last 9 numbers for pandigitality

       for x in range(9   ):
              if not check_last[x + 1]:
                     _A     :	Optional[int]      =					False
       if not f:
              return f

       # mark first 9 numbers
       _A     :	Optional[int]      =					int(str(lowerCamelCase   )[:9]   )

       for _ in range(9   ):
              _A     :	Optional[Any]      =					1
              _A     :	str      =					number // 10

       # check first 9 numbers for pandigitality

       for x in range(9   ):
              if not check_front[x + 1]:
                     _A     :	Optional[Any]      =					False
       return f






def       lowerCAmelCase__       (				lowerCamelCase     :			int   ):
       _A     :	Dict      =					[0] * 11

       # mark last 9 numbers
       for _ in range(9   ):
              _A     :	List[str]      =					1
              _A     :	Dict      =					number // 10
       # flag
       _A     :	Optional[int]      =					True

       # check last 9 numbers for pandigitality

       for x in range(9   ):
              if not check_last[x + 1]:
                     _A     :	List[str]      =					False
       return f






def       lowerCAmelCase__       (				):
       _A     :	List[Any]      =					1
       _A     :	Dict      =					1
       _A     :	Dict      =					2
       # temporary Fibonacci numbers

       _A     :	List[Any]      =					1
       _A     :	Union[str, Any]      =					1
       _A     :	List[Any]      =					2
       # temporary Fibonacci numbers mod 1e9

       # mod m=1e9, done for fast optimisation
       _A     :	Tuple      =					[0] * 1000000
       _A     :	Any      =					1000000000

       for x in range(1000000   ):
              _A     :	Tuple      =					(aa + ba) % m
              _A     :	Optional[Any]      =					ba % m
              _A     :	str      =					ca % m
              if checka(lowerCamelCase   ):
                     _A     :	Dict      =					1

       for x in range(1000000   ):
              _A     :	List[str]      =					a + b
              _A     :	Optional[int]      =					b
              _A     :	str      =					c
              # perform check only if in tocheck
              if tocheck[x + 3] and check(lowerCamelCase   ):
                     return x + 3  # first 2 already done
       return -1


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






