
import math
def    SCREAMING_SNAKE_CASE__		( lowerCAmelCase_				:			Optional[Any]       ,lowerCAmelCase_				:			List[Any]							)    ->   int:







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_	:							List[Any]											=len(lowerCAmelCase_							)
							SCREAMING_SNAKE_CASE_	:							Any											=int(math.floor(math.sqrt(lowerCAmelCase_							)							)							)
							SCREAMING_SNAKE_CASE_	:							Dict											=0
							while arr[min(lowerCAmelCase_       ,lowerCAmelCase_							) - 1] < x:
														SCREAMING_SNAKE_CASE_	:							Dict											=step
														step += int(math.floor(math.sqrt(lowerCAmelCase_							)							)							)
														if prev >= n:
																					return -1

							while arr[prev] < x:
														SCREAMING_SNAKE_CASE_	:							Optional[Any]											=prev + 1
														if prev == min(lowerCAmelCase_       ,lowerCAmelCase_							):
																					return -1
							if arr[prev] == x:
														return prev
							return -1


if __name__ == "__main__":
							__SCREAMING_SNAKE_CASE						       =						input('Enter numbers separated by a comma:\n').strip()
							__SCREAMING_SNAKE_CASE						       =						[int(item) for item in user_input.split(',')]
							__SCREAMING_SNAKE_CASE						       =						int(input('Enter the number to be searched:\n'))
							__SCREAMING_SNAKE_CASE						       =						jump_search(arr, x)
							if res == -1:
														print('Number not found!')
							else:
														print(f"""Number {x} is at index {res}""")







from __future__ import annotations







def 							A__       (    lowerCamelCase    )	->						bool:
				UpperCamelCase_:				Optional[int]						=    len(lowerCamelCase    )
				# We need to create solution object to save path.
				UpperCamelCase_:				List[str]						=    [[0 for _ in range(lowerCamelCase    )] for _ in range(lowerCamelCase    )]
				UpperCamelCase_:				Dict						=    run_maze(lowerCamelCase  ,     0  ,     0  ,     lowerCamelCase    )
				if solved:
								print("""\n""".join(str(lowerCamelCase    ) for row in solutions    )    )
				else:
								print("""No solution exists!"""    )
				return solved







def 							A__       (    lowerCamelCase  ,     lowerCamelCase  ,     lowerCamelCase  ,     lowerCamelCase    )	->						bool:
				UpperCamelCase_:				Dict						=    len(lowerCamelCase    )
				# Final check point.
				if i == j == (size - 1):
								UpperCamelCase_:				Union[str, Any]						=    1
								return True

				UpperCamelCase_:				List[str]						=    (not i < 0) and (not j < 0)  # Check lower bounds
				UpperCamelCase_:				List[str]						=    (i < size) and (j < size)  # Check upper bounds

				if lower_flag and upper_flag:
								# check for already visited and block points.
								UpperCamelCase_:				Dict						=    (not solutions[i][j]) and (not maze[i][j])
								if block_flag:
												# check visited
												UpperCamelCase_:				Optional[Any]						=    1

												# check for directions
												if (
												    run_maze(lowerCamelCase  ,     i + 1  ,     lowerCamelCase  ,     lowerCamelCase    )
												    or run_maze(lowerCamelCase  ,     lowerCamelCase  ,     j + 1  ,     lowerCamelCase    )
												    or run_maze(lowerCamelCase  ,     i - 1  ,     lowerCamelCase  ,     lowerCamelCase    )
												    or run_maze(lowerCamelCase  ,     lowerCamelCase  ,     j - 1  ,     lowerCamelCase    )
												):
																return True

												UpperCamelCase_:				Optional[Any]						=    0
												return False
				return False


if __name__ == "__main__":
							import doctest

							doctest.testmod()






