






import os
import sys

import transformers


lowerCAmelCase_           = '3'

print('Python version:', sys.version)
print('transformers version:', transformers.__version__)

try:
					import torch

					print('Torch version:', torch.__version__)
					print('Cuda available:', torch.cuda.is_available())
					print('Cuda version:', torch.version.cuda)
					print('CuDNN version:', torch.backends.cudnn.version())
					print('Number of GPUs available:', torch.cuda.device_count())
					print('NCCL version:', torch.cuda.nccl.version())
except ImportError:
					print('Torch version:', None)

try:
					import deepspeed

					print('DeepSpeed version:', deepspeed.__version__)
except ImportError:
					print('DeepSpeed version:', None)

try:
					import tensorflow as tf

					print('TensorFlow version:', tf.__version__)
					print('TF GPUs available:', bool(tf.config.list_physical_devices('GPU')))
					print('Number of TF GPUs available:', len(tf.config.list_physical_devices('GPU')))
except ImportError:
					print('TensorFlow version:', None)














from collections import deque

from .hash_table import HashTable
class      UpperCamelCase (				snake_case__ ):







		"""simple docstring"""



		def __init__(  self		:       Any						,*_SCREAMING_SNAKE_CASE		:       Optional[int]						,**_SCREAMING_SNAKE_CASE		:       Optional[Any]		)    ->   int:


						'''simple docstring'''
						super().__init__(*_SCREAMING_SNAKE_CASE						,**_SCREAMING_SNAKE_CASE		)
		def       A(  self		:       Optional[int]						,_SCREAMING_SNAKE_CASE		:       Optional[Any]						,_SCREAMING_SNAKE_CASE		:       Tuple		)    ->   List[str]:


						'''simple docstring'''
						A	 =      deque([]		) if self.values[key] is None else self.values[key]
						self.values[key].appendleft(_SCREAMING_SNAKE_CASE		)
						A	 =      self.values[key]
		def       A(  self		:       Optional[Any]		)    ->   Union[str, Any]:


						'''simple docstring'''
						return (
						    sum(self.charge_factor - len(_SCREAMING_SNAKE_CASE		) for slot in self.values		)
						    / self.size_table
						    * self.charge_factor
						)







		def       A(  self		:       Dict						,_SCREAMING_SNAKE_CASE		:       Optional[int]						,_SCREAMING_SNAKE_CASE		:       str=None		)    ->   Union[str, Any]:


						'''simple docstring'''
						if not (
						    len(self.values[key]		) == self.charge_factor and self.values.count(_SCREAMING_SNAKE_CASE		) == 0
						):
										return key
						return super()._collision_resolution(_SCREAMING_SNAKE_CASE						,_SCREAMING_SNAKE_CASE		)





