
import unittest
from timeit import timeit



def        lowerCamelCase_  (   __UpperCamelCase ,						__UpperCamelCase     ):
				A_       	=  first_num if first_num >= second_num else second_num
				A_       	=  max_num
				while (common_mult % first_num > 0) or (common_mult % second_num > 0):
								common_mult += max_num
				return common_mult



def        lowerCamelCase_  (   __UpperCamelCase ,						__UpperCamelCase     ):
				return b if a == 0 else greatest_common_divisor(b % a ,						_UpperCamelCase     )



def        lowerCamelCase_  (   __UpperCamelCase ,						__UpperCamelCase     ):
				return first_num // greatest_common_divisor(_UpperCamelCase ,						_UpperCamelCase     ) * second_num



def        lowerCamelCase_  (   ):
				A_       	=  (
				    '''from __main__ import least_common_multiple_slow, least_common_multiple_fast'''
				)
				print(
				    '''least_common_multiple_slow():''' ,						timeit('''least_common_multiple_slow(1000, 999)''' ,						setup=_UpperCamelCase     ) ,						)
				print(
				    '''least_common_multiple_fast():''' ,						timeit('''least_common_multiple_fast(1000, 999)''' ,						setup=_UpperCamelCase     ) ,						)






class 					__lowercase		(					unittest.TestCase       ):
					__magic_name__						:							str     	=	(
					    (10, 20),
					    (13, 15),
					    (4, 31),
					    (10, 42),
					    (43, 34),
					    (5, 12),
					    (12, 25),
					    (10, 25),
					    (6, 9),
					)
					__magic_name__						:							int     	=	(20, 1_95, 1_24, 2_10, 14_62, 60, 3_00, 50, 18)


					def        lowerCAmelCase_    (	self						)		->							int:





									'''simple docstring'''



									for i, (first_num, second_num) in enumerate(self.test_inputs						):
													A_       	=  least_common_multiple_slow(a_       ,       a_						)
													A_       	=  least_common_multiple_fast(a_       ,       a_						)
													with self.subTest(i=a_						):
																	self.assertEqual(a_       ,       self.expected_results[i]						)
																	self.assertEqual(a_       ,       self.expected_results[i]						)


if __name__ == "__main__":
				benchmark()
				unittest.main()

from collections import namedtuple

SCREAMING_SNAKE_CASE   :		Any					 =       namedtuple("from_to", "from_ to")

SCREAMING_SNAKE_CASE   :		str					 =       {
    "atm": from_to(1, 1),
    "pascal": from_to(0.0000098, 10_1325),
    "bar": from_to(0.986923, 1.01325),
    "kilopascal": from_to(0.00986923, 101.325),
    "megapascal": from_to(9.86923, 0.101325),
    "psi": from_to(0.068046, 14.6959),
    "inHg": from_to(0.0334211, 29.9213),
    "torr": from_to(0.00131579, 760),
}



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


if __name__ == "__main__":
						import doctest

						doctest.testmod()