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.*;
 
public class D
{
    static void solve(FastIO io)
    {
        int n = io.nextInt();
        int m = io.nextInt();

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

        for (int i = 0; i < n; i++)
            for (int j = 0; j < m; j++)
                a[i][j] = io.nextInt();


        int[] best = new int[1 << m];
        int[] bestVal = new int[1 << m];


        for (int i = 1; i < 1 << m; i++)
        {
            int val = -1;
            int id = -1;

            for (int j = 0; j < n; j++)
            {
                int min = Integer.MAX_VALUE;

                for (int k = 0; k < m; k++)
                    if ((i & (1 << k)) != 0)
                        min = Math.min(min, a[j][k]);

                if (min > val)
                {
                    val = min;
                    id = j;
                }
            }

            best[i] = id;
            bestVal[i] = val;
        }

        int full = (1 << m) - 1;
        int k1 = -1, k2 = -1;
        int max = -1 ;

        for (int i = 1; i < 1 << m; i++)
        {
            int other = full ^ i;

            int val = Math.min(bestVal[i], bestVal[other]);

            if (val > max)
            {
                max = val;
                k1 = best[i];
                k2 = best[other];
            }
        }

        io.println((k1 + 1) + " " + (k2 + 1));
    }  
 
    public static void main(String[] args) 
    {
        FastIO io = new FastIO();
 
        solve(io);
 
        io.close();
    }
 
    static class FastIO extends PrintWriter
    {
        StringTokenizer st = new StringTokenizer("");
        BufferedReader r = new BufferedReader(new InputStreamReader(System.in));
 
        FastIO()
        {
            super(System.out);
        }
 
        String next()
        {
            while (!st.hasMoreTokens())
            {
                try {
                    st = new StringTokenizer(r.readLine());
                } catch (Exception e) { }
            }
            return st.nextToken();
        }
 
        int nextInt()
        {
            return Integer.parseInt(next());
        }
 
        long nextLong()
        {
            return Long.parseLong(next());
        }
 
        double nextDouble()
        {
            return Double.parseDouble(next());
        }
    }
}