






from __future__ import annotations

from collections import deque
from enum import Enum
from math import atana, degrees
from sys import maxsize
class 							A_			(  UpperCAmelCase_	):






 '''simple docstring'''




 _SCREAMING_SNAKE_CASE							:	str       =    1
 _SCREAMING_SNAKE_CASE							:	List[Any]       =    2
 _SCREAMING_SNAKE_CASE							:	Optional[int]       =    3


 def __repr__(		self)       ->						List[Any]:

     """simple docstring"""



     return f'''{self.__class__.__name__}.{self.name}'''



def    _lowerCamelCase		(  __A			:							tuple[int, int]						,						__A			:							int						,						__A			:							int       )					->    float:
    _UpperCAmelCase :					Optional[Any]	     = point
    return degrees(atana(y - miny						,						x - minx       )       )

def    _lowerCamelCase		(  __A			:							tuple[int, int]						,						__A			:							tuple[int, int]						,						__A			:							tuple[int, int]       )					->    Direction:
    _UpperCAmelCase :					Any	     = starting
    _UpperCAmelCase :					Tuple	     = via
    _UpperCAmelCase :					Any	     = target
    _UpperCAmelCase :					int	     = degrees(atana(ya - ya						,						xa - xa       )       )
    via_angle %= 360
    _UpperCAmelCase :					str	     = degrees(atana(ya - ya						,						xa - xa       )       )
    target_angle %= 360
    # t-
    #  \ \
    #   \ v
    #    \|
    #     s
    # via_angle is always lower than target_angle, if direction is left.
    # If they are same, it means they are on a same line of convex hull.
    if target_angle > via_angle:
        return Direction.left
    elif target_angle == via_angle:
        return Direction.straight
    else:
        return Direction.right


def    _lowerCamelCase		(  __A			:							list[tuple[int, int]]       )					->    list[tuple[int, int]]:

    if len(__A       ) <= 2:
        # There is no convex hull
        raise ValueError('''graham_scan: argument must contain more than 3 points.'''       )
    if len(__A       ) == 3:
        return points
    # find the lowest and the most left point
    _UpperCAmelCase :					Any	     = 0
    _UpperCAmelCase :					Tuple	     = maxsize, maxsize
    for i, point in enumerate(__A       ):
        _UpperCAmelCase :					Any	     = point[0]
        _UpperCAmelCase :					List[Any]	     = point[1]
        if y < miny:
            _UpperCAmelCase :					str	     = y
            _UpperCAmelCase :					int	     = x
            _UpperCAmelCase :					Tuple	     = i
        if y == miny and x < minx:
            _UpperCAmelCase :					Any	     = x
            _UpperCAmelCase :					List[Any]	     = i

        # remove the lowest and the most left point from points for preparing for sort
    points.pop(__A       )

    _UpperCAmelCase :					int	     = sorted(__A						,						key=lambda __A       : angle_comparer(__A						,						__A						,						__A       )       )
    # This insert actually costs complexity,
    # and you should instead add (minx, miny) into stack later.
    # I'm using insert just for easy understanding.
    sorted_points.insert(0						,						(minx, miny)       )

    _UpperCAmelCase :					deque[tuple[int, int]]	     = deque()
    stack.append(sorted_points[0]       )
    stack.append(sorted_points[1]       )
    stack.append(sorted_points[2]       )
    # In any ways, the first 3 points line are towards left.
    # Because we sort them the angle from minx, miny.
    _UpperCAmelCase :					Optional[int]	     = Direction.left

    for i in range(3						,						len(__A       )       ):
        while True:
            _UpperCAmelCase :					Tuple	     = stack[-2]
            _UpperCAmelCase :					Tuple	     = stack[-1]
            _UpperCAmelCase :					str	     = sorted_points[i]
            _UpperCAmelCase :					Optional[Any]	     = check_direction(__A						,						__A						,						__A       )

            if next_direction == Direction.left:
                _UpperCAmelCase :					int	     = Direction.left
                break
            if next_direction == Direction.straight:
                if current_direction == Direction.left:
                    # We keep current_direction as left.
                    # Because if the straight line keeps as straight,
                    # we want to know if this straight line is towards left.
                    break
                elif current_direction == Direction.right:
                    # If the straight line is towards right,
                    # every previous points on those straigh line is not convex hull.
                    stack.pop()
            if next_direction == Direction.right:
                stack.pop()
        stack.append(sorted_points[i]       )
    return list(__A       )











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}""")




