


'''simple docstring'''



def     lowerCamelCase				(_SCREAMING_SNAKE_CASE :  int		, _SCREAMING_SNAKE_CASE :  int		, _SCREAMING_SNAKE_CASE :  list[list[int]]  ):







					def update_area_of_max_square(_SCREAMING_SNAKE_CASE :  int		, _SCREAMING_SNAKE_CASE :  int  ) -> int:
										# BASE CASE
										if row >= rows or col >= cols:
															return 0

										__a     :			Optional[int]          =    update_area_of_max_square(UpperCamelCase__		, col + 1  )
										__a     :			Union[str, Any]          =    update_area_of_max_square(row + 1		, col + 1  )
										__a     :			str          =    update_area_of_max_square(row + 1		, UpperCamelCase__  )

										if mat[row][col]:
															__a     :			List[Any]          =    1 + min([right, diagonal, down]  )
															__a     :			Any          =    max(largest_square_area[0]		, UpperCamelCase__  )
															return sub_problem_sol
										else:
															return 0

					__a     :			Any          =    [0]
					update_area_of_max_square(0		, 0  )
					return largest_square_area[0]






def     lowerCamelCase				(_SCREAMING_SNAKE_CASE :  int		, _SCREAMING_SNAKE_CASE :  int		, _SCREAMING_SNAKE_CASE :  list[list[int]]  ):







					def update_area_of_max_square_using_dp_array(
					    _SCREAMING_SNAKE_CASE :  int		, _SCREAMING_SNAKE_CASE :  int		, _SCREAMING_SNAKE_CASE :  list[list[int]]  ) -> int:
										if row >= rows or col >= cols:
															return 0
										if dp_array[row][col] != -1:
															return dp_array[row][col]

										__a     :			str          =    update_area_of_max_square_using_dp_array(UpperCamelCase__		, col + 1		, UpperCamelCase__  )
										__a     :			Union[str, Any]          =    update_area_of_max_square_using_dp_array(row + 1		, col + 1		, UpperCamelCase__  )
										__a     :			str          =    update_area_of_max_square_using_dp_array(row + 1		, UpperCamelCase__		, UpperCamelCase__  )

										if mat[row][col]:
															__a     :			Optional[Any]          =    1 + min([right, diagonal, down]  )
															__a     :			Optional[Any]          =    max(largest_square_area[0]		, UpperCamelCase__  )
															__a     :			Dict          =    sub_problem_sol
															return sub_problem_sol
										else:
															return 0

					__a     :			Dict          =    [0]
					__a     :			str          =    [[-1] * cols for _ in range(UpperCamelCase__  )]
					update_area_of_max_square_using_dp_array(0		, 0		, UpperCamelCase__  )

					return largest_square_area[0]






def     lowerCamelCase				(_SCREAMING_SNAKE_CASE :  int		, _SCREAMING_SNAKE_CASE :  int		, _SCREAMING_SNAKE_CASE :  list[list[int]]  ):
					__a     :			str          =    [[0] * (cols + 1) for _ in range(rows + 1  )]
					__a     :			Optional[Any]          =    0
					for row in range(rows - 1		, -1		, -1  ):
										for col in range(cols - 1		, -1		, -1  ):
															__a     :			Dict          =    dp_array[row][col + 1]
															__a     :			Any          =    dp_array[row + 1][col + 1]
															__a     :			Dict          =    dp_array[row + 1][col]

															if mat[row][col] == 1:
																				__a     :			Any          =    1 + min(UpperCamelCase__		, UpperCamelCase__		, UpperCamelCase__  )
																				__a     :			List[str]          =    max(dp_array[row][col]		, UpperCamelCase__  )
															else:
																				__a     :			Optional[int]          =    0

					return largest_square_area






def     lowerCamelCase				(_SCREAMING_SNAKE_CASE :  int		, _SCREAMING_SNAKE_CASE :  int		, _SCREAMING_SNAKE_CASE :  list[list[int]]  ):
					__a     :			int          =    [0] * (cols + 1)
					__a     :			List[str]          =    [0] * (cols + 1)
					__a     :			Any          =    0
					for row in range(rows - 1		, -1		, -1  ):
										for col in range(cols - 1		, -1		, -1  ):
															__a     :			List[str]          =    current_row[col + 1]
															__a     :			Any          =    next_row[col + 1]
															__a     :			List[str]          =    next_row[col]

															if mat[row][col] == 1:
																				__a     :			Optional[int]          =    1 + min(UpperCamelCase__		, UpperCamelCase__		, UpperCamelCase__  )
																				__a     :			Union[str, Any]          =    max(current_row[col]		, UpperCamelCase__  )
															else:
																				__a     :			str          =    0
										__a     :			Tuple          =    current_row

					return largest_square_area


if __name__ == "__main__":
	import doctest

	doctest.testmod()
	print(largest_square_area_in_matrix_bottom_up(2, 2, [[1, 1], [1, 1]]))







import requests
from bsa import BeautifulSoup





def 	_lowerCAmelCase					( UpperCamelCase__:  str = "https://www.worldometers.info/coronavirus"    )			-> dict:





	"""simple docstring"""







	A             =					BeautifulSoup(requests.get(UpperCamelCase__    ).text				,       """html.parser"""    )
	A             =					soup.findAll("""h1"""    )
	A             =					soup.findAll("""div"""				,       {"""class""": """maincounter-number"""}    )
	keys += soup.findAll("""span"""				,       {"""class""": """panel-title"""}    )
	values += soup.findAll("""div"""				,       {"""class""": """number-table-main"""}    )
	return {key.text.strip(): value.text.strip() for key, value in zip(UpperCamelCase__				,       UpperCamelCase__    )}


if __name__ == "__main__":
				print("\033[1m" + "COVID-19 Status of the World" + "\033[0m\n")
				for key, value in world_covidaa_stats().items():
								print(f'''{key}\n{value}\n''')



