






def        lowerCamelCase__   (					__lowerCamelCase    :  str						,	__lowerCamelCase    :  str	):
  # The longer word should come first
  if len(__lowerCamelCase	) < len(__lowerCamelCase	):
    return levenshtein_distance(__lowerCamelCase						,	__lowerCamelCase	)

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

  __UpperCAmelCase     =						list(range(len(__lowerCamelCase	) + 1	)	)

  for i, ca in enumerate(__lowerCamelCase	):
    __UpperCAmelCase     =						[i + 1]

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

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


if __name__ == "__main__":
       a	: List[Any]      =				input("Enter the first word:\n").strip()
       a	: List[Any]      =				input("Enter the second word:\n").strip()

       a	: Union[str, Any]      =				levenshtein_distance(first_word, second_word)
       print(f"""Levenshtein distance between {first_word} and {second_word} is {result}""")










from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tf_available, is_torch_available


a	: str      =				{"configuration_hubert": ["HUBERT_PRETRAINED_CONFIG_ARCHIVE_MAP", "HubertConfig"]}

try:
       if not is_torch_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       a	: str      =				[
           "HUBERT_PRETRAINED_MODEL_ARCHIVE_LIST",
           "HubertForCTC",
           "HubertForSequenceClassification",
           "HubertModel",
           "HubertPreTrainedModel",
       ]


try:
       if not is_tf_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       a	: List[str]      =				[
           "TF_HUBERT_PRETRAINED_MODEL_ARCHIVE_LIST",
           "TFHubertForCTC",
           "TFHubertModel",
           "TFHubertPreTrainedModel",
       ]

if TYPE_CHECKING:
       from .configuration_hubert import HUBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, HubertConfig

       try:
              if not is_torch_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .modeling_hubert import (
                  HUBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
                  HubertForCTC,
                  HubertForSequenceClassification,
                  HubertModel,
                  HubertPreTrainedModel,
              )

       try:
              if not is_tf_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .modeling_tf_hubert import (
                  TF_HUBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
                  TFHubertForCTC,
                  TFHubertModel,
                  TFHubertPreTrainedModel,
              )


else:
       import sys

       a	: List[Any]      =				_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)


