



import dataclasses
import enum
import functools
import math
import re

# The following script is adapted from the script of TaPas.
# Original: https://github.com/google-research/tapas/master/wikisql_utils.py
from typing import Any, List, Text


__magic_name__       =     '''none'''
__magic_name__       =     '''none'''





def 		__snake_case						(    _UpperCAmelCase       ,			_UpperCAmelCase				):
					"""simple docstring"""






					lowercase						   =       value.split(_UpperCAmelCase				)
					return len(_UpperCAmelCase				) > 1 and any((len(_UpperCAmelCase				) == 3 for x in split)				)





def 		__snake_case						(    _UpperCAmelCase				):
					"""simple docstring"""






					if isinstance(_UpperCAmelCase       ,			_UpperCAmelCase				):
										return value
					if isinstance(_UpperCAmelCase       ,			_UpperCAmelCase				):
										return float(_UpperCAmelCase				)
					if not isinstance(_UpperCAmelCase       ,			_UpperCAmelCase				):
										raise ValueError('Argument value is not a string. Can\'t parse it as float'				)
					lowercase						   =       value

					try:
										# Example: 1,000.7
										if "." in sanitized and "," in sanitized:
															return float(sanitized.replace(','       ,			''				)				)
										# 1,000
										if "," in sanitized and _split_thousands(','       ,			_UpperCAmelCase				):
															return float(sanitized.replace(','       ,			''				)				)
										# 5,5556
										if "," in sanitized and sanitized.count(','				) == 1 and not _split_thousands(','       ,			_UpperCAmelCase				):
															return float(sanitized.replace(','       ,			'.'				)				)
										# 0.0.0.1
										if sanitized.count('.'				) > 1:
															return float(sanitized.replace('.'       ,			''				)				)
										# 0,0,0,1
										if sanitized.count(','				) > 1:
															return float(sanitized.replace(','       ,			''				)				)
										return float(_UpperCAmelCase				)
					except ValueError:
										# Avoid adding the sanitized value in the error message.
										raise ValueError('Unable to convert value to float'				)





def 		__snake_case						(    _UpperCAmelCase				):
					"""simple docstring"""






					if answer is None:
										return None
					try:
										lowercase						   =       convert_to_float(_UpperCAmelCase				)
										if isinstance(_UpperCAmelCase       ,			_UpperCAmelCase				) and math.isnan(_UpperCAmelCase				):
															return None
										return value
					except ValueError:
										return answer.lower()


__magic_name__       =     {
    '''text''': lambda x: x,
    '''real''': convert_to_float,
}


class 	a__       (       enum.Enum       ):


					"""simple docstring"""



					A__  :				Union[str, Any]					 =				0
					A__  :				Dict					 =				1
					A__  :				Optional[Any]					 =				2
					A__  :				int					 =				3
					A__  :				List[Any]					 =				4
					A__  :				Optional[int]					 =				5




class 	a__       (       enum.Enum       ):


					"""simple docstring"""



					A__  :				Dict					 =				0
					A__  :				Union[str, Any]					 =				1
					A__  :				int					 =				2




@dataclasses.dataclass
class 	a__       :


					"""simple docstring"""



					A__  :				Text
					A__  :				_Operator
					A__  :				Any




__magic_name__       =     re.compile(r'''\w+|[^\w\s]+''', re.UNICODE | re.MULTILINE | re.DOTALL)





def 		__snake_case						(    _UpperCAmelCase				):
					"""simple docstring"""






					return list(_TOKENIZER.findall(x.lower()				)				)





def 		__snake_case						(    _UpperCAmelCase       ,			_UpperCAmelCase       ,			_UpperCAmelCase				):
					"""simple docstring"""






					if operator == _Operator.EQUALS:
										return src == tgt
					elif operator == _Operator.GREATER:
										return src > tgt
					elif operator == _Operator.LESSER:
										return src < tgt
					raise ValueError(f"""Unknown operator: {operator}"""				)





def 		__snake_case						(    _UpperCAmelCase       ,			_UpperCAmelCase       ,			_UpperCAmelCase				):
					"""simple docstring"""






					lowercase						   =       table['types']
					return _TYPE_CONVERTER[types[column]](_UpperCAmelCase				)





def 		__snake_case						(    _UpperCAmelCase				):
					"""simple docstring"""






					return isinstance(_UpperCAmelCase       ,			_UpperCAmelCase				)





def 		__snake_case						(    _UpperCAmelCase       ,			_UpperCAmelCase       ,			_UpperCAmelCase				):
					"""simple docstring"""






					for cond in conditions:
										lowercase						   =       row[cond.column]

										lowercase						   =       _parse_value(_UpperCAmelCase       ,			cond.column       ,			cond.cmp_value				)

										if _is_string(_UpperCAmelCase				) and _is_string(_UpperCAmelCase				):
															lowercase						   =       _normalize_for_match(_UpperCAmelCase				)
															lowercase						   =       _normalize_for_match(_UpperCAmelCase				)

										if not isinstance(_UpperCAmelCase       ,			type(_UpperCAmelCase				)				):
															raise ValueError('Type difference {} != {}'.format(type(_UpperCAmelCase				)       ,			type(_UpperCAmelCase				)				)				)

										if not _compare(cond.operator       ,			_UpperCAmelCase       ,			_UpperCAmelCase				):
															return False
					return True





def 		__snake_case						(    _UpperCAmelCase       ,			_UpperCAmelCase       ,			_UpperCAmelCase				):
					"""simple docstring"""






					if not answer_coordinates:
										if aggregation_op == _Aggregation.COUNT:
															return 0.0
										else:
															return EMPTY_ANSWER_AGG

    # Count can support non numeric answers.
					if aggregation_op == _Aggregation.COUNT:
										return float(len(_UpperCAmelCase				)				)

					# If we have just one answer, if float returns it or try a conversion.
					lowercase						   =       [table['rows'][i][j] for (i, j) in answer_coordinates]
					if len(_UpperCAmelCase				) == 1:
										try:
															return convert_to_float(values[0]				)
										except ValueError as e:
															if aggregation_op != _Aggregation.NONE:
																				raise e

					if aggregation_op == _Aggregation.NONE:
										return None

					# Other aggregation only support numeric values. Bail out if we have strings.
					if not all((isinstance(_UpperCAmelCase       ,			(int, float)				) for v in values)				):
										return None

					if aggregation_op == _Aggregation.SUM:
										return float(sum(_UpperCAmelCase				)				)
					elif aggregation_op == _Aggregation.AVERAGE:
										return sum(_UpperCAmelCase				) / len(_UpperCAmelCase				)
					else:
										raise ValueError(f"""Unknown aggregation: {aggregation_op}"""				)





def 		__snake_case						(    _UpperCAmelCase       ,			_UpperCAmelCase				):
					"""simple docstring"""






					lowercase						   =       sql_query['agg']
					if aggregation_op_index >= 3:
										lowercase						   =       _Aggregation(_UpperCAmelCase				)
					else:
										lowercase						   =       _Aggregation.NONE

					lowercase						   =       sql_query['sel']
					lowercase						   =       [
					    _Condition(_UpperCAmelCase       ,			_Operator(_UpperCAmelCase				)       ,			_UpperCAmelCase				)
					    for column, operator, cmp_value in zip(
					        sql_query['conds']['column_index']       ,			sql_query['conds']['operator_index']       ,			sql_query['conds']['condition']				)
					]

					lowercase						   =       []
					for row in range(len(table['rows']				)				):
										if _respect_conditions(_UpperCAmelCase       ,			table['rows'][row]       ,			_UpperCAmelCase				):
															indices.append((row, target_column)				)

					if not indices:
										return [], aggregation_op

					if len(_UpperCAmelCase				) == 1:
										return indices, aggregation_op

					# Parsing of MIN/MAX.
					if aggregation_op_index in (1, 2):
										lowercase						   =       {2: min, 1: max}
										lowercase						   =       [(table['rows'][i][j], index) for index, (i, j) in enumerate(_UpperCAmelCase				)]
										lowercase						   =       functools.reduce(operators[sql_query['agg']]       ,			_UpperCAmelCase				)

										lowercase						   =       [indices[reduced[1]]]
										return ret, _Aggregation.NONE

					return indices, aggregation_op





def 		__snake_case						(    _UpperCAmelCase       ,			_UpperCAmelCase       ,			_UpperCAmelCase				):
					"""simple docstring"""






					if float_answer is not None:
										return [str(_UpperCAmelCase				)]
					return [str(table['real_rows'][r][c]				) for r, c in answer_coordinates]





def 		__snake_case						(    _UpperCAmelCase       ,			_UpperCAmelCase				):
					"""simple docstring"""






					lowercase   ,      lowercase						   =       _get_answer_coordinates(_UpperCAmelCase       ,			_UpperCAmelCase				)
					lowercase						   =       _get_float_answer(_UpperCAmelCase       ,			_UpperCAmelCase       ,			_UpperCAmelCase				)
					lowercase						   =       _get_answer_text(_UpperCAmelCase       ,			_UpperCAmelCase       ,			_UpperCAmelCase				)
					# keep the original data the same with TaPas
					if len(_UpperCAmelCase				) == 0:
										lowercase						   =       [EMPTY_ANSWER]
					return answer_text











def 		__snake_case						(    _UpperCAmelCase       ,			_UpperCAmelCase				):
					"""simple docstring"""






					for index, item in enumerate(_UpperCAmelCase				):
										if item == target:
															return index
					return -1





def 		__snake_case						(    _UpperCAmelCase       ,			_UpperCAmelCase       ,			_UpperCAmelCase       ,			_UpperCAmelCase				):
					"""simple docstring"""






					if not (0 <= high < len(_UpperCAmelCase				) and 0 <= low < len(_UpperCAmelCase				)):
										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(_UpperCAmelCase       ,			low + 1       ,			high - 1       ,			_UpperCAmelCase				)


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

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






