Problem:
Score : 500 points

Problem Statement

You are going to hold a competition of one-to-one game called AtCoder Janken. (Janken is the Japanese name for Rock-paper-scissors.)
N players will participate in this competition, and they are given distinct integers from 1 through N.
The arena has M playing fields for two players. You need to assign each playing field two distinct integers between 1 and N (inclusive).
You cannot assign the same integer to multiple playing fields.
The competition consists of N rounds, each of which proceeds as follows:

For each player, if there is a playing field that is assigned the player's integer, the player goes to that field and fight the other player who comes there.

Then, each player adds 1 to its integer. If it becomes N+1, change it to 1.

You want to ensure that no player fights the same opponent more than once during the N rounds.
Print an assignment of integers to the playing fields satisfying this condition.
It can be proved that such an assignment always exists under the constraints given.

Constraints

1 \leq M

M \times 2 +1 \leq N \leq 200000

Input

Input is given from Standard Input in the following format:

N M

Output

Print M lines in the format below.
The i-th line should contain the two integers a_i and b_i assigned to the i-th playing field.

a_1 b_1
a_2 b_2
:
a_M b_M

Sample Input 1

4 1

Sample Output 1

2 3

Let us call the four players A, B, C, and D, and assume that they are initially given the integers 1, 2, 3, and 4, respectively.

The 1-st round is fought by B and C, who has the integers 2 and 3, respectively. After this round, A, B, C, and D have the integers 2, 3, 4, and 1, respectively.

The 2-nd round is fought by A and B, who has the integers 2 and 3, respectively. After this round, A, B, C, and D have the integers 3, 4, 1, and 2, respectively.

The 3-rd round is fought by D and A, who has the integers 2 and 3, respectively. After this round, A, B, C, and D have the integers 4, 1, 2, and 3, respectively.

The 4-th round is fought by C and D, who has the integers 2 and 3, respectively. After this round, A, B, C, and D have the integers 1, 2, 3, and 4, respectively.

No player fights the same opponent more than once during the four rounds, so this solution will be accepted.

Sample Input 2

7 3

Sample Output 2

1 6
2 5
3 4

Solution in C (GCC 9.2.1) (judge verdict: Runtime Error)

#include <stdio.h>

#if 0
static unsigned int x=123456789;
static unsigned int y=362436069;
static unsigned int z=521288629;
static unsigned int w=88675123;

void seed(unsigned int a,unsigned int b,unsigned int c,unsigned int d) {
	if((a|b|c|d)==0)return;
	x=a;y=b;z=c;w=d;
}

unsigned int randint(void) {
	unsigned int t;
	t=(x^(x<<11));
	x=y;y=z;z=w;
	w=(w^(w>>19))^(t^(t>>8));
	return w;
}

int matukisu[271828];

#if 0
int aru[271828];

int main(void) {
	int N, M;
	int i;
	int gen;
	if (scanf("%d%d", &N, &M) != 2) return 1;
	for (i = 0; i < N; i++) {
		matukisu[i] = i + 1;
	}
	for (gen = 1; ; gen++) {
		int ng = 0;
		for (i = N - 1; i > 0; i--) {
			int pos = (int)(randint() % (i + 1)); /* ごめん */
			int temp = matukisu[pos];
			matukisu[pos] = matukisu[i];
			matukisu[i] = temp;
		}
		for (i = 0; i < M; i++) {
			int tomatu = matukisu[i * 2] - matukisu[i * 2 + 1];
			if (tomatu < 0) tomatu = -tomatu;
			if (aru[tomatu] == gen || aru[N - tomatu] == gen) {
				ng = 1;
				break;
			}
			aru[tomatu] = gen;
			aru[N - tomatu] = gen;
		}
		if (!ng) {
			for (i = 0; i < M; i++) {
				printf("%d %d\n", matukisu[i * 2], matukisu[i * 2 + 1]);
			}
			break;
		}
	}
	return 0;
}
#else

char nyan[114514];

int asumi[114514], iguti[114514];

int main(void) {
	int N, M;
	int i, j;
	if (scanf("%d%d", &N, &M) != 2) return 1;
	for (i = 0; i < M; i++) {
		matukisu[i] = (i + 1) % M + 1;
	}
	for (;;) {
		int is, failed = 0;
#if 0
		for (i = M - 1; i > 0; i--) {
			int pos = (int)(randint() % (i + 1)); /* ごめん */
			int temp = matukisu[pos];
			matukisu[pos] = matukisu[i];
			matukisu[i] = temp;
		}
#endif
		i = 0;
		for (j = 0; j < M; j++) {
			is = i;
			while (nyan[i] || nyan[(i + matukisu[j]) % N]) {
				i++;
				if (i >= N) i = 0;
				if (i == is) {
					failed = 1;
					break;
				}
			}
			if (failed) break;
			nyan[i] = nyan[(i + matukisu[j]) % N] = 1;
			asumi[j] = i + 1;
			iguti[j] = (i + matukisu[j]) % N + 1;
		}
		if (!failed) {
			for (i = 0; i < M; i++) printf("%d %d\n", asumi[i], iguti[i]);
			return 0;
		}
		puts("ERROR");
		return 1;
	}
}
#endif
#else
char aru[114514];

int main(void) {
	int N, M;
	int i, j;
	if (scanf("%d%d", &N, &M) != 2) return 1;
	i = N - 1;
	for (j = 1; j <= M; j++) {
		if (i <= 0) {
			fputs("error!\n", stderr);
			return 1;
		}
		while (aru[i] || aru[N - i]) {
			i--;
			if (i <= 0) {
				fputs("error!\n", stderr);
				return 1;
			}
		}
		aru[j] = aru[j + i] = 1;
		printf("%d %d\n", j, j + i);
		i -= 2;
	}
	return 0;

}
#endif

/*

123**321
23**3211
3**32112
**321123
*321123*

NG

7 3のケース
1 6 -> 5 2
2 5 -> 3 4
3 4 -> 1 6

8 3にすると
1 8 -> 7 1
2 7 -> 5 3
3 6 -> 3 5

5が被るのでNG

1 7 -> 6 2
2 6 -> 4 4
3 5 -> 2 6

NG

1 6 -> 5 3
2 5 -> 3 5
3 4 -> 1 7

NG

1 2 -> 1 7
3 5 -> 2 6
4 7 -> 3 5

9 4のとき

6 7 -> 1 8
1 3 -> 2 7
2 5 -> 3 6
4 9 -> 4 5

*/