



from __future__ import annotations

from string import ascii_letters







def       lowerCamelCase_  (    _a       :						str   ,		_a       :						int   ,		_a       :						str | None = None    ):



    '''simple docstring'''




    UpperCAmelCase_     :       int  		=					alphabet or ascii_letters

    # The final result string
    UpperCAmelCase_     :       Union[str, Any]  		=					""""""

    for character in input_string:
        if character not in alpha:
            # Append without encryption if character is not in the alphabet
            result += character
        else:
            # Get the index of the new key and make sure it isn't too large
            UpperCAmelCase_     :       Any  		=					(alpha.index(_a    ) + key) % len(_a    )

            # Append the encoded character to the alphabet
            result += alpha[new_key]

    return result







def       lowerCamelCase_  (    _a       :						str   ,		_a       :						int   ,		_a       :						str | None = None    ):



    '''simple docstring'''




    key *= -1

    return encrypt(_a   ,		_a   ,		_a    )







def       lowerCamelCase_  (    _a       :						str   ,		_a       :						str | None = None    ):



    '''simple docstring'''




    UpperCAmelCase_     :       Dict  		=					alphabet or ascii_letters

    # To store data on all the combinations
    UpperCAmelCase_     :       List[Any]  		=					{}

    # Cycle through each combination
    for key in range(1   ,		len(_a    ) + 1    ):
        # Decrypt the message and store the result in the data
        UpperCAmelCase_     :       Optional[Any]  		=					decrypt(_a   ,		_a   ,		_a    )

    return brute_force_data


if __name__ == "__main__":
      while True:
            print(F"\n{'-' * 10}\n Menu\n{'-' * 10}")
            print(*['''1.Encrypt''', '''2.Decrypt''', '''3.BruteForce''', '''4.Quit'''], sep='''\n''')

            # get user input
            UpperCamelCase_									=   input('''\nWhat would you like to do?: ''').strip() or '''4'''

            # run functions based on what the user chose
            if choice not in ("1", "2", "3", "4"):
                  print('''Invalid choice, please enter a valid choice''')
            elif choice == "1":
                  UpperCamelCase_									=   input('''Please enter the string to be encrypted: ''')
                  UpperCamelCase_									=   int(input('''Please enter off-set: ''').strip())

                  print(encrypt(input_string, key))
            elif choice == "2":
                  UpperCamelCase_									=   input('''Please enter the string to be decrypted: ''')
                  UpperCamelCase_									=   int(input('''Please enter off-set: ''').strip())

                  print(decrypt(input_string, key))
            elif choice == "3":
                  UpperCamelCase_									=   input('''Please enter the string to be decrypted: ''')
                  UpperCamelCase_									=   brute_force(input_string)

                  for key, value in brute_force_data.items():
                        print(F"Key: {key} | Message: {value}")

            elif choice == "4":
                  print('''Goodbye.''')
                  break





from math import cos, sin







def       lowerCamelCase_  (    _a       :						float    ):



    '''simple docstring'''




    UpperCAmelCase_     :       str  		=					float(_a    )
    return [[scaling_factor * int(x == y    ) for x in range(2    )] for y in range(2    )]







def       lowerCamelCase_  (    _a       :						float    ):



    '''simple docstring'''




    UpperCAmelCase_		, UpperCAmelCase_     :       List[str]  		=					cos(_a    ), sin(_a    )
    return [[c, -s], [s, c]]







def       lowerCamelCase_  (    _a       :						float    ):



    '''simple docstring'''




    UpperCAmelCase_		, UpperCAmelCase_     :       Optional[Any]  		=					cos(_a    ), sin(_a    )
    UpperCAmelCase_     :       Dict  		=					c * s
    return [[c * c, cs], [cs, s * s]]







def       lowerCamelCase_  (    _a       :						float    ):



    '''simple docstring'''




    UpperCAmelCase_		, UpperCAmelCase_     :       List[Any]  		=					cos(_a    ), sin(_a    )
    UpperCAmelCase_     :       Optional[Any]  		=					c * s
    return [[2 * c - 1, 2 * cs], [2 * cs, 2 * s - 1]]


print(F"    {scaling(5) = }")
print(F"  {rotation(45) = }")
print(F"{projection(45) = }")






print(F"{reflection(45) = }")
