
'''simple docstring'''
import math
from itertools import permutations




def 					_UpperCamelCase		(    SCREAMING_SNAKE_CASE__       )   ->				bool:


		'''simple docstring'''


		if 1 < number < 4:
				# 2 and 3 are primes
				return True
		elif number < 2 or number % 2 == 0 or number % 3 == 0:
				# Negatives, 0, 1, all even numbers, all multiples of 3 are not primes
				return False

		# All primes number are in format of 6k +/- 1
		for i in range(5      ,    int(math.sqrt(SCREAMING_SNAKE_CASE__       ) + 1       )      ,    6       ):
				if number % i == 0 or number % (i + 2) == 0:
						return False
		return True




def 					_UpperCamelCase		(    SCREAMING_SNAKE_CASE__      ,    SCREAMING_SNAKE_CASE__       )   ->				bool:


		'''simple docstring'''


		snake_case       ,snake_case   :    Any			       =		0, len(SCREAMING_SNAKE_CASE__       ) - 1
		while left <= right:
				snake_case   :    Dict			       =		(left + right) // 2
				if prime_list[middle] == target:
						return True
				elif prime_list[middle] < target:
						snake_case   :    Dict			       =		middle + 1
				else:
						snake_case   :    Optional[int]			       =		middle - 1

		return False




def 					_UpperCamelCase		(    )   ->				str:


		'''simple docstring'''


		snake_case   :    Dict			       =		[n for n in range(1001      ,    1_0000      ,    2       ) if is_prime(SCREAMING_SNAKE_CASE__       )]
		snake_case   :    List[Any]			       =		[]

		for number in prime_list:
				snake_case   :    Tuple			       =		[]

				for prime_member in permutations(list(str(SCREAMING_SNAKE_CASE__       )       )       ):
						snake_case   :    List[str]			       =		int(''''''.join(SCREAMING_SNAKE_CASE__       )       )

						if prime % 2 == 0:
								continue

						if search(SCREAMING_SNAKE_CASE__      ,    SCREAMING_SNAKE_CASE__       ):
								tmp_numbers.append(SCREAMING_SNAKE_CASE__       )

				tmp_numbers.sort()
				if len(SCREAMING_SNAKE_CASE__       ) >= 3:
						candidates.append(SCREAMING_SNAKE_CASE__       )

		snake_case   :    List[str]			       =		[]
		for candidate in candidates:
				snake_case   :    Union[str, Any]			       =		len(SCREAMING_SNAKE_CASE__       )
				snake_case   :    Any			       =		False

				for i in range(SCREAMING_SNAKE_CASE__       ):
						for j in range(i + 1      ,    SCREAMING_SNAKE_CASE__       ):
								for k in range(j + 1      ,    SCREAMING_SNAKE_CASE__       ):
										if (
										    abs(candidate[i] - candidate[j]       )
										    == abs(candidate[j] - candidate[k]       )
										    and len({candidate[i], candidate[j], candidate[k]}       ) == 3
										):
												passed.append(
												    sorted([candidate[i], candidate[j], candidate[k]]       )       )
												snake_case   :    Dict			       =		True

										if found:
												break
								if found:
										break
						if found:
								break

		snake_case   :    int			       =		set()
		for seq in passed:
				answer.add(''''''.join([str(SCREAMING_SNAKE_CASE__       ) for i in seq]       )       )

		return max(int(SCREAMING_SNAKE_CASE__       ) for x in answer       )


if __name__ == "__main__":
						print(solution())









def 			lowerCamelCase_		(					lowerCAmelCase:		str			,							lowerCAmelCase:		str )->						int:
  # The longer word should come first
  if len(lowerCAmelCase ) < len(lowerCAmelCase ):
    return levenshtein_distance(lowerCAmelCase			,							lowerCAmelCase )

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

  _snake_case      : Dict														=		list(range(len(lowerCAmelCase ) + 1 ) )

  for i, ca in enumerate(lowerCAmelCase ):
    _snake_case      : Optional[int]														=		[i + 1]

    for j, ca in enumerate(lowerCAmelCase ):
      # Calculate insertions, deletions and substitutions
      _snake_case      : Optional[Any]														=		previous_row[j + 1] + 1
      _snake_case      : Optional[int]														=		current_row[j] + 1
      _snake_case      : Union[str, 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
    _snake_case      : str														=		current_row

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


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

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




