





'''simple docstring'''

from __future__ import annotations

from typing import Generic, TypeVar

lowercase_         =			TypeVar("""T""")


class  a_					(    snake_case_	):

    '''simple docstring'''
    pass




class  a_					(    snake_case_	):

    '''simple docstring'''
    pass




class  a_					(    Generic[T]	):

    '''simple docstring'''


    def __init__(		self			,		A = 10	)		->       Optional[Any]:
        _SCREAMING_SNAKE_CASE     =      []
        _SCREAMING_SNAKE_CASE     =      limit


    def __bool__(		self	)		->       bool:
        return bool(self.stack	)


    def __str__(		self	)		->       str:
        return str(self.stack	)


    def       snake_case_(		self			,		A	)		->       None:
        if len(self.stack	) >= self.limit:
            raise StackOverflowError
        self.stack.append(A	)


    def       snake_case_(		self	)		->       T:
        if not self.stack:
            raise StackUnderflowError
        return self.stack.pop()


    def       snake_case_(		self	)		->       T:
        if not self.stack:
            raise StackUnderflowError
        return self.stack[-1]


    def       snake_case_(		self	)		->       bool:
        return not bool(self.stack	)


    def       snake_case_(		self	)		->       bool:
        return self.size() == self.limit


    def       snake_case_(		self	)		->       int:
        return len(self.stack	)





    def __contains__(		self			,		A	)		->       bool:
        return item in self.stack





def lowerCamelCase						(					)						->None:
    _SCREAMING_SNAKE_CASE     =      Stack(10   )
    assert bool(__lowerCamelCase   ) is False
    assert stack.is_empty() is True
    assert stack.is_full() is False
    assert str(__lowerCamelCase   ) == "[]"

    try:
        _SCREAMING_SNAKE_CASE     =      stack.pop()
        raise AssertionError  # This should not happen
    except StackUnderflowError:
        assert True  # This should happen

    try:
        _SCREAMING_SNAKE_CASE     =      stack.peek()
        raise AssertionError  # This should not happen
    except StackUnderflowError:
        assert True  # This should happen

    for i in range(10   ):
        assert stack.size() == i
        stack.push(__lowerCamelCase   )

    assert bool(__lowerCamelCase   )
    assert not stack.is_empty()
    assert stack.is_full()
    assert str(__lowerCamelCase   ) == str(list(range(10   )   )   )
    assert stack.pop() == 9
    assert stack.peek() == 8

    stack.push(100   )
    assert str(__lowerCamelCase   ) == str([0, 1, 2, 3, 4, 5, 6, 7, 8, 100]   )

    try:
        stack.push(200   )
        raise AssertionError  # This should not happen
    except StackOverflowError:
        assert True  # This should happen

    assert not stack.is_empty()
    assert stack.size() == 10

    assert 5 in stack
    assert 55 not in stack


if __name__ == "__main__":
      test_stack()










'''simple docstring'''

def lowerCamelCase						(					__lowerCamelCase			:   int ,	__lowerCamelCase			:   int ,	__lowerCamelCase			:   int ,	__lowerCamelCase			:   int   )						->int:
    return len_board * len_board_column * row + column





def lowerCamelCase						(					__lowerCamelCase			:   list[list[str]] ,	__lowerCamelCase			:   str ,	__lowerCamelCase			:   int ,	__lowerCamelCase			:   int ,	__lowerCamelCase			:   int ,	__lowerCamelCase			:   set[int] ,	)						->bool:

    if board[row][column] != word[word_index]:
        return False

    if word_index == len(__lowerCamelCase   ) - 1:
        return True

    _SCREAMING_SNAKE_CASE     =      [(0, 1), (0, -1), (-1, 0), (1, 0)]
    _SCREAMING_SNAKE_CASE     =      len(__lowerCamelCase   )
    _SCREAMING_SNAKE_CASE     =      len(board[0]   )
    for direction in traverts_directions:
        _SCREAMING_SNAKE_CASE     =      row + direction[0]
        _SCREAMING_SNAKE_CASE     =      column + direction[1]
        if not (0 <= next_i < len_board and 0 <= next_j < len_board_column):
            continue

        _SCREAMING_SNAKE_CASE     =      get_point_key(__lowerCamelCase ,	__lowerCamelCase ,	__lowerCamelCase ,	__lowerCamelCase   )
        if key in visited_points_set:
            continue

        visited_points_set.add(__lowerCamelCase   )
        if exits_word(__lowerCamelCase ,	__lowerCamelCase ,	__lowerCamelCase ,	__lowerCamelCase ,	word_index + 1 ,	__lowerCamelCase   ):
            return True

        visited_points_set.remove(__lowerCamelCase   )

    return False





def lowerCamelCase						(					__lowerCamelCase			:   list[list[str]] ,	__lowerCamelCase			:   str   )						->bool:
    _SCREAMING_SNAKE_CASE     =      (
        """The board should be a non empty matrix of single chars strings."""
    )

    _SCREAMING_SNAKE_CASE     =      len(__lowerCamelCase   )
    if not isinstance(__lowerCamelCase ,	__lowerCamelCase   ) or len(__lowerCamelCase   ) == 0:
        raise ValueError(__lowerCamelCase   )

    for row in board:
        if not isinstance(__lowerCamelCase ,	__lowerCamelCase   ) or len(__lowerCamelCase   ) == 0:
            raise ValueError(__lowerCamelCase   )

        for item in row:
            if not isinstance(__lowerCamelCase ,	__lowerCamelCase   ) or len(__lowerCamelCase   ) != 1:
                raise ValueError(__lowerCamelCase   )

    # Validate word
    if not isinstance(__lowerCamelCase ,	__lowerCamelCase   ) or len(__lowerCamelCase   ) == 0:
        raise ValueError(
            """The word parameter should be a string of length greater than 0."""   )

    _SCREAMING_SNAKE_CASE     =      len(board[0]   )
    for i in range(__lowerCamelCase   ):
        for j in range(__lowerCamelCase   ):
            if exits_word(
                __lowerCamelCase ,	__lowerCamelCase ,	__lowerCamelCase ,	__lowerCamelCase ,	0 ,	{get_point_key(__lowerCamelCase ,	__lowerCamelCase ,	__lowerCamelCase ,	__lowerCamelCase   )}   ):
                return True

    return False


if __name__ == "__main__":
      import doctest

      doctest.testmod()



