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:
// package Quarantine;

import javafx.util.Pair;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.StringTokenizer;

public class MinimAx {
    public static void main(String[] args)throws IOException {
        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st=new StringTokenizer(br.readLine());
        int n=Integer.parseInt(st.nextToken());
        int m=Integer.parseInt(st.nextToken());
        int a[][]=new int[n][m];
        for(int i=0;i<n;i++){
            st=new StringTokenizer(br.readLine());
            for(int j=0;j<m;j++){
                a[i][j]=Integer.parseInt(st.nextToken());
            }
        }
        Pair<Integer,Integer> ans=getAns(a,n,m);
        System.out.println(ans.getKey()+" "+ans.getValue());
    }
    public static Pair<Integer, Integer> getAns(int a[][], int n, int m){
        int low=0,high=1000000000;
        Pair<Integer,Integer> ans=new Pair<>(0,0);
        while(low<=high){
//            System.out.println(low+" "+high);
            int mid=(low+high)/2;
//            System.out.println(mid);
            ArrayList<Integer> masks[];
            masks=getMasks(a,mid,n,m);
            boolean flag=false;
            int reqd=(1<<m)-1;
//            System.out.println(reqd+"r");
            for(int i=0;i<masks.length;i++){
                if(masks[i].size()>0){
                    for(int j=i;j<masks.length;j++){
                        if(masks[j].size()>0){
                            int val=i|j;
                            if(val==reqd){
                                flag=true;
                                ans=new Pair<>(masks[i].get(0),masks[j].get(0));
                                break;
                            }
                        }
                    }
                    if(flag){
                        break;
                    }
                }
            }
            if(flag){
                low=mid+1;
            }
            else{
                high=mid-1;
            }
        }
        return ans;
    }
    public static ArrayList<Integer>[] getMasks(int a[][],int x,int n,int m){
        ArrayList<Integer> ans[]=new ArrayList[1<<m];
        for(int i=0;i<ans.length;i++){
            ans[i]=new ArrayList<>();
        }
        for(int i=0;i<a.length;i++){
            int t=0;
            for(int j=0;j<m;j++){
                if(a[i][j]>=x){
                    int temp=1<<j;
                    t|=temp;
                }
            }
            ans[t].add(i+1);
        }
        return ans;
    }
}