






lowerCamelCase_						     =  {
    """A""": ("""ABCDEFGHIJKLM""", """NOPQRSTUVWXYZ"""),
    """B""": ("""ABCDEFGHIJKLM""", """NOPQRSTUVWXYZ"""),
    """C""": ("""ABCDEFGHIJKLM""", """ZNOPQRSTUVWXY"""),
    """D""": ("""ABCDEFGHIJKLM""", """ZNOPQRSTUVWXY"""),
    """E""": ("""ABCDEFGHIJKLM""", """YZNOPQRSTUVWX"""),
    """F""": ("""ABCDEFGHIJKLM""", """YZNOPQRSTUVWX"""),
    """G""": ("""ABCDEFGHIJKLM""", """XYZNOPQRSTUVW"""),
    """H""": ("""ABCDEFGHIJKLM""", """XYZNOPQRSTUVW"""),
    """I""": ("""ABCDEFGHIJKLM""", """WXYZNOPQRSTUV"""),
    """J""": ("""ABCDEFGHIJKLM""", """WXYZNOPQRSTUV"""),
    """K""": ("""ABCDEFGHIJKLM""", """VWXYZNOPQRSTU"""),
    """L""": ("""ABCDEFGHIJKLM""", """VWXYZNOPQRSTU"""),
    """M""": ("""ABCDEFGHIJKLM""", """UVWXYZNOPQRST"""),
    """N""": ("""ABCDEFGHIJKLM""", """UVWXYZNOPQRST"""),
    """O""": ("""ABCDEFGHIJKLM""", """TUVWXYZNOPQRS"""),
    """P""": ("""ABCDEFGHIJKLM""", """TUVWXYZNOPQRS"""),
    """Q""": ("""ABCDEFGHIJKLM""", """STUVWXYZNOPQR"""),
    """R""": ("""ABCDEFGHIJKLM""", """STUVWXYZNOPQR"""),
    """S""": ("""ABCDEFGHIJKLM""", """RSTUVWXYZNOPQ"""),
    """T""": ("""ABCDEFGHIJKLM""", """RSTUVWXYZNOPQ"""),
    """U""": ("""ABCDEFGHIJKLM""", """QRSTUVWXYZNOP"""),
    """V""": ("""ABCDEFGHIJKLM""", """QRSTUVWXYZNOP"""),
    """W""": ("""ABCDEFGHIJKLM""", """PQRSTUVWXYZNO"""),
    """X""": ("""ABCDEFGHIJKLM""", """PQRSTUVWXYZNO"""),
    """Y""": ("""ABCDEFGHIJKLM""", """OPQRSTUVWXYZN"""),
    """Z""": ("""ABCDEFGHIJKLM""", """OPQRSTUVWXYZN"""),
}
def      lowerCamelCase					(						a_	)	->			list[tuple[str, str]]:
							return [alphabet[char] for char in key.upper()]
def      lowerCamelCase					(						a_ ,						a_	)	->			str:
							lowerCAmelCase_										=     ''
							lowerCAmelCase_										=     0
							lowerCAmelCase_										=     generate_table(a_	)
							for char in words.upper():
														cipher += get_opponent(table[count] ,						a_	)
														lowerCAmelCase_										=     (count + 1) % len(a_	)
							return cipher
def      lowerCamelCase					(						a_ ,						a_	)	->			str:
							return encrypt(a_ ,						a_	)
def      lowerCamelCase					(						a_ ,						a_	)	->			tuple[int, int]:
							lowerCAmelCase_										=     0 if char in table[0] else 1
							lowerCAmelCase_										=     table[row].index(a_	)
							return row, col
def      lowerCamelCase					(						a_ ,						a_	)	->			str:
							lowerCAmelCase_						,   lowerCAmelCase_										=     get_position(a_ ,						char.upper()	)
							if row == 1:
														return table[0][col]
							else:
														return table[1][col] if row == 0 else char


if __name__ == "__main__":
		import doctest

		doctest.testmod()  # Fist ensure that all our tests are passing...
		lowerCamelCase_						     =  input("""Enter key: """).strip()
		lowerCamelCase_						     =  input("""Enter text to encrypt: """).strip()
		lowerCamelCase_						     =  encrypt(key, text)

		print(f'''Encrypted: {cipher_text}''')
		print(f'''Decrypted with key: {decrypt(key, cipher_text)}''')











from doctest import testmod
from math import sqrt
def      lowerCamelCase					(						a_	)	->			list:
							lowerCAmelCase_										=     []
							if num < 1:
														return facs
							facs.append(1	)
							if num == 1:
														return facs
							facs.append(a_	)
							for i in range(2 ,						int(sqrt(a_	)	) + 1	):
														if num % i == 0:  # If i is a factor of num
																					facs.append(a_	)
																					lowerCAmelCase_										=     num // i  # num//i is the other factor of num
																					if d != i:  # If d and i are distinct
																												facs.append(a_	)  # we have found another factor
							facs.sort()
							return facs


if __name__ == "__main__":
		testmod(name="""factors_of_a_number""", verbose=True)



