




from __future__ import annotations

import random
import string
class      _UpperCamelCase :
      def __init__(     self				:Tuple	, lowerCamelCase				:str | None = None )       ->     None:
       UpperCAmelCase__								=  passcode or self.__passcode_creator()
       UpperCAmelCase__								=  self.__make_key_list()
       UpperCAmelCase__								=  self.__make_shift_key()
      def __str__(     self				:Tuple )       ->     str:
       return "".join(self.__passcode )
      def 		UpperCAmelCase_  (     self				:int	, lowerCamelCase				:list[int] )       ->     list[int]:
       for i in range(1	, len(lowerCamelCase )	, 2 ):
        iterlist[i] *= -1
       return iterlist
      def 		UpperCAmelCase_  (     self				:Dict )       ->     list[str]:
       UpperCAmelCase__								=  string.ascii_letters + string.digits
       UpperCAmelCase__								=  [random.choice(lowerCamelCase ) for _ in range(random.randint(10	, 20 ) )]
       return password
      def 		UpperCAmelCase_  (     self				:str )       ->     list[str]:
       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(lowerCamelCase )

        # 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 		UpperCAmelCase_  (     self				:str )       ->     int:
       UpperCAmelCase__								=  sum(self.__neg_pos([ord(lowerCamelCase ) for x in self.__passcode] ) )
       return num if num > 0 else len(self.__passcode )
      def 		UpperCAmelCase_  (     self				:Any	, lowerCamelCase				:str )       ->     str:
       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(lowerCamelCase )
        decoded_message += self.__key_list[
            (position - self.__shift_key) % -len(self.__key_list )
        ]

       return decoded_message







      def 		UpperCAmelCase_  (     self				:Optional[int]	, lowerCamelCase				:str )       ->     str:
       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(lowerCamelCase )
        encoded_message += self.__key_list[
            (position + self.__shift_key) % len(self.__key_list )
        ]

       return encoded_message



def   lowerCAmelCase						(						_lowerCAmelCase							:				str = "Hello, this is a modified Caesar cipher"		):




 """simple docstring"""







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


if __name__ == "__main__":
  import doctest

  doctest.testmod()











from __future__ import annotations



def   lowerCAmelCase						(						_lowerCAmelCase							:				int  ,							_lowerCAmelCase							:				int  ,							_lowerCAmelCase							:				int		):




 """simple docstring"""







 assert (
     c % greatest_common_divisor(_lowerCAmelCase  ,							_lowerCAmelCase		) == 0
 )  # greatest_common_divisor(a,b) function implemented below
 ((UpperCAmelCase__)	,	(UpperCAmelCase__)	,	(UpperCAmelCase__))								=  extended_gcd(_lowerCAmelCase  ,							_lowerCAmelCase		)  # extended_gcd(a,b) function implemented below
 UpperCAmelCase__								=  c / d
 return (r * x, r * y)



def   lowerCAmelCase						(						_lowerCAmelCase							:				int  ,							_lowerCAmelCase							:				int  ,							_lowerCAmelCase							:				int  ,							_lowerCAmelCase							:				int = 2		):




 """simple docstring"""







 ((UpperCAmelCase__)	,	(UpperCAmelCase__))								=  diophantine(_lowerCAmelCase  ,							_lowerCAmelCase  ,							_lowerCAmelCase		)  # Initial value
 UpperCAmelCase__								=  greatest_common_divisor(_lowerCAmelCase  ,							_lowerCAmelCase		)
 UpperCAmelCase__								=  a // d
 UpperCAmelCase__								=  b // d

 for i in range(_lowerCAmelCase		):
  UpperCAmelCase__								=  xa + i * q
  UpperCAmelCase__								=  ya - i * p
  print(_lowerCAmelCase  ,							_lowerCAmelCase		)



def   lowerCAmelCase						(						_lowerCAmelCase							:				int  ,							_lowerCAmelCase							:				int		):




 """simple docstring"""







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

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

 return b



def   lowerCAmelCase						(						_lowerCAmelCase							:				int  ,							_lowerCAmelCase							:				int		):




 """simple docstring"""







 assert a >= 0 and b >= 0

 if b == 0:
  UpperCAmelCase__	,	UpperCAmelCase__	,	UpperCAmelCase__								=  a, 1, 0
 else:
  ((UpperCAmelCase__)	,	(UpperCAmelCase__)	,	(UpperCAmelCase__))								=  extended_gcd(_lowerCAmelCase  ,							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)


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

  testmod(name="diophantine", verbose=True)
  testmod(name="diophantine_all_soln", verbose=True)
  testmod(name="extended_gcd", verbose=True)
  testmod(name="greatest_common_divisor", verbose=True)





