




'''simple docstring'''







from __future__ import annotations

import random
import string





class      lowerCamelCase_							:




					'''simple docstring'''






					def __init__(    self,  __UpperCamelCase = None ):
							_snake_case	       =       passcode or self.__passcode_creator()
							_snake_case	       =       self.__make_key_list()
							_snake_case	       =       self.__make_shift_key()






					def __str__(    self ):
							return "".join(self.__passcode )






					def 				__SCREAMING_SNAKE_CASE	(    self,  __UpperCamelCase ):
							for i in range(1,  len(__UpperCamelCase ),  2 ):
									iterlist[i] *= -1
							return iterlist






					def 				__SCREAMING_SNAKE_CASE	(    self ):
							_snake_case	       =       string.ascii_letters + string.digits
							_snake_case	       =       [random.choice(__UpperCamelCase ) for _ in range(random.randint(10,  20 ) )]
							return password






					def 				__SCREAMING_SNAKE_CASE	(    self ):
							_snake_case	       =       (
							    string.ascii_letters + string.digits + string.punctuation + " \t\n"
							)

							_snake_case	       =       []

							# creates points known as breakpoints to break the key_list_options at those
							# points and pivot each substring
							_snake_case	       =       sorted(set(self.__passcode ) )
							_snake_case	       =       []

							# algorithm for creating a new shuffled list, keys_l, out of key_list_options
							for i in key_list_options:
									temp_list.extend(__UpperCamelCase )

									# checking breakpoints at which to pivot temporary sublist and add it into
									# keys_l
									if i in breakpoints or i == key_list_options[-1]:
											keys_l.extend(temp_list[::-1] )
											temp_list.clear()

        # returning a shuffled keys_l to prevent brute force guessing of shift key
							return keys_l






					def 				__SCREAMING_SNAKE_CASE	(    self ):
							_snake_case	       =       sum(self.__neg_pos([ord(__UpperCamelCase ) for x in self.__passcode] ) )
							return num if num > 0 else len(self.__passcode )






					def 				__SCREAMING_SNAKE_CASE	(    self,  __UpperCamelCase ):
							_snake_case	       =       ""

							# decoding shift like Caesar cipher algorithm implementing negative shift or
							# reverse shift or left shift
							for i in encoded_message:
									_snake_case	       =       self.__key_list.index(__UpperCamelCase )
									decoded_message += self.__key_list[
									    (position - self.__shift_key) % -len(self.__key_list )
									]

							return decoded_message






					def 				__SCREAMING_SNAKE_CASE	(    self,  __UpperCamelCase ):
							_snake_case	       =       ""

							# encoding shift like Caesar cipher algorithm implementing positive shift or
							# forward shift or right shift
							for i in plaintext:
									_snake_case	       =       self.__key_list.index(__UpperCamelCase )
									encoded_message += self.__key_list[
									    (position + self.__shift_key) % len(self.__key_list )
									]

							return encoded_message






def 		_lowercase		(	lowercase_ = "Hello, this is a modified Caesar cipher"  ):



		'''simple docstring'''







		_snake_case	       =       ShuffledShiftCipher()
		return cipa.decrypt(cipa.encrypt(lowercase_  )  )


if __name__ == "__main__":
						import doctest

						doctest.testmod()











'''simple docstring'''







import unittest
from timeit import timeit






def 		_lowercase		(	lowercase_						,							lowercase_  ):



		'''simple docstring'''







		_snake_case	       =       first_num if first_num >= second_num else second_num
		_snake_case	       =       max_num
		while (common_mult % first_num > 0) or (common_mult % second_num > 0):
				common_mult += max_num
		return common_mult






def 		_lowercase		(	lowercase_						,							lowercase_  ):



		'''simple docstring'''







		return b if a == 0 else greatest_common_divisor(b % a						,							lowercase_  )






def 		_lowercase		(	lowercase_						,							lowercase_  ):



		'''simple docstring'''







		return first_num // greatest_common_divisor(lowercase_						,							lowercase_  ) * second_num






def 		_lowercase		(	):



		'''simple docstring'''







		_snake_case	       =       (
		    "from __main__ import least_common_multiple_slow, least_common_multiple_fast"
		)
		print(
		    "least_common_multiple_slow():"						,							timeit("least_common_multiple_slow(1000, 999)"						,							setup=lowercase_  )						,							)
		print(
		    "least_common_multiple_fast():"						,							timeit("least_common_multiple_fast(1000, 999)"						,							setup=lowercase_  )						,							)





class      lowerCamelCase_							(       unittest.TestCase							):




					'''simple docstring'''






					lowercase__    = (
					    (1_0, 2_0),
					    (1_3, 1_5),
					    (4, 3_1),
					    (1_0, 4_2),
					    (4_3, 3_4),
					    (5, 1_2),
					    (1_2, 2_5),
					    (1_0, 2_5),
					    (6, 9),
					)
					lowercase__    = (2_0, 1_9_5, 1_2_4, 2_1_0, 1_4_6_2, 6_0, 3_0_0, 5_0, 1_8)






					def 				__SCREAMING_SNAKE_CASE	(    self ):
							for i, (first_num, second_num) in enumerate(self.test_inputs ):
									_snake_case	       =       least_common_multiple_slow(__UpperCamelCase,  __UpperCamelCase )
									_snake_case	       =       least_common_multiple_fast(__UpperCamelCase,  __UpperCamelCase )
									with self.subTest(i=__UpperCamelCase ):
											self.assertEqual(__UpperCamelCase,  self.expected_results[i] )
											self.assertEqual(__UpperCamelCase,  self.expected_results[i] )


if __name__ == "__main__":
						benchmark()
						unittest.main()





