



'''simple docstring'''

import math
import sys



def      __lowerCamelCase     (      lowerCAmelCase_  )			->      str:
		_a     :      Union[str, Any]        =							''
		try:
				with open(lowerCAmelCase_						,			'rb'  ) as binary_file:
						_a     :      Optional[int]        =							binary_file.read()
				for dat in data:
						_a     :      str        =							f"""{dat:08b}"""
						result += curr_byte
				return result
		except OSError:
				print('File not accessible'  )
				sys.exit()



def      __lowerCamelCase     (      lowerCAmelCase_  )			->      str:
		_a     :      int        =							{'0': '0', '1': '1'}
		_a       ,					_a     :      Optional[Any]        =							'', ''
		_a     :      Tuple        =							len(lowerCAmelCase_  )

		for i in range(len(lowerCAmelCase_  )  ):
				curr_string += data_bits[i]
				if curr_string not in lexicon:
						continue

				_a     :      Dict        =							lexicon[curr_string]
				result += last_match_id
				_a     :      Tuple        =							last_match_id + '0'

				if math.loga(lowerCAmelCase_  ).is_integer():
						_a     :      Optional[Any]        =							{}
						for curr_key in list(lowerCAmelCase_  ):
								_a     :      Tuple        =							lexicon.pop(lowerCAmelCase_  )
						_a     :      List[Any]        =							new_lex

				_a     :      Any        =							last_match_id + '1'
				index += 1
				_a     :      Optional[Any]        =							''
		return result



def      __lowerCamelCase     (      lowerCAmelCase_						,			lowerCAmelCase_  )			->      None:
		_a     :      Any        =							8
		try:
				with open(lowerCAmelCase_						,			'wb'  ) as opened_file:
						_a     :      int        =							[
						    to_write[i : i + byte_length]
						    for i in range(0						,			len(lowerCAmelCase_  )						,			lowerCAmelCase_  )
						]

						if len(result_byte_array[-1]  ) % byte_length == 0:
								result_byte_array.append('10000000'  )
						else:
								result_byte_array[-1] += "1" + "0" * (
								    byte_length - len(result_byte_array[-1]  ) - 1
								)

						for elem in result_byte_array[:-1]:
								opened_file.write(int(lowerCAmelCase_						,			2  ).to_bytes(1						,			byteorder='big'  )  )
		except OSError:
				print('File not accessible'  )
				sys.exit()



def      __lowerCamelCase     (      lowerCAmelCase_  )			->      str:
		_a     :      List[Any]        =							0
		for letter in data_bits:
				if letter == "1":
						break
				counter += 1

		_a     :      Union[str, Any]        =							data_bits[counter:]
		_a     :      int        =							data_bits[counter + 1 :]
		return data_bits



def      __lowerCamelCase     (      lowerCAmelCase_						,			lowerCAmelCase_  )			->      None:
		_a     :      str        =							read_file_binary(lowerCAmelCase_  )
		_a     :      List[Any]        =							remove_prefix(lowerCAmelCase_  )
		_a     :      str        =							decompress_data(lowerCAmelCase_  )
		write_file_binary(lowerCAmelCase_						,			lowerCAmelCase_  )


if __name__ == "__main__":
							compress(sys.argv[1], sys.argv[2])







from decimal import Decimal, getcontext
from math import ceil, factorial


def   __SCREAMING_SNAKE_CASE					(SCREAMING_SNAKE_CASE__       ):

						if not isinstance(SCREAMING_SNAKE_CASE__  ,		SCREAMING_SNAKE_CASE__       ):
												raise TypeError('''Undefined for non-integers'''       )
						elif precision < 1:
												raise ValueError('''Undefined for non-natural numbers'''       )

						snake_case_   =	precision
						snake_case_   =	ceil(precision / 14       )
						snake_case_   =	426880 * Decimal(10005       ).sqrt()
						snake_case_   =	1
						snake_case_   =	13591409
						snake_case_   =	Decimal(SCREAMING_SNAKE_CASE__       )
						for k in range(1  ,		SCREAMING_SNAKE_CASE__       ):
												snake_case_   =	factorial(6 * k       ) // (factorial(3 * k       ) * factorial(SCREAMING_SNAKE_CASE__       ) ** 3)
												linear_term += 545140134
												exponential_term *= -262537412640768000
												partial_sum += Decimal(multinomial_term * linear_term       ) / exponential_term
						return str(constant_term / partial_sum       )[:-1]


if __name__ == "__main__":
					lowerCAmelCase_       	=	50
					print(f"""The first {n} digits of pi is: {pi(n)}""")