





from math import ceil


def 			SCREAMING_SNAKE_CASE (			_UpperCAmelCase = 1001					)     ->	int:
    lowerCamelCase__       : Optional[int]   					=						1

    for i in range(1		,      int(ceil(n / 2.0					)					)					):
        lowerCamelCase__       : List[Any]   					=						2 * i + 1
        lowerCamelCase__       : Tuple   					=						2 * i
        lowerCamelCase__       : Tuple   					=						total + 4 * odd**2 - 6 * even

    return total


if __name__ == "__main__":
    import sys

    if len(sys.argv) == 1:
        print(solution())
    else:
        try:
            _UpperCAmelCase							:			List[str]        =							int(sys.argv[1])
            print(solution(n))
        except ValueError:
            print("""Invalid entry - please enter a number""")












def 			SCREAMING_SNAKE_CASE (			_UpperCAmelCase					)     ->	str:
    lowerCamelCase__       : Dict   					=						''
    for ch in key:
        if ch == " " or ch not in key_no_dups and ch.isalpha():
            key_no_dups += ch
    return key_no_dups


def 			SCREAMING_SNAKE_CASE (			_UpperCAmelCase					)     ->	dict[str, str]:
    lowerCamelCase__       : List[str]   					=						[chr(i + 65					) for i in range(26					)]
    # Remove duplicate characters from key
    lowerCamelCase__       : Any   					=						remove_duplicates(key.upper()					)
    lowerCamelCase__       : List[Any]   					=						len(_UpperCAmelCase					)
    # First fill cipher with key characters
    lowerCamelCase__       : Optional[int]   					=						{alphabet[i]: char for i, char in enumerate(_UpperCAmelCase					)}
    # Then map remaining characters in alphabet to
    # the alphabet from the beginning
    for i in range(len(_UpperCAmelCase					)		,      26					):
        lowerCamelCase__       : Any   					=						alphabet[i - offset]
        # Ensure we are not mapping letters to letters previously mapped
        while char in key:
            offset -= 1
            lowerCamelCase__       : Union[str, Any]   					=						alphabet[i - offset]
        lowerCamelCase__       : int   					=						char
    return cipher_alphabet


def 			SCREAMING_SNAKE_CASE (			_UpperCAmelCase		,      _UpperCAmelCase					)     ->	str:
    return "".join(cipher_map.get(_UpperCAmelCase		,      _UpperCAmelCase					) for ch in message.upper()					)


def 			SCREAMING_SNAKE_CASE (			_UpperCAmelCase		,      _UpperCAmelCase					)     ->	str:
    lowerCamelCase__       : List[str]   					=						{v: k for k, v in cipher_map.items()}
    return "".join(rev_cipher_map.get(_UpperCAmelCase		,      _UpperCAmelCase					) for ch in message.upper()					)


def 			SCREAMING_SNAKE_CASE (			)     ->	None:
    lowerCamelCase__       : str   					=						input('Enter message to encode or decode: '					).strip()
    lowerCamelCase__       : Union[str, Any]   					=						input('Enter keyword: '					).strip()
    lowerCamelCase__       : Dict   					=						input('Encipher or decipher? E/D:'					).strip()[0].lower()
    try:
        lowerCamelCase__       : Dict   					=						{'e': encipher, 'd': decipher}[option]
    except KeyError:
        raise KeyError('invalid input option'					)
    lowerCamelCase__       : int   					=						create_cipher_map(_UpperCAmelCase					)
    print(func(_UpperCAmelCase		,      _UpperCAmelCase					)					)


if __name__ == "__main__":
    import doctest

    doctest.testmod()
    main()





