

"""simple docstring"""

from __future__ import annotations

from enum import Enum, unique
from typing import TypeVar

# Create a generic variable that can be 'Enum', or any subclass.
a__			:						Any							=			TypeVar("""T""", bound="""Enum""")


@unique
class       _snake_case  (    lowerCamelCase_							):
						__snake_case			      =  80
						__snake_case			      =  70
						__snake_case			      =  60
						__snake_case			      =  50
						__snake_case			      =  40
						__snake_case			      =  30
						__snake_case			      =  20
						__snake_case			      =  10



@unique
class       _snake_case  (    lowerCamelCase_							):
						__snake_case			      =  24
						__snake_case			      =  21
						__snake_case			      =  18
						__snake_case			      =  15
						__snake_case			      =  12
						__snake_case			      =  9
						__snake_case			      =  6
						__snake_case			      =  3
						__snake_case			      =  2
						__snake_case			      =  1
						__snake_case			      =  -1
						__snake_case			      =  -2
						__snake_case			      =  -3
						__snake_case			      =  -6
						__snake_case			      =  -9
						__snake_case			      =  -12
						__snake_case			      =  -15
						__snake_case			      =  -18
						__snake_case			      =  -21
						__snake_case			      =  -24







						@classmethod
						def 							_UpperCamelCase     (cls				)      ->    str:
											return {unit.name: unit.value for unit in cls if unit.value > 0}







						@classmethod
						def 							_UpperCamelCase     (cls				)      ->    Dict:
											return {unit.name: unit.value for unit in cls if unit.value < 0}





def 					__UpperCamelCase (     a__:			str      )					->      str:




					"""simple docstring"""



					__lowercase        =      SIUnit.get_positive() if value > 0 else SIUnit.get_negative()
					for name_prefix, value_prefix in prefixes.items():
										__lowercase        =      value / (10**value_prefix)
										if numerical_part > 1:
															return f'''{numerical_part!s} {name_prefix}'''
					return str(a__      )





def 					__UpperCamelCase (     a__:			Dict      )					->      str:




					"""simple docstring"""



					for prefix in BinaryUnit:
										__lowercase        =      value / (2**prefix.value)
										if numerical_part > 1:
															return f'''{numerical_part!s} {prefix.name}'''
					return str(a__      )


if __name__ == "__main__":
							import doctest

							doctest.testmod()








'''simple docstring'''






def 		a_(			lowerCamelCase ,					lowerCamelCase   )					->int:






       '''simple docstring'''




       if len(lowerCamelCase   ) < len(lowerCamelCase   ):
              return levenshtein_distance(lowerCamelCase ,					lowerCamelCase   )

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

       lowercase	:		List[Any]    =   list(range(len(lowerCamelCase   ) + 1   )   )

       for i, ca in enumerate(lowerCamelCase   ):
              lowercase	:		Any    =   [i + 1]

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

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


if __name__ == "__main__":
      lowercase						:   Dict      						=							input('''Enter the first word:\n''').strip()
      lowercase						:   Tuple      						=							input('''Enter the second word:\n''').strip()

      lowercase						:   Tuple      						=							levenshtein_distance(first_word, second_word)
      print(f'Levenshtein distance between {first_word} and {second_word} is {result}')




