

'''simple docstring'''







class 					__a   :

						def __init__(		self	:						Optional[int])						->str:

							"""simple docstring"""



							_lowercase							=     []
							_lowercase							=     0
							_lowercase							=     0

						def __str__(		self	:						List[str])						->Tuple:

							"""simple docstring"""



							_lowercase							=     """<""" + str(self.entries)[1:-1] + """>"""
							return printed

						def 	_UpperCAmelCase							(		self	:						Any    ,			lowercase__	:						List[Any])						->List[Any]:

							"""simple docstring"""



							self.entries.append(__UpperCAmelCase)
							_lowercase							=     self.length + 1

						def 	_UpperCAmelCase							(		self	:						List[Any])						->Union[str, Any]:

							"""simple docstring"""



							_lowercase							=     self.length - 1
							_lowercase							=     self.entries[self.front]
							# self.front-=1
							# self.entries = self.entries[self.front:]
							_lowercase							=     self.entries[1:]
							return dequeued

						def 	_UpperCAmelCase							(		self	:						Any    ,			lowercase__	:						Dict)						->List[Any]:

							"""simple docstring"""



							for _ in range(__UpperCAmelCase):
								self.put(self.get())

						def 	_UpperCAmelCase							(		self	:						Any)						->Optional[int]:

							"""simple docstring"""



							return self.entries[0]


						def 	_UpperCAmelCase							(		self	:						Optional[int])						->Any:

							"""simple docstring"""



							return self.length






"""simple docstring"""






def    UpperCamelCase						(					UpperCAmelCase ,   UpperCAmelCase = 1_000     )						->str:

   """simple docstring"""



   if (not isinstance(UpperCAmelCase ,   UpperCAmelCase     )) or (digit_position <= 0):
      raise ValueError("Digit position must be a positive integer"     )
   elif (not isinstance(UpperCAmelCase ,   UpperCAmelCase     )) 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(UpperCAmelCase ,   1 ,   UpperCAmelCase     )
       - 2 * _subsum(UpperCAmelCase ,   4 ,   UpperCAmelCase     )
       - _subsum(UpperCAmelCase ,   5 ,   UpperCAmelCase     )
       - _subsum(UpperCAmelCase ,   6 ,   UpperCAmelCase     )
   )

   # return the first hex digit of the fractional part of the result
   return hex(int((sum_result % 1) * 16     )     )[2:]
def    UpperCamelCase						(					UpperCAmelCase ,   UpperCAmelCase ,   UpperCAmelCase     )						->float:

   """simple docstring"""



   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 ,   UpperCAmelCase     )
      else:
         a_						   =     pow(16 ,   digit_pos_to_extract - 1 - sum_index     )
      total += exponential_term / denominator
   return total


if __name__ == "__main__":
      import doctest

      doctest.testmod()