如果您感到无聊，可以玩的有趣游戏是Diffy Game。这是一款非常简单的单人游戏，可能会消耗大量时间。

Diffy游戏的工作方式如下：从一个非负整数列表开始，在本示例中，我们将使用

3 4 5 8

然后取相邻数字之间的绝对差

 (8)  3   4   5   8
    5   1   1   3

然后重复。重复直到您意识到自己已经进入循环。通常，游戏会从头开始。

3 4 5 8
5 1 1 3
2 4 0 2
0 2 4 2
2 2 2 2
0 0 0 0
0 0 0 0

游戏通常没有目标，您只是在脑海中进行算术而浪费时间。但是，当我乐于玩这款游戏时，我的目标始终是尝试选择一个时间段，并尝试构建一个在该特定时间段内循环的游戏。

并非所有游戏都是周期性的，例如，上面的示例不是周期性的，因为它最终会到达一个全零的游戏，因此永远无法使其回到初始位置。实际上，似乎绝大多数游戏都不是周期性的，因此很少有游戏是稀有的宝石。

给定一个具有特定周期循环的游戏，只需将序列加倍即可制作另一个具有相同周期循环的游戏。例如游戏：

1 0 1

玩法与游戏完全相同：

1 0 1 1 0 1

实际上，我们可以认为两者都是无限重复的游戏：

... 1 0 1 ...

为了应对这一挑战，我们将它们视为一场比赛。

以类似的方式，将整个序列乘以一个常数也将微不足道地保留该时间段，因此我们将再次将相差一个常数的任何两个游戏计算为同一游戏。

无限字符串... 1 0 1 ...和... 0 1 1 ...显然是同一字符串，只移位了一个字符。我们不会将它们视为不同的游戏，但是当一个游戏到达另一个游戏时，在确定游戏的时间段时不会被视为周期的结束。例如：

两场比赛

... 0 0 0 1 0 1 ...  = A
... 0 0 1 1 1 1 ...  = B
... 0 1 0 0 0 1 ...  = A << 4
... 1 1 0 0 1 1 ...  = B << 4
... 0 1 0 1 0 0 ...  = A << 2
... 1 1 1 1 0 0 ...  = B << 2

和

... 0 0 1 0 1 0 ...  = A << 1
... 0 1 1 1 1 0 ...  = B << 1
... 1 0 0 0 1 0 ...  = A << 5
... 1 0 0 1 1 1 ...  = B << 5
... 1 0 1 0 0 0 ...  = A << 3
... 1 1 1 0 0 1 ...  = B << 3

两者均为周期为6的游戏。它们在循环中的任何时候都彼此不共享任何术语（不一样... 1 1 0 ...，... 1 0 1 ...彼此之间也不会相互影响），但由于它们是彼此移位的版本，因此在计数时被视为同一游戏。

反射（或反转）无限字符串会产生基本相同的行为，但不一定会给出相同的周期。考虑例如

... 0 0 0 1 0 0 1 1 0 1 0 1 1 1 1 ...

及其反思

... 1 1 1 1 0 1 0 1 1 0 0 1 0 0 0 ...

如果我们认为下一代将在字符之间的中间点生成：

... 0 0 0 1 0 0 1 1 0 1 0 1 1 1 1 ...
 ... 0 0 1 1 0 1 0 1 1 1 1 0 0 0 1 ...

... 1 1 1 1 0 1 0 1 1 0 0 1 0 0 0 ...
 ... 0 0 0 1 1 1 1 0 1 0 1 1 0 0 1 ...

那么这两个位置都会偏移3.5个元素。但是，我们不认为下一代会以这种半元素偏移量生产，因此一个舍入到4个元素的移位给出一个15的周期，而另一个舍入到3个元素的移位给出一个周期的一个周期之5

因此，即使循环在某种意义上是同构的，我们也认为非对称字符串及其反射是不同的。当然，如果它们构成同一循环的一部分，则仅算作一个循环。

在这些限制下，一些数学运算可以表明，在任何给定的有限周期内，实际上存在有限数量的Diffy循环。而且，每个具有有限周期的无限字符串都是有限字符串的无限重复。

请注意，字符串可以大于或小于句点。例如，存在长度为5的字符串，其周期为15，长度为15的字符串，周期为5。所有周期为19的字符串的长度均为9709。

任务

n通过标准输入法，给定一个n大于1的数字，确定周期为的不同Diffy循环数n。

（在文献中，似乎0通常不将其视为周期性的Diffy游戏。由于这是一个灰色区域，因此我不会要求您解决n = 1）

这是code-golf，因此目标是最大程度地减少源代码中的字节数。

测试用例

2  ->   0
3  ->   1
4  ->   0
5  ->   1
6  ->   1
7  ->   3
8  ->   0
9  ->   4
10 ->   4
11 ->   3
12 ->   5
13 ->   5
14 ->  24
15 ->  77
16 ->   0
17 -> 259
18 -> 259
19 ->  27
20 -> 272
21 -> 811
22 -> 768
23 ->  91
24 -> 340
25 -> 656

提示

所有周期微分博弈将仅包含零和一个常数，这意味着每个周期博弈将与仅由零和一组成的某些微分博弈同构。

Python 2，181字节

n=input()
m=2**n
a=[m]*m
r=lambda i:[i*-~m>>k&m-1 for k in range(n)]
def s(i):
 if a[i]&m:a[i]=i;a[i]=s(min(r(i^i*2)))
 return a[i]
print sum(min(r(i)[1:])>i==s(i)for i in range(m))

在线尝试！

怎么运行的

将二元差分游戏的每一行转换为下一行的规则与将每一列转换为下一列的规则相同。因此，只要在所有规范长度为n的列的图形中找到所有不同的循环就足够了，如果列在字典上小于其所有旋转次数，则该列为“规范”（这自动排除了周期小于n的列）。

与列表示为二进制数0≤ 我 <2 ^Ñ，规则发送我到的最小旋转我 XOR（我 ⋅2）。（如果我是规范的，则其高位为零，我们无需担心此处的环绕。）

因此，我们遍历所有可能的列i，检查规范性，然后重复应用该规则，直到找到我们之前访问过的列为止，并记住第一个此类重新访问的列。每个周期中只有一列将是其自己的第一个重新访问的列。