




import itertools
import string
from collections.abc import Generator, Iterable



def 							_A       (						lowerCAmelCase_					: Iterable[str]       ,    lowerCAmelCase_					: int      ):
     """simple docstring"""

     lowerCAmelCase__          =			iter(lowerCAmelCase_      )
     while True:
          lowerCAmelCase__          =			tuple(itertools.islice(lowerCAmelCase_       ,    lowerCAmelCase_      )      )
          if not chunk:
               return
          yield chunk



def 							_A       (						lowerCAmelCase_					: str      ):
     """simple docstring"""

     lowerCAmelCase__          =			"".join([c.upper() for c in dirty if c in string.ascii_letters]      )
     lowerCAmelCase__          =			""

     if len(lowerCAmelCase_      ) < 2:
          return dirty

     for i in range(len(lowerCAmelCase_      ) - 1      ):
          clean += dirty[i]

          if dirty[i] == dirty[i + 1]:
               clean += "X"

     clean += dirty[-1]

     if len(lowerCAmelCase_      ) & 1:
          clean += "X"

     return clean



def 							_A       (						lowerCAmelCase_					: str      ):
     """simple docstring"""

     lowerCAmelCase__          =			"ABCDEFGHIKLMNOPQRSTUVWXYZ"
     # we're using a list instead of a '2d' array because it makes the math
     # for setting up the table and doing the actual encoding/decoding simpler
     lowerCAmelCase__          =			[]

     # copy key chars into the table if they are in `alphabet` ignoring duplicates
     for char in key.upper():
          if char not in table and char in alphabet:
               table.append(lowerCAmelCase_      )

    # fill the rest of the table in with the remaining alphabet chars
     for char in alphabet:
          if char not in table:
               table.append(lowerCAmelCase_      )

     return table



def 							_A       (						lowerCAmelCase_					: str       ,    lowerCAmelCase_					: str      ):
     """simple docstring"""

     lowerCAmelCase__          =			generate_table(lowerCAmelCase_      )
     lowerCAmelCase__          =			prepare_input(lowerCAmelCase_      )
     lowerCAmelCase__          =			""

     # https://en.wikipedia.org/wiki/Playfair_cipher#Description
     for chara, chara in chunker(lowerCAmelCase_       ,    2      ):
          lowerCAmelCase__     ,		lowerCAmelCase__          =			divmod(table.index(lowerCAmelCase_      )       ,    5      )
          lowerCAmelCase__     ,		lowerCAmelCase__          =			divmod(table.index(lowerCAmelCase_      )       ,    5      )

          if rowa == rowa:
               ciphertext += table[rowa * 5 + (cola + 1) % 5]
               ciphertext += table[rowa * 5 + (cola + 1) % 5]
          elif cola == cola:
               ciphertext += table[((rowa + 1) % 5) * 5 + cola]
               ciphertext += table[((rowa + 1) % 5) * 5 + cola]
          else:  # rectangle
               ciphertext += table[rowa * 5 + cola]
               ciphertext += table[rowa * 5 + cola]

     return ciphertext






def 							_A       (						lowerCAmelCase_					: str       ,    lowerCAmelCase_					: str      ):
     """simple docstring"""

     lowerCAmelCase__          =			generate_table(lowerCAmelCase_      )
     lowerCAmelCase__          =			""

     # https://en.wikipedia.org/wiki/Playfair_cipher#Description
     for chara, chara in chunker(lowerCAmelCase_       ,    2      ):
          lowerCAmelCase__     ,		lowerCAmelCase__          =			divmod(table.index(lowerCAmelCase_      )       ,    5      )
          lowerCAmelCase__     ,		lowerCAmelCase__          =			divmod(table.index(lowerCAmelCase_      )       ,    5      )

          if rowa == rowa:
               plaintext += table[rowa * 5 + (cola - 1) % 5]
               plaintext += table[rowa * 5 + (cola - 1) % 5]
          elif cola == cola:
               plaintext += table[((rowa - 1) % 5) * 5 + cola]
               plaintext += table[((rowa - 1) % 5) * 5 + cola]
          else:  # rectangle
               plaintext += table[rowa * 5 + cola]
               plaintext += table[rowa * 5 + cola]

     return plaintext












from math import pi, sqrt



def 							_A       (						lowerCAmelCase_					: float      ):
     """simple docstring"""

     if num <= 0:
          raise ValueError("math domain error"      )
     if num > 171.5:
          raise OverflowError("math range error"      )
     elif num - int(lowerCAmelCase_      ) not in (0, 0.5):
          raise NotImplementedError("num must be an integer or a half-integer"      )
     elif num == 0.5:
          return sqrt(lowerCAmelCase_      )
     else:
          return 1.0 if num == 1 else (num - 1) * gamma(num - 1      )



def 							_A       (						):
     """simple docstring"""

     assert gamma(0.5      ) == sqrt(lowerCAmelCase_      )
     assert gamma(1      ) == 1.0
     assert gamma(2      ) == 1.0


if __name__ == "__main__":
     from doctest import testmod

     testmod()
     UpperCamelCase								=					1.0
     while num:
          UpperCamelCase								=					float(input('Gamma of: '))
          print(F"""gamma({num}) = {gamma(num)}""")
          print('\nEnter 0 to exit...')
