

"""simple docstring"""





def     __lowercase					(    a :				int       ,		a :				int       ,		a :				list[list[int]] )					->					int:

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

            __snake_case      :    Optional[int]  			=update_area_of_max_square(a       ,		col + 1 )
            __snake_case      :    List[str]  			=update_area_of_max_square(row + 1       ,		col + 1 )
            __snake_case      :    Optional[Any]  			=update_area_of_max_square(row + 1       ,		a )

            if mat[row][col]:
                  __snake_case      :    Any  			=1 + min([right, diagonal, down] )
                  __snake_case      :    Union[str, Any]  			=max(largest_square_area[0]       ,		a )
                  return sub_problem_sol
            else:
                  return 0

      __snake_case      :    Optional[int]  			=[0]
      update_area_of_max_square(0       ,		0 )
      return largest_square_area[0]



def     __lowercase					(    a :				int       ,		a :				int       ,		a :				list[list[int]] )					->					int:

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

            __snake_case      :    str  			=update_area_of_max_square_using_dp_array(a       ,		col + 1       ,		a )
            __snake_case      :    List[str]  			=update_area_of_max_square_using_dp_array(row + 1       ,		col + 1       ,		a )
            __snake_case      :    str  			=update_area_of_max_square_using_dp_array(row + 1       ,		a       ,		a )

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

      __snake_case      :    str  			=[0]
      __snake_case      :    str  			=[[-1] * cols for _ in range(a )]
      update_area_of_max_square_using_dp_array(0       ,		0       ,		a )

      return largest_square_area[0]



def     __lowercase					(    a :				int       ,		a :				int       ,		a :				list[list[int]] )					->					int:
      __snake_case      :    int  			=[[0] * (cols + 1) for _ in range(rows + 1 )]
      __snake_case      :    int  			=0
      for row in range(rows - 1       ,		-1       ,		-1 ):
            for col in range(cols - 1       ,		-1       ,		-1 ):
                  __snake_case      :    Any  			=dp_array[row][col + 1]
                  __snake_case      :    Optional[int]  			=dp_array[row + 1][col + 1]
                  __snake_case      :    int  			=dp_array[row + 1][col]

                  if mat[row][col] == 1:
                        __snake_case      :    Union[str, Any]  			=1 + min(a       ,		a       ,		a )
                        __snake_case      :    Dict  			=max(dp_array[row][col]       ,		a )
                  else:
                        __snake_case      :    Union[str, Any]  			=0

      return largest_square_area



def     __lowercase					(    a :				int       ,		a :				int       ,		a :				list[list[int]] )					->					int:
      __snake_case      :    Dict  			=[0] * (cols + 1)
      __snake_case      :    List[Any]  			=[0] * (cols + 1)
      __snake_case      :    Any  			=0
      for row in range(rows - 1       ,		-1       ,		-1 ):
            for col in range(cols - 1       ,		-1       ,		-1 ):
                  __snake_case      :    int  			=current_row[col + 1]
                  __snake_case      :    Optional[Any]  			=next_row[col + 1]
                  __snake_case      :    Union[str, Any]  			=next_row[col]

                  if mat[row][col] == 1:
                        __snake_case      :    Tuple  			=1 + min(a       ,		a       ,		a )
                        __snake_case      :    str  			=max(current_row[col]       ,		a )
                  else:
                        __snake_case      :    Optional[int]  			=0
            __snake_case      :    Optional[Any]  			=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]]))










"""simple docstring"""





def     __lowercase					(    a :				int       ,		a :				int )					->					int:
      return x if y == 0 else greatest_common_divisor(a       ,		x % y )



def     __lowercase					(    a :				int       ,		a :				int )					->					int:
      return (x * y) // greatest_common_divisor(a       ,		a )



def     __lowercase					(    a :				int = 20 )					->					int:
      __snake_case      :    Optional[Any]  			=1
      for i in range(1       ,		n + 1 ):
            __snake_case      :    Optional[int]  			=lcm(a       ,		a )
      return g


if __name__ == "__main__":
    print(F'''{solution() = }''')


