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.awt.*;
import java.io.*;
import java.util.*;

public class Abc {
    static int arr[][];
    static int n,m;
    static int ansi,ansj;
    public static void main(String[] args) throws IOException {
        FastReader sc = new FastReader();
        n=sc.nextInt();m=sc.nextInt();
        arr=new int[n][m];
        for (int i=0;i<n;i++){
            for (int j=0;j<m;j++)arr[i][j]=sc.nextInt();
        }
        int l=0,r=1000000000;
        int ns=-1;
        while (l<=r){
            int mid=l+(r-l)/2;
            if (canExist(mid)){
                ns=mid;
                l=mid+1;
            }else r=mid-1;
        }
        System.out.println((ansi+1)+" "+(ansj+1));
    }
    static boolean canExist(int x){
        boolean che[]=new boolean[(1<<8)];
        int ar[]=new int[(1<<8)];
        for (int i=0;i<n;i++){
            int mask=0;
            for (int j=0;j<m;j++){
                if (arr[i][j]>=x){
                    mask|=(1<<j);
                }
            }
            che[mask]=true;
            ar[mask]=i;
        }
        for (int i=0;i<(1<<8);i++){
            if (che[i]){
                for (int j=0;j<(1<<8);j++){
                    if (che[j]){
                        if ((i|j)==(1<<m)-1){
                            ansi=ar[i];
                            ansj=ar[j];
                            return true;
                        }
                    }
                }
            }
        }
        return false;
    }
    static class FastReader {
        BufferedReader br;
        StringTokenizer st;

        public FastReader() {
            br = new BufferedReader(new
                    InputStreamReader(System.in));
        }

        String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        int nextInt() {
            return Integer.parseInt(next());
        }

        long nextLong() {
            return Long.parseLong(next());
        }

        double nextDouble() {
            return Double.parseDouble(next());
        }

        String nextLine() {
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }
    }
}