
"""simple docstring"""
from typing import TYPE_CHECKING

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


lowercase		:						Dict =					{
    'configuration_esm': ['ESM_PRETRAINED_CONFIG_ARCHIVE_MAP', 'EsmConfig'],
    'tokenization_esm': ['EsmTokenizer'],
}

try:
			if not is_torch_available():
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			pass
else:
			lowercase		:						List[str] =					[
			    'ESM_PRETRAINED_MODEL_ARCHIVE_LIST',
			    'EsmForMaskedLM',
			    'EsmForSequenceClassification',
			    'EsmForTokenClassification',
			    'EsmModel',
			    'EsmPreTrainedModel',
			]
			lowercase		:						Dict =					['EsmForProteinFolding', 'EsmFoldPreTrainedModel']

try:
			if not is_tf_available():
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			pass
else:
			lowercase		:						Optional[Any] =					[
			    'TF_ESM_PRETRAINED_MODEL_ARCHIVE_LIST',
			    'TFEsmForMaskedLM',
			    'TFEsmForSequenceClassification',
			    'TFEsmForTokenClassification',
			    'TFEsmModel',
			    'TFEsmPreTrainedModel',
			]

if TYPE_CHECKING:
			from .configuration_esm import ESM_PRETRAINED_CONFIG_ARCHIVE_MAP, EsmConfig
			from .tokenization_esm import EsmTokenizer

			try:
						if not is_torch_available():
									raise OptionalDependencyNotAvailable()
			except OptionalDependencyNotAvailable:
						pass
			else:
						from .modeling_esm import (
						    ESM_PRETRAINED_MODEL_ARCHIVE_LIST,
						    EsmForMaskedLM,
						    EsmForSequenceClassification,
						    EsmForTokenClassification,
						    EsmModel,
						    EsmPreTrainedModel,
						)
						from .modeling_esmfold import EsmFoldPreTrainedModel, EsmForProteinFolding

			try:
						if not is_tf_available():
									raise OptionalDependencyNotAvailable()
			except OptionalDependencyNotAvailable:
						pass
			else:
						from .modeling_tf_esm import (
						    TF_ESM_PRETRAINED_MODEL_ARCHIVE_LIST,
						    TFEsmForMaskedLM,
						    TFEsmForSequenceClassification,
						    TFEsmForTokenClassification,
						    TFEsmModel,
						    TFEsmPreTrainedModel,
						)


else:
			import sys

			lowercase		:						Union[str, Any] =					_LazyModule(__name__, globals()['__file__'], _import_structure)


"""simple docstring"""
def     lowerCamelCase_    (	lowerCamelCase_	,				lowerCamelCase_ )     ->			int:


					'''simple docstring'''
					for index, item in enumerate(lowerCamelCase_ ):
										if item == target:
															return index
					return -1


def     lowerCamelCase_    (	lowerCamelCase_	,				lowerCamelCase_	,				lowerCamelCase_	,				lowerCamelCase_ )     ->			int:


					'''simple docstring'''
					if not (0 <= high < len(lowerCamelCase_ ) and 0 <= low < len(lowerCamelCase_ )):
										raise Exception("""Invalid upper or lower bound!""" )
					if high < low:
										return -1
					if sequence[low] == target:
										return low
					if sequence[high] == target:
										return high
					return rec_linear_search(lowerCamelCase_	,				low + 1	,				high - 1	,				lowerCamelCase_ )


if __name__ == "__main__":
			lowercase		:						str =					input('Enter numbers separated by comma:\n').strip()
			lowercase		:						int =					[int(item.strip()) for item in user_input.split(',')]

			lowercase		:						Optional[Any] =					int(input('Enter a single number to be found in the list:\n').strip())
			lowercase		:						str =					linear_search(sequence, target)
			if result != -1:
						print(F"linear_search({sequence}, {target}) = {result}")
			else:
						print(F"{target} was not found in {sequence}")
