CUDA矩阵乘法的优化

2021-10-08:在cuda@11.2.2、CUTLASS@2.7.0下重新做了这个实验。

因为超算队的新大三队员正在做 CUDA 矩阵乘法的作业,因此给他们安排了一期关于 CUDA 的内培。重看了一年前我在刚学 CUDA 时候做的实验,有些辣眼睛,那重新做一遍这个实验叭

本文基于 CUDA 实现了稠密矩阵乘法过程 $C\to\alpha AB+\beta C$,并在 $A,B,C\in\reals^{2^{13}\times 2^{13}}$ 大小的测试数据上与 cuBLAS 等常见实现进行性能比较。最终在没有内嵌汇编的情况下达到了 NVIDIA V100 GPU 理论性能的 92.1%(14.46 TFLOPS / 15.7 TFLOPS)。同情况下 cuBLAS 性能为 97.0%(15.23 TFLOPS / 15.7 TFLOPS),CUTLASS 库性能为 92.6%(14.54 TFLOPS / 15.7 TFLOPS)。

参考资料

实验环境

实验在广州超算中心 TH-2K 集群的一个 gpu_v100 节点上进行。相关硬件环境为:

  • NVLINK 接口的 NVIDIA V100 显卡 x4,单卡拥有:
    • 5120 个 CUDA 核心
    • 5120 个 FP32 单元
    • 2560 个 FP64 单元
    • 理论单精度算力 $1530\text{MHz}\times5120\text{FP32 units}\times 2\approx 15.7\text{TFLOPS}$

相关软件环境为:

  • Centos@7.6
    • gcc@7.5.0
      • cuda@10.1.243%gcc@7.5.0
      • cmake@3.18.4%gcc@7.5.0
      • python@3.8.6%gcc@7.5.0

实验过程

这里我只放出自己优化矩阵乘法过程的示例,相关核函数代码都放在 namespace wuk 中。所有矩阵按照 cuBLAS 的习惯,按照列优先方式存储,即 C[i + j * ldc] 表示 $C$ 第 $i$ 行 $j$ 列的元素;这与 C 语言在 CPU 的默认方式(行优先)恰好相反,相关原因会在下文中解释。当然行优先列优先的表示方式之间可以通过一次矩阵转置来调整,因此在应用于实际问题上的时候其实不是一个很让人困扰的问题。

gemm_32x32_v0

严格意义上来说,我是从 gemm_32x32_v1 版本开始优化的,但是 v0 版本仍然可以作为和 v1 版本的对比存在。在 gemm_32x32_v0 版本中,32x32 代表一个 block 计算答案矩阵 $C$ 中一个 $32\times 32$ 的子矩阵的结果(下同)。

在这个版本中,每个线程负责计算答案矩阵的一个元素,各自需要读取 $A$ 矩阵的一行和 $B$ 矩阵的一列,同一个 block 的线程之间没有发生通信。线程的 x 维度对应 $C$ 的列维度,线程的 y 维度对应 $C$ 的行维度。

这个版本的运行时间为 4687.326172 ms,达到的计算效率为 2.345712e+11 FLOPS,甚至没有发挥到理论算力的 1.5%。

gemm_32x32_v1

v1 版本在 v0 版本的基础上调整了线程到 $C$ 矩阵的映射关系,使得线程的 x 维度对应 $C$ 的行维度,线程的 y 维度对应 $C$ 的列维度。对于已经有过一些 CUDA 经验的同学来说,很容易知道这样做有助于触发 GPU 的合并访存,将连续的对 global memory 的读写操作合并成一次操作。

gemm-tile-structure

这个还没有分块的矩阵乘法运行时间为 638.216309 ms,几乎已经达到了 Alcanderian 学长以前给大家内培时分块矩阵的 614.487305 ms。原因在哪里?我翻了一下之前的代码,发现学长的代码为了兼容块大小不是 32 的整数倍的情况下的运算时,是通过读取 $A,B,C$ 矩阵时判断 if (a_ir < M && a_ic < K) 等条件实现的,但是这样做显然会带来大量的分支判断,因为 GPU 的分支预测做的远没有 CPU 好,所以带来严重的性能下降。而我在核函数的开始就判断了这个 block 的计算会不会超过矩阵的边界,如果会超过的话则向前移动 $A,B,C$ 的指针,这样就避免了在循环内部判断越界的问题。

当然这样做也存在问题。首先,核函数不能用于任意维度小于 $32$ 的矩阵乘法;但是此时我们完全可以使用矩阵向量乘甚至 CPU 上的 blas 来代替。此外,这个方法也不能解决 $k\mod 32\neq 0$ 的情况,不过也可以靠额外填充 0 实现(为什么不在 $m,n$ 两个维度上填 $0$ 呢?因为填充 $0$ 代码上的开销明显大于我直接移动指针)。最后,这样做也存在部分位置上的元素被读写两次的问题,因此实际上只能用来做 $\beta=0$ 的示例!

gemm_32x32_v2

这个版本是在我写这篇文章时候偶然得到的。相较于 v1 版本,我仅通过把代码中对 threadIdx.x 的访问提前用变量存起来:idx = threadIdx.x,就使得运行时间缩减到了 462.786011 ms,相较于前一个版本提高了 38.9% 的效率!

起先我以为这样的原因是,threadIdx.x 这个变量不是直接存在寄存器里的,每次在使用的时候都要重新加载进寄存器带来了运行时的开销。但是通过检查生成的 PTX ISA 来看并不是这样,二者均在循环前便加载进了寄存器的。那么让我们结合 PTX ISA 解释一下这个问题。

以下是 gemm_32x32_v2 中核心矩阵乘法过程的 PTX ISA

BB8_13:
	cvt.s64.s32	%rd52, %r58;
	add.s64 	%rd53, %rd52, %rd12;
	shl.b64 	%rd54, %rd53, 2;
	add.s64 	%rd55, %rd64, %rd54;
	ld.global.f32 	%f22, [%rd68];
	ld.global.f32 	%f23, [%rd55];
	fma.rn.f32 	%f24, %f23, %f22, %f40;
	add.s64 	%rd56, %rd55, %rd15;
	ld.global.f32 	%f25, [%rd68+4];
	ld.global.f32 	%f26, [%rd56];
	fma.rn.f32 	%f27, %f26, %f25, %f24;
	add.s64 	%rd57, %rd56, %rd15;
	ld.global.f32 	%f28, [%rd68+8];
	ld.global.f32 	%f29, [%rd57];
	fma.rn.f32 	%f30, %f29, %f28, %f27;
	add.s64 	%rd58, %rd57, %rd15;
	ld.global.f32 	%f31, [%rd68+12];
	ld.global.f32 	%f32, [%rd58];
	fma.rn.f32 	%f40, %f32, %f31, %f30;
	add.s64 	%rd68, %rd68, 16;
	add.s32 	%r58, %r58, %r13;
	add.s32 	%r57, %r57, 4;
	setp.lt.s32	%p8, %r57, %r19;
	@%p8 bra 	BB8_13;

而它在 gemm_32x32_v1 中被展开成了这样:

BB7_12:
	mad.lo.s32 	%r49, %r63, %r17, %r6;
	cvt.u64.u32	%rd44, %r49;
	add.s64 	%rd45, %rd44, %rd12;
	shl.b64 	%rd46, %rd45, 2;
	add.s64 	%rd47, %rd81, %rd46;
	add.s32 	%r50, %r13, %r63;
	cvt.u64.u32	%rd48, %r50;
	add.s64 	%rd49, %rd48, %rd13;
	shl.b64 	%rd50, %rd49, 2;
	add.s64 	%rd51, %rd83, %rd50;
	ld.global.f32 	%f22, [%rd51];
	ld.global.f32 	%f23, [%rd47];
	fma.rn.f32 	%f24, %f23, %f22, %f40;
	add.s32 	%r51, %r63, 1;
	mad.lo.s32 	%r52, %r51, %r17, %r6;
	cvt.u64.u32	%rd52, %r52;
	add.s64 	%rd53, %rd52, %rd12;
	shl.b64 	%rd54, %rd53, 2;
	add.s64 	%rd55, %rd81, %rd54;
	add.s32 	%r53, %r13, %r51;
	cvt.u64.u32	%rd56, %r53;
	add.s64 	%rd57, %rd56, %rd13;
	shl.b64 	%rd58, %rd57, 2;
	add.s64 	%rd59, %rd83, %rd58;
	ld.global.f32 	%f25, [%rd59];
	ld.global.f32 	%f26, [%rd55];
	fma.rn.f32 	%f27, %f26, %f25, %f24;
	add.s32 	%r54, %r63, 2;
	mad.lo.s32 	%r55, %r54, %r17, %r6;
	cvt.u64.u32	%rd60, %r55;
	add.s64 	%rd61, %rd60, %rd12;
	shl.b64 	%rd62, %rd61, 2;
	add.s64 	%rd63, %rd81, %rd62;
	add.s32 	%r56, %r13, %r54;
	cvt.u64.u32	%rd64, %r56;
	add.s64 	%rd65, %rd64, %rd13;
	shl.b64 	%rd66, %rd65, 2;
	add.s64 	%rd67, %rd83, %rd66;
	ld.global.f32 	%f28, [%rd67];
	ld.global.f32 	%f29, [%rd63];
	fma.rn.f32 	%f30, %f29, %f28, %f27;
	add.s32 	%r57, %r63, 3;
	mad.lo.s32 	%r58, %r57, %r17, %r6;
	cvt.u64.u32	%rd68, %r58;
	add.s64 	%rd69, %rd68, %rd12;
	shl.b64 	%rd70, %rd69, 2;
	add.s64 	%rd71, %rd81, %rd70;
	add.s32 	%r59, %r13, %r57;
	cvt.u64.u32	%rd72, %r59;
	add.s64 	%rd73, %rd72, %rd13;
	shl.b64 	%rd74, %rd73, 2;
	add.s64 	%rd75, %rd83, %rd74;
	ld.global.f32 	%f31, [%rd75];
	ld.global.f32 	%f32, [%rd71];
	fma.rn.f32 	%f40, %f32, %f31, %f30;
	add.s32 	%r63, %r63, 4;
	setp.lt.s32	%p8, %r63, %r16;
	@%p8 bra 	BB7_12;

可以看到,前者由编译器做了大小为 4 的循环展开,后者由编译器做了大小为 5 的循环展开。但即使排除这一点,前者平均 6 条指令中有 1 次 fma (4/24)计算,后者则只有 5/58。因此结论单纯就是,cuda@10.1.243 没有为前者生成很好的 ISA ,在 ISA 编译到后端代码的时候也没有很好的优化这一过程。很可惜不能随便升级超算中心节点上安装的 418.67 版本驱动,其最高只支持 cuda@10.1.243。因此不能验证最新的 cuda@11.1.0 是否解决了这一问题。

此外我也注意到,这个不分块版本的矩阵乘法已经比很多实现比较一般的分块矩阵乘法要快了。原因是 v100 上的显存非常奢侈的使用了 HBM2,相较于网上其他矩阵乘法教程中使用的显卡(大多是 GDDR5 显存)已经强大了不少,一定程度上减小了访存问题对性能的影响程度。

gemm_32x32_v3

这个版本是最经典的 CUDA 分块矩阵乘法,在互联网上能找到的大部分矩阵乘法实现都是这样做的。

nyE43F1oTbq7fugUOY9ZdwpGvH

如上图(当然图上为了方便显示只画了 $3\times3$ 分块,实际上是 $32\times 32$ 分块),可以把矩阵分块之后进行计算,这样分过块的子矩阵可以通过读进更快的 shared memory,从而使对 global memoey 的访问流量减少到原先的 $\frac{1}{32}$。随后 block 内的每个线程再分别读子矩阵的一行/一列元素,如下图。

WJrGFMzjYp41Vihty3ceHCqNul

最后运行时间反而退步到了 1565.291992 ms,说明不合理的使用 shared memory 反而会造成严重的性能问题。相较于学长的 cuda_kernel_sgemm_1,提升的地方来自于把矩阵边界的判断从循环内移动到了循环外面。

gemm_32x32_v4

v4 版本在 v3 版本的基础上考虑了 bank conflict 的影响。shared memory 有 32 个 bank,在声明 shared memory 的时候可以通过这样 __shared__ T sA[TILE_WIDTH][TILE_WIDTH | 1]; 的 trick 避免 bank conflict(也可以参照 Alcanderian 学长的 cuda_kernel_sgemm_2cuda_kernel_sgemm_3)。

最后的运行时间为 326.478821 ms,应该是这个经典分块算法能够达到的一个比较好的效果了,但是有效算力只达到了理论算力的 21.7%(3.37 TFLOPS/15.7 FLOPS)。这是由两个原因导致的。一方面,分块矩阵乘法占用了大量的 shared memory,这会限制 block 中活跃线程的数量;另一方面,在编译出来的 PTX ISA 代码中(见下)也可以看到,平均每个有效的 fma 指令要伴随两条对 shared memory 的取指令 ld.shared,那么无形中就浪费了 $\frac{2}{3}$ 的指令吞吐。

	ld.shared.f32 	%f10, [%r9];
	ld.shared.f32 	%f11, [%r8];
	fma.rn.f32 	%f12, %f11, %f10, %f109;

gemm_32x32_v5

v5 版本致力于改善 v4 版本的两条问题,原理基于 PTX ISA 文档中的以下内容

Limited-length vector types are supported. Vectors of length 2 and 4 of any non-predicate fundamental type can be declared by prefixing the type with .v2 or .v4. Vectors must be based on a fundamental type, and they may reside in the register space. Vectors cannot exceed 128-bits in length; for example, .v4.f64 is not allowed. Three-element vectors may be handled by using a .v4 vector, where the fourth element provides padding. This is a common case for three-dimensional grids, textures, etc.

如上可以发现,显卡支持单线程对不超过 128-bits 的向量类型进行加速操作,那么我们就可以使用内置的 float4 或者 double2 类型来加速访存过程。访存过程主要有四个:对 global memory 的读操作 ld.global、对 global memory 的写操作 st.global 、对 shared memory 的读操作 ld.shared、对 shared memory 的写操作 st.shared。通过向量化加速,我们最多可以同时完成四个 float 元素的访存操作,那我们让一个线程完成原先行维度上四个相邻线程的计算任务即可,如下图(图上是三个线程)。

tBDGZnCFwSlVJuypEkXv1bmNHO

这个版本的运行时间达到了 203.944931 ms,相对于前一个版本提高了 37%,效果还是非常明显的!检查编译出来的 PTX ISA,可以发现其中确实使用了向量化指令(如 ld.shared.v4.f32),同时核心计算区域里每条有效指令 fma 占的比重已经达到了 $\frac{2}{3}$。

	ld.shared.v4.f32 	{%f68, %f69, %f70, %f71}, [%r58+128];
	ld.shared.f32 	%f76, [%r60+4224];
	fma.rn.f32 	%f77, %f76, %f68, %f64;
	fma.rn.f32 	%f78, %f76, %f69, %f65;
	fma.rn.f32 	%f79, %f76, %f70, %f66;
	fma.rn.f32 	%f80, %f76, %f71, %f67;

此外还有两个值得注意的小细节:

  1. s_B 是行优先的方式存储的,这是为了访问 global memory 的过程可以使用 ld.global.v4.f32 加速,而访问 shared memory 的过程因为开销比较小被战略性放弃了,只能使用单个 ld.shared.f32 实现(因为物理存储上不连续)。
  2. 如下,在这段代码中我将下次要读取的内容先预加载进寄存器,然后再进行矩阵乘法运算。如果我们把这段代码移动到矩阵乘法之后再进行的话也完全没有问题,但是会导致性能上的明显下降。这是因为单次访存代码的时间很长,很容易导致指令的流水线阻塞。

    if (l + 32 < k)
    {
    	A += lda << 5;
    	B += 32;
    	resA = *(Tv *)&A[((idx * TvSize) & 31) + ((idx * TvSize) >> 5) * lda];
    	resB = *(Tv *)&B[((idx * TvSize) & 31) + ((idx * TvSize) >> 5) * ldb];
    }
    

gemm_64x64

v5 版本在 v4 版本上优化了有效指令吞吐量到 $\frac{2}{3}$,但是这仍然不是很让人满意的水平;同时对于 s_B 的访问也没有用到向量化加速,让强迫症的我略有不爽;于是考虑一个线程完成一个 $4\times 4$ 小矩阵的计算。当然此时如果一个 block 只计算一个 $32\times 32$ 的子矩阵,那么一个 block 只需要启动 $64$ 个线程,会产生很大的浪费。于是我们让一个 block 对应到原先四个 block 的工作量,即 $64\times 64$,这样仍然需要 256 个线程完成块内计算。

值得注意的是,shared memory 使用的大小是有限制的。我使用的 V100 显卡有着 7.0 的 Compute Capability,单个 block 至多可以使用 96KB 的 shared memory但是超过 48 KB 的大小只能在运行时动态分配。shared memory 实际上就是可编程的 L1 Cache,其大小可以通过 cudaDeviceSetCacheConfig 调整;shared memory 过大的时候可用的 L1 Cache 就变少了,同样会影响性能。因此,为了方便和其它版本代码进行比较,此处我暂不使用更大的 shared memory,仍然只用 2048 个 float,需要 8KB。这意味着我们需要再次调整对 $A,B$ 矩阵的分块策略,每次读入一个 $64\times 16$ 的 $A$ 矩阵、$16\times 64$ 的 $B$ 矩阵。

分析一下此时的 SM 占有情况:每个 SM 有 96KB 的 shared memory,而每个 block 使用了 8KB,于是每个 SM 中最多分到 12 个 block;12 个 block 一共 3072 线程,大于每个 SM 的最大驻留线程数 2048,因此 SM 占有率是满的。

最终运行时间达到了 83.388191 ms,达到了理论算力的 84%,效果非常显著!再检查一下生成的 PTX ISA 文件,可以发现有效指令吞吐量已经达到了 $\frac{8}{9}$,也符合预期!

	ld.shared.v4.f32 	{%f147, %f148, %f149, %f150}, [%r79];
	ld.shared.v4.f32 	{%f155, %f156, %f157, %f158}, [%r80+4096];
	fma.rn.f32 	%f163, %f147, %f155, %f294;
	fma.rn.f32 	%f164, %f147, %f156, %f293;
	fma.rn.f32 	%f165, %f147, %f157, %f292;
	fma.rn.f32 	%f166, %f147, %f158, %f291;
	fma.rn.f32 	%f167, %f148, %f155, %f295;
	fma.rn.f32 	%f168, %f148, %f156, %f296;
	fma.rn.f32 	%f169, %f148, %f157, %f297;
	fma.rn.f32 	%f170, %f148, %f158, %f298;
	fma.rn.f32 	%f171, %f149, %f155, %f299;
	fma.rn.f32 	%f172, %f149, %f156, %f300;
	fma.rn.f32 	%f173, %f149, %f157, %f301;
	fma.rn.f32 	%f174, %f149, %f158, %f302;
	fma.rn.f32 	%f175, %f150, %f155, %f303;
	fma.rn.f32 	%f176, %f150, %f156, %f304;
	fma.rn.f32 	%f177, %f150, %f157, %f305;
	fma.rn.f32 	%f178, %f150, %f158, %f306;

gemm_128x128

本来我的优化已经到头了,但是又看到了来自 fynv/optimal_sgemm_cuda_c 的代码。原作者水平很高,但是可以看出他也是按照这个顺序去优化的。他是在 $64\times 64$ 的基础上,继续让每个 block 做四个 block 的任务,暴力实现了一个 128x128 的 kernel。此外还做了一些别的 trick,例如使用了两个 Buffer 来回切换,从而省掉一次 __syncthreads()

那么真的没有继续提升的空间了吗?为了在内培上保住面子,我决定在此基础上再挤出一点点水来。从生成的 PTX ISA 来看,这个循环 for (int j = 0; j < 8; ++j) 并没有被完全展开。于是考虑使用 #pragma unroll(4) 对其进行展开。值得注意的是,在 #pragma unroll(8) 时反而带来了性能下降,猜测是因为代码段太长导致了 Cache Miss。

最终运行时间达到了 76.045088 ms,达到了理论算力的 92.1%。再检查一下生成的 PTX ISA 文件,可以发现有效指令吞吐量已经达到了 $\frac{16}{17}$。

	ld.shared.v4.f32 	{%f531, %f532, %f533, %f534}, [%r63+512];
	ld.shared.v4.f32 	{%f539, %f540, %f541, %f542}, [%r63+768];
	ld.shared.v4.f32 	{%f547, %f548, %f549, %f550}, [%r65+4608];
	ld.shared.v4.f32 	{%f555, %f556, %f557, %f558}, [%r65+4864];
	fma.rn.f32 	%f563, %f531, %f547, %f467;
	fma.rn.f32 	%f564, %f532, %f547, %f468;
	fma.rn.f32 	%f565, %f533, %f547, %f469;
	fma.rn.f32 	%f566, %f534, %f547, %f470;
	fma.rn.f32 	%f567, %f531, %f548, %f471;
	fma.rn.f32 	%f568, %f532, %f548, %f472;
	fma.rn.f32 	%f569, %f533, %f548, %f473;
	fma.rn.f32 	%f570, %f534, %f548, %f474;
	fma.rn.f32 	%f571, %f531, %f549, %f475;
	fma.rn.f32 	%f572, %f532, %f549, %f476;
	fma.rn.f32 	%f573, %f533, %f549, %f477;
	fma.rn.f32 	%f574, %f534, %f549, %f478;
	fma.rn.f32 	%f575, %f531, %f550, %f479;
	fma.rn.f32 	%f576, %f532, %f550, %f480;
	fma.rn.f32 	%f577, %f533, %f550, %f481;
	fma.rn.f32 	%f578, %f534, %f550, %f482;
	fma.rn.f32 	%f579, %f531, %f555, %f483;
	fma.rn.f32 	%f580, %f532, %f555, %f484;
	fma.rn.f32 	%f581, %f533, %f555, %f485;
	fma.rn.f32 	%f582, %f534, %f555, %f486;
	fma.rn.f32 	%f583, %f531, %f556, %f487;
	fma.rn.f32 	%f584, %f532, %f556, %f488;
	fma.rn.f32 	%f585, %f533, %f556, %f489;
	fma.rn.f32 	%f586, %f534, %f556, %f490;
	fma.rn.f32 	%f587, %f531, %f557, %f491;
	fma.rn.f32 	%f588, %f532, %f557, %f492;
	fma.rn.f32 	%f589, %f533, %f557, %f493;
	fma.rn.f32 	%f590, %f534, %f557, %f494;
	fma.rn.f32 	%f591, %f531, %f558, %f495;
	fma.rn.f32 	%f592, %f532, %f558, %f496;
	fma.rn.f32 	%f593, %f533, %f558, %f497;
	fma.rn.f32 	%f594, %f534, %f558, %f498;
	fma.rn.f32 	%f595, %f539, %f547, %f499;
	fma.rn.f32 	%f596, %f540, %f547, %f500;
	fma.rn.f32 	%f597, %f541, %f547, %f501;
	fma.rn.f32 	%f598, %f542, %f547, %f502;
	fma.rn.f32 	%f599, %f539, %f548, %f503;
	fma.rn.f32 	%f600, %f540, %f548, %f504;
	fma.rn.f32 	%f601, %f541, %f548, %f505;
	fma.rn.f32 	%f602, %f542, %f548, %f506;
	fma.rn.f32 	%f603, %f539, %f549, %f507;
	fma.rn.f32 	%f604, %f540, %f549, %f508;
	fma.rn.f32 	%f605, %f541, %f549, %f509;
	fma.rn.f32 	%f606, %f542, %f549, %f510;
	fma.rn.f32 	%f607, %f539, %f550, %f511;
	fma.rn.f32 	%f608, %f540, %f550, %f512;
	fma.rn.f32 	%f609, %f541, %f550, %f513;
	fma.rn.f32 	%f610, %f542, %f550, %f514;
	fma.rn.f32 	%f611, %f539, %f555, %f515;
	fma.rn.f32 	%f612, %f540, %f555, %f516;
	fma.rn.f32 	%f613, %f541, %f555, %f517;
	fma.rn.f32 	%f614, %f542, %f555, %f518;
	fma.rn.f32 	%f615, %f539, %f556, %f519;
	fma.rn.f32 	%f616, %f540, %f556, %f520;
	fma.rn.f32 	%f617, %f541, %f556, %f521;
	fma.rn.f32 	%f618, %f542, %f556, %f522;
	fma.rn.f32 	%f619, %f539, %f557, %f523;
	fma.rn.f32 	%f620, %f540, %f557, %f524;
	fma.rn.f32 	%f621, %f541, %f557, %f525;
	fma.rn.f32 	%f622, %f542, %f557, %f526;
	fma.rn.f32 	%f623, %f539, %f558, %f527;
	fma.rn.f32 	%f624, %f540, %f558, %f528;
	fma.rn.f32 	%f625, %f541, %f558, %f529;
	fma.rn.f32 	%f626, %f542, %f558, %f530;

总结

可以发现,越是优化到后面,代码中 for 循环的层级就越多,这与 CUTLASS 库的实现理念 非常接近。究其原因,还是因为 CUDA 在设计上存在明显的层次性结构。如下图,当然我们这里并没有用到 warp-level GEMM,因为 wmma 指令只能作用于半精度矩阵乘法。

complete-hierarchy

那么最后,矩阵乘法做到这里是不是就到头了呢?我觉得未必。例如,单个 block 至多可以使用 96KB 的 shared memory,单个 thread 至多可以使用 255 个 32-bit 寄存器(256 线程下,因为每个 block 只能有 64K 寄存器),因此我觉得还可以通过增大分块大小继续压榨显卡的性能,而且还可以考虑非正方形分块、分块边长不是 2 的整数幂的情况;再比如某些时候的通信可以直接通过 warp shuffle 指令完成,不需要通过 shared memory;最后,如果认真读过上面所有优化过程的同学可以发现,如果对 B 矩阵提前做一个转置,同样可以使性能获得略微提升(因为此时 s_B 不需要转置存放了)。再进一步就不可避免的要进入汇编优化代码的领域了,我们需要:调整每条指令的顺序以获得最大的有效指令吞吐;调整寄存器的映射,最小化寄存器的 bank conflict(不错,寄存器也是有 bank 的!);调度好每个寄存器资源,避免不必要的浪费,从而获得更大的分块。

此外 v2 版本被发现的过程也说明 CUDA 的编译器确实没有那么智能,甚至可以说一份高性能的 CUDA 代码可能第一眼让人读上去感觉非常丑。CUDA 虽然目前已被市场证明是比较成功的 GPGPU 编程语言(甚至其老对手 AMD 也几乎抛弃了半死不活的 OpenCL,推出了镜像级复刻的 ROCm 和 HIP,甚至有一个一键转换的 CUDA to HIP 脚本),但是给我的感觉还是设计的上手门槛高了一些,想写出高性能的 CUDA 代码并不能像写 CPU 上的 C 语言一样随心所欲,而需要了解更多硬件上的设计细节。当然了,虽然号称代码里没有使用汇编,但是要想说明优化的效果还是应该结合 PTX ISA 甚至更进一步的 SASS 汇编。

想来半年前在做先导杯的时候只实现到 v5 版本的矩阵乘法就放弃了,半年后自己终于有空完整梳理一遍,写到这里让我觉得已经学到了很多东西。那就完结撒花叭~

源代码

slurm-696755.out

实验的结果。

+-----------------------------------------------------------------------------+
| NVIDIA-SMI 460.73.01    Driver Version: 460.73.01    CUDA Version: 11.2     |
|-------------------------------+----------------------+----------------------+
| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |
| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |
|                               |                      |               MIG M. |
|===============================+======================+======================|
|   0  Tesla V100-SXM2...  Off  | 00000000:8A:00.0 Off |                    0 |
| N/A   37C    P0    38W / 300W |      0MiB / 16160MiB |      0%      Default |
|                               |                      |                  N/A |
+-------------------------------+----------------------+----------------------+
|   1  Tesla V100-SXM2...  Off  | 00000000:8B:00.0 Off |                    0 |
| N/A   32C    P0    38W / 300W |      0MiB / 16160MiB |      0%      Default |
|                               |                      |                  N/A |
+-------------------------------+----------------------+----------------------+
|   2  Tesla V100-SXM2...  Off  | 00000000:B3:00.0 Off |                    0 |
| N/A   32C    P0    38W / 300W |      0MiB / 16160MiB |      0%      Default |
|                               |                      |                  N/A |
+-------------------------------+----------------------+----------------------+
|   3  Tesla V100-SXM2...  Off  | 00000000:B4:00.0 Off |                    0 |
| N/A   34C    P0    38W / 300W |      0MiB / 16160MiB |      0%      Default |
|                               |                      |                  N/A |
+-------------------------------+----------------------+----------------------+
                                                                               
+-----------------------------------------------------------------------------+
| Processes:                                                                  |
|  GPU   GI   CI        PID   Type   Process name                  GPU Memory |
|        ID   ID                                                   Usage      |
|=============================================================================|
|  No running processes found                                                 |
+-----------------------------------------------------------------------------+
clocks.max.sm [MHz]
1530 MHz
cublasSgemm: 71.745537 ms, 1.532516e+13 FLOPS.
CutlassSgemmNN: 79.368195 ms, 1.385330e+13 FLOPS.
Alcanderian::cuda_kernel_sgemm_1: 2114.584473 ms, 5.199658e+11 FLOPS.
Alcanderian::cuda_kernel_sgemm_2: 611.853333 ms, 1.797018e+12 FLOPS.
Alcanderian::cuda_kernel_sgemm_3: 2115.368896 ms, 5.197730e+11 FLOPS.
fynv::g_fgemm: 77.543427 ms, 1.417930e+13 FLOPS.
wuk::gemm_32x32_v0: 4670.738281 ms, 2.354042e+11 FLOPS.
wuk::gemm_32x32_v1: 512.018433 ms, 2.147406e+12 FLOPS.
wuk::gemm_32x32_v2: 458.981384 ms, 2.395547e+12 FLOPS.
wuk::gemm_32x32_v3: 1565.510620 ms, 7.023342e+11 FLOPS.
wuk::gemm_32x32_v4: 324.259827 ms, 3.390835e+12 FLOPS.
wuk::gemm_32x32_v5: 203.590652 ms, 5.400600e+12 FLOPS.
wuk::gemm_64x64: 80.806915 ms, 1.360665e+13 FLOPS.
wuk::gemm_128x128: 76.198914 ms, 1.442949e+13 FLOPS.

gemm.th2k.slurm

#!/bin/bash
#SBATCH -J WuK
#SBATCH -p gpu_v100
#SBATCH -N 1
#SBATCH --exclusive

DIR=/GPUFS/sysu_hpcedu_302/WuK

cd $DIR

if [[ ! -f cutlass-2.7.0.zip ]]; then
    curl -o cutlass-2.7.0.zip https://github.com/NVIDIA/cutlass/archive/v2.7.0.zip
    unzip cutlass-2.7.0.zip
fi

module purge
module load gcc/6.5.0
module load CUDA/11.2

nvidia-smi
nvidia-smi --query-gpu=clocks.max.sm --format=csv --id=0

nvcc -arch=sm_70 -Icutlass-2.7.0/include -Icutlass-2.7.0/tools/util/include -ptx -o gemm.ptx gemm.cu
nvcc -arch=sm_70 -Icutlass-2.7.0/include -Icutlass-2.7.0/tools/util/include -lcublas -run -o gemm gemm.cu

gemm.cu

#include <cstdio>
#include <cublas_v2.h>
#include <cuda_runtime.h>
#include <cutlass/gemm/device/gemm.h>
#include <cutlass/util/host_tensor.h>
#include <cutlass/util/reference/device/tensor_fill.h>
#include <functional>

///////////////////////////////////////////////////////////////////////////////////////////////////
//
// This function defines a CUTLASS GEMM kernel instantiation, constructs its
// parameters object, and launches it on the CUDA device.
//
///////////////////////////////////////////////////////////////////////////////////////////////////

/// Define a CUTLASS GEMM template and launch a GEMM kernel.
cudaError_t CutlassSgemmNN(int M, int N, int K, float alpha, float const *A,
                           int lda, float const *B, int ldb, float beta,
                           float *C, int ldc) {

  // Define type definition for single-precision CUTLASS GEMM with column-major
  // input matrices and 128x128x8 threadblock tile size (chosen by default).
  //
  // To keep the interface manageable, several helpers are defined for plausible
  // compositions including the following example for single-precision GEMM.
  // Typical values are used as default template arguments. See
  // `cutlass/gemm/device/default_gemm_configuration.h` for more details.
  //
  // To view the full gemm device API interface, see
  // `cutlass/gemm/device/gemm.h`

  using ColumnMajor = cutlass::layout::ColumnMajor;

  using CutlassGemm =
      cutlass::gemm::device::Gemm<float,        // Data-type of A matrix
                                  ColumnMajor,  // Layout of A matrix
                                  float,        // Data-type of B matrix
                                  ColumnMajor,  // Layout of B matrix
                                  float,        // Data-type of C matrix
                                  ColumnMajor>; // Layout of C matrix

  // Define a CUTLASS GEMM type
  CutlassGemm gemm_operator;

  // Construct the CUTLASS GEMM arguments object.
  //
  // One of CUTLASS's design patterns is to define gemm argument objects that
  // are constructible in host code and passed to kernels by value. These may
  // include pointers, strides, scalars, and other arguments needed by Gemm and
  // its components.
  //
  // The benefits of this pattern are (1.) a structured, composable strategy for
  // passing host-constructible arguments to kernels and (2.) minimized
  // initialization overhead on kernel entry.
  //
  CutlassGemm::Arguments args(
      {M, N, K}, // Gemm Problem dimensions
      {A, lda},  // Tensor-ref for source matrix A
      {B, ldb},  // Tensor-ref for source matrix B
      {C, ldc},  // Tensor-ref for source matrix C
      {C, ldc},  // Tensor-ref for destination matrix D (may be different memory
                 // than source C matrix)
      {alpha, beta}); // Scalars used in the Epilogue

  //
  // Launch the CUTLASS GEMM kernel.
  //

  cutlass::Status status = gemm_operator(args);

  //
  // Return a cudaError_t if the CUTLASS GEMM operator returned an error code.
  //

  if (status != cutlass::Status::kSuccess) {
    return cudaErrorUnknown;
  }

  // Return success, if no errors were encountered.
  return cudaSuccess;
}

namespace Alcanderian // https://github.com/Alcanderian/CUDA-tutorial/sgemm
{
__global__ void cuda_kernel_sgemm_1(float *a, float *b, float *c, size_t N,
                                    size_t M, size_t K, float alpha,
                                    float beta) {
  int tr = threadIdx.x;                   // row idx in block
  int tc = threadIdx.y;                   // col idx in block
  int ir = blockIdx.x * 32 + threadIdx.x; // row idx in global
  int ic = blockIdx.y * 32 + threadIdx.y; // col idx in global

  __shared__ float a_sub[32][32];
  __shared__ float b_sub[32][32];

  int load_size = K / 32;
  if (K % 32 != 0) {
    load_size += 1;
  }
  float acc = 0.0f;
  int a_ir = ir;
  int b_ic = ic;
#define idx(ri, ci, nc) ((ri) * (nc) + (ci))
  for (int l = 0; l < load_size; ++l) {
    int a_ic = l * 32 + tc;
    int b_ir = l * 32 + tr;
    a_sub[tr][tc] = 0.0f;
    b_sub[tr][tc] = 0.0f;
    if (a_ir < M && a_ic < K)
      a_sub[tr][tc] = a[idx(a_ir, a_ic, K)];
    if (b_ir < K && b_ic < N)
      b_sub[tr][tc] = b[idx(b_ir, b_ic, N)];

    __syncthreads();

#pragma unroll
    for (int k = 0; k < 32; ++k) {
      acc += a_sub[tr][k] * b_sub[k][tc];
    }

    __syncthreads();
  }

  if (ir < M && ic < N)
    c[idx(ir, ic, N)] = alpha * acc + beta * c[idx(ir, ic, N)];
#undef idx
}

// use __ldg & avoid bank conflict
__global__ void cuda_kernel_sgemm_2(float *__restrict__ a,
                                    float *__restrict__ b,
                                    float *__restrict__ c, size_t N, size_t M,
                                    size_t K, float alpha, float beta) {
  int tr = threadIdx.x;                   // row idx in block
  int tc = threadIdx.y;                   // col idx in block
  int ir = blockIdx.x * 32 + threadIdx.x; // row idx in global
  int ic = blockIdx.y * 32 + threadIdx.y; // col idx in global

  __shared__ float a_sub[32][32 + 1]; // avoid bank conflict
  __shared__ float b_sub[32][32 + 1];

  int load_size = K / 32;
  if (K % 32 != 0) {
    load_size += 1;
  }
  float acc = 0.0f;
  int a_ir = ir;
  int b_ic = ic;
#define idx(ri, ci, nc) ((ri) * (nc) + (ci))
  for (int l = 0; l < load_size; ++l) {
    int a_ic = l * 32 + tc;
    int b_ir = l * 32 + tr;
    a_sub[tr][tc] = 0.0f;
    b_sub[tr][tc] = 0.0f;
    if (a_ir < M && a_ic < K)
      a_sub[tr][tc] = a[idx(a_ir, a_ic, K)];
    if (b_ir < K && b_ic < N)
      b_sub[tr][tc] = b[idx(b_ir, b_ic, N)];

    __syncthreads();

#pragma unroll
    for (int k = 0; k < 32; ++k) {
      acc += a_sub[tr][k] * b_sub[k][tc];
    }

    __syncthreads();
  }

  if (ir < M && ic < N)
    c[idx(ir, ic, N)] = alpha * acc + beta * c[idx(ir, ic, N)];
#undef idx
}

// use __ldg without avoiding bank conflict
__global__ void cuda_kernel_sgemm_3(float *__restrict__ a,
                                    float *__restrict__ b,
                                    float *__restrict__ c, size_t N, size_t M,
                                    size_t K, float alpha, float beta) {
  int tr = threadIdx.x;                   // row idx in block
  int tc = threadIdx.y;                   // col idx in block
  int ir = blockIdx.x * 32 + threadIdx.x; // row idx in global
  int ic = blockIdx.y * 32 + threadIdx.y; // col idx in global

  __shared__ float a_sub[32][32]; // avoid bank conflict
  __shared__ float b_sub[32][32];

  int load_size = K / 32;
  if (K % 32 != 0) {
    load_size += 1;
  }
  float acc = 0.0f;
  int a_ir = ir;
  int b_ic = ic;
#define idx(ri, ci, nc) ((ri) * (nc) + (ci))
  for (int l = 0; l < load_size; ++l) {
    int a_ic = l * 32 + tc;
    int b_ir = l * 32 + tr;
    a_sub[tr][tc] = 0.0f;
    b_sub[tr][tc] = 0.0f;
    if (a_ir < M && a_ic < K)
      a_sub[tr][tc] = a[idx(a_ir, a_ic, K)];
    if (b_ir < K && b_ic < N)
      b_sub[tr][tc] = b[idx(b_ir, b_ic, N)];

    __syncthreads();

#pragma unroll
    for (int k = 0; k < 32; ++k) {
      acc += a_sub[tr][k] * b_sub[k][tc];
    }

    __syncthreads();
  }

  if (ir < M && ic < N)
    c[idx(ir, ic, N)] = alpha * acc + beta * c[idx(ir, ic, N)];
#undef idx
}
}; // namespace Alcanderian

namespace fynv // https://github.com/fynv/optimal_sgemm_cuda_c
{
struct f8 {
  float4 a, b;
  __device__ inline f8() { memset(this, 0, sizeof(f8)); }
};

struct f88 {
  f8 a, b, c, d, e, f, g, h;
};

__device__ inline void d_load8(const float *p, f8 &c) {
  c.a = ((float4 *)p)[0];
  c.b = ((float4 *)p)[16];
}

__device__ inline void d_store8(float *p, const f8 &c) {
  ((float4 *)p)[0] = c.a;
  ((float4 *)p)[16] = c.b;
}

__device__ inline void d_mult8v(f8 &c, const f8 &a, float b) {
  c.a.x += a.a.x * b;
  c.a.y += a.a.y * b;
  c.a.z += a.a.z * b;
  c.a.w += a.a.w * b;
  c.b.x += a.b.x * b;
  c.b.y += a.b.y * b;
  c.b.z += a.b.z * b;
  c.b.w += a.b.w * b;
}

template <typename T> __device__ inline void Swap(T &a, T &b) {
  T t = a;
  a = b;
  b = t;
}

__global__ __launch_bounds__(
    256) // https://docs.nvidia.com/cuda/cuda-c-programming-guide/index.html#launch-bounds
    void g_fgemm(float *d_C, const float *d_A, const float *d_B, int n, int lda,
                 int ldb, int ldc) {
  int x_a = threadIdx.x & 31;
  int y_a = threadIdx.x >> 5;

  int x_b = threadIdx.x & 1;
  int y_b = threadIdx.x >> 1;

  int x_c = threadIdx.x & 15;
  int y_c = threadIdx.x >> 4;

  __shared__ float smem[4096];
  float *s_A1 = smem;
  float *s_A2 = smem + 1024;
  float *s_B1 = smem + 2048;
  float *s_B2 = smem + 3072;

  f88 l_C;

  const float *p_A = d_A + (blockIdx.x << 7);
  const float *p_B = d_B + (blockIdx.y << 7) * ldb;

  float4 p, q;
  p = ((float4 *)p_A)[y_a * (lda >> 2) + x_a];
  q = ((float4 *)p_B)[y_b * (ldb >> 2) + x_b];

  for (int i = 0; i < n; i += 8) {
    ((float4 *)s_A1)[threadIdx.x] = p;
    s_B1[(((x_b << 2) + 0) << 7) + y_b] = q.x;
    s_B1[(((x_b << 2) + 1) << 7) + y_b] = q.y;
    s_B1[(((x_b << 2) + 2) << 7) + y_b] = q.z;
    s_B1[(((x_b << 2) + 3) << 7) + y_b] = q.w;
    __syncthreads();

    if (i + 8 < n) {
      p_A += (lda << 3);
      p_B += 8;
      p = ((float4 *)p_A)[y_a * (lda >> 2) + x_a];
      q = ((float4 *)p_B)[y_b * (ldb >> 2) + x_b];
    }

    for (int j = 0; j < 8; j++) {
      float *p_s_A = s_A1 + (j << 7) + (x_c << 2);
      float *p_s_B = s_B1 + (j << 7) + (y_c << 2);

      f8 a, b;
      d_load8(p_s_A, a);
      d_load8(p_s_B, b);

      d_mult8v(l_C.a, a, b.a.x);
      d_mult8v(l_C.b, a, b.a.y);
      d_mult8v(l_C.c, a, b.a.z);
      d_mult8v(l_C.d, a, b.a.w);
      d_mult8v(l_C.e, a, b.b.x);
      d_mult8v(l_C.f, a, b.b.y);
      d_mult8v(l_C.g, a, b.b.z);
      d_mult8v(l_C.h, a, b.b.w);
    }

    Swap(s_A1, s_A2);
    Swap(s_B1, s_B2);
  }

  float *p_C = d_C + ((blockIdx.x << 7) + (x_c << 2)) +
               ((blockIdx.y << 7) + (y_c << 2)) * ldc;
  d_store8(p_C, l_C.a);
  p_C += ldc;
  d_store8(p_C, l_C.b);
  p_C += ldc;
  d_store8(p_C, l_C.c);
  p_C += ldc;
  d_store8(p_C, l_C.d);
  p_C += (ldc * 61);
  d_store8(p_C, l_C.e);
  p_C += ldc;
  d_store8(p_C, l_C.f);
  p_C += ldc;
  d_store8(p_C, l_C.g);
  p_C += ldc;
  d_store8(p_C, l_C.h);
}
}; // namespace fynv

namespace wuk {
#define IDX2C(i, j, ld) (((j) * (ld)) + (i))

template <typename T>
__global__
__launch_bounds__(1024) void gemm_32x32_v0(int m, int n, int k, T alpha,
                                           const T *A, int lda, const T *B,
                                           int ldb, T beta, T *C, int ldc) {
  const int y_range = ((int)blockIdx.y + 1 << 5) - m,
            x_range = ((int)blockIdx.x + 1 << 5) - n;
  if (y_range > 0) {
    A -= y_range;
    C -= y_range;
  }
  if (x_range > 0) {
    B -= x_range * ldb;
    C -= x_range * ldc;
  }
  A += blockIdx.y << 5;
  B += (blockIdx.x << 5) * ldb;
  C += (blockIdx.y << 5) + (blockIdx.x << 5) * ldc;

  T resC = 0;
  for (int i = 0; i < k; ++i) {
    const T resA = A[IDX2C(threadIdx.y, i, lda)],
            resB = B[IDX2C(i, threadIdx.x, ldb)];
    resC += resA * resB;
  }
  resC = resC * alpha + C[IDX2C(threadIdx.y, threadIdx.x, ldc)] * beta;
  C[IDX2C(threadIdx.y, threadIdx.x, ldc)] = resC;
}

template <typename T>
__global__
__launch_bounds__(1024) void gemm_32x32_v1(int m, int n, int k, T alpha,
                                           const T *A, int lda, const T *B,
                                           int ldb, T beta, T *C, int ldc) {
  const int x_range = ((int)blockIdx.x + 1 << 5) - m,
            y_range = ((int)blockIdx.y + 1 << 5) - n;
  if (x_range > 0) {
    A -= x_range;
    C -= x_range;
  }
  if (y_range > 0) {
    B -= y_range * ldb;
    C -= y_range * ldc;
  }
  A += blockIdx.x << 5;
  B += (blockIdx.y << 5) * ldb;
  C += (blockIdx.x << 5) + (blockIdx.y << 5) * ldc;
  T resC = 0;
  for (int i = 0; i < k; ++i) {
    const T resA = A[IDX2C(threadIdx.x, i, lda)],
            resB = B[IDX2C(i, threadIdx.y, ldb)];
    resC += resA * resB;
  }
  resC = resC * alpha + C[IDX2C(threadIdx.x, threadIdx.y, ldc)] * beta;
  C[IDX2C(threadIdx.x, threadIdx.y, ldc)] = resC;
}

template <typename T>
__global__
__launch_bounds__(1024) void gemm_32x32_v2(int m, int n, int k, T alpha,
                                           const T *A, int lda, const T *B,
                                           int ldb, T beta, T *C, int ldc) {
  const int idx = threadIdx.x, idy = threadIdx.y,
            x_range = ((int)blockIdx.x + 1 << 5) - m,
            y_range = ((int)blockIdx.y + 1 << 5) - n;
  if (x_range > 0) {
    A -= x_range;
    C -= x_range;
  }
  if (y_range > 0) {
    B -= y_range * ldb;
    C -= y_range * ldc;
  }
  A += blockIdx.x << 5;
  B += (blockIdx.y << 5) * ldb;
  C += (blockIdx.x << 5) + (blockIdx.y << 5) * ldc;
  T resC = 0;
  for (int i = 0; i < k; ++i) {
    const T resA = A[IDX2C(idx, i, lda)], resB = B[IDX2C(i, idy, ldb)];
    resC += resA * resB;
  }
  resC = resC * alpha + C[IDX2C(idx, idy, ldc)] * beta;
  C[IDX2C(idx, idy, ldc)] = resC;
}

template <typename T, int TILE_WIDTH>
__global__ __launch_bounds__(TILE_WIDTH *TILE_WIDTH) void gemm_32x32_v3(
    int m, int n, int k, T alpha, const T *A, int lda, const T *B, int ldb,
    T beta, T *C, int ldc) {
  const int idx = threadIdx.x, idy = threadIdx.y,
            x_range = ((int)blockIdx.x + 1 << 5) - m,
            y_range = ((int)blockIdx.y + 1 << 5) - n;
  if (x_range > 0) {
    A -= x_range;
    C -= x_range;
  }
  if (y_range > 0) {
    B -= y_range * ldb;
    C -= y_range * ldc;
  }
  A += blockIdx.x << 5;
  B += (blockIdx.y << 5) * ldb;
  C += (blockIdx.x << 5) + (blockIdx.y << 5) * ldc;
  T resC = 0;
  __shared__ T sA[TILE_WIDTH][TILE_WIDTH];
  __shared__ T sB[TILE_WIDTH][TILE_WIDTH];
  for (int i = 0; i < k; i += TILE_WIDTH) {
    sA[idx][idy] = A[IDX2C(idx, i + idy, lda)];
    sB[idx][idy] = B[IDX2C(i + idx, idy, ldb)];
    __syncthreads();
    for (int j = 0; j < TILE_WIDTH; ++j)
      resC += sA[idx][j] * sB[j][idy];
    __syncthreads();
  }
  resC = resC * alpha + C[IDX2C(idx, idy, ldc)] * beta;
  C[IDX2C(idx, idy, ldc)] = resC;
}

template <typename T, int TILE_WIDTH>
__global__ __launch_bounds__(TILE_WIDTH *TILE_WIDTH) void gemm_32x32_v4(
    int m, int n, int k, T alpha, const T *A, int lda, const T *B, int ldb,
    T beta, T *C, int ldc) {
  const int idx = threadIdx.x, idy = threadIdx.y,
            x_range = ((int)blockIdx.x + 1 << 5) - m,
            y_range = ((int)blockIdx.y + 1 << 5) - n;
  if (x_range > 0) {
    A -= x_range;
    C -= x_range;
  }
  if (y_range > 0) {
    B -= y_range * ldb;
    C -= y_range * ldc;
  }
  A += blockIdx.x << 5;
  B += (blockIdx.y << 5) * ldb;
  C += (blockIdx.x << 5) + (blockIdx.y << 5) * ldc;
  T resC = 0;
  __shared__ T sA[TILE_WIDTH][TILE_WIDTH | 1];
  __shared__ T sB[TILE_WIDTH][TILE_WIDTH | 1];
  for (int i = 0; i < k; i += TILE_WIDTH) {
    sA[idx][idy] = A[IDX2C(idx, i + idy, lda)];
    sB[idx][idy] = B[IDX2C(i + idx, idy, ldb)];
    __syncthreads();
    for (int j = 0; j < TILE_WIDTH; ++j)
      resC += sA[idx][j] * sB[j][idy];
    __syncthreads();
  }
  resC = resC * alpha + C[IDX2C(idx, idy, ldc)] * beta;
  C[IDX2C(idx, idy, ldc)] = resC;
}
#undef IDX2C

template <typename T, typename Tv, int TWO_BUFFER>
__global__
__launch_bounds__(256) void gemm_32x32_v5(int m, int n, int k, T alpha,
                                          const T *A, int lda, const T *B,
                                          int ldb, T beta, T *C, int ldc) {
  const int TvSize = sizeof(Tv) / sizeof(T), idx = threadIdx.x,
            x_range = ((int)blockIdx.x + 1 << 5) - m,
            y_range = ((int)blockIdx.y + 1 << 5) - n;
  if (x_range > 0) {
    A -= x_range;
    C -= x_range;
  }
  if (y_range > 0) {
    B -= y_range * ldb;
    C -= y_range * ldc;
  }
  A += blockIdx.x << 5;
  B += (blockIdx.y << 5) * ldb;
  C += (blockIdx.x << 5) + (blockIdx.y << 5) * ldc;
  Tv ansC;
  memset(&ansC, 0, sizeof(ansC));

  __shared__ T s_buffer[2048];
  T *s_A = s_buffer;
  T *s_B = s_buffer + 1024;

#if TWO_BUFFER
  __shared__ T s_tbuffer[2048];
  T *s_tA = s_tbuffer;
  T *s_tB = s_tbuffer + 1024;
#endif

  Tv resA = *(Tv *)&A[((idx * TvSize) & 31) + ((idx * TvSize) >> 5) * lda],
     resB = *(Tv *)&B[((idx * TvSize) & 31) + ((idx * TvSize) >> 5) * ldb];

  for (int l = 0; l < k; l += 32) {
    ((Tv *)s_A)[idx] = resA;
    for (int i = 0; i < TvSize; ++i)
      s_B[(((idx * TvSize) & 31) << 5) + ((idx * TvSize) >> 5)] =
          ((T *)&resB)[i];
    __syncthreads();

    if (l + 32 < k) {
      A += lda << 5;
      B += 32;
      resA = *(Tv *)&A[((idx * TvSize) & 31) + ((idx * TvSize) >> 5) * lda];
      resB = *(Tv *)&B[((idx * TvSize) & 31) + ((idx * TvSize) >> 5) * ldb];
    }

    for (int j = 0; j < 32; ++j) {
      Tv tmpA = *(Tv *)&s_A[((idx * TvSize) & 31) + (j << 5)];
      T tmpB = s_B[(j << 5) + ((idx * TvSize) >> 5)];
      for (int i = 0; i < TvSize; ++i)
        ((T *)&ansC)[i] += ((T *)&tmpA)[i] * tmpB;
    }

#if TWO_BUFFER
    {
      T *tmp_A = s_A;
      s_A = s_tA;
      s_tA = tmp_A;
    }
    {
      T *tmp_B = s_B;
      s_B = s_tB;
      s_tB = tmp_B;
    }
#else
    __syncthreads();
#endif
  }

  {
    Tv *devC = (Tv *)&C[((idx * TvSize) & 31) + ((idx * TvSize) >> 5) * ldc],
       resC = *devC;
    for (int i = 0; i < TvSize; ++i)
      ((T *)&resC)[i] = alpha * ((T *)&ansC)[i] + beta * ((T *)&resC)[i];
    *devC = resC;
  }
}

template <typename T, typename Tv, int TWO_BUFFER>
__global__ __launch_bounds__(256) void gemm_64x64(int m, int n, int k, T alpha,
                                                  const T *A, int lda,
                                                  const T *B, int ldb, T beta,
                                                  T *C, int ldc) {
  const int TvSize = sizeof(Tv) / sizeof(T), idx = threadIdx.x,
            x_range = ((int)blockIdx.x + 1 << 6) - m,
            y_range = ((int)blockIdx.y + 1 << 6) - n;
  if (x_range > 0) {
    A -= x_range;
    C -= x_range;
  }
  if (y_range > 0) {
    B -= y_range * ldb;
    C -= y_range * ldc;
  }
  A += blockIdx.x << 6;
  B += (blockIdx.y << 6) * ldb;
  C += (blockIdx.x << 6) + (blockIdx.y << 6) * ldc;
  Tv ansC[TvSize];
  memset(ansC, 0, sizeof(ansC));

  __shared__ T s_buffer[2048];
  T *s_A = s_buffer;
  T *s_B = s_buffer + 1024;

#if TWO_BUFFER
  __shared__ T s_tbuffer[2048];
  T *s_tA = s_tbuffer;
  T *s_tB = s_tbuffer + 1024;
#endif

  Tv resA = *(Tv *)&(A[((idx * TvSize) & 63) + ((idx * TvSize) >> 6) * lda]),
     resB = *(Tv *)&(B[((idx * TvSize) & 15) + ((idx * TvSize) >> 4) * ldb]);
  for (int l = 0; l < k; l += 16) {
    ((Tv *)s_A)[idx] = resA;
    for (int i = 0; i < TvSize; ++i)
      s_B[((((idx * TvSize) & 15) + i) << 6) + ((idx * TvSize) >> 4)] =
          ((T *)&resB)[i];
    __syncthreads();

    if (l + 16 < k) {
      A += lda << 4;
      B += 16;
      resA = *(Tv *)&(A[((idx * TvSize) & 63) + ((idx * TvSize) >> 6) * lda]);
      resB = *(Tv *)&(B[((idx * TvSize) & 15) + ((idx * TvSize) >> 4) * ldb]);
    }

    for (int j = 0; j < 16; ++j) {
      const Tv tmpA = *(Tv *)&(s_A[((idx * TvSize) & 63) + (j << 6)]),
               tmpB = *(Tv *)&(s_B[(j << 6) + (idx >> 4) * TvSize]);
      for (int i = 0; i < TvSize; ++i)
        for (int h = 0; h < TvSize; ++h)
          ((T *)&ansC[i])[h] += ((T *)&tmpA)[i] * ((T *)&tmpB)[h];
    }

#if TWO_BUFFER
    {
      T *tmp_A = s_A;
      s_A = s_tA;
      s_tA = tmp_A;
    }
    {
      T *tmp_B = s_B;
      s_B = s_tB;
      s_tB = tmp_B;
    }
#else
    __syncthreads();
#endif
  }
  for (int i = 0; i < TvSize; ++i) {
    Tv *devC = (Tv *)&(C[(idx & 15) * 4 + ((idx >> 4) * 4 + i) * ldc]),
       resC = *devC;
    for (int h = 0; h < TvSize; ++h)
      ((T *)&resC)[h] = alpha * ((T *)&ansC[i])[h] + beta * ((T *)&resC)[h];
    *devC = resC;
  }
}

template <typename T, typename Tv, int TWO_BUFFER>
__global__
__launch_bounds__(256) void gemm_128x128(int m, int n, int k, T alpha,
                                         const T *A, int lda, const T *B,
                                         int ldb, T beta, T *C, int ldc) {
  const int TvSize = sizeof(Tv) / sizeof(T), idx = threadIdx.x,
            x_range = ((int)blockIdx.x + 1 << 7) - m,
            y_range = ((int)blockIdx.y + 1 << 7) - n, x_a = idx & 31,
            y_a = idx >> 5, x_b = idx & 1, y_b = idx >> 1, x_c = idx & 15,
            y_c = idx >> 4;
  if (x_range > 0) {
    A -= x_range;
    C -= x_range;
  }
  if (y_range > 0) {
    B -= y_range * ldb;
    C -= y_range * ldc;
  }

  A += blockIdx.x << 7;
  B += (blockIdx.y << 7) * ldb;
  C +=
      ((blockIdx.x << 7) + (x_c << 2)) + ((blockIdx.y << 7) + (y_c << 2)) * ldc;

  __shared__ T s_buffer[2048];
  T *s_A = s_buffer;
  T *s_B = s_buffer + 1024;

#if TWO_BUFFER
  __shared__ T s_tbuffer[2048];
  T *s_tA = s_tbuffer;
  T *s_tB = s_tbuffer + 1024;
#endif
  Tv ansC[2][2][TvSize];
  memset(ansC, 0, sizeof(ansC));

  Tv resA = ((Tv *)A)[x_a + y_a * (lda >> 2)];
  Tv resB = ((Tv *)B)[x_b + y_b * (ldb >> 2)];

  for (int l = 0; l < k; l += 8) {
    ((Tv *)s_A)[idx] = resA;
    for (int i = 0; i < TvSize; ++i)
      s_B[(((x_b << 2) + i) << 7) + y_b] = ((T *)&resB)[i];
    __syncthreads();

    if (l + 8 < k) {
      A += lda << 3;
      B += 8;
      resA = ((Tv *)A)[x_a + y_a * (lda >> 2)];
      resB = ((Tv *)B)[x_b + y_b * (ldb >> 2)];
    }

#pragma unroll(4)
    for (int j = 0; j < 8; ++j) {
      Tv a[2], b[2];
      for (int p = 0; p < 2; ++p)
        a[p] = ((Tv *)(s_A + (j << 7) + (x_c << 2)))[p << 4];
      for (int p = 0; p < 2; ++p)
        b[p] = ((Tv *)(s_B + (j << 7) + (y_c << 2)))[p << 4];
      for (int p = 0; p < 2; ++p)
        for (int q = 0; q < 2; ++q)
          for (int i = 0; i < TvSize; ++i)
            for (int j = 0; j < TvSize; ++j)
              ((T *)&ansC[p][q][i])[j] += ((T *)&a[p])[j] * ((T *)&b[q])[i];
    }

#if TWO_BUFFER
    {
      T *tmp_A = s_A;
      s_A = s_tA;
      s_tA = tmp_A;
    }
    {
      T *tmp_B = s_B;
      s_B = s_tB;
      s_tB = tmp_B;
    }
#else
    __syncthreads();
#endif
  }

  for (int p = 0; p < 2; ++p)
    for (int q = 0; q < 2; ++q)
      for (int i = 0; i < TvSize; ++i) {
        Tv *devC = ((Tv *)(C + ldc * (q * 64 + i))) + (p << 4), resC = *devC;
        for (int j = 0; j < TvSize; ++j)
          ((T *)&resC)[j] =
              alpha * ((T *)&ansC[p][q][i])[j] + beta * ((T *)&resC)[j];
        *devC = resC;
      }
}
}; // namespace wuk

void WuK_Timer(const char *tag, float flo, const std::function<void()> &kernel,
               int test_time = 9) {
  float min_time = 9e99;
  while (test_time--) {
    cudaEvent_t beg, end;
    cudaEventCreate(&beg);
    cudaEventCreate(&end);
    cudaEventRecord(beg);
    kernel();
    cudaEventRecord(end);
    cudaEventSynchronize(beg);
    cudaEventSynchronize(end);
    float elapsed_time;
    cudaEventElapsedTime(&elapsed_time, beg, end);
    min_time = std::min(min_time, elapsed_time);
  }
  std::printf("%s: %f ms, %e FLOPS.\n", tag, min_time, flo * 1e3 / min_time);
}

struct WuK_cublas {
  cublasHandle_t handle;
  WuK_cublas() { cublasCreate(&handle); }
  ~WuK_cublas() { cublasDestroy(handle); }
} wuk_cublas;

const float alpha = 1, beta = 0;
const cublasOperation_t opA = CUBLAS_OP_N, opB = CUBLAS_OP_N, opC = CUBLAS_OP_N;
const int m = 1 << 13, n = 1 << 13, k = 1 << 13,
          lda = opA == CUBLAS_OP_N ? k : m, ldb = opB == CUBLAS_OP_N ? n : k,
          ldc = opC == CUBLAS_OP_N ? n : m;
cutlass::HostTensor<float, cutlass::layout::ColumnMajor> dA({m, k}), dB({k, n}),
    dC({m, n});

int main() {
  cutlass::reference::device::TensorFill(dA.device_view(),
                                         static_cast<float>(2));
  cutlass::reference::device::TensorFill(dB.device_view(),
                                         static_cast<float>(1));
  cutlass::reference::device::TensorFill(dC.device_view(),
                                         static_cast<float>(0));
  WuK_Timer("cublasSgemm", 2.0 * m * k * n, [&] {
    cublasSgemm(wuk_cublas.handle, opA, opB, m, n, k, &alpha, dA.device_data(),
                lda, dB.device_data(), ldb, &beta, dC.device_data(), ldc);
  });
  WuK_Timer("CutlassSgemmNN", 2.0 * m * k * n, [&] {
    CutlassSgemmNN(m, n, k, alpha, dA.device_data(), lda, dB.device_data(), ldb,
                   beta, dC.device_data(), ldc);
  });
  WuK_Timer("Alcanderian::cuda_kernel_sgemm_1", 2.0 * m * k * n, [&] {
    const int TILE_WIDTH = 32;
    const dim3 blockDim(TILE_WIDTH, TILE_WIDTH),
        gridDim((m + TILE_WIDTH - 1) / TILE_WIDTH,
                (n + TILE_WIDTH - 1) / TILE_WIDTH);
    assert(opA == CUBLAS_OP_N);
    assert(opB == CUBLAS_OP_N);
    assert(opC == CUBLAS_OP_N);
    Alcanderian::cuda_kernel_sgemm_1<<<gridDim, blockDim>>>(
        dA.device_data(), dB.device_data(), dC.device_data(), n, m, k, alpha,
        beta);
  });
  WuK_Timer("Alcanderian::cuda_kernel_sgemm_2", 2.0 * m * k * n, [&] {
    const int TILE_WIDTH = 32;
    const dim3 blockDim(TILE_WIDTH, TILE_WIDTH),
        gridDim((m + TILE_WIDTH - 1) / TILE_WIDTH,
                (n + TILE_WIDTH - 1) / TILE_WIDTH);
    assert(opA == CUBLAS_OP_N);
    assert(opB == CUBLAS_OP_N);
    assert(opC == CUBLAS_OP_N);
    Alcanderian::cuda_kernel_sgemm_2<<<gridDim, blockDim>>>(
        dA.device_data(), dB.device_data(), dC.device_data(), n, m, k, alpha,
        beta);
  });
  WuK_Timer("Alcanderian::cuda_kernel_sgemm_3", 2.0 * m * k * n, [&] {
    const int TILE_WIDTH = 32;
    const dim3 blockDim(TILE_WIDTH, TILE_WIDTH),
        gridDim((m + TILE_WIDTH - 1) / TILE_WIDTH,
                (n + TILE_WIDTH - 1) / TILE_WIDTH);
    assert(opA == CUBLAS_OP_N);
    assert(opB == CUBLAS_OP_N);
    assert(opC == CUBLAS_OP_N);
    Alcanderian::cuda_kernel_sgemm_3<<<gridDim, blockDim>>>(
        dA.device_data(), dB.device_data(), dC.device_data(), n, m, k, alpha,
        beta);
  });
  WuK_Timer("fynv::g_fgemm", 2.0 * m * k * n, [&] {
    const int TILE_WIDTH = 128;
    const dim3 blockDim(256), gridDim((m + TILE_WIDTH - 1) / TILE_WIDTH,
                                      (n + TILE_WIDTH - 1) / TILE_WIDTH);
    assert(opA == CUBLAS_OP_N);
    assert(opB == CUBLAS_OP_N);
    assert(opC == CUBLAS_OP_N);
    assert(m % TILE_WIDTH == 0);
    assert(n % TILE_WIDTH == 0);
    assert(k % TILE_WIDTH == 0);
    fynv::g_fgemm<<<gridDim, blockDim>>>(dC.device_data(), dA.device_data(),
                                         dB.device_data(), k, lda, ldb, ldc);
  });
  WuK_Timer("wuk::gemm_32x32_v0", 2.0 * m * k * n, [&] {
    const int TILE_WIDTH = 32;
    const dim3 blockDim(TILE_WIDTH, TILE_WIDTH),
        gridDim((n + TILE_WIDTH - 1) / TILE_WIDTH,
                (m + TILE_WIDTH - 1) / TILE_WIDTH);
    assert(opA == CUBLAS_OP_N);
    assert(opB == CUBLAS_OP_N);
    assert(opC == CUBLAS_OP_N);
    assert(m >= blockDim.y);
    assert(n >= blockDim.x);
    wuk::gemm_32x32_v0<<<gridDim, blockDim>>>(m, n, k, alpha, dA.device_data(),
                                              lda, dB.device_data(), ldb, beta,
                                              dC.device_data(), ldc);
  });
  WuK_Timer("wuk::gemm_32x32_v1", 2.0 * m * k * n, [&] {
    const int TILE_WIDTH = 32;
    const dim3 blockDim(TILE_WIDTH, TILE_WIDTH),
        gridDim((m + TILE_WIDTH - 1) / TILE_WIDTH,
                (n + TILE_WIDTH - 1) / TILE_WIDTH);
    assert(opA == CUBLAS_OP_N);
    assert(opB == CUBLAS_OP_N);
    assert(opC == CUBLAS_OP_N);
    assert(m >= blockDim.x);
    assert(n >= blockDim.y);
    wuk::gemm_32x32_v1<<<gridDim, blockDim>>>(m, n, k, alpha, dA.device_data(),
                                              lda, dB.device_data(), ldb, beta,
                                              dC.device_data(), ldc);
  });
  WuK_Timer("wuk::gemm_32x32_v2", 2.0 * m * k * n, [&] {
    const int TILE_WIDTH = 32;
    const dim3 blockDim(TILE_WIDTH, TILE_WIDTH),
        gridDim((m + TILE_WIDTH - 1) / TILE_WIDTH,
                (n + TILE_WIDTH - 1) / TILE_WIDTH);
    assert(opA == CUBLAS_OP_N);
    assert(opB == CUBLAS_OP_N);
    assert(opC == CUBLAS_OP_N);
    assert(m >= blockDim.x);
    assert(n >= blockDim.y);
    wuk::gemm_32x32_v2<<<gridDim, blockDim>>>(m, n, k, alpha, dA.device_data(),
                                              lda, dB.device_data(), ldb, beta,
                                              dC.device_data(), ldc);
  });
  WuK_Timer("wuk::gemm_32x32_v3", 2.0 * m * k * n, [&] {
    const int TILE_WIDTH = 32;
    const dim3 blockDim(TILE_WIDTH, TILE_WIDTH),
        gridDim((m + TILE_WIDTH - 1) / TILE_WIDTH,
                (n + TILE_WIDTH - 1) / TILE_WIDTH);
    assert(opA == CUBLAS_OP_N);
    assert(opB == CUBLAS_OP_N);
    assert(opC == CUBLAS_OP_N);
    assert(m >= TILE_WIDTH);
    assert(n >= TILE_WIDTH);
    assert(k >= TILE_WIDTH);
    wuk::gemm_32x32_v3<float, TILE_WIDTH><<<gridDim, blockDim>>>(
        m, n, k, alpha, dA.device_data(), lda, dB.device_data(), ldb, beta,
        dC.device_data(), ldc);
  });
  WuK_Timer("wuk::gemm_32x32_v4", 2.0 * m * k * n, [&] {
    const int TILE_WIDTH = 32;
    const dim3 blockDim(TILE_WIDTH, TILE_WIDTH),
        gridDim((m + TILE_WIDTH - 1) / TILE_WIDTH,
                (n + TILE_WIDTH - 1) / TILE_WIDTH);
    assert(opA == CUBLAS_OP_N);
    assert(opB == CUBLAS_OP_N);
    assert(opC == CUBLAS_OP_N);
    assert(m >= TILE_WIDTH);
    assert(n >= TILE_WIDTH);
    assert(k >= TILE_WIDTH);
    wuk::gemm_32x32_v4<float, TILE_WIDTH><<<gridDim, blockDim>>>(
        m, n, k, alpha, dA.device_data(), lda, dB.device_data(), ldb, beta,
        dC.device_data(), ldc);
  });
  WuK_Timer("wuk::gemm_32x32_v5", 2.0 * m * k * n, [&] {
    const int TILE_WIDTH = 32;
    const dim3 blockDim(256), gridDim((m + TILE_WIDTH - 1) / TILE_WIDTH,
                                      (n + TILE_WIDTH - 1) / TILE_WIDTH);
    assert(opA == CUBLAS_OP_N);
    assert(opB == CUBLAS_OP_N);
    assert(opC == CUBLAS_OP_N);
    assert(m >= TILE_WIDTH);
    assert(n >= TILE_WIDTH);
    assert(k % 32 == 0);
    wuk::gemm_32x32_v5<float, float4, 0><<<gridDim, blockDim>>>(
        m, n, k, alpha, dA.device_data(), lda, dB.device_data(), ldb, beta,
        dC.device_data(), ldc);
  });
  WuK_Timer("wuk::gemm_64x64", 2.0 * m * k * n, [&] {
    const int TILE_WIDTH = 64;
    const dim3 blockDim(256), gridDim((m + TILE_WIDTH - 1) / TILE_WIDTH,
                                      (n + TILE_WIDTH - 1) / TILE_WIDTH);
    assert(opA == CUBLAS_OP_N);
    assert(opB == CUBLAS_OP_N);
    assert(opC == CUBLAS_OP_N);
    assert(m >= TILE_WIDTH);
    assert(n >= TILE_WIDTH);
    assert(k % 16 == 0);
    wuk::gemm_64x64<float, float4, 0><<<gridDim, blockDim>>>(
        m, n, k, alpha, dA.device_data(), lda, dB.device_data(), ldb, beta,
        dC.device_data(), ldc);
  });
  WuK_Timer("wuk::gemm_128x128", 2.0 * m * k * n, [&] {
    const int TILE_WIDTH = 128;
    const dim3 blockDim(256), gridDim((m + TILE_WIDTH - 1) / TILE_WIDTH,
                                      (n + TILE_WIDTH - 1) / TILE_WIDTH);
    assert(opA == CUBLAS_OP_N);
    assert(opB == CUBLAS_OP_N);
    assert(opC == CUBLAS_OP_N);
    assert(m >= TILE_WIDTH);
    assert(n >= TILE_WIDTH);
    assert(k % 8 == 0);
    wuk::gemm_128x128<float, float4, 1><<<gridDim, blockDim>>>(
        m, n, k, alpha, dA.device_data(), lda, dB.device_data(), ldb, beta,
        dC.device_data(), ldc);
  });
}

gemm.ptx

//
// Generated by NVIDIA NVVM Compiler
//
// Compiler Build ID: CL-29373293
// Cuda compilation tools, release 11.2, V11.2.67
// Based on NVVM 7.0.1
//

.version 7.2
.target sm_70
.address_size 64

	// .globl	_ZN7cutlass6KernelINS_4gemm6kernel4GemmINS1_11threadblock12MmaPipelinedINS1_9GemmShapeILi128ELi128ELi8EEENS_9transform11threadblock22PredicatedTileIteratorINS_11MatrixShapeILi128ELi8EEEfNS_6layout8RowMajorELi1ENS8_30PitchLinearStripminedThreadMapINS_16PitchLinearShapeILi8ELi128EEELi256ELi1EEELi1EEENS9_19RegularTileIteratorISC_fNSD_11ColumnMajorELi1ENS8_33TransposePitchLinearThreadMapSimtISI_EELi4EEENSA_INSB_ILi8ELi128EEEfSE_Li0ENSF_INSG_ILi128ELi8EEELi256ELi1EEELi1EEENSK_ISP_fSE_Li0ESR_Li4EEEfSE_NS4_9MmaPolicyINS1_4warp7MmaSimtINS6_ILi32ELi64ELi8EEEfSL_fSE_fSE_NSV_13MmaSimtPolicyINSB_ILi4ELi8EEENSD_19RowMajorInterleavedILi2EEENS6_ILi4ELi4ELi1EEEEELi1ELNS_16ComplexTransformE0ELS14_0EbEENSB_ILi4ELi0EEENSB_ILi0ELi0EEELi1EEENS_21NumericArrayConverterIffLi4ELNS_15FloatRoundStyleE2EEES1B_bEENS_8epilogue11threadblock8EpilogueIS7_S15_Li1ENS1E_22PredicatedTileIteratorINS1E_26OutputTileOptimalThreadMapINS1E_15OutputTileShapeILi128ELi1ELi4ELi4ELi1EEENS1I_ILi1ELi4ELi2ELi1ELi8EEELi256ELi1ELi32EEEfLb0EEENS1D_4warp20FragmentIteratorSimtISX_NS1_6thread3MmaINS6_ILi8ELi8ELi1EEEfSL_fSE_fSE_NS_4arch13OpMultiplyAddEbEESE_S13_EENS1N_16TileIteratorSimtISX_S1U_fSE_S13_EENS1E_18SharedLoadIteratorINS1L_18CompactedThreadMapEfLi4EEENS1D_6thread17LinearCombinationIfLi1EffLNS21_9ScaleType4KindE0ELS1A_2EEENSB_ILi0ELi17EEELi1ELi1EEENS4_30GemmIdentityThreadblockSwizzleILi1EEELb0EEEEEvNT_6ParamsE
.global .align 4 .b8 precalc_xorwow_matrix[25600] = {202, 29, 180, 50, 5, 158, 175, 136, 93, 225, 119, 90, 117, 16, 115, 72, 213, 129, 27, 96, 168, 215, 119, 38, 103, 148, 34, 49, 246, 182, 164, 209, 75, 152, 236, 242, 28, 31, 44, 184, 208, 150, 78, 253, 135, 186, 45, 227, 119, 159, 156, 65, 97, 161, 50, 3, 186, 12, 236, 167, 129, 146, 81, 188, 38, 252, 162, 98, 228, 60, 160, 56, 242, 187, 129, 184, 171, 131, 56, 243, 255, 19, 10, 245, 9, 182, 56, 193, 43, 192, 48, 166, 186, 28, 188, 253, 149, 117, 167, 144, 70, 140, 193, 249, 201, 85, 175, 84, 113, 110, 86, 225, 107, 29, 189, 65, 201, 74, 210, 98, 168, 202, 247, 199, 196, 51, 46, 150, 127, 36, 190, 30, 242, 212, 118, 202, 63, 80, 59, 109, 222, 222, 203, 68, 228, 28, 47, 114, 70, 67, 69, 115, 97, 2, 16, 47, 213, 224, 36, 20, 90, 15, 2, 81, 253, 84, 14, 134, 101, 219, 185, 203, 84, 203, 105, 51, 184, 123, 122, 31, 168, 212, 112, 75, 236, 155, 108, 117, 176, 169, 189, 213, 14, 121, 71, 217, 249, 90, 155, 18, 168, 20, 31, 81, 16, 239, 222, 118, 212, 197, 181, 138, 61, 254, 107, 151, 57, 192, 92, 70, 205, 108, 51, 132, 177, 48, 228, 10, 212, 205, 45, 35, 111, 79, 132, 113, 129, 225, 186, 151, 177, 170, 106, 220, 81, 254, 156, 64, 24, 242, 135, 202, 203, 58, 172, 130, 144, 225, 46, 161, 162, 12, 185, 63, 123, 252, 237, 140, 205, 62, 24, 94, 105, 107, 79, 212, 146, 156, 230, 204, 73, 207, 68, 87, 71, 204, 91, 96, 117, 52, 179, 133, 136, 128, 245, 216, 129, 210, 123, 101, 169, 2, 71, 145, 234, 55, 98, 2, 0, 186, 168, 120, 172, 55, 52, 226, 110, 198, 216, 214, 67, 40, 105, 26, 84, 149, 91, 38, 144, 130, 105, 114, 9, 169, 82, 234, 81, 199, 129, 25, 248, 219, 121, 16, 86, 38, 138, 148, 40, 239, 168, 15, 245, 135, 23, 184, 41, 28, 52, 174, 107, 74, 66, 108, 105, 74, 22, 253, 42, 176, 56, 50, 194, 122, 12, 87, 78, 70, 211, 181, 130, 43, 104, 157, 184, 222, 105, 220, 131, 151, 147, 206, 119, 19, 228, 229, 228, 201, 100, 81, 39, 41, 173, 172, 156, 104, 188, 163, 101, 41, 72, 215, 246, 165, 190, 112, 190, 237, 26, 113, 27, 252, 18, 26, 42, 80, 104, 40, 93, 45, 97, 7, 164, 100, 224, 234, 227, 142, 252, 40, 177, 12, 238, 207, 206, 246, 6, 28, 136, 79, 31, 65, 71, 20, 171, 91, 161, 159, 249, 63, 243, 178, 111, 36, 106, 23, 13, 227, 6, 11, 248, 236, 141, 71, 47, 55, 208, 110, 228, 149, 246, 125, 109, 170, 251, 139, 159, 164, 187, 84, 52, 59, 55, 229, 199, 9, 135, 202, 177, 222, 32, 52, 234, 123, 99, 40, 141, 84, 224, 22, 173, 71, 128, 41, 94, 252, 24, 217, 75, 78, 122, 96, 21, 148, 220, 38, 80, 109, 82, 157, 109, 39, 195, 148, 50, 132, 201, 1, 153, 166, 75, 45, 226, 175, 90, 156, 150, 83, 248, 160, 240, 20, 205, 125, 101, 113, 126, 48, 36, 114, 184, 89, 77, 171, 147, 247, 191, 78, 249, 242, 167, 197, 27, 78, 162, 195, 121, 56, 0, 80, 218, 243, 74, 47, 79, 23, 152, 195, 157, 244, 165, 17, 182, 6, 20, 29, 167, 193, 113, 42, 95, 75, 198, 82, 117, 96, 168, 101, 100, 185, 15, 212, 108, 99, 211, 23, 219, 80, 208, 80, 21, 134, 92, 17, 33, 119, 26, 25, 247, 65, 149, 78, 216, 15, 14, 123, 98, 205, 60, 69, 234, 194, 198, 123, 202, 29, 180, 50, 5, 158, 175, 136, 93, 225, 119, 90, 117, 16, 115, 72, 228, 254, 83, 229, 168, 215, 119, 38, 103, 148, 34, 49, 246, 182, 164, 209, 75, 152, 236, 242, 97, 71, 67, 164, 208, 150, 78, 253, 135, 186, 45, 227, 119, 159, 156, 65, 97, 161, 50, 3, 70, 2, 126, 84, 129, 146, 81, 188, 38, 252, 162, 98, 228, 60, 160, 56, 242, 187, 129, 184, 251, 129, 199, 113, 255, 19, 10, 245, 9, 182, 56, 193, 43, 192, 48, 166, 186, 28, 188, 253, 167, 102, 136, 223, 70, 140, 193, 249, 201, 85, 175, 84, 113, 110, 86, 225, 107, 29, 189, 65, 182, 203, 25, 0, 168, 202, 247, 199, 196, 51, 46, 150, 127, 36, 190, 30, 242, 212, 118, 202, 26, 86, 112, 158, 222, 222, 203, 68, 228, 28, 47, 114, 70, 67, 69, 115, 97, 2, 16, 47, 208, 86, 81, 11, 90, 15, 2, 81, 253, 84, 14, 134, 101, 219, 185, 203, 84, 203, 105, 51, 91, 65, 135, 59, 168, 212, 112, 75, 236, 155, 108, 117, 176, 169, 189, 213, 14, 121, 71, 217, 15, 9, 53, 177, 168, 20, 31, 81, 16, 239, 222, 118, 212, 197, 181, 138, 61, 254, 107, 151, 8, 160, 33, 136, 205, 108, 51, 132, 177, 48, 228, 10, 212, 205, 45, 35, 111, 79, 132, 113, 30, 113, 153, 6, 177, 170, 106, 220, 81, 254, 156, 64, 24, 242, 135, 202, 203, 58, 172, 130, 75, 170, 93, 246, 162, 12, 185, 63, 123, 252, 237, 140, 205, 62, 24, 94, 105, 107, 79, 212, 83, 11, 91, 216, 73, 207, 68, 87, 71, 204, 91, 96, 117, 52, 179, 133, 136, 128, 245, 216, 205, 248, 29, 194, 169, 2, 71, 145, 234, 55, 98, 2, 0, 186, 168, 120, 172, 55, 52, 226, 96, 187, 19, 61, 67, 40, 105, 26, 84, 149, 91, 38, 144, 130, 105, 114, 9, 169, 82, 234, 80, 131, 56, 164, 248, 219, 121, 16, 86, 38, 138, 148, 40, 239, 168, 15, 245, 135, 23, 184, 133, 63, 245, 167, 107, 74, 66, 108, 105, 74, 22, 253, 42, 176, 56, 50, 194, 122, 12, 87, 126, 47, 170, 135, 130, 43, 104, 157, 184, 222, 105, 220, 131, 151, 147, 206, 119, 19, 228, 229, 181, 14, 200, 7, 39, 41, 173, 172, 156, 104, 188, 163, 101, 41, 72, 215, 246, 165, 190, 112, 49, 179, 244, 47, 27, 252, 18, 26, 42, 80, 104, 40, 93, 45, 97, 7, 164, 100, 224, 234, 61, 81, 212, 145, 177, 12, 238, 207, 206, 246, 6, 28, 136, 79, 31, 65, 71, 20, 171, 91, 156, 243, 136, 89, 243, 178, 111, 36, 106, 23, 13, 227, 6, 11, 248, 236, 141, 71, 47, 55, 0, 69, 6, 52, 246, 125, 109, 170, 251, 139, 159, 164, 187, 84, 52, 59, 55, 229, 199, 9, 10, 134, 142, 232, 32, 52, 234, 123, 99, 40, 141, 84, 224, 22, 173, 71, 128, 41, 94, 252, 184, 198, 1, 42, 122, 96, 21, 148, 220, 38, 80, 109, 82, 157, 109, 39, 195, 148, 50, 132, 212, 243, 241, 195, 75, 45, 226, 175, 90, 156, 150, 83, 248, 160, 240, 20, 205, 125, 101, 113, 13, 241, 49, 121, 184, 89, 77, 171, 147, 247, 191, 78, 249, 242, 167, 197, 27, 78, 162, 195, 140, 122, 124, 78, 218, 243, 74, 47, 79, 23, 152, 195, 157, 244, 165, 17, 182, 6, 20, 29, 219, 3, 188, 18, 95, 75, 198, 82, 117, 96, 168, 101, 100, 185, 15, 212, 108, 99, 211, 23, 237, 187, 242, 98, 21, 134, 92, 17, 33, 119, 26, 25, 247, 65, 149, 78, 216, 15, 14, 123, 32, 214, 33, 188, 234, 194, 198, 123, 202, 29, 180, 50, 5, 158, 175, 136, 93, 225, 119, 90, 9, 153, 254, 19, 228, 254, 83, 229, 168, 215, 119, 38, 103, 148, 34, 49, 246, 182, 164, 209, 215, 83, 228, 56, 97, 71, 67, 164, 208, 150, 78, 253, 135, 186, 45, 227, 119, 159, 156, 65, 151, 6, 43, 203, 70, 2, 126, 84, 129, 146, 81, 188, 38, 252, 162, 98, 228, 60, 160, 56, 25, 8, 85, 19, 251, 129, 199, 113, 255, 19, 10, 245, 9, 182, 56, 193, 43, 192, 48, 166, 173, 90, 175, 112, 167, 102, 136, 223, 70, 140, 193, 249, 201, 85, 175, 84, 113, 110, 86, 225, 137, 142, 135, 221, 182, 203, 25, 0, 168, 202, 247, 199, 196, 51, 46, 150, 127, 36, 190, 30, 100, 233, 0, 224, 26, 86, 112, 158, 222, 222, 203, 68, 228, 28, 47, 114, 70, 67, 69, 115, 179, 177, 80, 50, 208, 86, 81, 11, 90, 15, 2, 81, 253, 84, 14, 134, 101, 219, 185, 203, 119, 52, 128, 61, 91, 65, 135, 59, 168, 212, 112, 75, 236, 155, 108, 117, 176, 169, 189, 213, 211, 130, 50, 189, 15, 9, 53, 177, 168, 20, 31, 81, 16, 239, 222, 118, 212, 197, 181, 138, 139, 8, 143, 42, 8, 160, 33, 136, 205, 108, 51, 132, 177, 48, 228, 10, 212, 205, 45, 35, 148, 134, 60, 128, 30, 113, 153, 6, 177, 170, 106, 220, 81, 254, 156, 64, 24, 242, 135, 202, 143, 70, 195, 45, 75, 170, 93, 246, 162, 12, 185, 63, 123, 252, 237, 140, 205, 62, 24, 94, 28, 114, 143, 2, 83, 11, 91, 216, 73, 207, 68, 87, 71, 204, 91, 96, 117, 52, 179, 133, 208, 182, 14, 192, 205, 248, 29, 194, 169, 2, 71, 145, 234, 55, 98, 2, 0, 186, 168, 120, 108, 152, 77, 187, 96, 187, 19, 61, 67, 40, 105, 26, 84, 149, 91, 38, 144, 130, 105, 114, 92, 94, 191, 54, 80, 131, 56, 164, 248, 219, 121, 16, 86, 38, 138, 148, 40, 239, 168, 15, 96, 53, 34, 253, 133, 63, 245, 167, 107, 74, 66, 108, 105, 74, 22, 253, 42, 176, 56, 50, 48, 118, 251, 84, 126, 47, 170, 135, 130, 43, 104, 157, 184, 222, 105, 220, 131, 151, 147, 206, 254, 146, 233, 88, 181, 14, 200, 7, 39, 41, 173, 172, 156, 104, 188, 163, 101, 41, 72, 215, 134, 9, 242, 109, 49, 179, 244, 47, 27, 252, 18, 26, 42, 80, 104, 40, 93, 45, 97, 7, 81, 178, 204, 203, 61, 81, 212, 145, 177, 12, 238, 207, 206, 246, 6, 28, 136, 79, 31, 65, 180, 239, 14, 195, 156, 243, 136, 89, 243, 178, 111, 36, 106, 23, 13, 227, 6, 11, 248, 236, 16, 184, 23, 170, 0, 69, 6, 52, 246, 125, 109, 170, 251, 139, 159, 164, 187, 84, 52, 59, 128, 166, 129, 85, 10, 134, 142, 232, 32, 52, 234, 123, 99, 40, 141, 84, 224, 22, 173, 71, 217, 58, 206, 150, 184, 198, 1, 42, 122, 96, 21, 148, 220, 38, 80, 109, 82, 157, 109, 39, 188, 148, 8, 30, 212, 243, 241, 195, 75, 45, 226, 175, 90, 156, 150, 83, 248, 160, 240, 20, 39, 148, 71, 246, 13, 241, 49, 121, 184, 89, 77, 171, 147, 247, 191, 78, 249, 242, 167, 197, 33, 18, 46, 14, 140, 122, 124, 78, 218, 243, 74, 47, 79, 23, 152, 195, 157, 244, 165, 17, 159, 250, 40, 103, 219, 3, 188, 18, 95, 75, 198, 82, 117, 96, 168, 101, 100, 185, 15, 212, 145, 166, 157, 92, 237, 187, 242, 98, 21, 134, 92, 17, 33, 119, 26, 25, 247, 65, 149, 78, 96, 162, 128, 57, 32, 214, 33, 188, 234, 194, 198, 123, 202, 29, 180, 50, 5, 158, 175, 136, 179, 79, 226, 65, 9, 153, 254, 19, 228, 254, 83, 229, 168, 215, 119, 38, 103, 148, 34, 49, 170, 80, 75, 166, 215, 83, 228, 56, 97, 71, 67, 164, 208, 150, 78, 253, 135, 186, 45, 227, 77, 171, 182, 234, 151, 6, 43, 203, 70, 2, 126, 84, 129, 146, 81, 188, 38, 252, 162, 98, 114, 104, 50, 37, 25, 8, 85, 19, 251, 129, 199, 113, 255, 19, 10, 245, 9, 182, 56, 193, 74, 177, 201, 136, 173, 90, 175, 112, 167, 102, 136, 223, 70, 140, 193, 249, 201, 85, 175, 84, 33, 210, 216, 135, 137, 142, 135, 221, 182, 203, 25, 0, 168, 202, 247, 199, 196, 51, 46, 150, 178, 243, 109, 212, 100, 233, 0, 224, 26, 86, 112, 158, 222, 222, 203, 68, 228, 28, 47, 114, 202, 255, 242, 208, 179, 177, 80, 50, 208, 86, 81, 11, 90, 15, 2, 81, 253, 84, 14, 134, 144, 175, 108, 142, 119, 52, 128, 61, 91, 65, 135, 59, 168, 212, 112, 75, 236, 155, 108, 117, 207, 109, 207, 166, 211, 130, 50, 189, 15, 9, 53, 177, 168, 20, 31, 81, 16, 239, 222, 118, 22, 219, 97, 100, 139, 8, 143, 42, 8, 160, 33, 136, 205, 108, 51, 132, 177, 48, 228, 10, 198, 211, 105, 103, 148, 134, 60, 128, 30, 113, 153, 6, 177, 170, 106, 220, 81, 254, 156, 64, 2, 252, 135, 9, 143, 70, 195, 45, 75, 170, 93, 246, 162, 12, 185, 63, 123, 252, 237, 140, 50, 16, 240, 76, 28, 114, 143, 2, 83, 11, 91, 216, 73, 207, 68, 87, 71, 204, 91, 96, 173, 141, 224, 58, 208, 182, 14, 192, 205, 248, 29, 194, 169, 2, 71, 145, 234, 55, 98, 2, 207, 50, 52, 217, 108, 152, 77, 187, 96, 187, 19, 61, 67, 40, 105, 26, 84, 149, 91, 38, 8, 208, 170, 88, 92, 94, 191, 54, 80, 131, 56, 164, 248, 219, 121, 16, 86, 38, 138, 148, 62, 246, 52, 8, 96, 53, 34, 253, 133, 63, 245, 167, 107, 74, 66, 108, 105, 74, 22, 253, 116, 24, 130, 90, 48, 118, 251, 84, 126, 47, 170, 135, 130, 43, 104, 157, 184, 222, 105, 220, 19, 96, 235, 251, 254, 146, 233, 88, 181, 14, 200, 7, 39, 41, 173, 172, 156, 104, 188, 163, 91, 68, 54, 121, 134, 9, 242, 109, 49, 179, 244, 47, 27, 252, 18, 26, 42, 80, 104, 40, 40, 105, 219, 163, 81, 178, 204, 203, 61, 81, 212, 145, 177, 12, 238, 207, 206, 246, 6, 28, 250, 210, 79, 17, 180, 239, 14, 195, 156, 243, 136, 89, 243, 178, 111, 36, 106, 23, 13, 227, 191, 127, 193, 151, 16, 184, 23, 170, 0, 69, 6, 52, 246, 125, 109, 170, 251, 139, 159, 164, 190, 236, 65, 244, 128, 166, 129, 85, 10, 134, 142, 232, 32, 52, 234, 123, 99, 40, 141, 84, 55, 104, 119, 162, 217, 58, 206, 150, 184, 198, 1, 42, 122, 96, 21, 148, 220, 38, 80, 109, 205, 32, 98, 238, 188, 148, 8, 30, 212, 243, 241, 195, 75, 45, 226, 175, 90, 156, 150, 83, 199, 239, 40, 230, 39, 148, 71, 246, 13, 241, 49, 121, 184, 89, 77, 171, 147, 247, 191, 78, 77, 241, 137, 75, 33, 18, 46, 14, 140, 122, 124, 78, 218, 243, 74, 47, 79, 23, 152, 195, 204, 247, 230, 75, 159, 250, 40, 103, 219, 3, 188, 18, 95, 75, 198, 82, 117, 96, 168, 101, 87, 48, 224, 87, 145, 166, 157, 92, 237, 187, 242, 98, 21, 134, 92, 17, 33, 119, 26, 25, 42, 149, 141, 231, 193, 228, 15, 184, 179, 117, 29, 197, 121, 216, 117, 192, 219, 146, 96, 102, 47, 11, 34, 111, 156, 5, 120, 226, 198, 101, 110, 141, 172, 89, 110, 160, 150, 33, 232, 69, 72, 159, 0, 94, 106, 179, 220, 51, 141, 253, 130, 127, 176, 70, 66, 24, 140, 169, 59, 15, 202, 187, 130, 53, 64, 205, 55, 40, 153, 76, 195, 52, 223, 203, 181, 223, 119, 136, 184, 179, 139, 211, 2, 102, 82, 71, 51, 193, 32, 111, 174, 126, 104, 87, 161, 148, 21, 163, 21, 140, 0, 65, 184, 204, 83, 249, 232, 124, 142, 194, 83, 200, 146, 175, 241, 195, 43, 23, 159, 242, 136, 124, 151, 203, 48, 29, 186, 116, 92, 252, 131, 195, 236, 121, 55, 234, 233, 235, 22, 202, 199, 221, 3, 247, 78, 135, 223, 215, 0, 133, 8, 191, 41, 209, 92, 208, 30, 68, 12, 16, 171, 252, 3, 130, 107, 32, 200, 172, 179, 185, 200, 155, 130, 231, 190, 237, 226, 46, 228, 128, 25, 9, 153, 56, 112, 97, 20, 196, 187, 11, 42, 212, 255, 52, 175, 200, 185, 212, 228, 125, 153, 179, 245, 56, 229, 111, 190, 106, 6, 78, 173, 41, 173, 88, 214, 231, 170, 105, 215, 60, 59, 169, 177, 244, 42, 235, 215, 136, 51, 2, 36, 241, 233, 75, 155, 132, 222, 34, 174, 45, 10, 35, 57, 254, 107, 40, 80, 5, 225, 8, 39, 125, 58, 198, 88, 60, 94, 190, 201, 111, 249, 199, 225, 114, 188, 94, 190, 45, 31, 126, 2, 39, 238, 52, 59, 254, 157, 13, 224, 240, 179, 177, 132, 244, 48, 163, 33, 254, 164, 31, 78, 127, 175, 37, 30, 138, 49, 20, 241, 224, 7, 153, 7, 24, 146, 225, 124, 83, 210, 233, 158, 253, 250, 5, 6, 45, 206, 88, 160, 138, 167, 216, 0, 156, 30, 166, 75, 248, 197, 191, 230, 71, 213, 210, 251, 143, 233, 167, 222, 254, 71, 101, 216, 86, 44, 102, 127, 39, 186, 224, 100, 47, 209, 53, 98, 49, 162, 255, 7, 48, 177, 2, 85, 70, 136, 206, 224, 131, 88, 49, 11, 45, 215, 254, 171, 61, 54, 41, 164, 53, 56, 245, 155, 113, 144, 190, 236, 110, 229, 20, 133, 18, 157, 95, 225, 54, 192, 58, 109, 138, 118, 76, 127, 189, 183, 129, 224, 4, 112, 214, 14, 245, 127, 93, 76, 107, 86, 216, 176, 6, 99, 211, 13, 41, 202, 216, 164, 62, 59, 86, 62, 186, 139, 17, 28, 17, 76, 88, 71, 81, 7, 58, 129, 205, 176, 202, 201, 83, 10, 240, 85, 183, 138, 157, 77, 100, 46, 31, 20, 95, 220, 83, 245, 69, 69, 220, 146, 40, 6, 100, 206, 163, 223, 78, 228, 33, 34, 106, 189, 204, 210, 173, 116, 66, 57, 197, 7, 169, 186, 133, 138, 153, 14, 172, 81, 193, 65, 76, 208, 126, 242, 79, 159, 110, 119, 135, 104, 233, 129, 244, 214, 132, 220, 181, 73, 90, 39, 60, 206, 89, 159, 153, 147, 61, 235, 136, 80, 47, 189, 60, 204, 66, 21, 142, 183, 244, 164, 153, 100, 238, 99, 93, 40, 124, 247, 87, 82, 72, 69, 217, 162, 219, 14, 150, 54, 201, 55, 188, 67, 213, 84, 23, 178, 124, 147, 248, 154, 154, 180, 108, 221, 108, 185, 157, 236, 21, 1, 196, 161, 190, 59, 36, 182, 115, 118, 213, 63, 56, 87, 199, 17, 54, 219, 189, 109, 120, 1, 78, 39, 87, 67, 121, 180, 176, 143, 142, 82, 251, 16, 116, 122, 156, 203, 119, 198, 142, 148, 60, 0, 220, 89, 42, 24, 218, 14, 26, 248, 141, 159, 188, 101, 209, 114, 7, 151, 179, 103, 129, 203, 162, 140, 36, 35, 100, 91, 192, 231, 125, 167, 197, 232, 201, 218, 66, 8, 124, 98, 115, 83, 85, 40, 221, 229, 232, 86, 170, 37, 157, 17, 22, 181, 129, 223, 15, 80, 133, 4, 212, 187, 222, 59, 232, 53, 155, 34, 157, 11, 232, 43, 124, 95, 208, 90, 212, 90, 245, 107, 230, 130, 82, 174, 187, 40, 218, 83, 233, 2, 121, 179, 40, 118, 164, 83, 253, 240, 2, 234, 34, 208, 5, 230, 72, 0, 153, 155, 7, 90, 93, 48, 219, 110, 186, 134, 181, 121, 34, 124, 108, 92, 89, 92, 28, 226, 153, 223, 30, 172, 16, 253, 230, 66, 48, 239, 233, 188, 85, 27, 125, 99, 52, 239, 29, 32, 89, 251, 240, 175, 203, 233, 104, 103, 170, 208, 169, 58, 183, 222, 122, 252, 35, 166, 140, 77, 141, 28, 159, 88, 23, 243, 234, 115, 234, 106, 77, 232, 171, 52, 87, 29, 88, 175, 118, 41, 111, 65, 135, 100, 174, 53, 104, 97, 246, 173, 2, 0, 13, 142, 47, 249, 21, 152, 56, 32, 119, 252, 70, 31, 66, 113, 185, 78, 102, 103, 9, 195, 24, 150, 142, 114, 5, 193, 194, 49, 151, 221, 179, 213, 85, 182, 211, 184, 28, 236, 179, 120, 8, 175, 71, 240, 58, 59, 81, 206, 123, 155, 79, 90, 170, 203, 58, 123, 242, 144, 210, 227, 6, 107, 184, 80, 81, 222, 63, 155, 211, 59, 124, 64, 222, 5, 10, 165, 105, 17, 136, 73, 149, 146, 90, 211, 14, 75, 173, 50, 84, 251, 167, 65, 243, 74, 138, 52, 9, 245, 71, 133, 98, 242, 178, 101, 234, 97, 82, 83, 187, 76, 88, 255, 187, 158, 160, 125, 185, 187, 207, 97, 164, 174, 113, 244, 140, 124, 235, 55, 170, 15, 54, 81, 47, 207, 47, 68, 30, 124, 244, 183, 15, 147, 93, 9, 242, 118, 154, 55, 196, 155, 97, 109, 94, 70, 65, 199, 151, 57, 222, 221, 26, 52, 184, 229, 175, 5, 108, 74, 161, 146, 137, 155, 106, 252, 135, 55, 240, 63, 100, 160, 155, 196, 180, 45, 34, 230, 136, 117, 254, 155, 211, 244, 129, 134, 104, 196, 157, 119, 51, 183, 42, 99, 186, 2, 231, 216, 71, 222, 50, 162, 4, 62, 145, 177, 105, 191, 249, 239, 42, 45, 164, 245, 101, 58, 32, 221, 217, 85, 243, 238, 167, 57, 44, 71, 162, 242, 15, 98, 220, 220, 94, 19, 73, 12, 149, 39, 178, 237, 190, 230, 205, 199, 8, 94, 251, 62, 165, 167, 120, 56, 84, 165, 192, 205, 136, 52, 48, 45, 115, 148, 112, 140, 53, 15, 97, 128, 109, 180, 143, 154, 185, 28, 160, 196, 155, 123, 10, 65, 187, 127, 193, 116, 16, 167, 70, 127, 112, 234, 33, 43, 45, 196, 95, 168, 223, 218, 219, 169, 163, 248, 184, 1, 86, 27, 207, 167, 226, 199, 209, 85, 13, 10, 197, 86, 129, 244, 43, 194, 79, 84, 42, 23, 217, 170, 29, 144, 166, 27, 72, 169, 138, 180, 117, 108, 51, 247, 25, 54, 213, 131, 214, 96, 37, 252, 127, 233, 32, 171, 32, 235, 246, 62, 212, 180, 137, 224, 215, 199, 34, 18, 216, 72, 11, 25, 74, 147, 72, 168, 73, 98, 4, 221, 118, 30, 145, 202, 152, 88, 164, 171, 58, 150, 142, 232, 185, 198, 180, 253, 114, 5, 213, 181, 109, 175, 172, 173, 196, 234, 156, 185, 112, 230, 183, 64, 99, 11, 225, 86, 186, 200, 152, 249, 91, 140, 80, 209, 207, 1, 241, 108, 239, 130, 107, 99, 33, 127, 185, 178, 112, 43, 31, 71, 221, 91, 160, 169, 131, 204, 155, 39, 141, 24, 227, 150, 144, 61, 105, 123, 168, 220, 31, 209, 118, 22, 115, 160, 58, 247, 134, 140, 36, 35, 100, 91, 192, 231, 125, 167, 197, 232, 201, 218, 66, 8, 124, 30, 40, 135, 4, 40, 221, 229, 232, 86, 170, 37, 157, 17, 22, 181, 129, 223, 15, 80, 133, 166, 232, 112, 141, 59, 232, 53, 155, 34, 157, 11, 232, 43, 124, 95, 208, 90, 212, 90, 245, 249, 97, 226, 31, 174, 187, 40, 218, 83, 233, 2, 121, 179, 40, 118, 164, 83, 253, 240, 2, 146, 51, 221, 58, 230, 72, 0, 153, 155, 7, 90, 93, 48, 219, 110, 186, 134, 181, 121, 34, 154, 97, 106, 222, 92, 28, 226, 153, 223, 30, 172, 16, 253, 230, 66, 48, 239, 233, 188, 85, 98, 174, 73, 130, 239, 29, 32, 89, 251, 240, 175, 203, 233, 104, 103, 170, 208, 169, 58, 183, 136, 156, 64, 250, 166, 140, 77, 141, 28, 159, 88, 23, 243, 234, 115, 234, 106, 77, 232, 171, 190, 155, 117, 83, 175, 118, 41, 111, 65, 135, 100, 174, 53, 104, 97, 246, 173, 2, 0, 13, 102, 12, 204, 166, 152, 56, 32, 119, 252, 70, 31, 66, 113, 185, 78, 102, 103, 9, 195, 24, 84, 203, 205, 112, 193, 194, 49, 151, 221, 179, 213, 85, 182, 211, 184, 28, 236, 179, 120, 8, 116, 103, 157, 19, 59, 81, 206, 123, 155, 79, 90, 170, 203, 58, 123, 242, 144, 210, 227, 6, 193, 62, 152, 157, 222, 63, 155, 211, 59, 124, 64, 222, 5, 10, 165, 105, 17, 136, 73, 149, 91, 158, 143, 127, 75, 173, 50, 84, 251, 167, 65, 243, 74, 138, 52, 9, 245, 71, 133, 98, 214, 86, 202, 226, 97, 82, 83, 187, 76, 88, 255, 187, 158, 160, 125, 185, 187, 207, 97, 164, 46, 123, 255, 2, 124, 235, 55, 170, 15, 54, 81, 47, 207, 47, 68, 30, 124, 244, 183, 15, 163, 48, 41, 198, 118, 154, 55, 196, 155, 97, 109, 94, 70, 65, 199, 151, 57, 222, 221, 26, 52, 167, 248, 205, 5, 108, 74, 161, 146, 137, 155, 106, 252, 135, 55, 240, 63, 100, 160, 155, 229, 68, 155, 228, 230, 136, 117, 254, 155, 211, 244, 129, 134, 104, 196, 157, 119, 51, 183, 42, 210, 213, 101, 155, 216, 71, 222, 50, 162, 4, 62, 145, 177, 105, 191, 249, 239, 42, 45, 164, 243, 88, 58, 27, 221, 217, 85, 243, 238, 167, 57, 44, 71, 162, 242, 15, 98, 220, 220, 94, 114, 141, 65, 162, 39, 178, 237, 190, 230, 205, 199, 8, 94, 251, 62, 165, 167, 120, 56, 84, 74, 240, 66, 116, 52, 48, 45, 115, 148, 112, 140, 53, 15, 97, 128, 109, 180, 143, 154, 185, 200, 42, 140, 25, 123, 10, 65, 187, 127, 193, 116, 16, 167, 70, 127, 112, 234, 33, 43, 45, 118, 96, 110, 57, 218, 219, 169, 163, 248, 184, 1, 86, 27, 207, 167, 226, 199, 209, 85, 13, 196, 220, 166, 13, 244, 43, 194, 79, 84, 42, 23, 217, 170, 29, 144, 166, 27, 72, 169, 138, 131, 17, 73, 12, 247, 25, 54, 213, 131, 214, 96, 37, 252, 127, 233, 32, 171, 32, 235, 246, 22, 41, 245, 88, 224, 215, 199, 34, 18, 216, 72, 11, 25, 74, 147, 72, 168, 73, 98, 4, 95, 115, 186, 211, 202, 152, 88, 164, 171, 58, 150, 142, 232, 185, 198, 180, 253, 114, 5, 213, 4, 101, 81, 48, 173, 196, 234, 156, 185, 112, 230, 183, 64, 99, 11, 225, 86, 186, 200, 152, 150, 228, 253, 54, 209, 207, 1, 241, 108, 239, 130, 107, 99, 33, 127, 185, 178, 112, 43, 31, 56, 95, 102, 106, 169, 131, 204, 155, 39, 141, 24, 227, 150, 144, 61, 105, 123, 168, 220, 31, 156, 197, 73, 210, 160, 58, 247, 134, 140, 36, 35, 100, 91, 192, 231, 125, 167, 197, 232, 201, 93, 32, 112, 196, 30, 40, 135, 4, 40, 221, 229, 232, 86, 170, 37, 157, 17, 22, 181, 129, 204, 225, 20, 213, 166, 232, 112, 141, 59, 232, 53, 155, 34, 157, 11, 232, 43, 124, 95, 208, 149, 196, 79, 76, 249, 97, 226, 31, 174, 187, 40, 218, 83, 233, 2, 121, 179, 40, 118, 164, 23, 58, 222, 17, 146, 51, 221, 58, 230, 72, 0, 153, 155, 7, 90, 93, 48, 219, 110, 186, 205, 25, 243, 230, 154, 97, 106, 222, 92, 28, 226, 153, 223, 30, 172, 16, 253, 230, 66, 48, 44, 81, 210, 184, 98, 174, 73, 130, 239, 29, 32, 89, 251, 240, 175, 203, 233, 104, 103, 170, 121, 96, 26, 78, 136, 156, 64, 250, 166, 140, 77, 141, 28, 159, 88, 23, 243, 234, 115, 234, 202, 181, 219, 163, 190, 155, 117, 83, 175, 118, 41, 111, 65, 135, 100, 174, 53, 104, 97, 246, 2, 228, 215, 199, 102, 12, 204, 166, 152, 56, 32, 119, 252, 70, 31, 66, 113, 185, 78, 102, 237, 11, 175, 93, 84, 203, 205, 112, 193, 194, 49, 151, 221, 179, 213, 85, 182, 211, 184, 28, 225, 154, 30, 148, 116, 103, 157, 19, 59, 81, 206, 123, 155, 79, 90, 170, 203, 58, 123, 242, 154, 178, 186, 228, 193, 62, 152, 157, 222, 63, 155, 211, 59, 124, 64, 222, 5, 10, 165, 105, 196, 224, 32, 70, 91, 158, 143, 127, 75, 173, 50, 84, 251, 167, 65, 243, 74, 138, 52, 9, 252, 130, 2, 173, 214, 86, 202, 226, 97, 82, 83, 187, 76, 88, 255, 187, 158, 160, 125, 185, 1, 215, 64, 143, 46, 123, 255, 2, 124, 235, 55, 170, 15, 54, 81, 47, 207, 47, 68, 30, 59, 7, 46, 140, 163, 48, 41, 198, 118, 154, 55, 196, 155, 97, 109, 94, 70, 65, 199, 151, 254, 111, 132, 44, 52, 167, 248, 205, 5, 108, 74, 161, 146, 137, 155, 106, 252, 135, 55, 240, 89, 167, 67, 225, 229, 68, 155, 228, 230, 136, 117, 254, 155, 211, 244, 129, 134, 104, 196, 157, 98, 245, 26, 155, 210, 213, 101, 155, 216, 71, 222, 50, 162, 4, 62, 145, 177, 105, 191, 249, 60, 56, 48, 123, 243, 88, 58, 27, 221, 217, 85, 243, 238, 167, 57, 44, 71, 162, 242, 15, 57, 219, 224, 178, 114, 141, 65, 162, 39, 178, 237, 190, 230, 205, 199, 8, 94, 251, 62, 165, 52, 136, 92, 5, 74, 240, 66, 116, 52, 48, 45, 115, 148, 112, 140, 53, 15, 97, 128, 109, 118, 250, 127, 56, 200, 42, 140, 25, 123, 10, 65, 187, 127, 193, 116, 16, 167, 70, 127, 112, 47, 132, 4, 154, 118, 96, 110, 57, 218, 219, 169, 163, 248, 184, 1, 86, 27, 207, 167, 226, 89, 81, 19, 252, 196, 220, 166, 13, 244, 43, 194, 79, 84, 42, 23, 217, 170, 29, 144, 166, 241, 25, 90, 147, 131, 17, 73, 12, 247, 25, 54, 213, 131, 214, 96, 37, 252, 127, 233, 32, 179, 178, 48, 154, 22, 41, 245, 88, 224, 215, 199, 34, 18, 216, 72, 11, 25, 74, 147, 72, 60, 105, 181, 208, 95, 115, 186, 211, 202, 152, 88, 164, 171, 58, 150, 142, 232, 185, 198, 180, 194, 208, 37, 44, 4, 101, 81, 48, 173, 196, 234, 156, 185, 112, 230, 183, 64, 99, 11, 225, 25, 49, 40, 217, 150, 228, 253, 54, 209, 207, 1, 241, 108, 239, 130, 107, 99, 33, 127, 185, 54, 217, 236, 131, 56, 95, 102, 106, 169, 131, 204, 155, 39, 141, 24, 227, 150, 144, 61, 105, 80, 102, 114, 45, 156, 197, 73, 210, 160, 58, 247, 134, 140, 36, 35, 100, 91, 192, 231, 125, 78, 57, 203, 81, 93, 32, 112, 196, 30, 40, 135, 4, 40, 221, 229, 232, 86, 170, 37, 157, 211, 216, 208, 185, 204, 225, 20, 213, 166, 232, 112, 141, 59, 232, 53, 155, 34, 157, 11, 232, 63, 150, 146, 54, 149, 196, 79, 76, 249, 97, 226, 31, 174, 187, 40, 218, 83, 233, 2, 121, 94, 41, 165, 20, 23, 58, 222, 17, 146, 51, 221, 58, 230, 72, 0, 153, 155, 7, 90, 93, 88, 60, 183, 210, 205, 25, 243, 230, 154, 97, 106, 222, 92, 28, 226, 153, 223, 30, 172, 16, 231, 61, 113, 146, 44, 81, 210, 184, 98, 174, 73, 130, 239, 29, 32, 89, 251, 240, 175, 203, 46, 3, 126, 96, 121, 96, 26, 78, 136, 156, 64, 250, 166, 140, 77, 141, 28, 159, 88, 23, 229, 56, 201, 119, 202, 181, 219, 163, 190, 155, 117, 83, 175, 118, 41, 111, 65, 135, 100, 174, 99, 149, 131, 3, 2, 228, 215, 199, 102, 12, 204, 166, 152, 56, 32, 119, 252, 70, 31, 66, 222, 246, 36, 195, 237, 11, 175, 93, 84, 203, 205, 112, 193, 194, 49, 151, 221, 179, 213, 85, 127, 99, 252, 69, 225, 154, 30, 148, 116, 103, 157, 19, 59, 81, 206, 123, 155, 79, 90, 170, 157, 67, 43, 242, 154, 178, 186, 228, 193, 62, 152, 157, 222, 63, 155, 211, 59, 124, 64, 222, 153, 193, 123, 157, 196, 224, 32, 70, 91, 158, 143, 127, 75, 173, 50, 84, 251, 167, 65, 243, 88, 69, 66, 186, 252, 130, 2, 173, 214, 86, 202, 226, 97, 82, 83, 187, 76, 88, 255, 187, 21, 236, 100, 86, 1, 215, 64, 143, 46, 123, 255, 2, 124, 235, 55, 170, 15, 54, 81, 47, 182, 117, 118, 209, 59, 7, 46, 140, 163, 48, 41, 198, 118, 154, 55, 196, 155, 97, 109, 94, 200, 91, 195, 216, 254, 111, 132, 44, 52, 167, 248, 205, 5, 108, 74, 161, 146, 137, 155, 106, 227, 1, 186, 205, 89, 167, 67, 225, 229, 68, 155, 228, 230, 136, 117, 254, 155, 211, 244, 129, 20, 228, 179, 237, 98, 245, 26, 155, 210, 213, 101, 155, 216, 71, 222, 50, 162, 4, 62, 145, 83, 18, 63, 128, 60, 56, 48, 123, 243, 88, 58, 27, 221, 217, 85, 243, 238, 167, 57, 44, 245, 74, 252, 213, 57, 219, 224, 178, 114, 141, 65, 162, 39, 178, 237, 190, 230, 205, 199, 8, 94, 160, 158, 204, 52, 136, 92, 5, 74, 240, 66, 116, 52, 48, 45, 115, 148, 112, 140, 53, 224, 63, 49, 228, 118, 250, 127, 56, 200, 42, 140, 25, 123, 10, 65, 187, 127, 193, 116, 16, 129, 138, 16, 150, 47, 132, 4, 154, 118, 96, 110, 57, 218, 219, 169, 163, 248, 184, 1, 86, 119, 88, 143, 132, 89, 81, 19, 252, 196, 220, 166, 13, 244, 43, 194, 79, 84, 42, 23, 217, 81, 170, 207, 62, 241, 25, 90, 147, 131, 17, 73, 12, 247, 25, 54, 213, 131, 214, 96, 37, 180, 62, 91, 66, 179, 178, 48, 154, 22, 41, 245, 88, 224, 215, 199, 34, 18, 216, 72, 11, 190, 211, 216, 88, 60, 105, 181, 208, 95, 115, 186, 211, 202, 152, 88, 164, 171, 58, 150, 142, 44, 160, 82, 211, 194, 208, 37, 44, 4, 101, 81, 48, 173, 196, 234, 156, 185, 112, 230, 183, 251, 138, 13, 45, 25, 49, 40, 217, 150, 228, 253, 54, 209, 207, 1, 241, 108, 239, 130, 107, 102, 55, 122, 116, 54, 217, 236, 131, 56, 95, 102, 106, 169, 131, 204, 155, 39, 141, 24, 227, 155, 131, 95, 181, 33, 18, 123, 188, 4, 145, 96, 166, 169, 19, 93, 113, 13, 224, 113, 51, 192, 67, 184, 200, 134, 215, 147, 117, 222, 211, 104, 218, 203, 96, 14, 36, 190, 147, 105, 180, 150, 233, 157, 85, 151, 193, 38, 244, 1, 220, 56, 95, 207, 180, 181, 250, 92, 249, 10, 246, 239, 180, 113, 192, 27, 120, 145, 237, 129, 74, 106, 214, 198, 33, 100, 253, 107, 188, 183, 205, 234, 247, 86, 36, 185, 70, 82, 200, 13, 184, 202, 81, 40, 215, 15, 38, 12, 101, 225, 226, 8, 173, 224, 236, 5, 36, 139, 107, 11, 155, 225, 250, 93, 46, 130, 120, 230, 100, 6, 212, 210, 240, 107, 24, 90, 252, 10, 126, 104, 128, 253, 40, 168, 165, 138, 151, 247, 188, 171, 73, 203, 90, 114, 27, 15, 246, 180, 119, 190, 10, 236, 52, 3, 38, 251, 234, 159, 69, 207, 178, 13, 152, 161, 248, 163, 196, 70, 136, 183, 92, 24, 77, 194, 250, 238, 93, 107, 137, 137, 4, 85, 181, 220, 85, 195, 166, 153, 119, 204, 212, 9, 92, 231, 86, 102, 53, 97, 218, 163, 40, 111, 49, 16, 244, 30, 45, 37, 238, 162, 139, 62, 61, 176, 4, 1, 135, 161, 42, 135, 115, 234, 175, 184, 12, 200, 156, 66, 13, 53, 176, 87, 36, 58, 239, 121, 213, 103, 146, 95, 29, 75, 100, 46, 7, 222, 45, 133, 102, 203, 61, 131, 67, 6, 5, 78, 54, 227, 19, 102, 173, 245, 134, 198, 33, 13, 150, 71, 236, 77, 142, 163, 207, 30, 180, 229, 106, 236, 72, 222, 9, 175, 234, 17, 217, 81, 173, 180, 142, 70, 68, 242, 202, 208, 236, 183, 99, 145, 94, 155, 54, 93, 80, 6, 68, 28, 182, 11, 189, 123, 56, 179, 226, 102, 44, 232, 179, 219, 229, 24, 111, 8, 10, 128, 147, 143, 162, 188, 193, 12, 6, 85, 232, 59, 41, 179, 72, 224, 69, 15, 3, 97, 209, 250, 80, 132, 248, 196, 101, 8, 164, 201, 218, 185, 81, 9, 55, 227, 64, 124, 20, 166, 2, 231, 237, 235, 107, 68, 233, 64, 254, 143, 75, 32, 224, 127, 238, 80, 1, 180, 227, 84, 10, 105, 175, 102, 89, 248, 208, 51, 111, 164, 83, 193, 34, 199, 118, 97, 39, 215, 33, 49, 221, 74, 131, 184, 163, 199, 165, 148, 31, 207, 102, 173, 246, 139, 143, 5, 38, 57, 183, 45, 114, 253, 237, 114, 51, 137, 147, 133, 82, 56, 32, 95, 125, 63, 130, 233, 40, 19, 224, 174, 104, 25, 201, 242, 50, 136, 67, 133, 90, 107, 65, 150, 105, 190, 243, 138, 128, 23, 193, 38, 183, 34, 146, 55, 195, 70, 24, 32, 152, 6, 190, 120, 66, 206, 101, 241, 171, 153, 1, 218, 108, 178, 166, 16, 132, 56, 184, 202, 177, 126, 242, 117, 9, 231, 203, 57, 121, 3, 187, 170, 11, 136, 171, 206, 186, 81, 1, 168, 162, 70, 0, 145, 231, 193, 220, 156, 48, 115, 114, 2, 250, 15, 70, 67, 224, 191, 7, 89, 195, 151, 198, 40, 217, 132, 65, 187, 47, 21, 41, 241, 75, 85, 110, 97, 161, 63, 158, 144, 240, 68, 194, 242, 227, 22, 223, 94, 81, 16, 210, 75, 98, 154, 136, 245, 177, 66, 208, 201, 216, 247, 0, 150, 171, 77, 211, 92, 51, 21, 119, 19, 233, 86, 46, 63, 73, 4, 253, 253, 153, 33, 209, 249, 252, 112, 225, 84, 56, 154, 125, 16, 176, 127, 127, 235, 58, 114, 82, 242, 11, 90, 139, 100, 239, 167, 189, 181, 32, 166, 76, 36, 212, 49, 178, 66, 227, 75, 198, 116, 58, 167, 69, 76, 101, 193, 47, 229, 230, 13, 180, 35, 45, 31, 227, 254, 43, 159, 60, 149, 239, 20, 95, 88, 119, 74, 26, 10, 33, 74, 198, 47, 111, 87, 196, 165, 14, 3, 10, 159, 80, 20, 216, 142, 135, 79, 60, 179, 221, 162, 177, 228, 137, 255, 105, 171, 33, 77, 181, 150, 223, 72, 95, 209, 12, 29, 120, 50, 182, 98, 138, 39, 179, 27, 202, 63, 45, 3, 145, 85, 61, 192, 6, 16, 250, 221, 235, 68, 184, 220, 226, 65, 245, 198, 176, 39, 159, 81, 121, 139, 138, 159, 208, 32, 30, 188, 171, 41, 239, 171, 99, 148, 242, 203, 95, 17, 66, 87, 25, 217, 159, 65, 75, 20, 177, 109, 132, 32, 133, 60, 251, 90, 161, 11, 128, 213, 180, 37, 166, 112, 183, 53, 64, 169, 181, 77, 124, 72, 167, 7, 182, 172, 35, 166, 213, 115, 6, 152, 179, 37, 204, 28, 17, 64, 13, 234, 76, 223, 196, 25, 243, 195, 73, 124, 158, 146, 54, 105, 253, 142, 48, 60, 143, 206, 112, 244, 171, 181, 23, 78, 211, 10, 72, 179, 244, 131, 211, 116, 20, 53, 215, 33, 190, 107, 14, 144, 243, 251, 85, 158, 206, 113, 172, 118, 15, 171, 69, 168, 169, 94, 145, 163, 29, 117, 57, 66, 16, 183, 42, 193, 58, 47, 192, 74, 176, 216, 32, 252, 129, 150, 34, 184, 204, 6, 164, 41, 217, 152, 137, 214, 132, 142, 100, 56, 185, 207, 138, 166, 131, 39, 229, 140, 35, 71, 51, 5, 194, 186, 20, 166, 193, 213, 4, 243, 30, 37, 187, 240, 35, 158, 182, 24, 0, 45, 147, 241, 82, 188, 127, 90, 3, 38, 0, 113, 94, 121, 21, 54, 110, 23, 189, 100, 43, 51, 253, 148, 50, 80, 207, 28, 108, 161, 10, 134, 25, 114, 185, 73, 74, 185, 165, 34, 251, 7, 133, 18, 10, 54, 73, 55, 27, 68, 27, 251, 254, 55, 76, 172, 231, 21, 187, 242, 134, 130, 151, 109, 185, 82, 193, 12, 187, 28, 12, 231, 157, 16, 162, 212, 200, 87, 103, 117, 217, 119, 236, 24, 210, 178, 21, 135, 87, 214, 225, 31, 212, 19, 251, 31, 159, 98, 13, 149, 49, 148, 216, 113, 255, 173, 95, 199, 251, 2, 136, 224, 64, 177, 88, 211, 13, 92, 254, 216, 185, 229, 250, 112, 13, 109, 30, 163, 52, 141, 48, 11, 51, 34, 71, 74, 119, 222, 128, 27, 38, 139, 44, 224, 140, 64, 110, 233, 215, 202, 92, 218, 239, 86, 51, 46, 65, 241, 128, 33, 254, 230, 97, 100, 110, 34, 246, 87, 25, 60, 68, 128, 145, 93, 27, 171, 17, 214, 42, 237, 22, 35, 34, 39, 212, 185, 174, 190, 104, 79, 45, 143, 60, 246, 210, 81, 214, 65, 20, 122, 1, 89, 91, 48, 37, 147, 77, 75, 129, 185, 112, 15, 106, 77, 103, 144, 38, 92, 176, 1, 87, 188, 115, 165, 157, 97, 228, 226, 118, 16, 5, 208, 235, 132, 222, 207, 54, 74, 179, 92, 128, 114, 191, 249, 120, 81, 158, 187, 228, 42, 216, 103, 239, 208, 10, 230, 28, 142, 34, 176, 217, 225, 34, 135, 117, 241, 17, 20, 36, 83, 6, 255, 37, 176, 192, 160, 16, 245, 126, 19, 213, 153, 144, 162, 17, 20, 182, 155, 104, 171, 14, 137, 151, 69, 227, 177, 94, 54, 207, 143, 89, 149, 179, 215, 245, 115, 175, 107, 211, 21, 11, 98, 105, 102, 106, 76, 91, 131, 250, 11, 6, 236, 238, 179, 192, 32, 105, 226, 106, 188, 200, 2, 190, 4, 38, 22, 11, 91, 151, 227, 47, 238, 172, 25, 168, 160, 198, 196, 119, 183, 40, 35, 142, 248, 110, 125, 132, 217, 25, 196, 37, 56, 38, 232, 120, 203, 252, 251, 74, 13, 129, 125, 32, 35, 45, 31, 227, 254, 43, 159, 60, 149, 239, 20, 95, 88, 119, 74, 26, 246, 178, 150, 53, 47, 111, 87, 196, 165, 14, 3, 10, 159, 80, 20, 216, 142, 135, 79, 60, 65, 36, 132, 235, 228, 137, 255, 105, 171, 33, 77, 181, 150, 223, 72, 95, 209, 12, 29, 120, 240, 24, 93, 112, 39, 179, 27, 202, 63, 45, 3, 145, 85, 61, 192, 6, 16, 250, 221, 235, 83, 193, 164, 235, 65, 245, 198, 176, 39, 159, 81, 121, 139, 138, 159, 208, 32, 30, 188, 171, 37, 124, 158, 19, 148, 242, 203, 95, 17, 66, 87, 25, 217, 159, 65, 75, 20, 177, 109, 132, 217, 159, 166, 4, 90, 161, 11, 128, 213, 180, 37, 166, 112, 183, 53, 64, 169, 181, 77, 124, 59, 9, 148, 38, 172, 35, 166, 213, 115, 6, 152, 179, 37, 204, 28, 17, 64, 13, 234, 76, 94, 135, 118, 87, 195, 73, 124, 158, 146, 54, 105, 253, 142, 48, 60, 143, 206, 112, 244, 171, 128, 69, 251, 207, 10, 72, 179, 244, 131, 211, 116, 20, 53, 215, 33, 190, 107, 14, 144, 243, 88, 3, 230, 209, 113, 172, 118, 15, 171, 69, 168, 169, 94, 145, 163, 29, 117, 57, 66, 16, 119, 47, 124, 81, 47, 192, 74, 176, 216, 32, 252, 129, 150, 34, 184, 204, 6, 164, 41, 217, 54, 193, 140, 24, 142, 100, 56, 185, 207, 138, 166, 131, 39, 229, 140, 35, 71, 51, 5, 194, 102, 93, 216, 34, 213, 4, 243, 30, 37, 187, 240, 35, 158, 182, 24, 0, 45, 147, 241, 82, 193, 179, 155, 232, 38, 0, 113, 94, 121, 21, 54, 110, 23, 189, 100, 43, 51, 253, 148, 50, 102, 197, 54, 115, 161, 10, 134, 25, 114, 185, 73, 74, 185, 165, 34, 251, 7, 133, 18, 10, 21, 29, 32, 165, 68, 27, 251, 254, 55, 76, 172, 231, 21, 187, 242, 134, 130, 151, 109, 185, 233, 17, 12, 176, 28, 12, 231, 157, 16, 162, 212, 200, 87, 103, 117, 217, 119, 236, 24, 210, 185, 81, 225, 141, 214, 225, 31, 212, 19, 251, 31, 159, 98, 13, 149, 49, 148, 216, 113, 255, 95, 248, 92, 72, 2, 136, 224, 64, 177, 88, 211, 13, 92, 254, 216, 185, 229, 250, 112, 13, 222, 7, 82, 105, 141, 48, 11, 51, 34, 71, 74, 119, 222, 128, 27, 38, 139, 44, 224, 140, 79, 159, 67, 106, 202, 92, 218, 239, 86, 51, 46, 65, 241, 128, 33, 254, 230, 97, 100, 110, 120, 72, 135, 68, 60, 68, 128, 145, 93, 27, 171, 17, 214, 42, 237, 22, 35, 34, 39, 212, 146, 126, 136, 142, 79, 45, 143, 60, 246, 210, 81, 214, 65, 20, 122, 1, 89, 91, 48, 37, 246, 47, 149, 21, 185, 112, 15, 106, 77, 103, 144, 38, 92, 176, 1, 87, 188, 115, 165, 157, 84, 61, 10, 193, 16, 5, 208, 235, 132, 222, 207, 54, 74, 179, 92, 128, 114, 191, 249, 120, 255, 163, 230, 6, 42, 216, 103, 239, 208, 10, 230, 28, 142, 34, 176, 217, 225, 34, 135, 117, 163, 46, 243, 43, 83, 6, 255, 37, 176, 192, 160, 16, 245, 126, 19, 213, 153, 144, 162, 17, 189, 176, 206, 237, 171, 14, 137, 151, 69, 227, 177, 94, 54, 207, 143, 89, 149, 179, 215, 245, 80, 121, 209, 179, 21, 11, 98, 105, 102, 106, 76, 91, 131, 250, 11, 6, 236, 238, 179, 192, 29, 214, 206, 247, 188, 200, 2, 190, 4, 38, 22, 11, 91, 151, 227, 47, 238, 172, 25, 168, 190, 117, 12, 118, 183, 40, 35, 142, 248, 110, 125, 132, 217, 25, 196, 37, 56, 38, 232, 120, 9, 42, 192, 188, 13, 129, 125, 32, 35, 45, 31, 227, 254, 43, 159, 60, 149, 239, 20, 95, 76, 8, 93, 41, 246, 178, 150, 53, 47, 111, 87, 196, 165, 14, 3, 10, 159, 80, 20, 216, 78, 45, 147, 88, 65, 36, 132, 235, 228, 137, 255, 105, 171, 33, 77, 181, 150, 223, 72, 95, 60, 107, 110, 170, 240, 24, 93, 112, 39, 179, 27, 202, 63, 45, 3, 145, 85, 61, 192, 6, 94, 69, 161, 39, 83, 193, 164, 235, 65, 245, 198, 176, 39, 159, 81, 121, 139, 138, 159, 208, 9, 167, 67, 33, 37, 124, 158, 19, 148, 242, 203, 95, 17, 66, 87, 25, 217, 159, 65, 75, 147, 112, 129, 221, 217, 159, 166, 4, 90, 161, 11, 128, 213, 180, 37, 166, 112, 183, 53, 64, 67, 1, 184, 250, 59, 9, 148, 38, 172, 35, 166, 213, 115, 6, 152, 179, 37, 204, 28, 17, 42, 53, 52, 151, 94, 135, 118, 87, 195, 73, 124, 158, 146, 54, 105, 253, 142, 48, 60, 143, 157, 225, 73, 183, 128, 69, 251, 207, 10, 72, 179, 244, 131, 211, 116, 20, 53, 215, 33, 190, 52, 186, 108, 151, 88, 3, 230, 209, 113, 172, 118, 15, 171, 69, 168, 169, 94, 145, 163, 29, 191, 123, 148, 145, 119, 47, 124, 81, 47, 192, 74, 176, 216, 32, 252, 129, 150, 34, 184, 204, 63, 3, 2, 95, 54, 193, 140, 24, 142, 100, 56, 185, 207, 138, 166, 131, 39, 229, 140, 35, 193, 175, 129, 62, 102, 93, 216, 34, 213, 4, 243, 30, 37, 187, 240, 35, 158, 182, 24, 0, 165, 149, 139, 123, 193, 179, 155, 232, 38, 0, 113, 94, 121, 21, 54, 110, 23, 189, 100, 43, 29, 116, 109, 50, 102, 197, 54, 115, 161, 10, 134, 25, 114, 185, 73, 74, 185, 165, 34, 251, 155, 144, 143, 63, 21, 29, 32, 165, 68, 27, 251, 254, 55, 76, 172, 231, 21, 187, 242, 134, 106, 221, 237, 111, 233, 17, 12, 176, 28, 12, 231, 157, 16, 162, 212, 200, 87, 103, 117, 217, 61, 50, 67, 151, 185, 81, 225, 141, 214, 225, 31, 212, 19, 251, 31, 159, 98, 13, 149, 49, 236, 128, 40, 31, 95, 248, 92, 72, 2, 136, 224, 64, 177, 88, 211, 13, 92, 254, 216, 185, 67, 127, 84, 82, 222, 7, 82, 105, 141, 48, 11, 51, 34, 71, 74, 119, 222, 128, 27, 38, 155, 209, 197, 39, 79, 159, 67, 106, 202, 92, 218, 239, 86, 51, 46, 65, 241, 128, 33, 254, 105, 124, 160, 122, 120, 72, 135, 68, 60, 68, 128, 145, 93, 27, 171, 17, 214, 42, 237, 22, 202, 248, 75, 20, 146, 126, 136, 142, 79, 45, 143, 60, 246, 210, 81, 214, 65, 20, 122, 1, 213, 100, 119, 184, 246, 47, 149, 21, 185, 112, 15, 106, 77, 103, 144, 38, 92, 176, 1, 87, 160, 236, 183, 69, 84, 61, 10, 193, 16, 5, 208, 235, 132, 222, 207, 54, 74, 179, 92, 128, 4, 134, 37, 23, 255, 163, 230, 6, 42, 216, 103, 239, 208, 10, 230, 28, 142, 34, 176, 217, 69, 153, 49, 105, 163, 46, 243, 43, 83, 6, 255, 37, 176, 192, 160, 16, 245, 126, 19, 213, 84, 4, 214, 218, 189, 176, 206, 237, 171, 14, 137, 151, 69, 227, 177, 94, 54, 207, 143, 89, 110, 69, 87, 125, 80, 121, 209, 179, 21, 11, 98, 105, 102, 106, 76, 91, 131, 250, 11, 6, 252, 55, 84, 236, 29, 214, 206, 247, 188, 200, 2, 190, 4, 38, 22, 11, 91, 151, 227, 47, 115, 77, 47, 204, 190, 117, 12, 118, 183, 40, 35, 142, 248, 110, 125, 132, 217, 25, 196, 37, 52, 33, 236, 180, 9, 42, 192, 188, 13, 129, 125, 32, 35, 45, 31, 227, 254, 43, 159, 60, 45, 112, 228, 39, 76, 8, 93, 41, 246, 178, 150, 53, 47, 111, 87, 196, 165, 14, 3, 10, 156, 79, 164, 119, 78, 45, 147, 88, 65, 36, 132, 235, 228, 137, 255, 105, 171, 33, 77, 181, 109, 84, 140, 168, 60, 107, 110, 170, 240, 24, 93, 112, 39, 179, 27, 202, 63, 45, 3, 145, 197, 125, 151, 220, 94, 69, 161, 39, 83, 193, 164, 235, 65, 245, 198, 176, 39, 159, 81, 121, 10, 69, 24, 87, 9, 167, 67, 33, 37, 124, 158, 19, 148, 242, 203, 95, 17, 66, 87, 25, 233, 98, 97, 101, 147, 112, 129, 221, 217, 159, 166, 4, 90, 161, 11, 128, 213, 180, 37, 166, 40, 28, 86, 161, 67, 1, 184, 250, 59, 9, 148, 38, 172, 35, 166, 213, 115, 6, 152, 179, 69, 209, 87, 176, 42, 53, 52, 151, 94, 135, 118, 87, 195, 73, 124, 158, 146, 54, 105, 253, 87, 35, 147, 133, 157, 225, 73, 183, 128, 69, 251, 207, 10, 72, 179, 244, 131, 211, 116, 20, 169, 81, 55, 29, 52, 186, 108, 151, 88, 3, 230, 209, 113, 172, 118, 15, 171, 69, 168, 169, 55, 98, 206, 242, 191, 123, 148, 145, 119, 47, 124, 81, 47, 192, 74, 176, 216, 32, 252, 129, 245, 171, 103, 109, 63, 3, 2, 95, 54, 193, 140, 24, 142, 100, 56, 185, 207, 138, 166, 131, 180, 187, 24, 197, 193, 175, 129, 62, 102, 93, 216, 34, 213, 4, 243, 30, 37, 187, 240, 35, 221, 221, 141, 177, 165, 149, 139, 123, 193, 179, 155, 232, 38, 0, 113, 94, 121, 21, 54, 110, 225, 158, 191, 195, 29, 116, 109, 50, 102, 197, 54, 115, 161, 10, 134, 25, 114, 185, 73, 74, 242, 188, 146, 11, 155, 144, 143, 63, 21, 29, 32, 165, 68, 27, 251, 254, 55, 76, 172, 231, 206, 79, 180, 111, 106, 221, 237, 111, 233, 17, 12, 176, 28, 12, 231, 157, 16, 162, 212, 200, 204, 155, 22, 247, 61, 50, 67, 151, 185, 81, 225, 141, 214, 225, 31, 212, 19, 251, 31, 159, 220, 133, 17, 44, 236, 128, 40, 31, 95, 248, 92, 72, 2, 136, 224, 64, 177, 88, 211, 13, 197, 37, 233, 214, 67, 127, 84, 82, 222, 7, 82, 105, 141, 48, 11, 51, 34, 71, 74, 119, 100, 155, 47, 122, 155, 209, 197, 39, 79, 159, 67, 106, 202, 92, 218, 239, 86, 51, 46, 65, 94, 86, 23, 9, 105, 124, 160, 122, 120, 72, 135, 68, 60, 68, 128, 145, 93, 27, 171, 17, 164, 211, 113, 190, 202, 248, 75, 20, 146, 126, 136, 142, 79, 45, 143, 60, 246, 210, 81, 214, 153, 24, 194, 10, 213, 100, 119, 184, 246, 47, 149, 21, 185, 112, 15, 106, 77, 103, 144, 38, 55, 169, 132, 146, 160, 236, 183, 69, 84, 61, 10, 193, 16, 5, 208, 235, 132, 222, 207, 54, 162, 101, 232, 203, 4, 134, 37, 23, 255, 163, 230, 6, 42, 216, 103, 239, 208, 10, 230, 28, 86, 218, 238, 157, 69, 153, 49, 105, 163, 46, 243, 43, 83, 6, 255, 37, 176, 192, 160, 16, 126, 198, 76, 133, 84, 4, 214, 218, 189, 176, 206, 237, 171, 14, 137, 151, 69, 227, 177, 94, 86, 219, 0, 74, 110, 69, 87, 125, 80, 121, 209, 179, 21, 11, 98, 105, 102, 106, 76, 91, 196, 192, 61, 105, 252, 55, 84, 236, 29, 214, 206, 247, 188, 200, 2, 190, 4, 38, 22, 11, 179, 108, 132, 130, 115, 77, 47, 204, 190, 117, 12, 118, 183, 40, 35, 142, 248, 110, 125, 132, 223, 159, 195, 235, 160, 45, 162, 144, 202, 200, 72, 229, 204, 119, 189, 179, 85, 35, 161, 139, 33, 180, 92, 215, 53, 194, 182, 207, 146, 191, 2, 255, 198, 86, 247, 117, 66, 56, 32, 69, 132, 186, 95, 221, 170, 146, 162, 23, 28, 56, 77, 195, 117, 139, 85, 196, 237, 227, 104, 241, 209, 176, 141, 84, 169, 162, 254, 23, 149, 67, 26, 161, 77, 28, 125, 136, 79, 145, 32, 135, 75, 147, 141, 207, 99, 207, 42, 201, 11, 62, 136, 118, 186, 121, 3, 219, 214, 150, 216, 245, 57, 6, 14, 63, 235, 117, 233, 25, 162, 91, 99, 191, 171, 1, 128, 244, 254, 33, 156, 127, 178, 103, 89, 189, 248, 135, 124, 140, 40, 151, 156, 236, 124, 225, 194, 92, 20, 227, 219, 157, 21, 70, 255, 235, 0, 138, 138, 28, 40, 71, 58, 89, 37, 62, 70, 197, 224, 92, 249, 33, 237, 33, 48, 218, 54, 180, 3, 152, 226, 134, 47, 70, 45, 26, 29, 158, 236, 234, 107, 32, 216, 54, 255, 113, 64, 137, 201, 135, 44, 38, 125, 88, 193, 210, 215, 212, 40, 213, 195, 177, 163, 130, 68, 84, 67, 96, 97, 189, 141, 233, 248, 180, 50, 163, 18, 65, 119, 199, 138, 205, 61, 208, 35, 86, 107, 204, 8, 191, 54, 112, 232, 186, 105, 65, 25, 49, 195, 112, 12, 223, 158, 68, 100, 242, 254, 7, 24, 73, 145, 27, 68, 143, 2, 185, 10, 32, 232, 226, 19, 206, 207, 156, 165, 115, 241, 78, 253, 104, 109, 177, 81, 67, 227, 79, 167, 145, 177, 140, 200, 190, 73, 179, 18, 244, 250, 51, 245, 158, 231, 73, 12, 36, 52, 200, 238, 131, 198, 212, 250, 178, 97, 126, 229, 27, 226, 199, 116, 148, 40, 30, 141, 218, 133, 241, 95, 94, 190, 64, 198, 181, 149, 232, 27, 214, 80, 31, 94, 153, 165, 99, 194, 183, 100, 63, 33, 87, 132, 90, 159, 49, 138, 105, 64, 222, 93, 80, 45, 21, 232, 163, 46, 240, 135, 199, 156, 49, 49, 124, 173, 126, 110, 93, 106, 219, 184, 239, 114, 193, 18, 50, 121, 79, 212, 28, 101, 111, 180, 121, 161, 26, 98, 39, 46, 76, 215, 173, 148, 124, 203, 42, 228, 247, 154, 187, 31, 242, 153, 208, 9, 49, 55, 75, 215, 68, 110, 236, 19, 17, 212, 65, 195, 69, 164, 126, 69, 152, 167, 211, 254, 218, 25, 118, 217, 164, 223, 46, 238, 138, 134, 117, 190, 113, 170, 183, 214, 210, 56, 245, 115, 24, 26, 41, 14, 237, 151, 239, 72, 25, 127, 127, 253, 173, 182, 132, 219, 161, 12, 62, 217, 3, 105, 15, 171, 28, 240, 7, 88, 148, 14, 105, 167, 77, 1, 227, 246, 131, 239, 162, 32, 252, 156, 130, 45, 131, 249, 210, 132, 6, 174, 56, 212, 180, 142, 157, 176, 113, 92, 215, 128, 38, 162, 195, 24, 84, 194, 138, 149, 220, 99, 93, 43, 201, 88, 30, 127, 37, 119, 28, 32, 80, 211, 144, 81, 253, 129, 236, 21, 206, 177, 179, 161, 72, 134, 254, 130, 51, 121, 30, 238, 86, 61, 219, 130, 54, 52, 150, 180, 205, 157, 244, 217, 64, 161, 108, 89, 67, 211, 169, 217, 56, 252, 72, 107, 143, 130, 142, 39, 10, 214, 138, 241, 208, 107, 58, 63, 61, 192, 52, 182, 170, 87, 224, 9, 26, 1, 59, 9, 80, 111, 126, 94, 45, 63, 7, 143, 158, 42, 12, 237, 247, 240, 25, 172, 248, 52, 217, 145, 145, 200, 238, 197, 125, 213, 56, 11, 138, 105, 240, 9, 52, 95, 151, 216, 102, 236, 251, 92, 228, 159, 182, 115, 40, 33, 195, 127, 94, 150, 235, 92, 208, 88, 16, 29, 119, 222, 156, 222, 158, 51, 1, 200, 237, 20, 26, 196, 194, 33, 155, 44, 230, 154, 59, 84, 193, 93, 209, 37, 74, 108, 236, 40, 131, 141, 78, 205, 227, 139, 109, 146, 249, 152, 51, 182, 205, 137, 199, 113, 181, 81, 25, 63, 125, 104, 97, 134, 139, 222, 94, 136, 13, 208, 127, 199, 102, 88, 209, 116, 192, 160, 24, 43, 186, 78, 226, 17, 255, 80, 39, 171, 184, 245, 14, 23, 157, 63, 42, 241, 215, 248, 121, 74, 12, 157, 228, 231, 112, 255, 160, 74, 128, 101, 12, 70, 60, 77, 245, 110, 0, 231, 54, 50, 177, 239, 241, 100, 12, 237, 197, 254, 199, 100, 145, 146, 154, 183, 117, 96, 10, 224, 109, 92, 221, 2, 114, 19, 251, 232, 75, 209, 198, 56, 249, 214, 69, 133, 226, 230, 170, 69, 36, 187, 90, 206, 167, 44, 120, 75, 236, 27, 252, 20, 197, 162, 129, 177, 90, 131, 87, 162, 138, 189, 234, 253, 63, 102, 29, 240, 22, 125, 192, 145, 58, 27, 154, 13, 73, 132, 185, 251, 102, 32, 112, 216, 15, 88, 152, 112, 35, 16, 119, 41, 224, 172, 22, 239, 31, 49, 199, 7, 154, 36, 197, 196, 243, 198, 209, 11, 139, 91, 215, 86, 208, 86, 152, 247, 108, 132, 6, 3, 90, 5, 142, 208, 32, 120, 231, 7, 172, 251, 94, 62, 27, 247, 128, 225, 101, 115, 201, 156, 232, 130, 167, 96, 80, 93, 90, 42, 100, 114, 33, 174, 12, 214, 18, 191, 16, 52, 113, 185, 50, 57, 4, 57, 197, 192, 204, 203, 205, 103, 252, 177, 12, 205, 153, 4, 180, 245, 1, 134, 162, 166, 248, 211, 134, 99, 118, 47, 23, 243, 213, 238, 125, 145, 123, 175, 126, 49, 155, 151, 202, 135, 22, 197, 164, 124, 147, 101, 125, 105, 185, 25, 69, 112, 48, 230, 52, 8, 106, 236, 3, 128, 100, 10, 130, 251, 57, 92, 3, 162, 234, 195, 186, 157, 161, 90, 30, 61, 25, 199, 131, 15, 99, 76, 82, 210, 47, 72, 135, 98, 111, 24, 251, 235, 104, 36, 2, 30, 200, 116, 63, 209, 12, 243, 145, 184, 40, 152, 196, 142, 239, 121, 246, 32, 215, 5, 65, 50, 129, 225, 36, 36, 109, 234, 126, 5, 202, 7, 137, 242, 249, 205, 191, 114, 37, 3, 168, 221, 172, 30, 71, 57, 59, 203, 244, 107, 204, 164, 71, 37, 157, 199, 120, 178, 217, 204, 174, 26, 106, 1, 24, 144, 99, 194, 123, 140, 243, 57, 113, 176, 238, 254, 19, 172, 46, 238, 118, 21, 129, 225, 12, 167, 103, 36, 84, 130, 22, 89, 181, 185, 65, 103, 150, 242, 115, 148, 185, 233, 234, 6, 66, 170, 219, 36, 103, 41, 112, 54, 196, 53, 131, 216, 59, 12, 0, 135, 212, 176, 162, 146, 54, 96, 29, 157, 116, 190, 178, 105, 128, 45, 229, 231, 110, 74, 219, 236, 70, 234, 130, 220, 183, 170, 251, 139, 75, 76, 21, 7, 26, 40, 222, 120, 27, 117, 108, 249, 209, 255, 139, 182, 213, 246, 255, 99, 166, 102, 116, 0, 46, 12, 213, 87, 36, 163, 121, 251, 6, 218, 13, 195, 29, 91, 249, 135, 176, 219, 155, 228, 209, 174, 6, 174, 33, 2, 216, 245, 47, 31, 199, 139, 55, 160, 184, 208, 220, 160, 75, 68, 137, 209, 212, 118, 206, 249, 198, 197, 56, 131, 17, 249, 1, 135, 219, 31, 124, 108, 68, 178, 103, 233, 16, 199, 100, 106, 129, 215, 240, 21, 109, 57, 171, 153, 240, 195, 133, 7, 119, 250, 108, 234, 7, 165, 66, 102, 2, 193, 38, 162, 128, 50, 153, 24, 213, 41, 137, 135, 190, 224, 89, 47, 212, 67, 230, 211, 202, 88, 16, 29, 119, 222, 156, 222, 158, 51, 1, 200, 237, 20, 26, 196, 194, 151, 248, 158, 215, 154, 59, 84, 193, 93, 209, 37, 74, 108, 236, 40, 131, 141, 78, 205, 227, 189, 134, 121, 221, 152, 51, 182, 205, 137, 199, 113, 181, 81, 25, 63, 125, 104, 97, 134, 139, 221, 213, 41, 189, 208, 127, 199, 102, 88, 209, 116, 192, 160, 24, 43, 186, 78, 226, 17, 255, 39, 201, 88, 136, 245, 14, 23, 157, 63, 42, 241, 215, 248, 121, 74, 12, 157, 228, 231, 112, 216, 225, 195, 5, 101, 12, 70, 60, 77, 245, 110, 0, 231, 54, 50, 177, 239, 241, 100, 12, 248, 198, 112, 99, 100, 145, 146, 154, 183, 117, 96, 10, 224, 109, 92, 221, 2, 114, 19, 251, 41, 36, 239, 2, 56, 249, 214, 69, 133, 226, 230, 170, 69, 36, 187, 90, 206, 167, 44, 120, 92, 104, 19, 7, 20, 197, 162, 129, 177, 90, 131, 87, 162, 138, 189, 234, 253, 63, 102, 29, 224, 243, 202, 225, 145, 58, 27, 154, 13, 73, 132, 185, 251, 102, 32, 112, 216, 15, 88, 152, 4, 86, 190, 199, 41, 224, 172, 22, 239, 31, 49, 199, 7, 154, 36, 197, 196, 243, 198, 209, 164, 51, 153, 81, 86, 208, 86, 152, 247, 108, 132, 6, 3, 90, 5, 142, 208, 32, 120, 231, 82, 190, 18, 93, 62, 27, 247, 128, 225, 101, 115, 201, 156, 232, 130, 167, 96, 80, 93, 90, 178, 109, 225, 137, 174, 12, 214, 18, 191, 16, 52, 113, 185, 50, 57, 4, 57, 197, 192, 204, 250, 186, 31, 154, 177, 12, 205, 153, 4, 180, 245, 1, 134, 162, 166, 248, 211, 134, 99, 118, 21, 105, 196, 197, 238, 125, 145, 123, 175, 126, 49, 155, 151, 202, 135, 22, 197, 164, 124, 147, 23, 25, 42, 54, 25, 69, 112, 48, 230, 52, 8, 106, 236, 3, 128, 100, 10, 130, 251, 57, 101, 191, 195, 118, 195, 186, 157, 161, 90, 30, 61, 25, 199, 131, 15, 99, 76, 82, 210, 47, 161, 97, 17, 54, 24, 251, 235, 104, 36, 2, 30, 200, 116, 63, 209, 12, 243, 145, 184, 40, 156, 198, 76, 167, 121, 246, 32, 215, 5, 65, 50, 129, 225, 36, 36, 109, 234, 126, 5, 202, 145, 136, 64, 164, 205, 191, 114, 37, 3, 168, 221, 172, 30, 71, 57, 59, 203, 244, 107, 204, 94, 232, 237, 214, 199, 120, 178, 217, 204, 174, 26, 106, 1, 24, 144, 99, 194, 123, 140, 243, 35, 231, 145, 221, 254, 19, 172, 46, 238, 118, 21, 129, 225, 12, 167, 103, 36, 84, 130, 22, 242, 192, 97, 140, 103, 150, 242, 115, 148, 185, 233, 234, 6, 66, 170, 219, 36, 103, 41, 112, 26, 220, 218, 239, 216, 59, 12, 0, 135, 212, 176, 162, 146, 54, 96, 29, 157, 116, 190, 178, 239, 211, 25, 162, 231, 110, 74, 219, 236, 70, 234, 130, 220, 183, 170, 251, 139, 75, 76, 21, 148, 226, 170, 78, 120, 27, 117, 108, 249, 209, 255, 139, 182, 213, 246, 255, 99, 166, 102, 116, 193, 224, 4, 213, 87, 36, 163, 121, 251, 6, 218, 13, 195, 29, 91, 249, 135, 176, 219, 155, 240, 57, 69, 26, 174, 33, 2, 216, 245, 47, 31, 199, 139, 55, 160, 184, 208, 220, 160, 75, 163, 161, 103, 13, 118, 206, 249, 198, 197, 56, 131, 17, 249, 1, 135, 219, 31, 124, 108, 68, 83, 233, 165, 204, 199, 100, 106, 129, 215, 240, 21, 109, 57, 171, 153, 240, 195, 133, 7, 119, 57, 152, 106, 171, 165, 66, 102, 2, 193, 38, 162, 128, 50, 153, 24, 213, 41, 137, 135, 190, 14, 96, 54, 65, 67, 230, 211, 202, 88, 16, 29, 119, 222, 156, 222, 158, 51, 1, 200, 237, 179, 26, 135, 242, 151, 248, 158, 215, 154, 59, 84, 193, 93, 209, 37, 74, 108, 236, 40, 131, 121, 122, 83, 26, 189, 134, 121, 221, 152, 51, 182, 205, 137, 199, 113, 181, 81, 25, 63, 125, 29, 21, 7, 130, 221, 213, 41, 189, 208, 127, 199, 102, 88, 209, 116, 192, 160, 24, 43, 186, 124, 171, 82, 117, 39, 201, 88, 136, 245, 14, 23, 157, 63, 42, 241, 215, 248, 121, 74, 12, 223, 211, 22, 123, 216, 225, 195, 5, 101, 12, 70, 60, 77, 245, 110, 0, 231, 54, 50, 177, 77, 204, 53, 65, 248, 198, 112, 99, 100, 145, 146, 154, 183, 117, 96, 10, 224, 109, 92, 221, 11, 49, 26, 172, 41, 36, 239, 2, 56, 249, 214, 69, 133, 226, 230, 170, 69, 36, 187, 90, 17, 247, 171, 58, 92, 104, 19, 7, 20, 197, 162, 129, 177, 90, 131, 87, 162, 138, 189, 234, 148, 87, 221, 135, 224, 243, 202, 225, 145, 58, 27, 154, 13, 73, 132, 185, 251, 102, 32, 112, 20, 202, 45, 253, 4, 86, 190, 199, 41, 224, 172, 22, 239, 31, 49, 199, 7, 154, 36, 197, 212, 161, 31, 172, 164, 51, 153, 81, 86, 208, 86, 152, 247, 108, 132, 6, 3, 90, 5, 142, 16, 140, 21, 169, 82, 190, 18, 93, 62, 27, 247, 128, 225, 101, 115, 201, 156, 232, 130, 167, 192, 92, 120, 97, 178, 109, 225, 137, 174, 12, 214, 18, 191, 16, 52, 113, 185, 50, 57, 4, 67, 5, 132, 207, 250, 186, 31, 154, 177, 12, 205, 153, 4, 180, 245, 1, 134, 162, 166, 248, 178, 206, 253, 133, 21, 105, 196, 197, 238, 125, 145, 123, 175, 126, 49, 155, 151, 202, 135, 22, 130, 221, 222, 195, 23, 25, 42, 54, 25, 69, 112, 48, 230, 52, 8, 106, 236, 3, 128, 100, 139, 208, 229, 239, 101, 191, 195, 118, 195, 186, 157, 161, 90, 30, 61, 25, 199, 131, 15, 99, 49, 10, 139, 134, 161, 97, 17, 54, 24, 251, 235, 104, 36, 2, 30, 200, 116, 63, 209, 12, 94, 165, 126, 233, 156, 198, 76, 167, 121, 246, 32, 215, 5, 65, 50, 129, 225, 36, 36, 109, 233, 103, 155, 252, 145, 136, 64, 164, 205, 191, 114, 37, 3, 168, 221, 172, 30, 71, 57, 59, 193, 77, 92, 121, 94, 232, 237, 214, 199, 120, 178, 217, 204, 174, 26, 106, 1, 24, 144, 99, 105, 91, 15, 7, 35, 231, 145, 221, 254, 19, 172, 46, 238, 118, 21, 129, 225, 12, 167, 103, 50, 252, 27, 12, 242, 192, 97, 140, 103, 150, 242, 115, 148, 185, 233, 234, 6, 66, 170, 219, 123, 210, 144, 32, 26, 220, 218, 239, 216, 59, 12, 0, 135, 212, 176, 162, 146, 54, 96, 29, 164, 0, 250, 60, 239, 211, 25, 162, 231, 110, 74, 219, 236, 70, 234, 130, 220, 183, 170, 251, 67, 211, 16, 37, 148, 226, 170, 78, 120, 27, 117, 108, 249, 209, 255, 139, 182, 213, 246, 255, 112, 217, 115, 66, 193, 224, 4, 213, 87, 36, 163, 121, 251, 6, 218, 13, 195, 29, 91, 249, 225, 62, 1, 236, 240, 57, 69, 26, 174, 33, 2, 216, 245, 47, 31, 199, 139, 55, 160, 184, 189, 129, 94, 215, 163, 161, 103, 13, 118, 206, 249, 198, 197, 56, 131, 17, 249, 1, 135, 219, 135, 246, 169, 98, 83, 233, 165, 204, 199, 100, 106, 129, 215, 240, 21, 109, 57, 171, 153, 240, 33, 103, 104, 222, 57, 152, 106, 171, 165, 66, 102, 2, 193, 38, 162, 128, 50, 153, 24, 213, 156, 89, 34, 110, 14, 96, 54, 65, 67, 230, 211, 202, 88, 16, 29, 119, 222, 156, 222, 158, 25, 181, 106, 225, 179, 26, 135, 242, 151, 248, 158, 215, 154, 59, 84, 193, 93, 209, 37, 74, 96, 125, 88, 162, 121, 122, 83, 26, 189, 134, 121, 221, 152, 51, 182, 205, 137, 199, 113, 181, 138, 58, 62, 239, 29, 21, 7, 130, 221, 213, 41, 189, 208, 127, 199, 102, 88, 209, 116, 192, 142, 217, 181, 124, 124, 171, 82, 117, 39, 201, 88, 136, 245, 14, 23, 157, 63, 42, 241, 215, 18, 151, 235, 189, 223, 211, 22, 123, 216, 225, 195, 5, 101, 12, 70, 60, 77, 245, 110, 0, 177, 254, 184, 38, 77, 204, 53, 65, 248, 198, 112, 99, 100, 145, 146, 154, 183, 117, 96, 10, 149, 183, 235, 247, 11, 49, 26, 172, 41, 36, 239, 2, 56, 249, 214, 69, 133, 226, 230, 170, 1, 116, 97, 154, 17, 247, 171, 58, 92, 104, 19, 7, 20, 197, 162, 129, 177, 90, 131, 87, 215, 136, 127, 63, 148, 87, 221, 135, 224, 243, 202, 225, 145, 58, 27, 154, 13, 73, 132, 185, 10, 116, 101, 234, 20, 202, 45, 253, 4, 86, 190, 199, 41, 224, 172, 22, 239, 31, 49, 199, 48, 185, 155, 76, 212, 161, 31, 172, 164, 51, 153, 81, 86, 208, 86, 152, 247, 108, 132, 6, 182, 13, 49, 138, 16, 140, 21, 169, 82, 190, 18, 93, 62, 27, 247, 128, 225, 101, 115, 201, 23, 121, 54, 40, 192, 92, 120, 97, 178, 109, 225, 137, 174, 12, 214, 18, 191, 16, 52, 113, 205, 241, 172, 130, 67, 5, 132, 207, 250, 186, 31, 154, 177, 12, 205, 153, 4, 180, 245, 1, 202, 145, 230, 17, 178, 206, 253, 133, 21, 105, 196, 197, 238, 125, 145, 123, 175, 126, 49, 155, 45, 236, 248, 183, 130, 221, 222, 195, 23, 25, 42, 54, 25, 69, 112, 48, 230, 52, 8, 106, 35, 19, 231, 134, 139, 208, 229, 239, 101, 191, 195, 118, 195, 186, 157, 161, 90, 30, 61, 25, 149, 93, 209, 48, 49, 10, 139, 134, 161, 97, 17, 54, 24, 251, 235, 104, 36, 2, 30, 200, 37, 233, 20, 68, 94, 165, 126, 233, 156, 198, 76, 167, 121, 246, 32, 215, 5, 65, 50, 129, 227, 123, 221, 244, 233, 103, 155, 252, 145, 136, 64, 164, 205, 191, 114, 37, 3, 168, 221, 172, 201, 244, 76, 181, 193, 77, 92, 121, 94, 232, 237, 214, 199, 120, 178, 217, 204, 174, 26, 106, 46, 150, 229, 142, 105, 91, 15, 7, 35, 231, 145, 221, 254, 19, 172, 46, 238, 118, 21, 129, 242, 178, 57, 162, 50, 252, 27, 12, 242, 192, 97, 140, 103, 150, 242, 115, 148, 185, 233, 234, 124, 45, 9, 165, 123, 210, 144, 32, 26, 220, 218, 239, 216, 59, 12, 0, 135, 212, 176, 162, 64, 196, 26, 241, 164, 0, 250, 60, 239, 211, 25, 162, 231, 110, 74, 219, 236, 70, 234, 130, 59, 146, 233, 158, 67, 211, 16, 37, 148, 226, 170, 78, 120, 27, 117, 108, 249, 209, 255, 139, 159, 143, 230, 211, 112, 217, 115, 66, 193, 224, 4, 213, 87, 36, 163, 121, 251, 6, 218, 13, 29, 228, 54, 200, 225, 62, 1, 236, 240, 57, 69, 26, 174, 33, 2, 216, 245, 47, 31, 199, 208, 67, 23, 88, 189, 129, 94, 215, 163, 161, 103, 13, 118, 206, 249, 198, 197, 56, 131, 17, 93, 91, 242, 250, 135, 246, 169, 98, 83, 233, 165, 204, 199, 100, 106, 129, 215, 240, 21, 109, 126, 167, 95, 247, 33, 103, 104, 222, 57, 152, 106, 171, 165, 66, 102, 2, 193, 38, 162, 128, 31, 181, 176, 199, 77, 79, 39, 27, 255, 97, 34, 134, 101, 101, 68, 190, 214, 105, 62, 194, 193, 41, 110, 89, 126, 78, 239, 246, 235, 123, 230, 68, 68, 254, 104, 88, 53, 188, 181, 249, 156, 248, 75, 19, 18, 162, 199, 117, 102, 53, 43, 167, 207, 147, 250, 161, 138, 86, 2, 138, 203, 163, 228, 56, 112, 186, 48, 229, 26, 78, 105, 238, 48, 86, 94, 74, 213, 241, 232, 103, 206, 163, 181, 178, 188, 78, 51, 220, 217, 226, 181, 242, 235, 28, 103, 11, 86, 169, 221, 167, 166, 210, 235, 78, 38, 47, 142, 64, 56, 125, 16, 203, 235, 121, 137, 96, 222, 246, 32, 0, 238, 39, 212, 196, 13, 237, 191, 200, 20, 32, 168, 219, 221, 246, 78, 230, 228, 164, 255, 45, 49, 35, 234, 50, 119, 225, 94, 137, 247, 205, 30, 25, 53, 216, 113, 75, 67, 81, 157, 229, 252, 52, 51, 18, 25, 7, 212, 91, 21, 55, 138, 113, 72, 187, 173, 49, 24, 226, 2, 8, 146, 106, 142, 179, 193, 129, 136, 240, 11, 229, 90, 174, 80, 131, 239, 92, 188, 242, 146, 229, 82, 52, 211, 42, 84, 1, 34, 82, 49, 16, 150, 94, 93, 195, 35, 81, 200, 73, 185, 203, 211, 117, 95, 76, 139, 29, 90, 60, 235, 49, 128, 80, 78, 112, 58, 235, 178, 10, 194, 177, 228, 71, 134, 211, 29, 199, 245, 16, 1, 228, 52, 71, 68, 156, 13, 184, 116, 113, 109, 236, 132, 99, 121, 124, 94, 51, 15, 217, 187, 149, 127, 19, 125, 75, 102, 35, 151, 114, 29, 65, 12, 65, 148, 146, 113, 219, 153, 241, 104, 133, 11, 200, 188, 106, 54, 140, 165, 136, 13, 28, 104, 209, 158, 60, 180, 141, 197, 192, 1, 114, 35, 234, 170, 170, 174, 194, 62, 62, 125, 251, 79, 141, 66, 73, 12, 175, 212, 254, 23, 198, 43, 162, 14, 246, 151, 212, 134, 8, 12, 38, 205, 41, 64, 141, 37, 250, 8, 171, 116, 179, 248, 185, 68, 53, 173, 112, 96, 116, 74, 197, 176, 107, 161, 225, 90, 91, 22, 246, 46, 85, 34, 222, 168, 238, 246, 9, 133, 205, 126, 27, 22, 205, 189, 237, 7, 49, 27, 175, 190, 177, 73, 237, 122, 233, 66, 66, 25, 50, 41, 120, 110, 206, 110, 0, 153, 180, 33, 159, 14, 41, 150, 64, 145, 187, 235, 194, 162, 206, 254, 231, 203, 192, 175, 160, 218, 153, 21, 253, 85, 57, 150, 191, 231, 251, 122, 20, 152, 60, 170, 191, 127, 109, 102, 39, 69, 4, 191, 174, 39, 218, 197, 225, 53, 216, 99, 122, 144, 137, 169, 21, 52, 21, 178, 6, 231, 37, 44, 171, 88, 158, 71, 8, 26, 45, 75, 237, 96, 162, 214, 120, 20, 1, 146, 107, 126, 250, 44, 35, 14, 26, 61, 38, 254, 202, 103, 0, 60, 196, 174, 211, 216, 173, 246, 232, 78, 237, 223, 59, 236, 42, 1, 125, 184, 191, 98, 114, 71, 54, 53, 9, 20, 255, 60, 7, 11, 133, 117, 72, 49, 229, 55, 70, 91, 66, 102, 65, 142, 245, 77, 168, 33, 130, 167, 15, 141, 71, 112, 175, 176, 115, 109, 105, 29, 25, 111, 230, 31, 47, 160, 110, 22, 214, 183, 237, 11, 50, 129, 37, 234, 12, 128, 201, 26, 53, 197, 211, 180, 20, 199, 11, 214, 132, 51, 34, 6, 199, 36, 122, 187, 70, 122, 173, 24, 231, 29, 160, 110, 41, 228, 102, 36, 232, 160, 209, 121, 179, 82, 43, 254, 69, 251, 73, 173, 172, 94, 133, 106, 200, 52, 4, 51, 74, 49, 115, 77, 237, 110, 132, 108, 138, 6, 90, 85, 18, 108, 241, 240, 80, 10, 243, 33, 212, 203, 230, 183, 42, 224, 47, 20, 252, 56, 4, 184, 107, 2, 99, 193, 191, 211, 117, 228, 105, 81, 130, 132, 236, 161, 33, 123, 97, 241, 87, 157, 212, 195, 134, 41, 183, 13, 253, 224, 214, 20, 64, 109, 144, 30, 220, 185, 66, 15, 22, 16, 158, 39, 241, 156, 77, 68, 144, 138, 135, 5, 139, 185, 241, 93, 12, 182, 208, 23, 37, 68, 26, 17, 179, 71, 20, 176, 49, 213, 231, 210, 187, 169, 179, 26, 97, 185, 149, 254, 20, 216, 187, 110, 145, 243, 208, 189, 189, 184, 179, 36, 161, 73, 99, 221, 191, 80, 109, 161, 188, 114, 88, 207, 103, 93, 58, 108, 57, 173, 223, 209, 252, 240, 220, 168, 61, 240, 17, 89, 121, 129, 188, 24, 237, 135, 16, 253, 91, 148, 44, 105, 179, 21, 99, 169, 97, 162, 211, 235, 140, 169, 20, 222, 203, 147, 177, 222, 19, 125, 215, 144, 67, 183, 138, 123, 86, 235, 80, 184, 36, 159, 70, 182, 191, 87, 232, 80, 181, 15, 160, 223, 237, 142, 249, 211, 73, 200, 226, 143, 30, 9, 216, 28, 194, 96, 8, 87, 96, 251, 117, 97, 166, 183, 78, 146, 5, 136, 12, 210, 170, 166, 38, 86, 113, 238, 87, 177, 174, 101, 56, 216, 129, 133, 208, 157, 138, 177, 47, 24, 190, 91, 137, 161, 77, 31, 38, 50, 48, 209, 13, 150, 175, 191, 154, 229, 207, 26, 233, 74, 120, 65, 148, 225, 44, 221, 38, 100, 65, 22, 255, 232, 77, 244, 137, 112, 10, 148, 99, 62, 215, 194, 157, 173, 50, 9, 112, 207, 197, 87, 215, 231, 11, 140, 94, 150, 19, 34, 243, 194, 189, 235, 51, 44, 215, 131, 61, 232, 242, 75, 29, 222, 211, 107, 3, 86, 126, 162, 90, 81, 89, 104, 158, 54, 75, 52, 219, 32, 132, 209, 63, 164, 56, 173, 84, 153, 66, 183, 20, 47, 128, 232, 154, 207, 172, 102, 65, 17, 95, 249, 231, 250, 52, 142, 226, 34, 2, 139, 87, 167, 168, 85, 219, 176, 149, 16, 92, 1, 215, 234, 155, 104, 195, 227, 175, 26, 134, 212, 177, 186, 78, 188, 1, 51, 213, 109, 135, 230, 15, 227, 99, 190, 90, 234, 3, 117, 113, 141, 153, 240, 114, 239, 30, 166, 156, 176, 23, 2, 198, 105, 53, 33, 13, 197, 80, 216, 25, 199, 56, 44, 85, 224, 77, 198, 58, 59, 84, 228, 126, 175, 127, 224, 27, 9, 38, 96, 96, 138, 103, 105, 19, 210, 167, 125, 26, 128, 125, 177, 38, 253, 235, 182, 100, 179, 70, 4, 89, 54, 228, 114, 132, 248, 15, 56, 7, 193, 145, 55, 127, 104, 105, 85, 209, 233, 236, 121, 76, 182, 105, 39, 252, 31, 107, 156, 220, 180, 92, 30, 20, 235, 85, 141, 84, 206, 14, 238, 70, 49, 97, 215, 29, 213, 33, 81, 105, 42, 121, 233, 115, 58, 5, 16, 56, 194, 244, 255, 54, 76, 78, 24, 11, 22, 193, 161, 186, 20, 186, 246, 100, 88, 244, 181, 180, 14, 95, 188, 127, 4, 50, 45, 85, 88, 175, 174, 88, 69, 39, 246, 214, 68, 158, 238, 123, 226, 156, 222, 145, 183, 9, 26, 159, 69, 52, 166, 192, 199, 54, 107, 148, 40, 64, 65, 192, 97, 135, 135, 173, 183, 185, 201, 22, 123, 161, 106, 90, 87, 65, 27, 37, 106, 80, 202, 82, 212, 93, 66, 104, 123, 74, 181, 114, 201, 71, 149, 154, 61, 96, 42, 28, 223, 227, 82, 7, 232, 134, 40, 154, 227, 182, 124, 52, 47, 45, 46, 241, 79, 213, 13, 102, 21, 74, 142, 254, 219, 121, 172, 79, 210, 124, 16, 202, 241, 42, 200, 22, 1, 9, 134, 222, 185, 123, 113, 27, 33, 212, 203, 230, 183, 42, 224, 47, 20, 252, 56, 4, 184, 107, 2, 99, 176, 225, 235, 14, 228, 105, 81, 130, 132, 236, 161, 33, 123, 97, 241, 87, 157, 212, 195, 134, 175, 20, 56, 39, 224, 214, 20, 64, 109, 144, 30, 220, 185, 66, 15, 22, 16, 158, 39, 241, 171, 225, 217, 190, 138, 135, 5, 139, 185, 241, 93, 12, 182, 208, 23, 37, 68, 26, 17, 179, 30, 14, 117, 222, 213, 231, 210, 187, 169, 179, 26, 97, 185, 149, 254, 20, 216, 187, 110, 145, 174, 214, 241, 212, 184, 179, 36, 161, 73, 99, 221, 191, 80, 109, 161, 188, 114, 88, 207, 103, 61, 131, 226, 40, 173, 223, 209, 252, 240, 220, 168, 61, 240, 17, 89, 121, 129, 188, 24, 237, 45, 209, 213, 229, 148, 44, 105, 179, 21, 99, 169, 97, 162, 211, 235, 140, 169, 20, 222, 203, 223, 168, 103, 140, 125, 215, 144, 67, 183, 138, 123, 86, 235, 80, 184, 36, 159, 70, 182, 191, 70, 192, 87, 103, 15, 160, 223, 237, 142, 249, 211, 73, 200, 226, 143, 30, 9, 216, 28, 194, 31, 244, 3, 158, 251, 117, 97, 166, 183, 78, 146, 5, 136, 12, 210, 170, 166, 38, 86, 113, 37, 222, 248, 125, 101, 56, 216, 129, 133, 208, 157, 138, 177, 47, 24, 190, 91, 137, 161, 77, 80, 219, 9, 178, 209, 13, 150, 175, 191, 154, 229, 207, 26, 233, 74, 120, 65, 148, 225, 44, 30, 217, 184, 144, 22, 255, 232, 77, 244, 137, 112, 10, 148, 99, 62, 215, 194, 157, 173, 50, 245, 234, 155, 61, 87, 215, 231, 11, 140, 94, 150, 19, 34, 243, 194, 189, 235, 51, 44, 215, 111, 231, 221, 239, 75, 29, 222, 211, 107, 3, 86, 126, 162, 90, 81, 89, 104, 158, 54, 75, 55, 143, 78, 17, 209, 63, 164, 56, 173, 84, 153, 66, 183, 20, 47, 128, 232, 154, 207, 172, 195, 20, 16, 10, 249, 231, 250, 52, 142, 226, 34, 2, 139, 87, 167, 168, 85, 219, 176, 149, 12, 92, 79, 172, 234, 155, 104, 195, 227, 175, 26, 134, 212, 177, 186, 78, 188, 1, 51, 213, 209, 78, 252, 106, 227, 99, 190, 90, 234, 3, 117, 113, 141, 153, 240, 114, 239, 30, 166, 156, 94, 100, 155, 74, 105, 53, 33, 13, 197, 80, 216, 25, 199, 56, 44, 85, 224, 77, 198, 58, 141, 78, 91, 161, 175, 127, 224, 27, 9, 38, 96, 96, 138, 103, 105, 19, 210, 167, 125, 26, 70, 127, 81, 7, 253, 235, 182, 100, 179, 70, 4, 89, 54, 228, 114, 132, 248, 15, 56, 7, 244, 100, 48, 204, 104, 105, 85, 209, 233, 236, 121, 76, 182, 105, 39, 252, 31, 107, 156, 220, 209, 86, 30, 98, 235, 85, 141, 84, 206, 14, 238, 70, 49, 97, 215, 29, 213, 33, 81, 105, 231, 180, 173, 233, 58, 5, 16, 56, 194, 244, 255, 54, 76, 78, 24, 11, 22, 193, 161, 186, 9, 186, 65, 3, 88, 244, 181, 180, 14, 95, 188, 127, 4, 50, 45, 85, 88, 175, 174, 88, 13, 253, 132, 247, 68, 158, 238, 123, 226, 156, 222, 145, 183, 9, 26, 159, 69, 52, 166, 192, 144, 219, 109, 95, 40, 64, 65, 192, 97, 135, 135, 173, 183, 185, 201, 22, 123, 161, 106, 90, 79, 146, 30, 209, 106, 80, 202, 82, 212, 93, 66, 104, 123, 74, 181, 114, 201, 71, 149, 154, 192, 210, 0, 169, 223, 227, 82, 7, 232, 134, 40, 154, 227, 182, 124, 52, 47, 45, 46, 241, 127, 99, 80, 176, 21, 74, 142, 254, 219, 121, 172, 79, 210, 124, 16, 202, 241, 42, 200, 22, 122, 91, 218, 26, 185, 123, 113, 27, 33, 212, 203, 230, 183, 42, 224, 47, 20, 252, 56, 4, 194, 231, 41, 123, 176, 225, 235, 14, 228, 105, 81, 130, 132, 236, 161, 33, 123, 97, 241, 87, 185, 142, 92, 100, 175, 20, 56, 39, 224, 214, 20, 64, 109, 144, 30, 220, 185, 66, 15, 22, 88, 255, 222, 155, 171, 225, 217, 190, 138, 135, 5, 139, 185, 241, 93, 12, 182, 208, 23, 37, 115, 143, 70, 158, 30, 14, 117, 222, 213, 231, 210, 187, 169, 179, 26, 97, 185, 149, 254, 20, 24, 128, 236, 192, 174, 214, 241, 212, 184, 179, 36, 161, 73, 99, 221, 191, 80, 109, 161, 188, 217, 39, 149, 0, 61, 131, 226, 40, 173, 223, 209, 252, 240, 220, 168, 61, 240, 17, 89, 121, 75, 137, 172, 96, 45, 209, 213, 229, 148, 44, 105, 179, 21, 99, 169, 97, 162, 211, 235, 140, 48, 198, 248, 89, 223, 168, 103, 140, 125, 215, 144, 67, 183, 138, 123, 86, 235, 80, 184, 36, 204, 151, 133, 218, 70, 192, 87, 103, 15, 160, 223, 237, 142, 249, 211, 73, 200, 226, 143, 30, 226, 129, 124, 232, 31, 244, 3, 158, 251, 117, 97, 166, 183, 78, 146, 5, 136, 12, 210, 170, 18, 9, 71, 13, 37, 222, 248, 125, 101, 56, 216, 129, 133, 208, 157, 138, 177, 47, 24, 190, 116, 227, 86, 149, 80, 219, 9, 178, 209, 13, 150, 175, 191, 154, 229, 207, 26, 233, 74, 120, 104, 2, 233, 164, 30, 217, 184, 144, 22, 255, 232, 77, 244, 137, 112, 10, 148, 99, 62, 215, 211, 65, 204, 113, 245, 234, 155, 61, 87, 215, 231, 11, 140, 94, 150, 19, 34, 243, 194, 189, 210, 209, 39, 100, 111, 231, 221, 239, 75, 29, 222, 211, 107, 3, 86, 126, 162, 90, 81, 89, 46, 207, 149, 209, 55, 143, 78, 17, 209, 63, 164, 56, 173, 84, 153, 66, 183, 20, 47, 128, 183,