






from __future__ import annotations

import random
import string





class     __a						:







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


      '''simple docstring'''






      UpperCamelCase__    :     Optional[int]        =						passcode or self.__passcode_creator()
      UpperCamelCase__    :     Dict        =						self.__make_key_list()
      UpperCamelCase__    :     Dict        =						self.__make_shift_key()







 def __str__(	self      :     str		):


      '''simple docstring'''






      return "".join(self.__passcode		)







 def       __lowercase      (	self      :     Optional[int]							,     SCREAMING_SNAKE_CASE      :     list[int]		):


      '''simple docstring'''






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







 def       __lowercase      (	self      :     Optional[int]		):


      '''simple docstring'''






      UpperCamelCase__    :     Union[str, Any]        =						string.ascii_letters + string.digits
      UpperCamelCase__    :     Optional[Any]        =						[random.choice(SCREAMING_SNAKE_CASE		) for _ in range(random.randint(10							,     20		)		)]
      return password







 def       __lowercase      (	self      :     Union[str, Any]		):


      '''simple docstring'''






      UpperCamelCase__    :     Tuple        =						(
          string.ascii_letters + string.digits + string.punctuation + " \t\n"
      )

      UpperCamelCase__    :     Optional[Any]        =						[]

      # creates points known as breakpoints to break the key_list_options at those
      # points and pivot each substring
      UpperCamelCase__    :     List[Any]        =						sorted(set(self.__passcode		)		)
      UpperCamelCase__    :     list[str]        =						[]

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

           # 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       __lowercase      (	self      :     List[str]		):


      '''simple docstring'''






      UpperCamelCase__    :     Tuple        =						sum(self.__neg_pos([ord(SCREAMING_SNAKE_CASE		) for x in self.__passcode]		)		)
      return num if num > 0 else len(self.__passcode		)







 def       __lowercase      (	self      :     Optional[int]							,     SCREAMING_SNAKE_CASE      :     str		):


      '''simple docstring'''






      UpperCamelCase__    :     Dict        =						""

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

      return decoded_message







 def       __lowercase      (	self      :     List[str]							,     SCREAMING_SNAKE_CASE      :     str		):


      '''simple docstring'''






      UpperCamelCase__    :     Tuple        =						""

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

      return encoded_message







def 	SCREAMING_SNAKE_CASE							(      __lowerCAmelCase = "Hello, this is a modified Caesar cipher"    )				->			str:
     UpperCamelCase__    :     List[Any]        =						ShuffledShiftCipher()
     return cipa.decrypt(cipa.encrypt(__lowerCAmelCase    )    )


if __name__ == "__main__":
 import doctest

 doctest.testmod()







from __future__ import annotations







def 	SCREAMING_SNAKE_CASE							(      __lowerCAmelCase    )				->			list[int]:
     assert (
         isinstance(__lowerCAmelCase      ,					__lowerCAmelCase    ) and mask > 0
     ), f'mask needs to be positive integer, your input {mask}'
     UpperCamelCase__    :     Any        =						[]
     UpperCamelCase__    :     int        =						mask

     while submask:
          all_submasks.append(__lowerCAmelCase    )
          UpperCamelCase__    :     List[str]        =						(submask - 1) & mask

     return all_submasks


if __name__ == "__main__":
 import doctest

 doctest.testmod()