'''simple docstring'''





from __future__ import annotations

import random
import string


class _lowercase					:





							"""simple docstring"""




							def __init__(    self     ,   UpperCAmelCase = None  ):







														'''simple docstring'''






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



							def __str__(    self  ):







														'''simple docstring'''






														return "".join(self.__passcode  )



							def     _UpperCAmelCase       (    self     ,   UpperCAmelCase  ):







														'''simple docstring'''






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



							def     _UpperCAmelCase       (    self  ):







														'''simple docstring'''






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



							def     _UpperCAmelCase       (    self  ):







														'''simple docstring'''






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

														_lowercase				=	[]

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

														# 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     _UpperCAmelCase       (    self  ):







														'''simple docstring'''






														_lowercase				=	sum(self.__neg_pos([ord(UpperCAmelCase  ) for x in self.__passcode]  )  )
														return num if num > 0 else len(self.__passcode  )



							def     _UpperCAmelCase       (    self     ,   UpperCAmelCase  ):







														'''simple docstring'''






														_lowercase				=	""""""

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

														return decoded_message



							def     _UpperCAmelCase       (    self     ,   UpperCAmelCase  ):







														'''simple docstring'''






														_lowercase				=	""""""

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

														return encoded_message






def 					__lowerCAmelCase			(  _A = "Hello, this is a modified Caesar cipher"					):



							"""simple docstring"""


							_lowercase				=	ShuffledShiftCipher()
							return cipa.decrypt(cipa.encrypt(_A					)					)


if __name__ == "__main__":
				import doctest

				doctest.testmod()



import math
from timeit import timeit


def 					__lowerCAmelCase			(  _A					):



							"""simple docstring"""


							_lowercase				=	0
							_lowercase				=	abs(_A					)
							while True:
														_lowercase				=	n // 10
														digits += 1
														if n == 0:
																					break
							return digits


def 					__lowerCAmelCase			(  _A					):



							"""simple docstring"""


							return 1 if n == 0 else math.floor(math.log(abs(_A					) ,10					) + 1					)


def 					__lowerCAmelCase			(  _A					):



							"""simple docstring"""


							return len(str(abs(_A					)					)					)


def 					__lowerCAmelCase			(  ):



							"""simple docstring"""


							from collections.abc import Callable

							def benchmark_a_function(_A ,_A					) -> None:
														_lowercase				=	f'''{func.__name__}({value})'''
														_lowercase				=	timeit(f'''__main__.{call}''' ,setup="""import __main__"""					)
														print(f'''{call}: {func(_A					)} -- {timing} seconds'''					)

							for value in (262_144, 1_125_899_906_842_624, 1_267_650_600_228_229_401_496_703_205_376):
														for func in (num_digits, num_digits_fast, num_digits_faster):
																					benchmark_a_function(_A ,_A					)
														print()


if __name__ == "__main__":
				import doctest

				doctest.testmod()
				benchmark()


