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 PYTHON):

Solution:
import sys
import time
from collections import deque


buff = []
cur = 0


def ni():
    global buff, cur
    if cur < len(buff):
        cur = cur + 1
        return buff[cur - 1]
    cur = 0
    data = sys.stdin.readline().split(' ')
    buff = [int(g) for g in data]
    return ni()

def nia(n):
    a = [0]*n
    for i in range(0, n):
        a[i] = ni()
    return a

#
# MOD = 1000000007
#
# def pow(x, m):
#     if m == 0:
#         return 1
#     if m == 1:
#         return x
#     a = pow(x, m / 2)
#     a = a * a % MOD
#     if m % 2 == 1:
#         a = a * x
#     return a % MOD
#
# def inv(x):
#     return pow(x, MOD - 2)
#
# fact = [1]
# ifact = [1]
# for i in range(1, 1020):
#     fact.append(fact[-1] * i % MOD)
#     ifact.append(ifact[-1] * inv(i) % MOD)

#
# def c(n, k):
#     return (fact[n] * ifact[k] % MOD) * ifact[n - k] % MOD
#
# def ct_array(len, max):
#     return c(len + max - 1, max - 1)

a = ni()
m = ni()

data = []
for i in range(0, a):
    data.append(nia(m))

def slv(data, m):
    mask = [-1] * (1 << len(data[0]))
    ttl = (1 << len(data[0])) - 1
    for i in range(0, len(data)):
        mm = 0
        for x in range(0, len(data[i])):
            if(data[i][x] >= m):
                mm = mm + (1 << x)
        mask[mm] = i
    for s in range(0, ttl + 1):
        if mask[s] == -1:
            continue
        for x in range(s, ttl + 1):
            if mask[x] == -1:
                continue
            if (x | s) == ttl:
                return mask[s] + 1, mask[x] + 1
    return None

f = 0
to = 1000000001
while (f < to - 1):
    m = (f + to) / 2
    ans = slv(data, m)
    if ans:
        f = m
    else:
        to = m
a, b = slv(data, f)
print a, b