
import math


def      UpperCamelCase   (       ):
       snake_case			:  int     							= input("Enter message: "       )
       snake_case			:  List[str]     							= int(input(f"""Enter key [2-{len(__lowerCamelCase       ) - 1}]: """       )       )
       snake_case			:  List[Any]     							= input("Encryption/Decryption [e/d]: "       )

       if mode.lower().startswith("e"       ):
              snake_case			:  List[str]     							= encrypt_message(__lowerCamelCase							,   __lowerCamelCase       )
       elif mode.lower().startswith("d"       ):
              snake_case			:  Tuple     							= decrypt_message(__lowerCamelCase							,   __lowerCamelCase       )

       # Append pipe symbol (vertical bar) to identify spaces at the end.
       print(f"""Output:\n{text + '|'}"""       )


def      UpperCamelCase   (       __lowerCamelCase	:					int							,   __lowerCamelCase	:					str       ):
       snake_case			:  Optional[Any]     							= [""] * key
       for col in range(__lowerCamelCase       ):
              snake_case			:  Optional[int]     							= col
              while pointer < len(__lowerCamelCase       ):
                     cipher_text[col] += message[pointer]
                     pointer += key
       return "".join(__lowerCamelCase       )


def      UpperCamelCase   (       __lowerCamelCase	:					int							,   __lowerCamelCase	:					str       ):
       snake_case			:  Optional[Any]     							= math.ceil(len(__lowerCamelCase       ) / key       )
       snake_case			:  Dict     							= key
       snake_case			:  List[str]     							= (num_cols * num_rows) - len(__lowerCamelCase       )
       snake_case			:  int     							= [""] * num_cols
       snake_case			:  Dict     							= 0
       snake_case			:  int     							= 0

       for symbol in message:
              plain_text[col] += symbol
              col += 1

              if (
                  (col == num_cols)
                  or (col == num_cols - 1)
                  and (row >= num_rows - num_shaded_boxes)
              ):
                     snake_case			:  Tuple     							= 0
                     row += 1

       return "".join(__lowerCamelCase       )


if __name__ == "__main__":
   import doctest

   doctest.testmod()
   main()







__lowerCamelCase				=			"""Tobias Carryer"""

from time import time






class     UpperCAmelCase						:



   def __init__(self						:   Dict       ,		snake_case__						:   Optional[Any]       ,		snake_case__						:   Optional[Any]       ,		snake_case__						:   str       ,		snake_case__						:   Optional[int]=int(time()					)					)						->      List[Any]:  # noqa: B008


          '''simple docstring'''


          snake_case			:  Dict     							= multiplier
          snake_case			:  Dict     							= increment
          snake_case			:  Union[str, Any]     							= modulo
          snake_case			:  Tuple     							= seed



   def 							_SCREAMING_SNAKE_CASE  (self						:   List[Any]					)						->      Any:


          '''simple docstring'''


          snake_case			:  Optional[int]     							= (self.multiplier * self.seed + self.increment) % self.modulo
          return self.seed


if __name__ == "__main__":
   # Show the LCG in action.
   __lowerCamelCase				=			LinearCongruentialGenerator(1_66_45_25, 10_13_90_42_23, 2 << 31)
   while True:
      print(lcg.next_number())





