Bohan 正在举办一场派对。由于他非常喜欢葱油饼，他决定从附近的商店购买葱油饼来招待客人。商店出售 $N$ 种不同口味的葱油饼，编号为 $0$ 到 $N - 1$。Bohan 决定每种口味购买 $N$ 个葱油饼，总共购买 $N^2$ 个葱油饼。每个葱油饼在放入各自的袋子之前都被切成了 $K$ 个相同的切片。袋子编号为 $0$ 到 $N^2 - 1$。令 $F[i]$ 表示袋子 $i$ 中葱油饼的口味。

在派对期间，Bohan 邀请了 $N$ 位客人来玩一个游戏。游戏过程如下：

首先，Bohan 挑选了 $N$ 位客人，并将他们带到编号为 $0, 1, \dots, N - 1$ 的房间，使得每个房间恰好有一位客人。其余的客人留在外面，直到游戏结束。所有 $N$ 个房间看起来完全一样，因此客人们无法分辨自己身处哪个房间。

接下来，对于每个房间 $i$ ($0 \le i < N$)，Bohan 进入房间 $i$ 并秘密地告诉客人一个整数 $P[i]$，代表一种禁止食用的口味。他可能会也可能不会告诉客人他们所在的房间号。Bohan 保证 $[P[0], P[1], \dots, P[N - 1]]$ 是 $[0, 1, \dots, N - 1]$ 的一个排列。

然后，游戏进行 $N$ 轮。在第 $i$ 轮中，Bohan 将袋子 $0, 1, \dots, N^2 - 1$ 按顺序一个接一个地带入房间 $i - 1$。当房间 $i - 1$ 中的客人收到袋子 $j$ 时，他们会获知： $F[j]$，即袋子 $j$ 中葱油饼的口味，以及 袋子中剩余的切片数量。

在收到下一个袋子之前，房间 $i - 1$ 中的客人必须决定从当前袋子中吃掉多少片。他们可以吃掉的切片数量取决于具体情况： 如果 $P[i - 1] \neq F[j]$，客人可以从袋子中取出任意数量的切片并吃掉。 如果 $P[i - 1] = F[j]$，客人不允许吃任何切片。

注意，客人们事先并不知道序列 $F[0], F[1], \dots, F[N^2 - 1]$。

在所有 $N$ 轮结束后，外面的客人们会得到这些袋子。看到袋子后，他们会获知每个袋子中葱油饼的口味和剩余的切片数量。利用这些信息，他们必须确定 $P[0], P[1], \dots, P[N - 1]$ 的值。

客人们在游戏开始前可以进行交流。他们也预先知道 $N$ 和 $K$ 的值。你的目标是实现一种策略，使得外面的客人们总是能正确确定 $P[0], P[1], \dots, P[N - 1]$ 的值。

实现细节

你需要实现三个过程。

你应该为房间 $0, 1, \dots, N - 1$ 中的客人实现以下两个过程：

void init(int N, int K, int p, int r)

假设客人身处房间 $i$。

• $N$：葱油饼的口味数量。
• $K$：游戏开始前每个葱油饼的切片数量。
• $p = P[i]$：房间 $i$ 中禁止食用的口味。
• 如果 Bohan 决定告诉客人他们所在的房间，则 $r = i$。否则，$r = -1$。

int strategy(int b, int f, int s)

假设客人身处房间 $i$。

• $b$：当前袋子编号。
• $f = F[b]$：袋子 $b$ 中葱油饼的口味。
• $s$：袋子 $b$ 中剩余的切片数量。
• 此过程应返回一个非负整数 $x$，代表客人决定吃掉的切片数量。
  • 如果 $f \neq P[i]$，则必须满足 $0 \le x \le s$。
  • 如果 $f = P[i]$，则必须满足 $x = 0$。

你应该为外面的客人们实现以下过程：

std::vector<int> guess(int N, int K, std::vector<int> F, std::vector<int> S)

• $N$：葱油饼的口味数量。
• $K$：游戏开始前每个葱油饼的切片数量。
• $F$：一个长度为 $N^2$ 的数组，其中 $F[i]$ 是袋子 $i$ 中葱油饼的口味。
• $S$：一个长度为 $N^2$ 的数组，其中 $S[i]$ 是所有 $N$ 轮结束后袋子 $i$ 中剩余的切片数量。
• 此过程应返回一个长度为 $N$ 的数组 $P$，其中 $P[i]$ 是给房间 $i$ 中客人的数字。

每个测试用例包含 $T$ 个独立的游戏。

在评测过程中，对于 $T$ 个游戏中的每一个，会有 $N + 1$ 个进程。对于每个满足 $0 \le i < N$ 的 $i$，进程 $i$ 代表房间 $i$ 中的客人。进程 $N$ 代表外面的客人。对于每个满足 $0 \le i < N$ 的 $i$，进程 $(i + 1)$ 在进程 $i$ 结束后开始。

对于进程 $0$ 到 $N - 1$： init 被调用恰好一次。 strategy 在 init 之后被调用 $N^2$ 次。 * 保证第 $j$ 次调用时，$b = j - 1$。

对于进程 $N$： * guess 被调用恰好一次。

评测程序可能会交替执行来自不同游戏的进程，但保证每个独立游戏内进程的相对顺序得到保留。

数据范围

• $1 \le T \le 400$。
• $2 \le N \le 30$。
• 所有游戏中 $N^3$ 的总和不超过 $27\,000$。
• $1 \le K \le N$。
• $K \in \{1, 3, N\}$。
• $[P[0], P[1], \dots, P[N - 1]]$ 是 $[0, 1, \dots, N - 1]$ 的一个排列。
• 对于每个满足 $0 \le j < N^2$ 的 $j$，$0 \le F[j] < N$。
• 对于每个满足 $0 \le i < N$ 的 $i$，$i$ 在 $[F[0], F[1], \dots, F[N^2 - 1]]$ 中恰好出现 $N$ 次。
• 评测程序不是自适应的，即 $[P[0], P[1], \dots, P[N - 1]]$ 和 $[F[0], F[1], \dots, F[N^2 - 1]]$ 在第一次调用 init 之前就已经固定。

子任务

样例

考虑 $T = 1$，$N = 2, K = 2, P = [1, 0], F = [1, 0, 0, 1]$ 的情况。

令 $S[i]$ 表示袋子 $i$ 中剩余的切片数量。初始时，$S = [2, 2, 2, 2]$。

假设客人们在游戏开始前确定了以下策略： 对于房间里的客人，如果他们被允许食用当前的葱油饼： 如果当前的葱油饼是他们可以食用的第一个，那么他们将吃掉所有剩余的切片。 否则，他们只会吃掉一片。 对于外面的客人： 如果 $S = [0, 0, 1, 1]$，那么他们会猜测 $P = [1, 0]$。 否则，他们会猜测 $P = [0, 1]$。

游戏过程如下：

首先，评测程序启动代表房间 $0$ 中客人的进程 $0$，并调用 init(2, 2, 1, -1)。 初始化后，评测程序进行以下调用：

输入格式 1

strategy(0, 1, 2)
strategy(1, 0, 2)
strategy(2, 0, 2)
strategy(3, 1, 2)

输出格式 1

0
2
1
0

说明

第一次和第四次调用必须返回 $0$，因为 $P[0] = F[0] = F[3] = 1$。 此进程结束后（第 $1$ 轮结束），$S = [2, 0, 1, 2]$。

接下来，评测程序启动代表房间 $1$ 中客人的进程 $1$，并调用 init(2, 2, 0, -1)。 初始化后，评测程序进行以下调用：

输入格式 2

strategy(0, 1, 2)
strategy(1, 0, 0)
strategy(2, 0, 1)
strategy(3, 1, 2)

输出格式 2

2
0
0
1

说明

注意，第二次和第三次调用必须返回 $0$，因为 $P[1] = F[1] = F[2] = 0$。 此进程结束后（第 $2$ 轮结束），$S = [0, 0, 1, 1]$。

最后，评测程序启动代表外面客人的进程 $2$。评测程序进行以下调用：

输入格式 3

guess(2, 2, [1, 0, 0, 1], [0, 0, 1, 1])

输出格式 3

[1, 0]

外面的客人们猜对了排列。因此，该测试用例被认为是正确的。

注意，这种方法并不总是能让外面的客人们正确猜出排列。

样例评测程序

样例评测程序仅支持每个测试用例进行一场游戏。

输入格式

N K
P[0] P[1] ... P[N-1]
F[0] F[1] ... F[N*N-1]
reveal

• reveal 为 $0$ 或 $1$。
  • 如果 reveal 为 $0$，评测程序将表现为 Bohan 不告诉任何人他们的房间号。
  • 如果 reveal 为 $1$，评测程序将表现为 Bohan 告诉所有人他们的房间号。

如果 guess 返回的数组与 $[P[0], P[1], \dots, P[N - 1]]$ 匹配，样例评测程序将打印：

Accepted

此外，评测程序会按顺序打印所调用的函数以供调试。