

__A    	=			[
    [0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0],
    [0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0],
    [0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0],
    [0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 0, 0],
    [0, 1, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0],
    [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0],
    [0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0],
    [0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0],
]



def    snake_case_(_UpperCamelCase				, _UpperCamelCase				, _UpperCamelCase				, _UpperCamelCase  )							->			bool:



  """simple docstring"""






  return 0 <= row < rows and 0 <= col < cols



def    snake_case_(_UpperCamelCase				, _UpperCamelCase				, _UpperCamelCase				, _UpperCamelCase  )							->			int:



  """simple docstring"""






  _snake_case		=							len(_UpperCamelCase  )
  _snake_case		=							len(mat[0]  )
  if is_safe(_UpperCamelCase				, _UpperCamelCase				, _UpperCamelCase				, _UpperCamelCase  ) and (row, col) not in seen and mat[row][col] == 1:
    seen.add((row, col)  )
    return (
        1
        + depth_first_search(row + 1				, _UpperCamelCase				, _UpperCamelCase				, _UpperCamelCase  )
        + depth_first_search(row - 1				, _UpperCamelCase				, _UpperCamelCase				, _UpperCamelCase  )
        + depth_first_search(_UpperCamelCase				, col + 1				, _UpperCamelCase				, _UpperCamelCase  )
        + depth_first_search(_UpperCamelCase				, col - 1				, _UpperCamelCase				, _UpperCamelCase  )
    )
  else:
    return 0



def    snake_case_(_UpperCamelCase  )							->			int:



  """simple docstring"""






  _snake_case		=							set()

  _snake_case		=							0
  for row, line in enumerate(_UpperCamelCase  ):
    for col, item in enumerate(_UpperCamelCase  ):
      if item == 1 and (row, col) not in seen:
        # Maximizing the area
        _snake_case		=							max(_UpperCamelCase				, depth_first_search(_UpperCamelCase				, _UpperCamelCase				, _UpperCamelCase				, _UpperCamelCase  )  )
  return max_area


if __name__ == "__main__":
 import doctest

 print(find_max_area(matrix))  # Output -> 6
 doctest.testmod()




__A    	=			{
    '''+''': lambda x, y: x + y,
    '''-''': lambda x, y: x - y,
    '''*''': lambda x, y: x * y,
    '''/''': lambda x, y: x / y,
}



def    snake_case_(_UpperCamelCase  )							->			str:



  """simple docstring"""






  return c.isdigit()



def    snake_case_(_UpperCamelCase  )							->			str:



  """simple docstring"""






  _snake_case		=							[]

  # iterate over the string in reverse order
  for c in expression.split()[::-1]:
    # push operand to stack
    if is_operand(_UpperCamelCase  ):
      stack.append(int(_UpperCamelCase  )  )

    else:
      # pop values from stack can calculate the result
      # push the result onto the stack again
      _snake_case		=							stack.pop()
      _snake_case		=							stack.pop()
      stack.append(calc[c](_UpperCamelCase				, _UpperCamelCase  )  )

  return stack.pop()


# Driver code
if __name__ == "__main__":
 __A    	=			'''+ 9 * 2 6'''
 print(evaluate(test_expression))

 __A    	=			'''/ * 10 2 + 4 1 '''
 print(evaluate(test_expression))

