Problem: You are given n arrays a_1, a_2, ..., a_n; each array consists of exactly m integers. We denote the y-th element of the x-th array as a_{x, y}.

You have to choose two arrays a_i and a_j (1 ≤ i, j ≤ n, it is possible that i = j). After that, you will obtain a new array b consisting of m integers, such that for every k ∈ [1, m] b_k = max(a_{i, k}, a_{j, k}).

Your goal is to choose i and j so that the value of min _{k = 1}^{m} b_k is maximum possible.

Input

The first line contains two integers n and m (1 ≤ n ≤ 3 ⋅ 10^5, 1 ≤ m ≤ 8) — the number of arrays and the number of elements in each array, respectively.

Then n lines follow, the x-th line contains the array a_x represented by m integers a_{x, 1}, a_{x, 2}, ..., a_{x, m} (0 ≤ a_{x, y} ≤ 10^9).

Output

Print two integers i and j (1 ≤ i, j ≤ n, it is possible that i = j) — the indices of the two arrays you have to choose so that the value of min _{k = 1}^{m} b_k is maximum possible. If there are multiple answers, print any of them.

Example

Input


6 5
5 0 3 1 2
1 8 9 1 3
1 2 3 4 5
9 1 0 3 7
2 3 0 6 3
6 4 1 7 0


Output


1 5

Solution (in JAVA):

Solution:
import java.io.*;
import java.util.*;
import java.math.*;

public class p1288D {

	public void realMain() throws Exception {

		BufferedReader fin = new BufferedReader(new InputStreamReader(System.in), 1000000);

		String in = fin.readLine();

		String[] ar = in.split(" ");

		int n = Integer.parseInt(ar[0]);
		int m = Integer.parseInt(ar[1]);

		int[][] a = new int[n][m];

		for(int i = 0; i < n; i++) {
			for(int j = 0; j < m; j++) {
			int ret = 0;
			boolean dig = false;
			for (int ch = 0; (ch = fin.read()) != -1; ) {
        			if (ch >= '0' && ch <= '9') {
            				dig = true;
           				ret = ret * 10 + ch - '0';
        			} else if (dig) break;
    			}

			a[i][j] = ret;
			}
			
		}


		int low = 0;

		int high = 1000000000;

		int maxkey = 1 << (m);

		//System.err.println(maxkey);
		//System.err.println(2 << -1);

		int ans1 = 1;
		int ans2 = 2;

		int maxmid = -1;

		while(low <= high) {
			int mid = (low + high) / 2;

			//System.err.println(mid);

			boolean can = false;

			int[] has = new int[maxkey];

			for(int i = 0; i < n; i++) {
				int key = 0;

				for(int j = 0; j < m; j++) {
					if(a[i][j] >= mid) {
						key += 1 << j;
					}
				}

				//System.err.println("setting key: " + key);
				has[key] = i + 1;
			}

			for(int i = 0; i < maxkey && !can; i++) {
				for(int j = i; j < maxkey; j++) {
					if( (i | j) != (maxkey - 1)) {
						continue;
					}

					if(has[i] > 0 && has[j] > 0) {
						can = true;
						if(mid > maxmid) {
							maxmid = mid;
							ans1 = has[i];
							ans2 = has[j];
						}
					}
				}
			}

			if(can) {
				low = mid + 1;
			} else {
				high = mid - 1;
			}
		}

		System.out.println(ans1 + " " + ans2);
			
		

	}


	public static void main(String[] args) throws Exception {
		p1288D a = new p1288D();
		a.realMain();
	}
}