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 r80p4 {

    private static InputReader sc;

    static class InputReader {
        private final InputStream stream;
        private final byte[] buf = new byte[8192];
        private int curChar, snumChars;
        private SpaceCharFilter filter;

        InputReader(InputStream stream) {
            this.stream = stream;
        }

        int snext() {
            if (snumChars == -1)
                throw new InputMismatchException();
            if (curChar >= snumChars) {
                curChar = 0;
                try {
                    snumChars = stream.read(buf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (snumChars <= 0)
                    return -1;
            }
            return buf[curChar++];
        }

        int nextInt() {
            int c = snext();
            while (isSpaceChar(c)) {
                c = snext();
            }
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = snext();
            }
            int res = 0;
            do {
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = snext();
            } while (!isSpaceChar(c));
            return res * sgn;
        }

        long nextLong() {
            int c = snext();
            while (isSpaceChar(c)) {
                c = snext();
            }
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = snext();
            }
            long res = 0;
            do {
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = snext();
            } while (!isSpaceChar(c));
            return res * sgn;
        }

        String readString() {
            int c = snext();
            while (isSpaceChar(c)) {
                c = snext();
            }
            StringBuilder res = new StringBuilder();
            do {
                res.appendCodePoint(c);
                c = snext();
            } while (!isSpaceChar(c));
            return res.toString();
        }

        String nextLine() {
            int c = snext();
            while (isSpaceChar(c))
                c = snext();
            StringBuilder res = new StringBuilder();
            do {
                res.appendCodePoint(c);
                c = snext();
            } while (!isEndOfLine(c));
            return res.toString();
        }

        boolean isSpaceChar(int c) {
            if (filter != null)
                return filter.isSpaceChar(c);
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        private boolean isEndOfLine(int c) {
            return c == '\n' || c == '\r' || c == -1;
        }

        public interface SpaceCharFilter {
            boolean isSpaceChar(int ch);
        }
    }

    private static ArrayList<ArrayList<Integer>> gph = new ArrayList<>();
    private static int n, m, arr[][], no[];
    private static PrintWriter pw = new PrintWriter(System.out);
    
    private static void gengph(){
        int sz = 1<<m;

        for(int i=0; i<sz; i++)
            gph.add(new ArrayList<>());

        for(int i=0; i<sz; i++){

            for(int j=0; j<m; j++){

                if((i&(1<<j)) > 0)
                    gph.get(i).add(i^(1<<j));
            }

        }
    }

    private static void input(){
        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();
        }

    }

    private static void fill(int mask, int n){
        if(no[mask] != -1)
            return;

        no[mask] = n;
        for(Integer ch : gph.get(mask))
            fill(ch, n);
    }

    private static int[] check(int val){
        no = new int[(1<<m)];
        Arrays.fill(no, -1);

        for(int i=0; i<n; i++){
            int mask = 0, req = 0;
            for(int j=0; j<m; j++){
                if(arr[i][j] >= val)
                    mask = mask|(1<<j);
                else
                    req = req|(1<<j);
            }
            fill(mask, i);

            if(no[req] != -1){
                int ans[] = {no[req], i};
                return ans;
            }
        }

        return null;
    }

    private static void bs(){
        int low = 0, high = (int)1e9;

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

            int res[] = check(mid);

            if(res == null)
                high = mid - 1;
            else
                low = mid + 1;
        }

        int ans[] = check(high);

        pw.println(+(ans[0]+1)+" "+(ans[1]+1));
    }

    public static void main(String args[]){
        sc = new InputReader(System.in);

        input();
        gengph();
        bs();

        pw.flush();
        pw.close();
    }
}