在 Code Jam 的秘密算法实验室中，我们投入了无数时间来攻克当今最复杂的问题之一：如何高效地将整数列表按非递减顺序排序。我们仔细研究了经典的冒泡排序算法，并很高兴地宣布推出一种新的变体。

标准冒泡排序算法的基本操作是检查一对相邻数字，如果左侧数字大于右侧数字，则交换这对数字。但我们的算法检查一组三个相邻数字，如果最左侧的数字大于最右侧的数字，则反转整个组。因为我们的算法是“三元组冒泡排序”，所以我们将其简称为 Trouble Sort。

TroubleSort(L): // L 是一个 0-indexed 的整数列表
 let done := false
 while not done:
 done = true
 for i := 0; i < len(L)-2; i++:
 if L[i] > L[i+2]:
 done = false
 reverse the sublist from L[i] to L[i+2], inclusive

例如，对于 $L = 5\ 6\ 6\ 4\ 3$，Trouble Sort 的执行过程如下：

第一轮： 检查 $5\ 6\ 6$，不执行任何操作：$5\ 6\ 6\ 4\ 3$ 检查 $6\ 6\ 4$，发现 $6 > 4$，反转三元组：$5\ 4\ 6\ 6\ 3$ * 检查 $6\ 6\ 3$，发现 $6 > 3$，反转三元组：$5\ 4\ 3\ 6\ 6$

第二轮： 检查 $5\ 4\ 3$，发现 $5 > 3$，反转三元组：$3\ 4\ 5\ 6\ 6$ 检查 $4\ 5\ 6$，不执行任何操作：$3\ 4\ 5\ 6\ 6$ * 检查 $5\ 6\ 6$，不执行任何操作：$3\ 4\ 5\ 6\ 6$

然后第三轮检查这三个三元组，没有执行任何操作，因此算法终止。

我们本期待在夏威夷举行的排序特别兴趣小组会议上展示 Trouble Sort，但我们的一位实习生指出一个问题：Trouble Sort 可能无法正确地对列表进行排序！以列表 $8\ 9\ 7$ 为例。

我们需要您协助进行进一步研究。给定一个包含 $N$ 个整数的列表，确定 Trouble Sort 是否能成功将列表按非递减顺序排序。如果不能，请找出算法结束后第一个排序错误的位置索引（从 0 开始计数）：即算法结束后，第一个大于其后紧邻值的元素索引。

输入格式

输入的第一行给出测试用例的数量 $T$。接下来是 $T$ 个测试用例。每个测试用例包含两行：第一行是一个整数 $N$，表示列表中的数值个数；第二行包含 $N$ 个整数 $V_i$，即列表中的数值。

输出格式

对于每个测试用例，输出一行 Case #x: y，其中 $x$ 是测试用例编号（从 1 开始），如果 Trouble Sort 正确地对列表进行了排序，则 $y$ 为 OK；否则，$y$ 为上述定义的第一个排序错误的索引（从 0 开始计数）。

数据范围

$1 \le T \le 100$。 $0 \le V_i \le 10^9$，对于所有 $i$。 内存限制：1GB。

子任务 1 (可见)

$3 \le N \le 100$。 时间限制（整个测试集）：10 秒。

子任务 2 (隐藏)

$3 \le N \le 10^5$。 时间限制（整个测试集）：20 秒。

说明

请注意，此问题的子任务 2 有大量输入，因此使用非缓冲读取器可能会导致输入读取变慢。此外，请记住某些语言默认具有较小的输入缓冲区。

样例

样例输入 1

2
5
5 6 8 4 3
3
8 9 7

样例输出 1

Case #1: OK
Case #2: 1

样例 #1 与问题描述中的第一个例子类似。Trouble Sort 正确地对该列表进行了排序，因此答案是 OK。

样例 #2 是问题描述中提到的第二个例子。Trouble Sort 未能正确对该列表排序，因为它最终得到的列表为 $7\ 9\ 8$。其中的 $9$ 是列表中第一个大于其后值的元素，因此第一个排序错误的索引为 $1$。