


"""simple docstring"""






from collections import namedtuple

_lowerCamelCase  =	namedtuple('from_to', 'from_ to')

_lowerCamelCase  =	{
    'atm': from_to(1, 1),
    'pascal': from_to(0.0_000_098, 101325),
    'bar': from_to(0.986_923, 1.01_325),
    'kilopascal': from_to(0.00_986_923, 101.325),
    'megapascal': from_to(9.86_923, 0.101_325),
    'psi': from_to(0.068_046, 14.6_959),
    'inHg': from_to(0.0_334_211, 29.9_213),
    'torr': from_to(0.00_131_579, 760),
}


def __lowercase  (   lowerCamelCase_	:   Tuple    ,       lowerCamelCase_	:   int    ,       lowerCamelCase_	:   Any	):
				if from_type not in PRESSURE_CONVERSION:
								raise ValueError(
								    F'''Invalid \'from_type\' value: {from_type!r}  Supported values are:\n'''
								    + ", ".join(_SCREAMING_SNAKE_CASE	)	)
				if to_type not in PRESSURE_CONVERSION:
								raise ValueError(
								    F'''Invalid \'to_type\' value: {to_type!r}.  Supported values are:\n'''
								    + ", ".join(_SCREAMING_SNAKE_CASE	)	)
				return (
				    value * PRESSURE_CONVERSION[from_type].from_ * PRESSURE_CONVERSION[to_type].to
				)


if __name__ == "__main__":
	import doctest

	doctest.testmod()




"""simple docstring"""
from typing import Any





class   __A  :





							'''simple docstring'''

							def __init__(					self				:   List[Any]							)       ->int:



														"""simple docstring"""



														snake_case_     							=		[]
														snake_case_     							=		0



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



														"""simple docstring"""



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



							def 		lowerCAmelCase							(					self				:   List[Any]		,							UpperCAmelCase_				:   Any							)       ->None:



														"""simple docstring"""



														self.stack.append(UpperCAmelCase_							)
														snake_case_     							=		self.length + 1



							def 		lowerCAmelCase							(					self				:   List[str]							)       ->Any:



														"""simple docstring"""



														self.rotate(1							)
														snake_case_     							=		self.stack[self.length - 1]
														snake_case_     							=		self.stack[:-1]
														self.rotate(self.length - 1							)
														snake_case_     							=		self.length - 1
														return dequeued



							def 		lowerCAmelCase							(					self				:   List[str]		,							UpperCAmelCase_				:   int							)       ->None:



														"""simple docstring"""



														for _ in range(UpperCAmelCase_							):
																					snake_case_     							=		self.stack[0]
																					snake_case_     							=		self.stack[1:]
																					self.put(UpperCAmelCase_							)
																					snake_case_     							=		self.length - 1



							def 		lowerCAmelCase							(					self				:   Dict							)       ->Any:



														"""simple docstring"""



														snake_case_     							=		self.get()
														self.put(UpperCAmelCase_							)
														self.rotate(self.length - 1							)
														return front



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



														"""simple docstring"""



														return self.length



