H
```/**
* @file
*
* @details
* Saddleback Algorithm is an algorithm that searches 2D array in linear time,
* i.e, O(m + n), where m is number of rows and n is number of columns of 2D array. Also, each row and
* column of the matrix should be sorted beforehand for this algorithm to work.
*
* @author [Hashir Niazi](https://github.com/HashirGJ8842)
*/
#include <cassert>      /// for assert
#include <iostream>     /// for io operations, and std::pair
#include <vector>       /// for std::vector

/** \namespace search
* \brief Algorithms for searching
*/
namespace search {
*/
/**
* on a sorted 2D array, and finds the location of the element needed to search
* @param matrix 2D matrix which is sorted on the basis of rows and columns
* @param element element to be searched
* @return An std::pair of with row and column populated within it, if the
* element is present.
* @return An std::pair with (0, 0), if the element is not present.
*/
int32_t element) {
uint32_t left_index = 0;
uint32_t right_index = matrix.size() - 1;  // Start from top right corner
while (left_index < matrix.size()) {  // Exit once the value of indexes get out of range.
if (element ==
matrix[left_index]
[right_index]) {  // If value on this position of matrix is
// equal to element, return (row, column).
return std::make_pair(left_index+1, right_index+1);
} else if (element >
matrix[left_index]
[right_index]) {  // Else if value on this position of
// matrix is less than the element,
// move left.
++left_index;
} else if (element <
matrix[left_index]
[right_index]) {  // Else if value on this position of
// matrix is greater than the
// element, move down.
if(!right_index)
break;
else --right_index;
}
}
return std::make_pair(
0, 0);  // If the program reaches here, that means one of the index
// went out of index, hence no element present.
}
}  // namespace search

/**
* @brief Test implementations
* @returns void
*/
static void test() {
std::vector<std::vector<int32_t>> matrix = {{1, 10, 100, 1000, 10000},
{2, 20, 200, 2000, 20000},
{3, 30, 300, 3000, 30000},
{4, 40, 400, 4000, 40000},
{5, 50, 500, 5000, 50000}};

std::pair<uint32_t, uint32_t> not_found = std::make_pair(0, 0);
// Test 1
// Test 2
// Test 3
// Test 4
// Test 5
}

/**
* @brief Main function
* @returns 0 on exit
*/
int main() {
test();     // execute the tests
return 0;
}
```  