




'''simple docstring'''




from __future__ import annotations

def    _UpperCamelCase      (				SCREAMING_SNAKE_CASE__			:      int       ,						SCREAMING_SNAKE_CASE__			:      int       ,						SCREAMING_SNAKE_CASE__			:      int       ):
 '''simple docstring'''





 assert n > 1 and a > 0 and greatest_common_divisor(SCREAMING_SNAKE_CASE__       ,						SCREAMING_SNAKE_CASE__       ) == 1
 ((UpperCAmelCase__)							,			(UpperCAmelCase__)							,			(UpperCAmelCase__))										=    extended_gcd(SCREAMING_SNAKE_CASE__       ,						SCREAMING_SNAKE_CASE__       )  # Implemented below
 UpperCAmelCase__										=    (b * s) % n
 return x

def    _UpperCamelCase      (				SCREAMING_SNAKE_CASE__			:      int       ,						SCREAMING_SNAKE_CASE__			:      int       ):
 '''simple docstring'''





 ((UpperCAmelCase__)							,			(UpperCAmelCase__))										=    extended_euclid(SCREAMING_SNAKE_CASE__       ,						SCREAMING_SNAKE_CASE__       )  # Implemented below
 if b < 0:
  UpperCAmelCase__										=    (b % n + n) % n
 return b

def    _UpperCamelCase      (				SCREAMING_SNAKE_CASE__			:      int       ,						SCREAMING_SNAKE_CASE__			:      int       ,						SCREAMING_SNAKE_CASE__			:      int       ):
 '''simple docstring'''





 UpperCAmelCase__										=    invert_modulo(SCREAMING_SNAKE_CASE__       ,						SCREAMING_SNAKE_CASE__       )
 UpperCAmelCase__										=    (b * s) % n
 return x

def    _UpperCamelCase      (				SCREAMING_SNAKE_CASE__			:      int       ,						SCREAMING_SNAKE_CASE__			:      int       ):
 '''simple docstring'''





 assert a >= 0 and b >= 0

 if b == 0:
  UpperCAmelCase__							,			UpperCAmelCase__							,			UpperCAmelCase__										=    a, 1, 0
 else:
  ((UpperCAmelCase__)							,			(UpperCAmelCase__)							,			(UpperCAmelCase__))										=    extended_gcd(SCREAMING_SNAKE_CASE__       ,						a % b       )
  UpperCAmelCase__										=    q
  UpperCAmelCase__										=    p - q * (a // b)

 assert a % d == 0 and b % d == 0
 assert d == a * x + b * y

 return (d, x, y)

def    _UpperCamelCase      (				SCREAMING_SNAKE_CASE__			:      int       ,						SCREAMING_SNAKE_CASE__			:      int       ):
 '''simple docstring'''





 if b == 0:
  return (1, 0)
 ((UpperCAmelCase__)							,			(UpperCAmelCase__))										=    extended_euclid(SCREAMING_SNAKE_CASE__       ,						a % b       )
 UpperCAmelCase__										=    a // b
 return (y, x - k * y)

def    _UpperCamelCase      (				SCREAMING_SNAKE_CASE__			:      int       ,						SCREAMING_SNAKE_CASE__			:      int       ):
 '''simple docstring'''





 if a < b:
  UpperCAmelCase__							,			UpperCAmelCase__										=    b, a

 while a % b != 0:
  UpperCAmelCase__							,			UpperCAmelCase__										=    b, a % b

 return b


if __name__ == "__main__":
    from doctest import testmod

    testmod(name='modular_division', verbose=True)
    testmod(name='modular_division2', verbose=True)
    testmod(name='invert_modulo', verbose=True)
    testmod(name='extended_gcd', verbose=True)
    testmod(name='extended_euclid', verbose=True)
    testmod(name='greatest_common_divisor', verbose=True)






'''simple docstring'''




from __future__ import annotations

import random
import string

class 						lowerCAmelCase_   :







  '''simple docstring'''







  def __init__(						self    :	int						,		_UpperCAmelCase    :	str | None = None ):






   """simple docstring"""






   UpperCAmelCase__										=    passcode or self.__passcode_creator()
   UpperCAmelCase__										=    self.__make_key_list()
   UpperCAmelCase__										=    self.__make_shift_key()


  def __str__(						self    :	int ):






   """simple docstring"""






   return "".join(self.__passcode )


  def 							SCREAMING_SNAKE_CASE__			(						self    :	List[str]						,		_UpperCAmelCase    :	list[int] ):






   """simple docstring"""






   for i in range(1						,		len(_UpperCAmelCase )						,		2 ):
    iterlist[i] *= -1
   return iterlist


  def 							SCREAMING_SNAKE_CASE__			(						self    :	int ):






   """simple docstring"""






   UpperCAmelCase__										=    string.ascii_letters + string.digits
   UpperCAmelCase__										=    [random.choice(_UpperCAmelCase ) for _ in range(random.randint(10						,		20 ) )]
   return password


  def 							SCREAMING_SNAKE_CASE__			(						self    :	Tuple ):






   """simple docstring"""






   UpperCAmelCase__										=    (
       string.ascii_letters + string.digits + string.punctuation + """ \t\n"""
   )

   UpperCAmelCase__										=    []

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

   # 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    :	Tuple ):






   """simple docstring"""






   UpperCAmelCase__										=    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    :	Optional[Any]						,		_UpperCAmelCase    :	str ):






   """simple docstring"""






   UpperCAmelCase__										=    """"""

   # decoding shift like Caesar cipher algorithm implementing negative shift or
   # reverse shift or left shift
   for i in encoded_message:
    UpperCAmelCase__										=    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    :	List[str]						,		_UpperCAmelCase    :	str ):






   """simple docstring"""






   UpperCAmelCase__										=    """"""

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

   return encoded_message

def    _UpperCamelCase      (				SCREAMING_SNAKE_CASE__			:      str = "Hello, this is a modified Caesar cipher"       ):
 '''simple docstring'''





 UpperCAmelCase__										=    ShuffledShiftCipher()
 return cipa.decrypt(cipa.encrypt(SCREAMING_SNAKE_CASE__       )       )


if __name__ == "__main__":
    import doctest

    doctest.testmod()
