





def 			lowerCamelCase_		(					lowerCAmelCase:		int )->						str:
  if not isinstance(lowerCAmelCase			,							lowerCAmelCase ):
    _snake_case      : Dict														=		(
        'operation can not be conducted on a object of type '
        F"""{type(lowerCAmelCase ).__name__}"""
    )
    raise TypeError(lowerCAmelCase )
  _snake_case      : Union[str, Any]														=		''
  for _ in range(0			,							32 ):
    bit_string += str(number % 2 )
    _snake_case      : Optional[int]														=		number >> 1
  return bit_string


def 			lowerCamelCase_		(					lowerCAmelCase:		int )->						str:
  if number < 0:
    raise ValueError('the value of input must be positive' )
  elif isinstance(lowerCAmelCase			,							lowerCAmelCase ):
    raise TypeError('Input value must be a \'int\' type' )
  elif isinstance(lowerCAmelCase			,							lowerCAmelCase ):
    raise TypeError('\'<\' not supported between instances of \'str\' and \'int\'' )
  _snake_case      : Tuple														=		0
  # iterator over [1 to 32],since we are dealing with 32 bit integer
  for _ in range(1			,							33 ):
    # left shift the bits by unity
    _snake_case      : Tuple														=		result << 1
    # get the end bit
    _snake_case      : Optional[int]														=		number % 2
    # right shift the bits by unity
    _snake_case      : Tuple														=		number >> 1
    # add that bit to our ans
    _snake_case      : Dict														=		result | end_bit
  return get_reverse_bit_string(lowerCAmelCase )


if __name__ == "__main__":
      import doctest

      doctest.testmod()











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




