human
What is a the Python program you requested given the following:
The numbers 1,   2,   ...,   n ⋅ k are colored with n colors. These colors are indexed by 1,   2,   ...,   n. For each 1 ≤ i ≤ n, there are exactly k numbers colored with color i.

Let [a,   b] denote the interval of integers between a and b inclusive, that is, the set \\{a,   a + 1,   ...,   b\}. You must choose n intervals [a_1,   b_1],   [a_2,   b_2],   ..., [a_n,   b_n] such that: 

  * for each 1 ≤ i ≤ n, it holds 1 ≤ a_i < b_i ≤ n ⋅ k.

  * for each 1 ≤ i ≤ n, the numbers a_i and b_i are colored with color i.

  * each number 1 ≤ x ≤ n ⋅ k belongs to at most \left⌈ (n)/(k - 1) \right⌉ intervals. 


One can show that such a family of intervals always exists under the given constraints.

Input

The first line contains two integers n and k (1 ≤ n ≤ 100, 2 ≤ k ≤ 100) — the number of colors and the number of occurrences of each color.

The second line contains n ⋅ k integers c_1,   c_2,   ...,   c_{nk} (1 ≤ c_j ≤ n), where c_j is the color of number j. It is guaranteed that, for each 1 ≤ i ≤ n, it holds c_j = i for exactly k distinct indices j.

Output

Output n lines. The i-th line should contain the two integers a_i and b_i.

If there are multiple valid choices of the intervals, output any.

Examples

Input

4 3
2 4 3 1 1 4 2 3 2 1 3 4

Output

4 5
1 7
8 11
6 12

Input

1 2
1 1

Output

1 2

Input

3 3
3 1 2 3 2 1 2 1 3

Output

6 8
3 7
1 4

Input

2 3
2 1 1 1 2 2

Output

2 3
5 6

Note

In the first sample, each number can be contained in at most \left⌈ (4)/(3 - 1) \right⌉ = 2 intervals. The output is described by the following picture:


In the second sample, the only interval to be chosen is forced to be [1,   2], and each number is indeed contained in at most \left⌈ (1)/(2 - 1) \right⌉ = 1 interval.

In the third sample, each number can be contained in at most \left⌈ (3)/(3 - 1) \right⌉ = 2 intervals. The output is described by the following picture:

The above is tricky. Write me a correct solution in PYTHON3.
assistant
#Here is the Python program you requested.

def naiveSolve():
    
    
    
    return


def main():
    
    n,k=readIntArr()
    c=readIntArr()
    
    a=[-1]*(n+1)
    b=[-1]*(n+1)
    
    prev=[-1]*(n+1) # previous index of each color
    cnts=[0]*(n*k) # counts of intervals including each c index
    limit=(n+k-2)//(k-1)
    
    start=0 # start idx of current "n/(k-1) batch"
    for i in range(n*k):
        if prev[c[i]]>=start and a[c[i]]==-1:
            a[c[i]]=prev[c[i]]
            b[c[i]]=i
            for j in range(prev[c[i]],i+1):
                cnts[j]+=1
                if cnts[j]==limit: # update start
                    start=i+1
                    # print('i:{} start:{}'.format(i,start))
        else:
            prev[c[i]]=i
    
    for i in range(1,n+1):
        print('{} {}'.format(a[i]+1,b[i]+1))
    
    return

# n=4,k=3,limit=2
# 2 4 3 1 1 4 2 3 2 1 3 4
#       < >
#   <       >
#             <   >
#               <     >

# n=3,k=3,limit=2
# 3 1 2 3 2 1 2 1 3
# <     >
#     <   >
#           <   >

import sys
input=sys.stdin.buffer.readline #FOR READING PURE INTEGER INPUTS (space separation ok)
# input=lambda: sys.stdin.readline().rstrip("\r\n") #FOR READING STRING/TEXT INPUTS.

def oneLineArrayPrint(arr):
    print(' '.join([str(x) for x in arr]))
def multiLineArrayPrint(arr):
    print('\n'.join([str(x) for x in arr]))
def multiLineArrayOfArraysPrint(arr):
    print('\n'.join([' '.join([str(x) for x in y]) for y in arr]))
 
def readIntArr():
    return [int(x) for x in input().split()]
# def readFloatArr():
#     return [float(x) for x in input().split()]
 
def makeArr(defaultValFactory,dimensionArr): # eg. makeArr(lambda:0,[n,m])
    dv=defaultValFactory;da=dimensionArr
    if len(da)==1:return [dv() for _ in range(da[0])]
    else:return [makeArr(dv,da[1:]) for _ in range(da[0])]
 
def queryInteractive(l,r):
    print('? {} {}'.format(l,r))
    sys.stdout.flush()
    return int(input())
 
def answerInteractive(x):
    print('! {}'.format(x))
    sys.stdout.flush()
 
inf=float('inf')
#...