



'''simple docstring'''


_lowerCamelCase	:       str      	=	"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"







def 				__lowerCamelCase				(   A__    )       ->	bytes:






   """simple docstring"""
   # Make sure the supplied data is a bytes-like object
   if not isinstance(A__    ,						A__    ):
      UpperCamelCase					=  F"""a bytes-like object is required, not '{data.__class__.__name__}'"""
      raise TypeError(A__    )

   UpperCamelCase					=  ''.join(bin(A__    )[2:].zfill(8    ) for byte in data    )

   UpperCamelCase					=  len(A__    ) % 6 != 0

   if padding_needed:
      # The padding that will be added later
      UpperCamelCase					=  B'=' * ((6 - len(A__    ) % 6) // 2)

      # Append binary_stream with arbitrary binary digits (0's by default) to make its
      # length a multiple of 6.
      binary_stream += "0" * (6 - len(A__    ) % 6)
   else:
      UpperCamelCase					=  B''

   # Encode every 6 binary digits to their corresponding Base64 character
   return (
       "".join(
           B64_CHARSET[int(binary_stream[index : index + 6]    ,						2    )]
           for index in range(0    ,						len(A__    )    ,						6    )    ).encode()
       + padding
   )







def 				__lowerCamelCase				(   A__    )       ->	bytes:






   """simple docstring"""
   # Make sure encoded_data is either a string or a bytes-like object
   if not isinstance(A__    ,						A__    ) and not isinstance(A__    ,						A__    ):
      UpperCamelCase					=  (
          'argument should be a bytes-like object or ASCII string, '
          F"""not '{encoded_data.__class__.__name__}'"""
      )
      raise TypeError(A__    )

   # In case encoded_data is a bytes-like object, make sure it contains only
   # ASCII characters so we convert it to a string object
   if isinstance(A__    ,						A__    ):
      try:
         UpperCamelCase					=  encoded_data.decode('utf-8'    )
      except UnicodeDecodeError:
         raise ValueError('base64 encoded data should only contain ASCII characters'    )

   UpperCamelCase					=  encoded_data.count('='    )

   # Check if the encoded string contains non base64 characters
   if padding:
      assert all(
          char in B64_CHARSET for char in encoded_data[:-padding]    ), "Invalid base64 character(s) found."
   else:
      assert all(
          char in B64_CHARSET for char in encoded_data    ), "Invalid base64 character(s) found."

   # Check the padding
   assert len(A__    ) % 4 == 0 and padding < 3, "Incorrect padding"

   if padding:
      # Remove padding if there is one
      UpperCamelCase					=  encoded_data[:-padding]

      UpperCamelCase					=  ''.join(
          bin(B64_CHARSET.index(A__    )    )[2:].zfill(6    ) for char in encoded_data    )[: -padding * 2]
   else:
      UpperCamelCase					=  ''.join(
          bin(B64_CHARSET.index(A__    )    )[2:].zfill(6    ) for char in encoded_data    )

   UpperCamelCase					=  [
       int(binary_stream[index : index + 8]    ,						2    )
       for index in range(0    ,						len(A__    )    ,						8    )
   ]

   return bytes(A__    )


if __name__ == "__main__":
   import doctest

   doctest.testmod()







from math import pi, sqrt





def 		__A		(	__lowerCamelCase    )      ->       float:
	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		(	)      ->       None:
	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					:       str    					=      1.0
		while num:
				__UpperCamelCase					:       Dict    					=      float(input("Gamma of: "))
				print(F'gamma({num}) = {gamma(num)}')
				print("\nEnter 0 to exit...")

