

'''simple docstring'''

import math




def 				UpperCamelCase(					):
 UpperCAmelCase	:     List[str]						 =			input('Enter message: '     )
 UpperCAmelCase	:     str						 =			int(input(F"""Enter key [2-{len(UpperCAmelCase_     ) - 1}]: """     )     )
 UpperCAmelCase	:     List[str]						 =			input('Encryption/Decryption [e/d]: '     )

 if mode.lower().startswith('e'     ):
  UpperCAmelCase	:     Optional[int]						 =			encrypt_message(UpperCAmelCase_  ,	UpperCAmelCase_     )
 elif mode.lower().startswith('d'     ):
  UpperCAmelCase	:     Any						 =			decrypt_message(UpperCAmelCase_  ,	UpperCAmelCase_     )

 # Append pipe symbol (vertical bar) to identify spaces at the end.
 print(F"""Output:\n{text + "|"}"""     )




def 				UpperCamelCase(					UpperCAmelCase_  ,	UpperCAmelCase_     ):
 UpperCAmelCase	:     List[Any]						 =			[''] * key
 for col in range(UpperCAmelCase_     ):
  UpperCAmelCase	:     List[str]						 =			col
  while pointer < len(UpperCAmelCase_     ):
   cipher_text[col] += message[pointer]
   pointer += key
 return "".join(UpperCAmelCase_     )




def 				UpperCamelCase(					UpperCAmelCase_  ,	UpperCAmelCase_     ):
 UpperCAmelCase	:     Optional[int]						 =			math.ceil(len(UpperCAmelCase_     ) / key     )
 UpperCAmelCase	:     List[Any]						 =			key
 UpperCAmelCase	:     Union[str, Any]						 =			(num_cols * num_rows) - len(UpperCAmelCase_     )
 UpperCAmelCase	:     List[str]						 =			[''] * num_cols
 UpperCAmelCase	:     Optional[Any]						 =			0
 UpperCAmelCase	:     Tuple						 =			0

 for symbol in message:
  plain_text[col] += symbol
  col += 1

  if (
      (col == num_cols)
      or (col == num_cols - 1)
      and (row >= num_rows - num_shaded_boxes)
  ):
   UpperCAmelCase	:     Any						 =			0
   row += 1

 return "".join(UpperCAmelCase_     )


if __name__ == "__main__":
 import doctest

 doctest.testmod()
 main()







'''simple docstring'''

import inspect
import os
import unittest

import torch

import accelerate
from accelerate import Accelerator
from accelerate.test_utils import execute_subprocess_async, require_multi_gpu
from accelerate.utils import patch_environment




class 	A_			(    unittest.TestCase							):






     '''simple docstring'''



     def        UpperCAmelCase_	(		self			:					str	)						->     Tuple:
      UpperCAmelCase	:     Any						 =			inspect.getfile(accelerate.test_utils	)
      UpperCAmelCase	:     Dict						 =			os.path.sep.join(mod_file.split(os.path.sep	)[:-1] + ['scripts', 'test_script.py']	)
      UpperCAmelCase	:     Dict						 =			os.path.sep.join(
          mod_file.split(os.path.sep	)[:-1] + ['scripts', 'test_distributed_data_loop.py']	)
      UpperCAmelCase	:     List[Any]						 =			os.path.sep.join(mod_file.split(os.path.sep	)[:-1] + ['scripts', 'test_ops.py']	)


     @require_multi_gpu
     def        UpperCAmelCase_	(		self			:					Optional[Any]	)						->     Optional[int]:
      print(f"""Found {torch.cuda.device_count()} devices."""	)
      UpperCAmelCase	:     Dict						 =			['torchrun', f"""--nproc_per_node={torch.cuda.device_count()}""", self.test_file_path]
      with patch_environment(omp_num_threads=1	):
       execute_subprocess_async(lowercase_					,      env=os.environ.copy()	)


     @require_multi_gpu
     def        UpperCAmelCase_	(		self			:					Union[str, Any]	)						->     List[Any]:
      print(f"""Found {torch.cuda.device_count()} devices."""	)
      UpperCAmelCase	:     int						 =			['torchrun', f"""--nproc_per_node={torch.cuda.device_count()}""", self.operation_file_path]
      print(f"""Command: {cmd}"""	)
      with patch_environment(omp_num_threads=1	):
       execute_subprocess_async(lowercase_					,      env=os.environ.copy()	)


     @require_multi_gpu
     def        UpperCAmelCase_	(		self			:					str	)						->     List[Any]:
      UpperCAmelCase	:     Optional[int]						 =			['torchrun', f"""--nproc_per_node={torch.cuda.device_count()}""", inspect.getfile(self.__class__	)]
      with patch_environment(omp_num_threads=1	):
       execute_subprocess_async(lowercase_					,      env=os.environ.copy()	)




     @require_multi_gpu
     def        UpperCAmelCase_	(		self			:					List[str]	)						->     Optional[Any]:
      print(f"""Found {torch.cuda.device_count()} devices, using 2 devices only"""	)
      UpperCAmelCase	:     Dict						 =			['torchrun', f"""--nproc_per_node={torch.cuda.device_count()}""", self.data_loop_file_path]
      with patch_environment(omp_num_threads=1					,      cuda_visible_devices='0,1'	):
       execute_subprocess_async(lowercase_					,      env=os.environ.copy()	)


if __name__ == "__main__":
 lowercase__         =      Accelerator()
 lowercase__         =      (accelerator.state.process_index + 2, 10)
 lowercase__         =      torch.randint(0, 10, shape).to(accelerator.device)

 lowercase__         =      ""

 lowercase__         =      accelerator.pad_across_processes(tensor)
 if tensora.shape[0] != accelerator.state.num_processes + 1:
  error_msg += f"Found shape {tensora.shape} but should have {accelerator.state.num_processes + 1} at dim 0."
 if not torch.equal(tensora[: accelerator.state.process_index + 2], tensor):
  error_msg += "Tensors have different values."
 if not torch.all(tensora[accelerator.state.process_index + 2 :] == 0):
  error_msg += "Padding was not done with the right value (0)."

 lowercase__         =      accelerator.pad_across_processes(tensor, pad_first=True)
 if tensora.shape[0] != accelerator.state.num_processes + 1:
  error_msg += f"Found shape {tensora.shape} but should have {accelerator.state.num_processes + 1} at dim 0."
 lowercase__         =      accelerator.state.num_processes - accelerator.state.process_index - 1
 if not torch.equal(tensora[index:], tensor):
  error_msg += "Tensors have different values."
 if not torch.all(tensora[:index] == 0):
  error_msg += "Padding was not done with the right value (0)."

 # Raise error at the end to make sure we don't stop at the first failure.
 if len(error_msg) > 0:
  raise ValueError(error_msg)




