




import unittest
from timeit import timeit


def 		_lowerCamelCase					(       UpperCamelCase       ,  UpperCamelCase				)      ->		int:





  """simple docstring"""





  _lowercase:			Optional[int]      =     first_num if first_num >= second_num else second_num
  _lowercase:			Optional[int]      =     max_num
  while (common_mult % first_num > 0) or (common_mult % second_num > 0):
    common_mult += max_num
  return common_mult


def 		_lowerCamelCase					(       UpperCamelCase       ,  UpperCamelCase				)      ->		int:





  """simple docstring"""





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


def 		_lowerCamelCase					(       UpperCamelCase       ,  UpperCamelCase				)      ->		int:





  """simple docstring"""





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


def 		_lowerCamelCase					(       )      ->		List[Any]:





  """simple docstring"""





  _lowercase:			int      =     (
      'from __main__ import least_common_multiple_slow, least_common_multiple_fast'
  )
  print(
      'least_common_multiple_slow():'       ,  timeit('least_common_multiple_slow(1000, 999)'       ,  setup=UpperCamelCase				)       ,  )
  print(
      'least_common_multiple_fast():'       ,  timeit('least_common_multiple_fast(1000, 999)'       ,  setup=UpperCamelCase				)       ,  )

class   UpperCAmelCase    (      unittest.TestCase ):
   __SCREAMING_SNAKE_CASE		:				Optional[int]      					=       (
       (10, 20),
       (13, 15),
       (4, 31),
       (10, 42),
       (43, 34),
       (5, 12),
       (12, 25),
       (10, 25),
       (6, 9),
   )
   __SCREAMING_SNAKE_CASE		:				str      					=       (20, 1_95, 1_24, 2_10, 14_62, 60, 3_00, 50, 18)






   def 			_a    (						self :							List[Any]  )->      Optional[Any]:
     for i, (first_num, second_num) in enumerate(self.test_inputs  ):
       _lowercase:			Any      =     least_common_multiple_slow(UpperCamelCase_    ,       UpperCamelCase_  )
       _lowercase:			Tuple      =     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()






import random
import sys

UpperCAmelCase__    :							str       		=     'ABCDEFGHIJKLMNOPQRSTUVWXYZ'


def 		_lowerCamelCase					(       )      ->		None:





  """simple docstring"""





  _lowercase:			Any      =     input('Enter message: '				)
  _lowercase:			List[str]      =     'LFWOAYUISVKMNXPBDCRJTQEGHZ'
  _lowercase:			Tuple      =     input('Encrypt/Decrypt [e/d]: '				)

  check_valid_key(UpperCamelCase				)

  if resp.lower().startswith('e'				):
    _lowercase:			int      =     'encrypt'
    _lowercase:			Optional[int]      =     encrypt_message(UpperCamelCase       ,  UpperCamelCase				)
  elif resp.lower().startswith('d'				):
    _lowercase:			str      =     'decrypt'
    _lowercase:			Dict      =     decrypt_message(UpperCamelCase       ,  UpperCamelCase				)

  print(F'\n{mode.title()}ion: \n{translated}'				)


def 		_lowerCamelCase					(       UpperCamelCase				)      ->		None:





  """simple docstring"""





  _lowercase:			List[Any]      =     list(UpperCamelCase				)
  _lowercase:			Union[str, Any]      =     list(UpperCamelCase				)
  key_list.sort()
  letters_list.sort()

  if key_list != letters_list:
    sys.exit('Error in the key or symbol set.'				)


def 		_lowerCamelCase					(       UpperCamelCase       ,  UpperCamelCase				)      ->		str:





  """simple docstring"""





  return translate_message(UpperCamelCase       ,  UpperCamelCase       ,  'encrypt'				)


def 		_lowerCamelCase					(       UpperCamelCase       ,  UpperCamelCase				)      ->		str:





  """simple docstring"""





  return translate_message(UpperCamelCase       ,  UpperCamelCase       ,  'decrypt'				)


def 		_lowerCamelCase					(       UpperCamelCase       ,  UpperCamelCase       ,  UpperCamelCase				)      ->		str:





  """simple docstring"""





  _lowercase:			Optional[int]      =     ''
  _lowercase:			Any      =     LETTERS
  _lowercase:			Tuple      =     key

  if mode == "decrypt":
    _lowercase  ,       _lowercase:			Tuple      =     chars_b, chars_a

  for symbol in message:
    if symbol.upper() in chars_a:
      _lowercase:			int      =     chars_a.find(symbol.upper()				)
      if symbol.isupper():
        translated += chars_b[sym_index].upper()
      else:
        translated += chars_b[sym_index].lower()
    else:
      translated += symbol

  return translated


def 		_lowerCamelCase					(       )      ->		str:





  """simple docstring"""





  _lowercase:			Union[str, Any]      =     list(UpperCamelCase				)
  random.shuffle(UpperCamelCase				)
  return "".join(UpperCamelCase				)


if __name__ == "__main__":
   main()
