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:
//it's not working and not going to work and you know this....
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Scanner;
import java.util.StringTokenizer;
import java.util.*;
public class Main
{

    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;
        }
    }

    public static void main(String[] args)
    {
        FastReader sc=new FastReader();

        StringBuilder sb=new StringBuilder();
        int n=sc.nextInt();
        int m=sc.nextInt();
        int a[][]=new int[n][m];
        for( int i=0;i<n;i++)
        {
          for( int j=0;j<m;j++)
          {
            a[i][j]=sc.nextInt();
          }
        }
        int val=binary_search(a);
        int mask[]=new int[1<<m];
        for( int i=0;i<a.length;i++)
        {
          int cur=0;
          for( int j=0;j<a[i].length;j++)
          {
            if(val<=a[i][j])
            {
              cur^=(1<<j);
            }
          }
          mask[cur]=i+1;
        }
        for(int i=0;i<(1<<m);i++)
         {
			       if(mask[i]>0)
             {
				           for(int j=0;j<(1<<m);j++)
                    {
					                 if(mask[j]>0 && (i|j)==((1<<m)-1))
                            {
						                        System.out.println((mask[i])+" "+(mask[j]));
						                              return;
					                  }
                    }
			        }
            }
        //System.out.println(sb.toString());
    }

    public static int binary_search(int a[][])
    {
      int start=0;
      int end=(int)1e9+10;
      int ans=0;
      while(start<end)
      {
        int mid=(start+end)>>1;
        if(check(mid, a))
        {
          start=mid+1;
          ans=mid;
        }
        else
        {
          end=mid;
        }
      }
      return ans;
    }
    public static boolean check( int mid, int a[][])
    {
      int m=a[0].length;
      int mask[]=new int[1<<m];
      for( int i=0;i<a.length;i++)
      {
        int cur=0;
        for( int j=0;j<a[i].length;j++)
        {
          if(mid<=a[i][j])
          cur^=(1<<j);
        }
        mask[cur]=1;
      }
      for( int i=0;i<(1<<m);i++)
      {
        if(mask[i]>0)
        {
          for( int j=0;j<(1<<m);j++)
          {
            if(mask[j]>0&&(i|j)==((1<<m)-1))
            return true;
          }
        }
      }
    
      return false;
}
}

class Pair implements Comparable<Pair>
{
  long first;int  sec;
  Pair( long first, int sec)
  {
    this.first=first;
    this.sec=sec;
  }
  @Override
  public int compareTo( Pair a)
  {
    return Long.compare( a.first, this.first);
  }
}