
import sys

sys.set_int_max_str_digits(0)  # type: ignore



def      __UpperCAmelCase    (  snake_case_							:		int				):



	'''simple docstring'''



	UpperCAmelCase:					int 						=     [0] * 1_1
	UpperCAmelCase:					Optional[Any] 						=     [0] * 1_1

	# mark last 9 numbers
	for _ in range(9				):
		UpperCAmelCase:					str 						=     1
		UpperCAmelCase:					List[str] 						=     number // 1_0
	# flag
	UpperCAmelCase:					List[str] 						=     True

	# check last 9 numbers for pandigitality

	for x in range(9				):
		if not check_last[x + 1]:
			UpperCAmelCase:					Optional[Any] 						=     False
	if not f:
		return f

	# mark first 9 numbers
	UpperCAmelCase:					Union[str, Any] 						=     int(str(lowerCAmelCase__				)[:9]				)

	for _ in range(9				):
		UpperCAmelCase:					Dict 						=     1
		UpperCAmelCase:					str 						=     number // 1_0

	# check first 9 numbers for pandigitality

	for x in range(9				):
		if not check_front[x + 1]:
			UpperCAmelCase:					str 						=     False
	return f



def      __UpperCAmelCase    (  snake_case_							:		int				):



	'''simple docstring'''



	UpperCAmelCase:					List[Any] 						=     [0] * 1_1

	# mark last 9 numbers
	for _ in range(9				):
		UpperCAmelCase:					List[Any] 						=     1
		UpperCAmelCase:					Dict 						=     number // 1_0
	# flag
	UpperCAmelCase:					Optional[int] 						=     True

	# check last 9 numbers for pandigitality

	for x in range(9				):
		if not check_last[x + 1]:
			UpperCAmelCase:					Dict 						=     False
	return f



def      __UpperCAmelCase    (  ):



	'''simple docstring'''



	UpperCAmelCase:					str 						=     1
	UpperCAmelCase:					str 						=     1
	UpperCAmelCase:					Dict 						=     2
	# temporary Fibonacci numbers

	UpperCAmelCase:					str 						=     1
	UpperCAmelCase:					Union[str, Any] 						=     1
	UpperCAmelCase:					int 						=     2
	# temporary Fibonacci numbers mod 1e9

	# mod m=1e9, done for fast optimisation
	UpperCAmelCase:					Union[str, Any] 						=     [0] * 1_0_0_0_0_0_0
	UpperCAmelCase:					Optional[int] 						=     1_0_0_0_0_0_0_0_0_0

	for x in range(1_0_0_0_0_0_0				):
		UpperCAmelCase:					int 						=     (aa + ba) % m
		UpperCAmelCase:					Any 						=     ba % m
		UpperCAmelCase:					Tuple 						=     ca % m
		if checka(lowerCAmelCase__				):
			UpperCAmelCase:					List[str] 						=     1

	for x in range(1_0_0_0_0_0_0				):
		UpperCAmelCase:					Union[str, Any] 						=     a + b
		UpperCAmelCase:					Dict 						=     b
		UpperCAmelCase:					str 						=     c
		# perform check only if in tocheck
		if tocheck[x + 3] and check(lowerCAmelCase__				):
			return x + 3  # first 2 already done
	return -1


if __name__ == "__main__":
	print(f"""{solution() = }""")





"""simple docstring"""







import unittest
from timeit import timeit

def 							UpperCamelCase_       (       lowerCAmelCase__ :							int       ,  lowerCAmelCase__ :							int		)		->  int:

  """simple docstring"""




  lowerCAmelCase_  :							Any								=					first_num if first_num >= second_num else second_num
  lowerCAmelCase_  :							Union[str, Any]								=					max_num
  while (common_mult % first_num > 0) or (common_mult % second_num > 0):
    common_mult += max_num
  return common_mult

def 							UpperCamelCase_       (       lowerCAmelCase__ :							int       ,  lowerCAmelCase__ :							int		)		->  int:

  """simple docstring"""




  return b if a == 0 else greatest_common_divisor(b % a       ,  lowerCAmelCase__		)

def 							UpperCamelCase_       (       lowerCAmelCase__ :							int       ,  lowerCAmelCase__ :							int		)		->  int:

  """simple docstring"""




  return first_num // greatest_common_divisor(lowerCAmelCase__       ,  lowerCAmelCase__		) * second_num

def 							UpperCamelCase_       (       )		->  Dict:

  """simple docstring"""




  lowerCAmelCase_  :							str								=					(
      'from __main__ import least_common_multiple_slow, least_common_multiple_fast'
  )
  print(
      'least_common_multiple_slow():'       ,  timeit('least_common_multiple_slow(1000, 999)'       ,  setup=lowerCAmelCase__		)       ,  )
  print(
      'least_common_multiple_fast():'       ,  timeit('least_common_multiple_fast(1000, 999)'       ,  setup=lowerCAmelCase__		)       ,  )







class  UpperCamelCase__  (      unittest.TestCase    ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE    							=	(
          (10, 20),
          (13, 15),
          (4, 31),
          (10, 42),
          (43, 34),
          (5, 12),
          (12, 25),
          (10, 25),
          (6, 9),
      )
      _SCREAMING_SNAKE_CASE    							=	(20, 195, 124, 210, 1462, 60, 300, 50, 18)



      def 	SCREAMING_SNAKE_CASE__					( self							: List[str]			):
        for i, (first_num, second_num) in enumerate(self.test_inputs			):
          lowerCAmelCase_  :							Union[str, Any]								=					least_common_multiple_slow(SCREAMING_SNAKE_CASE_       ,     SCREAMING_SNAKE_CASE_			)
          lowerCAmelCase_  :							Any								=					least_common_multiple_fast(SCREAMING_SNAKE_CASE_       ,     SCREAMING_SNAKE_CASE_			)
          with self.subTest(i=SCREAMING_SNAKE_CASE_			):
            self.assertEqual(SCREAMING_SNAKE_CASE_       ,     self.expected_results[i]			)
            self.assertEqual(SCREAMING_SNAKE_CASE_       ,     self.expected_results[i]			)


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





