

def 		SCREAMING_SNAKE_CASE__				(							_UpperCAmelCase,      _UpperCAmelCase				)					-> str:



    '''simple docstring'''






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

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

    lowerCAmelCase				:			Optional[int]    			=      list(range(len(lowerCAmelCase__				) + 1				)				)

    for i, ca in enumerate(lowerCAmelCase__				):
        lowerCAmelCase				:			Union[str, Any]    			=      [i + 1]

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

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


if __name__ == "__main__":
 __A   :     Optional[int]      =			input('''Enter the first word:\n''').strip()
 __A   :     List[str]      =			input('''Enter the second word:\n''').strip()

 __A   :     Optional[int]      =			levenshtein_distance(first_word, second_word)
 print(F'Levenshtein distance between {first_word} and {second_word} is {result}')








from __future__ import annotations
def 		SCREAMING_SNAKE_CASE__				(							_UpperCAmelCase				)					-> set[int]:



    '''simple docstring'''






    lowerCAmelCase				:			List[str]    			=      {1}
    lowerCAmelCase				:			int    			=      [1]
    for _ in range(2,      depth + 1				):
        lowerCAmelCase				:			str    			=      [*previous_coefficients, 0]
        lowerCAmelCase				:			Optional[int]    			=      [0, *previous_coefficients]
        lowerCAmelCase				:			Tuple    			=      []
        for x, y in zip(_UpperCAmelCase,      _UpperCAmelCase				):
            coefficients.add(x + y				)
            previous_coefficients.append(x + y				)
    return coefficients
def 		SCREAMING_SNAKE_CASE__				(							_UpperCAmelCase				)					-> set[int]:



    '''simple docstring'''






    lowerCAmelCase				:			str    			=      set()
    for number in unique_coefficients:
        lowerCAmelCase				:			Dict    			=      2
        lowerCAmelCase				:			Tuple    			=      number
        while divisor**2 <= copy_number:
            lowerCAmelCase				:			List[str]    			=      0
            while copy_number % divisor == 0:
                copy_number //= divisor
                multiplicity += 1
            if multiplicity >= 2:
                non_squarefrees.add(_UpperCAmelCase				)
                break
            divisor += 1

    return unique_coefficients.difference(_UpperCAmelCase				)
def 		SCREAMING_SNAKE_CASE__				(							_UpperCAmelCase = 51				)					-> int:



    '''simple docstring'''






    lowerCAmelCase				:			int    			=      get_pascal_triangle_unique_coefficients(_UpperCAmelCase				)
    lowerCAmelCase				:			Optional[int]    			=      get_squarefrees(_UpperCAmelCase				)
    return sum(_UpperCAmelCase				)


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





