description: 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:
  
  <image>
  
  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:
  
  <image>
solution: import static java.lang.Integer.parseInt;
  import static java.lang.Long.parseLong;
  import static java.lang.Math.max;
  import static java.lang.System.exit;
  
  import java.io.BufferedReader;
  import java.io.IOException;
  import java.io.InputStreamReader;
  import java.io.PrintWriter;
  import java.util.StringTokenizer;
  
  public class E {
  
  	static void sortBy(int a[], int n, int v[]) {
  		if (n == 0) {
  			return;
  		}
  		for (int i = 1; i < n; i++) {
  			int j = i;
  			int ca = a[i];
  			int cv = v[ca];
  			do {
  				int nj = (j - 1) >> 1;
  				int na = a[nj];
  				if (cv <= v[na]) {
  					break;
  				}
  				a[j] = na;
  				j = nj;
  			} while (j != 0);
  			a[j] = ca;
  		}
  		int ca = a[0];
  		for (int i = n - 1; i > 0; i--) {
  			int j = 0;
  			while ((j << 1) + 2 + Integer.MIN_VALUE < i + Integer.MIN_VALUE) {
  				j <<= 1;
  				j += (v[a[j + 2]] > v[a[j + 1]]) ? 2 : 1;
  			}
  			if ((j << 1) + 2 == i) {
  				j = (j << 1) + 1;
  			}
  			int na = a[i];
  			a[i] = ca;
  			ca = na;
  			int cv = v[ca];
  			while (j != 0 && v[a[j]] < cv) {
  				j = (j - 1) >> 1;
  			}
  			while (j != 0) {
  				na = a[j];
  				a[j] = ca;
  				ca = na;
  				j = (j - 1) >> 1;
  			}
  		}
  		a[0] = ca;
  	}
  
  	static void solve() throws Exception {
  		int n = scanInt(), k = scanInt(), cnt[] = new int[n], occ[][] = new int[k][n];
  		for (int i = 0; i < n * k; i++) {
  			int c = scanInt() - 1;
  			occ[cnt[c]++][c] = -i;
  		}
  		int idx[] = new int[n];
  		for (int i = 0; i < n; i++) {
  			idx[i] = i;
  		}
  		int p = n, s = (n + k - 2) / (k - 1);
  		int a[] = new int[n], b[] = new int[n];
  		for (int i = 1; i < k; i++) {
  			sortBy(idx, p, occ[i]);
  			int np = max(p - s, 0);
  			for (int j = np; j < p; j++) {
  				int jj = idx[j];
  				a[jj] = -occ[i - 1][jj];
  				b[jj] = -occ[i][jj];
  			}
  			p = np;
  		}
  		for (int i = 0; i < n; i++) {
  			out.println((a[i] + 1) + " " + (b[i] + 1));
  		}
  	}
  
  	static int scanInt() throws IOException {
  		return parseInt(scanString());
  	}
  
  	static long scanLong() throws IOException {
  		return parseLong(scanString());
  	}
  
  	static String scanString() throws IOException {
  		while (tok == null || !tok.hasMoreTokens()) {
  			tok = new StringTokenizer(in.readLine());
  		}
  		return tok.nextToken();
  	}
  
  	static BufferedReader in;
  	static PrintWriter out;
  	static StringTokenizer tok;
  
  	public static void main(String[] args) {
  		try {
  			in = new BufferedReader(new InputStreamReader(System.in));
  			out = new PrintWriter(System.out);
  			solve();
  			in.close();
  			out.close();
  		} catch (Throwable e) {
  			e.printStackTrace();
  			exit(1);
  		}
  	}
  }