



def 						UpperCAmelCase (    _lowerCamelCase			,     _lowerCamelCase     ):
			# The longer word should come first
			if len(_lowerCamelCase     ) < len(_lowerCamelCase     ):
						return levenshtein_distance(_lowerCamelCase			,     _lowerCamelCase     )

			if len(_lowerCamelCase     ) == 0:
						return len(_lowerCamelCase     )

			A				:       int														=    list(range(len(_lowerCamelCase     ) + 1     )     )

			for i, ca in enumerate(_lowerCamelCase     ):
						A				:       Tuple														=    [i + 1]

						for j, ca in enumerate(_lowerCamelCase     ):
									# Calculate insertions, deletions and substitutions
									A				:       Any														=    previous_row[j + 1] + 1
									A				:       List[Any]														=    current_row[j] + 1
									A				:       Any														=    previous_row[j] + (ca != ca)

									# Get the minimum to append to the current row
									current_row.append(min(_lowerCamelCase			,     _lowerCamelCase			,     _lowerCamelCase     )     )

						# Store the previous row
						A				:       List[str]														=    current_row

			# Returns the last element (distance)
			return previous_row[-1]


if __name__ == "__main__":
							__SCREAMING_SNAKE_CASE     =	input("""Enter the first word:\n""").strip()
							__SCREAMING_SNAKE_CASE     =	input("""Enter the second word:\n""").strip()

							__SCREAMING_SNAKE_CASE     =	levenshtein_distance(first_word, second_word)
							print(F"""Levenshtein distance between {first_word} and {second_word} is {result}""")




import math
from decimal import Decimal, getcontext




def 						UpperCAmelCase (    _lowerCamelCase = 400_0000     ):

			try:
						A				:       Any														=    int(_lowerCamelCase     )
			except (TypeError, ValueError):
						raise TypeError("Parameter n must be int or castable to int."     )
			if n <= 0:
						raise ValueError("Parameter n must be greater than or equal to one."     )
			A				:       int														=    100
			A				:       Tuple														=    (Decimal(5     ) ** Decimal(0.5     ) + 1) / Decimal(2     )

			A				:       str														=    (math.floor(math.log(n * (phi + 2)			,     _lowerCamelCase     ) - 1     ) // 3) * 3 + 2
			A				:       Optional[int]														=    Decimal(round(phi ** Decimal(index + 1     )     )     ) / (phi + 2)
			A				:       str														=    num // 2
			return int(_lowerCamelCase     )


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