


import string

import numpy







def 						lowerCamelCase(   a__	,a__):
				return b if a == 0 else greatest_common_divisor(b % a	,a__)

class 						A__							:
						UpperCAmelCase             =						string.ascii_uppercase + string.digits
						# This cipher takes alphanumerics into account
						# i.e. a total of 36 characters

						# take x and return x % len(key_string)
						UpperCAmelCase             =						numpy.vectorize(lambda UpperCamelCase__  : x % 36  )

						UpperCAmelCase             =						numpy.vectorize(UpperCamelCase__  )




						def __init__(       self					:      int				,    _a					:      numpy.ndarray  )							->     None:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE			  =self.modulus(_a  )  # mod36 calc's on the encrypt key
										self.check_determinant()  # validate the determinant of the encryption key
										_SCREAMING_SNAKE_CASE			  =encrypt_key.shape[0]




						def 							__UpperCamelCase				(       self					:      Dict				,    _a					:      str  )							->     int:


										"""simple docstring"""





										return self.key_string.index(_a  )




						def 							__UpperCamelCase				(       self					:      List[str]				,    _a					:      int  )							->     str:


										"""simple docstring"""





										return self.key_string[round(_a  )]




						def 							__UpperCamelCase				(       self					:      int  )							->     None:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE			  =round(numpy.linalg.det(self.encrypt_key  )  )

										if det < 0:
														_SCREAMING_SNAKE_CASE			  =det % len(self.key_string  )

										_SCREAMING_SNAKE_CASE			  =len(self.key_string  )
										if greatest_common_divisor(_a				,    len(self.key_string  )  ) != 1:
														_SCREAMING_SNAKE_CASE			  =(
														    f"determinant modular {req_l} of encryption key({det}) "
														    f"is not co prime w.r.t {req_l}.\nTry another key."
														)
														raise ValueError(_a  )




						def 							__UpperCamelCase				(       self					:      List[str]				,    _a					:      str  )							->     str:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE			  =[char for char in text.upper() if char in self.key_string]

										_SCREAMING_SNAKE_CASE			  =chars[-1]
										while len(_a  ) % self.break_key != 0:
														chars.append(_a  )

										return "".join(_a  )




						def 							__UpperCamelCase				(       self					:      List[str]				,    _a					:      str  )							->     str:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE			  =self.process_text(text.upper()  )
										_SCREAMING_SNAKE_CASE			  =''''''

										for i in range(0				,    len(_a  ) - self.break_key + 1				,    self.break_key  ):
														_SCREAMING_SNAKE_CASE			  =text[i : i + self.break_key]
														_SCREAMING_SNAKE_CASE			  =[self.replace_letters(_a  ) for char in batch]
														_SCREAMING_SNAKE_CASE			  =numpy.array([vec]  ).T
														_SCREAMING_SNAKE_CASE			  =self.modulus(self.encrypt_key.dot(_a  )  ).T.tolist()[
														    0
														]
														_SCREAMING_SNAKE_CASE			  =''''''.join(
														    self.replace_digits(_a  ) for num in batch_encrypted  )
														encrypted += encrypted_batch

										return encrypted




						def 							__UpperCamelCase				(       self					:      Union[str, Any]  )							->     numpy.ndarray:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE			  =round(numpy.linalg.det(self.encrypt_key  )  )

										if det < 0:
														_SCREAMING_SNAKE_CASE			  =det % len(self.key_string  )
										_SCREAMING_SNAKE_CASE			  =None
										for i in range(len(self.key_string  )  ):
														if (det * i) % len(self.key_string  ) == 1:
																		_SCREAMING_SNAKE_CASE			  =i
																		break

										_SCREAMING_SNAKE_CASE			  =(
										    det_inv
										    * numpy.linalg.det(self.encrypt_key  )
										    * numpy.linalg.inv(self.encrypt_key  )
										)

										return self.to_int(self.modulus(_a  )  )




						def 							__UpperCamelCase				(       self					:      str				,    _a					:      str  )							->     str:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE			  =self.make_decrypt_key()
										_SCREAMING_SNAKE_CASE			  =self.process_text(text.upper()  )
										_SCREAMING_SNAKE_CASE			  =''''''

										for i in range(0				,    len(_a  ) - self.break_key + 1				,    self.break_key  ):
														_SCREAMING_SNAKE_CASE			  =text[i : i + self.break_key]
														_SCREAMING_SNAKE_CASE			  =[self.replace_letters(_a  ) for char in batch]
														_SCREAMING_SNAKE_CASE			  =numpy.array([vec]  ).T
														_SCREAMING_SNAKE_CASE			  =self.modulus(decrypt_key.dot(_a  )  ).T.tolist()[0]
														_SCREAMING_SNAKE_CASE			  =''''''.join(
														    self.replace_digits(_a  ) for num in batch_decrypted  )
														decrypted += decrypted_batch

										return decrypted







def 						lowerCamelCase(   ):
				_SCREAMING_SNAKE_CASE			  =int(input('''Enter the order of the encryption key: '''))
				_SCREAMING_SNAKE_CASE			  =[]

				print('''Enter each row of the encryption key with space separated integers''')
				for _ in range(a__):
								_SCREAMING_SNAKE_CASE			  =[int(a__) for x in input().split()]
								hill_matrix.append(a__)

				_SCREAMING_SNAKE_CASE			  =HillCipher(numpy.array(a__))

				print('''Would you like to encrypt or decrypt some text? (1 or 2)''')
				_SCREAMING_SNAKE_CASE			  =input('''\n1. Encrypt\n2. Decrypt\n''')
				if option == "1":
								_SCREAMING_SNAKE_CASE			  =input('''What text would you like to encrypt?: ''')
								print('''Your encrypted text is:''')
								print(hc.encrypt(a__))
				elif option == "2":
								_SCREAMING_SNAKE_CASE			  =input('''What text would you like to decrypt?: ''')
								print('''Your decrypted text is:''')
								print(hc.decrypt(a__))


if __name__ == "__main__":
							import doctest

							doctest.testmod()

							main()



import os
import sys
import tempfile

import torch

from .state import AcceleratorState
from .utils import PrecisionType, PrepareForLaunch, is_mps_available, patch_environment







def 						lowerCamelCase(   a__	,a__=()	,a__=None	,a__="no"	,a__="29500"):
				_SCREAMING_SNAKE_CASE			  =False
				_SCREAMING_SNAKE_CASE			  =False
				if any(key.startswith('''KAGGLE''') for key in os.environ.keys()):
								_SCREAMING_SNAKE_CASE			  =True
				elif "IPython" in sys.modules:
								_SCREAMING_SNAKE_CASE			  ='''google.colab''' in str(sys.modules['''IPython'''].get_ipython())

				try:
								_SCREAMING_SNAKE_CASE			  =PrecisionType(mixed_precision.lower())
				except ValueError:
								raise ValueError(
								    f"Unknown mixed_precision mode: {args.mixed_precision.lower()}. Choose between {PrecisionType.list()}.")

				if (in_colab or in_kaggle) and (os.environ.get('''TPU_NAME'''	,a__) is not None):
								# TPU launch
								import torch_xla.distributed.xla_multiprocessing as xmp

								if len(AcceleratorState._shared_state) > 0:
												raise ValueError(
												    '''To train on TPU in Colab or Kaggle Kernel, the `Accelerator` should only be initialized inside '''
												    '''your training function. Restart your notebook and make sure no cells initializes an '''
												    '''`Accelerator`.''')
								if num_processes is None:
												_SCREAMING_SNAKE_CASE			  =8

								_SCREAMING_SNAKE_CASE			  =PrepareForLaunch(a__	,distributed_type='''TPU''')
								print(f"Launching a training on {num_processes} TPU cores.")
								xmp.spawn(a__	,args=a__	,nprocs=a__	,start_method='''fork''')
				elif in_colab:
								# No need for a distributed launch otherwise as it's either CPU or one GPU.
								if torch.cuda.is_available():
												print('''Launching training on one GPU.''')
								else:
												print('''Launching training on one CPU.''')
								function(*a__)
				else:
								if num_processes is None:
												raise ValueError(
												    '''You have to specify the number of GPUs you would like to use, add `num_processes=...` to your call.''')

								if num_processes > 1:
												# Multi-GPU launch
												from torch.multiprocessing import start_processes
												from torch.multiprocessing.spawn import ProcessRaisedException

												if len(AcceleratorState._shared_state) > 0:
																raise ValueError(
																    '''To launch a multi-GPU training from your notebook, the `Accelerator` should only be initialized '''
																    '''inside your training function. Restart your notebook and make sure no cells initializes an '''
																    '''`Accelerator`.''')

												if torch.cuda.is_initialized():
																raise ValueError(
																    '''To launch a multi-GPU training from your notebook, you need to avoid running any instruction '''
																    '''using `torch.cuda` in any cell. Restart your notebook and make sure no cells use any CUDA '''
																    '''function.''')

												# torch.distributed will expect a few environment variable to be here. We set the ones common to each
												# process here (the other ones will be set be the launcher).
												with patch_environment(
												    world_size=a__	,master_addr='''127.0.01'''	,master_port=a__	,mixed_precision=a__):
																_SCREAMING_SNAKE_CASE			  =PrepareForLaunch(a__	,distributed_type='''MULTI_GPU''')
																print(f"Launching training on {num_processes} GPUs.")
																try:
																				start_processes(a__	,args=a__	,nprocs=a__	,start_method='''fork''')
																except ProcessRaisedException as e:
																				if "Cannot re-initialize CUDA in forked subprocess" in e.args[0]:
																								raise RuntimeError(
																								    '''CUDA has been initialized before the `notebook_launcher` could create a forked subprocess. '''
																								    '''This likely stems from an outside import causing issues once the `notebook_launcher()` is called. '''
																								    '''Please review your imports and test them when running the `notebook_launcher()` to identify '''
																								    '''which one is problematic.''') from e

								else:
												# No need for a distributed launch otherwise as it's either CPU, GPU or MPS.
												if is_mps_available():
																_SCREAMING_SNAKE_CASE			  ='''1'''
																print('''Launching training on MPS.''')
												elif torch.cuda.is_available():
																print('''Launching training on one GPU.''')
												else:
																print('''Launching training on CPU.''')
												function(*a__)







def 						lowerCamelCase(   a__	,a__=()	,a__=2):
				from torch.multiprocessing import start_processes

				with tempfile.NamedTemporaryFile() as tmp_file:
								# torch.distributed will expect a few environment variable to be here. We set the ones common to each
								# process here (the other ones will be set be the launcher).
								with patch_environment(
								    world_size=a__	,master_addr='''127.0.01'''	,master_port='''29500'''	,accelerate_mixed_precision='''no'''	,accelerate_debug_rdv_file=tmp_file.name	,accelerate_use_cpu='''yes'''	,):
												_SCREAMING_SNAKE_CASE			  =PrepareForLaunch(a__	,debug=a__)
												start_processes(a__	,args=a__	,nprocs=a__	,start_method='''fork''')