



__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     UpperCAmelCase__ (							__snake_case							):
  return [alphabet[char] for char in key.upper()]




def     UpperCAmelCase__ (							__snake_case						,				__snake_case							):
  _A           =    ''''''
  _A           =    0
  _A           =    generate_table(__snake_case							)
  for char in words.upper():
    cipher += get_opponent(table[count]						,				__snake_case							)
    _A           =    (count + 1) % len(__snake_case							)
  return cipher




def     UpperCAmelCase__ (							__snake_case						,				__snake_case							):
  return encrypt(__snake_case						,				__snake_case							)




def     UpperCAmelCase__ (							__snake_case						,				__snake_case							):
  _A           =    0 if char in table[0] else 1
  _A           =    table[row].index(__snake_case							)
  return row, col




def     UpperCAmelCase__ (							__snake_case						,				__snake_case							):
  _A    ,   _A           =    get_position(__snake_case						,				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)}''')




def     UpperCAmelCase__ (							__snake_case						,				__snake_case = 1_000							)   -> str:
  if (not isinstance(__snake_case						,				__snake_case							)) or (digit_position <= 0):
    raise ValueError('''Digit position must be a positive integer'''							)
  elif (not isinstance(__snake_case						,				__snake_case							)) or (precision < 0):
    raise ValueError('''Precision must be a nonnegative integer'''							)

  # compute an approximation of (16 ** (n - 1)) * pi whose fractional part is mostly
  # accurate
  _A           =    (
      4 * _subsum(__snake_case						,				1						,				__snake_case							)
      - 2 * _subsum(__snake_case						,				4						,				__snake_case							)
      - _subsum(__snake_case						,				5						,				__snake_case							)
      - _subsum(__snake_case						,				6						,				__snake_case							)
  )

  # return the first hex digit of the fractional part of the result
  return hex(int((sum_result % 1) * 16							)							)[2:]




def     UpperCAmelCase__ (							__snake_case						,				__snake_case						,				__snake_case							)   -> float:
  _A           =    0.0
  for sum_index in range(digit_pos_to_extract + precision							):
    _A           =    8 * sum_index + denominator_addend
    if sum_index < digit_pos_to_extract:
      # if the exponential term is an integer and we mod it by the denominator
      # before dividing, only the integer part of the sum will change;
      # the fractional part will not
      _A           =    pow(
          16						,				digit_pos_to_extract - 1 - sum_index						,				__snake_case							)
    else:
      _A           =    pow(16						,				digit_pos_to_extract - 1 - sum_index							)
    total += exponential_term / denominator
  return total


if __name__ == "__main__":
    import doctest

    doctest.testmod()