"""simple docstring"""




def 							SCREAMING_SNAKE_CASE					(      _lowerCamelCase						:	str     )	->				str:
		_lowerCAmelCase						:	Dict        =					0

		# if input_string is "aba" than new_input_string become "a|b|a"
		_lowerCAmelCase						:	Any        =					""""""
		_lowerCAmelCase						:	List[str]        =					""""""

		# append each character + "|" in new_string for range(0, length-1)
		for i in input_string[: len(_lowerCamelCase     ) - 1]:
				new_input_string += i + "|"
		# append last character
		new_input_string += input_string[-1]

		# we will store the starting and ending of previous furthest ending palindromic
		# substring
		_lowerCAmelCase						:	Optional[Any]        =					0, 0

		# length[i] shows the length of palindromic substring with center i
		_lowerCAmelCase						:	Optional[int]        =					[1 for i in range(len(_lowerCamelCase     )     )]

		# for each character in new_string find corresponding palindromic string
		_lowerCAmelCase						:	int        =					0
		for j in range(len(_lowerCamelCase     )     ):
				_lowerCAmelCase						:	List[Any]        =					1 if j > r else min(length[l + r - j] // 2      ,r - j + 1     )
				while (
				    j - k >= 0
				    and j + k < len(_lowerCamelCase     )
				    and new_input_string[k + j] == new_input_string[j - k]
				):
						k += 1

				_lowerCAmelCase						:	Any        =					2 * k - 1

				# does this string is ending after the previously explored end (that is r) ?
				# if yes the update the new r to the last index of this
				if j + k - 1 > r:
						_lowerCAmelCase						:	Dict        =					j - k + 1  # noqa: E741
						_lowerCAmelCase						:	List[Any]        =					j + k - 1

				# update max_length and start position
				if max_length < length[j]:
						_lowerCAmelCase						:	Union[str, Any]        =					length[j]
						_lowerCAmelCase						:	Union[str, Any]        =					j

				# create that string
		_lowerCAmelCase						:	Optional[Any]        =					new_input_string[start - max_length // 2 : start + max_length // 2 + 1]
		for i in s:
				if i != "|":
						output_string += i

		return output_string


if __name__ == "__main__":
					import doctest

					doctest.testmod()





"""simple docstring"""




import math





def 							SCREAMING_SNAKE_CASE					(      )	->				None:
  _lowerCAmelCase						:	Any        =					input("""Enter message: """     )
  _lowerCAmelCase						:	List[Any]        =					int(input(f"Enter key [2-{len(_lowerCamelCase     ) - 1}]: "     )     )
  _lowerCAmelCase						:	Optional[Any]        =					input("""Encryption/Decryption [e/d]: """     )

  if mode.lower().startswith("""e"""     ):
    _lowerCAmelCase						:	Tuple        =					encrypt_message(_lowerCamelCase      ,_lowerCamelCase     )
  elif mode.lower().startswith("""d"""     ):
    _lowerCAmelCase						:	Dict        =					decrypt_message(_lowerCamelCase      ,_lowerCamelCase     )

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





def 							SCREAMING_SNAKE_CASE					(      _lowerCamelCase						:	int      ,_lowerCamelCase						:	str     )	->				str:
  _lowerCAmelCase						:	Dict        =					[""""""] * key
  for col in range(_lowerCamelCase     ):
    _lowerCAmelCase						:	List[str]        =					col
    while pointer < len(_lowerCamelCase     ):
      cipher_text[col] += message[pointer]
      pointer += key
  return "".join(_lowerCamelCase     )





def 							SCREAMING_SNAKE_CASE					(      _lowerCamelCase						:	int      ,_lowerCamelCase						:	str     )	->				str:
  _lowerCAmelCase						:	str        =					math.ceil(len(_lowerCamelCase     ) / key     )
  _lowerCAmelCase						:	Union[str, Any]        =					key
  _lowerCAmelCase						:	Any        =					(num_cols * num_rows) - len(_lowerCamelCase     )
  _lowerCAmelCase						:	Dict        =					[""""""] * num_cols
  _lowerCAmelCase						:	Optional[Any]        =					0
  _lowerCAmelCase						:	Dict        =					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)
    ):
      _lowerCAmelCase						:	str        =					0
      row += 1

  return "".join(_lowerCamelCase     )


if __name__ == "__main__":
     import doctest

     doctest.testmod()
     main()




