serial_no int64 1 24.2k | cuda_source stringlengths 11 9.01M |
|---|---|
21,101 | #include <stdio.h>
#include <stdlib.h>
#include <sys/time.h>
#include <unistd.h>
#include <assert.h>
#include <string.h>
#ifdef CPUGPU_CU_
#define IMG_DIMENSION 32
#define N_IMG_PAIRS 10000
#define NREQUESTS 100000
#define N_STREMS 64
#define HIST_SIZE 256
typedef unsigned char uchar;
#define OUT
#define CUDA_CHECK(f) do { \
cudaError_t e = f; \
if (e != cudaSuccess) { \
printf("Cuda failure %s:%d: '%s'\n", __FILE__, __LINE__, cudaGetErrorString(e)); \
exit(1); \
} \
} while (0)
#define SQR(a) ((a) * (a))
#define QUEUE_SIZE 10
__device__ __host__ bool is_in_image_bounds(int i, int j) {
return (i >= 0) && (i < IMG_DIMENSION) && (j >= 0) && (j < IMG_DIMENSION);
}
__device__ __host__ uchar local_binary_pattern(uchar *image, int i, int j) {
uchar center = image[i * IMG_DIMENSION + j];
uchar pattern = 0;
if (is_in_image_bounds(i - 1, j - 1)) pattern |= (image[(i - 1) * IMG_DIMENSION + (j - 1)] >= center) << 7;
if (is_in_image_bounds(i - 1, j )) pattern |= (image[(i - 1) * IMG_DIMENSION + (j )] >= center) << 6;
if (is_in_image_bounds(i - 1, j + 1)) pattern |= (image[(i - 1) * IMG_DIMENSION + (j + 1)] >= center) << 5;
if (is_in_image_bounds(i , j + 1)) pattern |= (image[(i ) * IMG_DIMENSION + (j + 1)] >= center) << 4;
if (is_in_image_bounds(i + 1, j + 1)) pattern |= (image[(i + 1) * IMG_DIMENSION + (j + 1)] >= center) << 3;
if (is_in_image_bounds(i + 1, j )) pattern |= (image[(i + 1) * IMG_DIMENSION + (j )] >= center) << 2;
if (is_in_image_bounds(i + 1, j - 1)) pattern |= (image[(i + 1) * IMG_DIMENSION + (j - 1)] >= center) << 1;
if (is_in_image_bounds(i , j - 1)) pattern |= (image[(i ) * IMG_DIMENSION + (j - 1)] >= center) << 0;
return pattern;
}
__device__ void gpu_image_to_histogram(uchar *image, int *histogram) {
uchar pattern = local_binary_pattern(image, threadIdx.x / IMG_DIMENSION, threadIdx.x % IMG_DIMENSION);
atomicAdd(&histogram[pattern], 1);
}
__device__ void gpu_histogram_distance(int *h1, int *h2, double *distance) {
int length = 256;
int tid = threadIdx.x;
if(tid<length){
distance[tid] = 0;
if (h1[tid] + h2[tid] != 0) {
distance[tid] = ((double)SQR(h1[tid] - h2[tid])) / (h1[tid] + h2[tid]);
}
h1[tid] = h2[tid]=0;
}
__syncthreads();
while (length > 1) {
if (threadIdx.x < length / 2) {
distance[tid] = distance[tid] + distance[tid + length / 2];
}
length /= 2;
__syncthreads();
}
}
void image_to_histogram(uchar *image, int *histogram) {
memset(histogram, 0, sizeof(int) * 256);
for (int i = 0; i < IMG_DIMENSION; i++) {
for (int j = 0; j < IMG_DIMENSION; j++) {
uchar pattern = local_binary_pattern(image, i, j);
histogram[pattern]++;
}
}
}
double histogram_distance(int *h1, int *h2) {
/* we'll use the chi-square distance */
double distance = 0;
for (int i = 0; i < 256; i++) {
if (h1[i] + h2[i] != 0) {
distance += ((double)SQR(h1[i] - h2[i])) / (h1[i] + h2[i]);
}
}
return distance;
}
double static inline get_time_msec(void) {
struct timeval t;
gettimeofday(&t, NULL);
return t.tv_sec * 1e+3 + t.tv_usec * 1e-3;
}
/* we won't load actual files. just fill the images with random bytes */
void load_image_pairs(uchar *images1, uchar *images2) {
srand(0);
for (int i = 0; i < N_IMG_PAIRS * IMG_DIMENSION * IMG_DIMENSION; i++) {
images1[i] = rand() % 256;
images2[i] = rand() % 256;
}
}
class cpu2gpuQueue {
public:
cpu2gpuQueue():size(QUEUE_SIZE),head(0),tail(0){}
~cpu2gpuQueue(){}
//__device__ __host__ cpu2gpuQueue& operator=(const cpu2gpuQueue& rhs);
__host__ int produce(int img_idx);
__device__ int consume(int* img_idx);
private:
volatile int size;
volatile int head;
volatile int tail;
int q[QUEUE_SIZE];
};
__device__ int cpu2gpuQueue::consume(int* img_idx)
{
if(!(tail<head))return 0;
*img_idx=q[(tail%QUEUE_SIZE)];
size++;
tail++;
__threadfence_system();
return 1;
}
__host__ int cpu2gpuQueue::produce(int img_idx)
{
if(!(head<size)){
return 0;
}
q[(head%QUEUE_SIZE)]=img_idx;
head++;
return 1;
}
class gpu2cpuQueue {
public:
gpu2cpuQueue():size(QUEUE_SIZE),head(0),tail(0){}
~gpu2cpuQueue(){}
//__device__ __host__ gpu2cpuQueue& operator=(const gpu2cpuQueue& rhs);
__device__ int produce(double distance);
__host__ int consume(double* distance);
private:
volatile int size;
volatile int head;
volatile int tail;
double q[QUEUE_SIZE];
};
/*__device__ __host__ gpu2cpuQueue& gpu2cpuQueue::operator=(const gpu2cpuQueue& rhs)
{
this->head=rhs.head;
this->size=rhs.size;
this->tail=rhs.tail;
memcpy(this->q,rhs.q,QUEUE_SIZE*sizeof(*rhs.q));
return *this;
}*/
__host__ int gpu2cpuQueue::consume(double* distance)
{
if(!(tail<head))return 0;
*distance=q[(tail%QUEUE_SIZE)];
size++;
tail++;
return 1;
}
__device__ int gpu2cpuQueue::produce(double distance)
{
if(!(head<size)) return 0;
q[(head%QUEUE_SIZE)]=distance;
__threadfence_system();
head++;
__threadfence_system();
return 1;
}
typedef struct {
cpu2gpuQueue cpugpu;
gpu2cpuQueue gpucpu;
} QP;
__global__ void test(QP** gpuQPs,uchar* imags1,uchar* imags2 ){
if(!threadIdx.x) printf("test kernel\n");
//__shared__ uchar images[2*SQR(IMG_DIMENSION)];
__shared__ int hist1[HIST_SIZE],hist2[HIST_SIZE];
__shared__ double distance[HIST_SIZE];
__shared__ double total_distance;
__shared__ int img_idx;
if(!threadIdx.x) total_distance=0;
for(int i=threadIdx.x;i<HIST_SIZE;i+=gridDim.x)
hist1[i]=hist2[i]=0;
bool running=true;
//for(int i=0;i<NREQUESTS;i++)
while( running )
{
if(!threadIdx.x)while(!gpuQPs[blockIdx.x]->cpugpu.consume(&img_idx));
__syncthreads();
//printf("img_idx=%d\n",img_idx);
if(img_idx==-1)
break;
gpu_image_to_histogram(&imags1[img_idx*SQR(IMG_DIMENSION)],hist1);
gpu_image_to_histogram(&imags2[img_idx*SQR(IMG_DIMENSION)],hist2);
__syncthreads();
gpu_histogram_distance(hist1,hist2,distance);
__syncthreads();
if(!threadIdx.x)total_distance+=distance[0];
if(!threadIdx.x)while(!gpuQPs[blockIdx.x]->gpucpu.produce(distance[0]));
__syncthreads();
}
__syncthreads();
if(!threadIdx.x)printf("gpu average distance between images %f\n", total_distance / NREQUESTS);
}
int calcNumOfThreadblocks(){return 3;}
void checkQueueComplition(int num_of_threadblocks,QP **cpuQPs,int * finished, double* total_distance )
{
double distance;
for(int i=0,ret;i<num_of_threadblocks;i++)
{
do{
ret=cpuQPs[i]->gpucpu.consume(&distance);
*total_distance+=ret*distance;
*finished+=ret;
}while(ret);
}
}
void QueueProduce(int num_of_threadblocks,QP **cpuQPs,int img_idx,int * finished, double* total_distance )
{
bool produced=false;
while(!produced)
{
for(int i=0;i<num_of_threadblocks;i++)
{
if(cpuQPs[i]->cpugpu.produce(img_idx))
{
produced=true;
break;
}
else
checkQueueComplition(num_of_threadblocks,cpuQPs,finished, total_distance );
}
}
}
void QueueProduceBlock(int blockId,int num_of_threadblocks,QP **cpuQPs,int img_idx,int * finished, double* total_distance )
{
bool produced=false;
while(!produced)
{
if(cpuQPs[blockId]->cpugpu.produce(img_idx))
{
produced=true;
break;
}
else
checkQueueComplition(num_of_threadblocks,cpuQPs,finished, total_distance );
}
}
int main(void) {
uchar *images1;
uchar *images2;
CUDA_CHECK( cudaHostAlloc(&images1, N_IMG_PAIRS * IMG_DIMENSION * IMG_DIMENSION, 0) );
CUDA_CHECK( cudaHostAlloc(&images2, N_IMG_PAIRS * IMG_DIMENSION * IMG_DIMENSION, 0) );
load_image_pairs(images1, images2);
double t_start, t_finish;
double total_distance=0;
int num_of_threadblocks = calcNumOfThreadblocks();
QP **cpuQPs,**gpuQPs;
CUDA_CHECK( cudaHostAlloc(&cpuQPs, num_of_threadblocks*sizeof(QP*), 0) );
CUDA_CHECK( cudaHostGetDevicePointer(&gpuQPs,cpuQPs,0) );
for(int i=0;i<num_of_threadblocks;i++)
{
CUDA_CHECK( cudaHostAlloc(&cpuQPs[i], sizeof(QP), 0) );
cpuQPs[i]->cpugpu=cpu2gpuQueue();
cpuQPs[i]->gpucpu=gpu2cpuQueue();
CUDA_CHECK( cudaHostGetDevicePointer(&gpuQPs[i],cpuQPs[i],0) );
}
uchar *gpu_image1, *gpu_image2;
CUDA_CHECK(cudaMalloc(&gpu_image1,SQR(IMG_DIMENSION)*N_IMG_PAIRS));
CUDA_CHECK(cudaMalloc(&gpu_image2,SQR(IMG_DIMENSION)*N_IMG_PAIRS));
CUDA_CHECK(cudaMemcpy(gpu_image1,images1, SQR(IMG_DIMENSION)*N_IMG_PAIRS,cudaMemcpyHostToDevice));
CUDA_CHECK(cudaMemcpy(gpu_image2,images2, SQR(IMG_DIMENSION)*N_IMG_PAIRS,cudaMemcpyHostToDevice));
printf("\n=== CPU ===\n");
int histogram1[256];
int histogram2[256];
t_start = get_time_msec();
for (int i = 0; i < NREQUESTS; i++) {
int img_idx = i % N_IMG_PAIRS;
image_to_histogram(&images1[img_idx * IMG_DIMENSION * IMG_DIMENSION], histogram1);
image_to_histogram(&images2[img_idx * IMG_DIMENSION * IMG_DIMENSION], histogram2);
total_distance += histogram_distance(histogram1, histogram2);
}
t_finish = get_time_msec();
printf("average distance between images %f\n", total_distance / NREQUESTS);
printf("throughput = %lf (req/sec)\n", NREQUESTS / (t_finish - t_start) * 1e+3);
total_distance=0;
test<<<num_of_threadblocks, 1024>>>(gpuQPs,gpu_image1,gpu_image2);
int finished=0;
for(int i=0;i<NREQUESTS;i++)
{
int img_idx = i % N_IMG_PAIRS;
checkQueueComplition(num_of_threadblocks,cpuQPs,&finished, &total_distance );
QueueProduce(num_of_threadblocks,cpuQPs,img_idx,&finished, &total_distance );
}
for(int i=0;i<num_of_threadblocks;i++)
QueueProduceBlock(i,num_of_threadblocks,cpuQPs,-1,&finished, &total_distance );
while(finished<NREQUESTS)
checkQueueComplition(num_of_threadblocks,cpuQPs,&finished, &total_distance );
CUDA_CHECK( cudaDeviceSynchronize());
printf("average distance between images %f\n", total_distance / NREQUESTS);
CUDA_CHECK(cudaFree(gpu_image1));
CUDA_CHECK(cudaFree(gpu_image2));
for(int i=0;i<num_of_threadblocks;i++)
CUDA_CHECK( cudaFreeHost(cpuQPs[i]) );
CUDA_CHECK( cudaFreeHost(cpuQPs) );
return 0;
}
__global__ void test1(int *gpu)
{
__shared__ int h[60000];
if(!threadIdx.x)printf("gpu\n");
if(!threadIdx.x)*gpu=1;
__threadfence_system();
if(!threadIdx.x)while(*gpu!=2);
__syncthreads();
}
int main2()
{
int *cpu,*gpu;
CUDA_CHECK( cudaHostAlloc(&cpu, sizeof(int), 0) );
CUDA_CHECK( cudaHostGetDevicePointer(&gpu,cpu,0) );
*cpu=0;
test1<<<1, 1024>>>(gpu);
while(!*cpu){
cudaError_t ret=cudaStreamQuery(0);
}
CUDA_CHECK( cudaDeviceSynchronize());
printf("cpu=%d\n",*cpu);
*cpu=2;
CUDA_CHECK( cudaDeviceSynchronize());
CUDA_CHECK( cudaFreeHost(cpu) );
return 1;
}
#endif
|
21,102 | #include "includes.h"
__global__ void gaussjordan(double *A, double *I, int nn, int i)
{
int x = blockIdx.x * blockDim.x + threadIdx.x;
int y = blockIdx.y * blockDim.y + threadIdx.y;
if ( x< nn && y < nn){
if (x < nn && y < nn){
if (x != i){
I[x*nn + y] -= I[i*nn + y] * A[x*nn + i];
if (y != i){
A[x*nn + y] -= A[i*nn + y] * A[x*nn + i];
}
}
}
}
} |
21,103 | #include "includes.h"
/// Tile size used by the OptimizedMMKernel
#define TILE_SIZE 32
/// Naive matrix multiplication CUDA Kernel
/// Tiled 1D Shared Memory No Unrolling
/// Tiled 2D Shared Memory No Unrolling
/// Tiled 2D Shared Memory With Unrolling (4x4 Tile Size)
/// Tiled 2D Shared Memory With Unrolling (8x8 Tile Size)
/// Tiled 2D Shared Memory With Unrolling (16x16 Tile Size)
/// Tiled 2D Shared Memory With Unrolling (32x32 Tile Size)
/// Prints a matrix out to the stderr stream
__global__ void NaiveMMKernel(float *a, float *b, float *c, int size)
{
int xOut = blockDim.x * blockIdx.x + threadIdx.x;
int yOut = blockDim.y * blockIdx.y + threadIdx.y;
float outValue = 0;
for (int i = 0; i < size; i++)
{
// Row of a mulitplied by the column of b
float prod = a[yOut * size + i] * b[i * size + xOut];
outValue += prod;
}
// Store sum of dot products in C matrix
c[yOut * size + xOut] = outValue;
} |
21,104 |
#include "cuda_runtime.h"
#include "device_launch_parameters.h"
#include <iostream>
#include <iomanip>
#include <fstream>
#include <stdio.h>
cudaError_t addWithCuda(int *c, const int *a, const int *b, unsigned int size);
void doCudaComputation(int* input, int* output);
int doComputationOutput2(int input);
void readFile(int* input);
__global__ void addKernel(int *output, const int *input)
{
int i = blockIdx.x * blockDim.x + threadIdx.x;
int x = input[i] / 3;
output[i] = x - 2;
}
int main()
{
int* input = new int[100];
int* output = new int[100];
readFile(input);
doCudaComputation(input, output);
int sum = 0;
for (int i = 0; i < 100; ++i) {
sum += output[i];
}
int sum2 = 0;
for (int i = 0; i < 100; ++i) {
sum2 += doComputationOutput2(output[i]);
}
printf("Sum: %d\n", sum);
printf("Sum2: %d\n", sum2);
return 0;
}
int doComputationOutput2(int input) {
int x = input / 3;
if (x != 0 && x - 2 > 0) {
return input + doComputationOutput2(x - 2);
}
else {
return input;
}
}
void readFile(int* input) {
int mass = 0;
int compt = 0;
std::ifstream inFile;
inFile.open("input.txt");
while (inFile >> mass) {
input[compt] = mass;
compt++;
}
}
void doCudaComputation(int *input, int *output) {
int *dev_input = nullptr;
int *dev_output = nullptr;
cudaError_t cudaStatus;
cudaSetDevice(0);
cudaMalloc((void**)&dev_input, 100 * sizeof(int));
cudaMalloc((void**)&dev_output, 100 * sizeof(int));
cudaMemcpy(dev_input, input, 100 * sizeof(int), cudaMemcpyHostToDevice);
addKernel<<<1, 100>>>(dev_output, dev_input);
cudaDeviceSynchronize();
cudaMemcpy(output, dev_output, 100 * sizeof(int), cudaMemcpyDeviceToHost);
cudaFree(dev_input);
cudaFree(dev_output);
}
|
21,105 | extern "C" __global__ void vector_add(float* A, float* B, float* C)
{
int i = blockIdx.x;
C[i] = A[i] + B[i];
}
|
21,106 | #include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <cuda.h>
#include <cuda_runtime.h>
#define dT 0.2f
#define G 0.6f
#define BLOCK_SIZE 64
// Global variables
int num_planets;
int num_timesteps;
// Host arrays
float2* velocities;
float4* planets;
// Device arrays
float2* velocities_d;
float4* planets_d;
// Parse command line arguments
void parse_args(int argc, char** argv){
if(argc != 2){
printf("Useage: nbody num_timesteps\n");
exit(-1);
}
num_timesteps = strtol(argv[1], 0, 10);
}
// Reads planets from planets.txt
void read_planets(){
FILE* file = fopen("planets.txt", "r");
if(file == NULL){
printf("'planets.txt' not found. Exiting\n");
exit(-1);
}
char line[200];
fgets(line, 200, file);
sscanf(line, "%d", &num_planets);
planets = (float4*)malloc(sizeof(float4)*num_planets);
velocities = (float2*)malloc(sizeof(float2)*num_planets);
for(int p = 0; p < num_planets; p++){
fgets(line, 200, file);
sscanf(line, "%f %f %f %f %f",
&planets[p].x,
&planets[p].y,
&velocities[p].x,
&velocities[p].y,
&planets[p].z);
}
fclose(file);
}
// Writes planets to file
void write_planets(int timestep){
char name[20];
int n = sprintf(name, "planets_out.txt");
FILE* file = fopen(name, "wr+");
for(int p = 0; p < num_planets; p++){
fprintf(file, "%f %f %f %f %f\n",
planets[p].x,
planets[p].y,
velocities[p].x,
velocities[p].y,
planets[p].z);
}
fclose(file);
}
// TODO 7. Calculate the change in velocity for p, caused by the interaction with q
__device__ float2 calculate_velocity_change_planet(float4 p, float4 q){
}
// TODO 5. Calculate the change in velocity for my_planet, caused by the interactions with a block of planets
__device__ float2 calculate_velocity_change_block(float4 my_planet, float4* shared_planets){
}
// TODO 4. Update the velocities by calculating the planet interactions
__global__ void update_velocities(float4* planets, float2* velocities, int num_planets){
}
// TODO 7. Update the positions of the planets using the new velocities
__global__ void update_positions(float4* planets, float2* velocities, int num_planets){
}
int main(int argc, char** argv){
parse_args(argc, argv);
read_planets();
// TODO 1. Allocate device memory, and transfer data to device
// Calculating the number of blocks
int num_blocks = num_planets/BLOCK_SIZE + ((num_planets%BLOCK_SIZE == 0) ? 0 : 1);
// Main loop
for(int t = 0; t < num_timesteps; t++){
// TODO 2. Call kernels
}
// TODO 3. Transfer data back to host
// Output
write_planets(num_timesteps);
}
|
21,107 | // #include <pycuda-helpers.hpp>
__global__ void copyDensity( double *cnsv, double *rho ){
int t_j = blockIdx.x*blockDim.x + threadIdx.x;
int t_i = blockIdx.y*blockDim.y + threadIdx.y;
int t_k = blockIdx.z*blockDim.z + threadIdx.z;
int tid = t_j + t_i*blockDim.x*gridDim.x + t_k*blockDim.x*gridDim.x*blockDim.y*gridDim.y;
rho[tid] = cnsv[tid];
}
__global__ void FFT_divideK2( const double pi4,
double *kxfft, double *kyfft, double *kzfft,
double *data_re, double *data_im){
int t_j = blockIdx.x*blockDim.x + threadIdx.x;
int t_i = blockIdx.y*blockDim.y + threadIdx.y;
int t_k = blockIdx.z*blockDim.z + threadIdx.z;
int tid = t_j + t_i*blockDim.x*gridDim.x + t_k*blockDim.x*gridDim.x*blockDim.y*gridDim.y;
double kx = kxfft[t_j];
double ky = kyfft[t_i];
double kz = kzfft[t_k];
double k2 = kx*kx + ky*ky + kz*kz;
if ( abs( k2 ) < 1e-5 ) k2 = 1 ;
data_re[tid] = -data_re[tid]*pi4/k2;
data_im[tid] = -data_im[tid]*pi4/k2;
}
__global__ void iterPoissonStep( const int parity,
const int nX, const int nY, const int nZ,
double dx, double dy, double dz,
const double omega, const double pi4, const double convEpsilon,
double* rho_all, double* phi_all, int* converged ){
int t_j = 2*(blockIdx.x*blockDim.x + threadIdx.x);
int t_i = blockIdx.y*blockDim.y + threadIdx.y;
int t_k = blockIdx.z*blockDim.z + threadIdx.z;
//Make a checkboard 3D grid
if ( t_i%2 == 0 ){
if ( t_k%2 == parity ) t_j +=1;
}
else if ( (t_k+1)%2 == parity ) t_j +=1;
int tid = t_j + t_i*nX + t_k*nX*blockDim.y*gridDim.y;
//Set neighbors ids
int l_indx, r_indx, d_indx, u_indx, b_indx, t_indx;
l_indx = t_j==0 ? 1 : t_j-1; //Left
r_indx = t_j==nX-1 ? nX-2 : t_j+1; //Right
d_indx = t_i==0 ? 1 : t_i-1; //Down
u_indx = t_i==nY-1 ? nY-2 : t_i+1; //Up
b_indx = t_k==0 ? 1 : t_k-1; //bottom
t_indx = t_k==nZ-1 ? nZ-2 : t_k+1; //top
double rho, phi_c, phi_l, phi_r, phi_d, phi_u, phi_b, phi_t, phi_new;
rho = rho_all[ tid ];
phi_c = phi_all[tid];
phi_l = phi_all[ l_indx + t_i*nX + t_k*nX*blockDim.y*gridDim.y ];
phi_r = phi_all[ r_indx + t_i*nX + t_k*nX*blockDim.y*gridDim.y ];
phi_d = phi_all[ t_j + d_indx*nX + t_k*nX*blockDim.y*gridDim.y ];
phi_u = phi_all[ t_j + u_indx*nX + t_k*nX*blockDim.y*gridDim.y ];
phi_b = phi_all[ t_j + t_i*nX + b_indx*nX*blockDim.y*gridDim.y ];
phi_t = phi_all[ t_j + t_i*nX + t_indx*nX*blockDim.y*gridDim.y ];
phi_new = (1-omega)*phi_c + omega/6*( phi_l + phi_r + phi_d + phi_u + phi_b + phi_t - dx*dx*pi4*rho );
phi_all[ tid ] = phi_new;
if ( ( abs( ( phi_new - phi_c ) / phi_c ) > convEpsilon ) ) converged[0] = 0;
// if ( ( abs( phi_new - phi_c ) > 0.0001 ) ) converged[0] = 0;
}
__global__ void getGravityForce(const int nCells, const int nW, const int nH, const int nD,
double dx, double dy, double dz,
double* gForce_x, double* gForce_y, double* gForce_z,
double* cnsv, double *phi_all, double *gravWork ){
int t_j = blockIdx.x*blockDim.x + threadIdx.x;
int t_i = blockIdx.y*blockDim.y + threadIdx.y;
int t_k = blockIdx.z*blockDim.z + threadIdx.z;
int tid = t_j + t_i*blockDim.x*gridDim.x + t_k*blockDim.x*gridDim.x*blockDim.y*gridDim.y;
//Set neighbors ids
int l_indx, r_indx, d_indx, u_indx, b_indx, t_indx;
l_indx = t_j==0 ? 1 : t_j-1; //Left
r_indx = t_j==nW-1 ? nW-2 : t_j+1; //Right
d_indx = t_i==0 ? 1 : t_i-1; //Down
u_indx = t_i==nH-1 ? nH-2 : t_i+1; //Up
b_indx = t_k==0 ? 1 : t_k-1; //bottom
t_indx = t_k==nD-1 ? nD-2 : t_k+1; //top
double phi_l, phi_r, phi_d, phi_u, phi_b, phi_t;
phi_l = phi_all[ l_indx + t_i*nW + t_k*nW*nH ];
phi_r = phi_all[ r_indx + t_i*nW + t_k*nW*nH ];
phi_d = phi_all[ t_j + d_indx*nW + t_k*nW*nH ];
phi_u = phi_all[ t_j + u_indx*nW + t_k*nW*nH ];
phi_b = phi_all[ t_j + t_i*nW + b_indx*nW*nH ];
phi_t = phi_all[ t_j + t_i*nW + t_indx*nW*nH ];
// //Boundary conditions
// if ( t_j == 0 ) phi_l = phi_r;
// if ( t_j == nWidth-1 ) phi_r = phi_l;
// if ( t_i == 0 ) phi_d = phi_u;
// if ( t_i == nWidth-1 ) phi_u = phi_d;
// if ( t_k == 0 ) phi_b = phi_t;
// if ( t_k == nWidth-1 ) phi_t = phi_b;
//Get partial derivatives for force
double gField_x, gField_y, gField_z;
gField_x = ( phi_l - phi_r ) * 0.5 / dx;
gField_y = ( phi_d - phi_u ) * 0.5 / dy;
gField_z = ( phi_b - phi_t ) * 0.5 / dz;
double p_x, p_y, p_z, rho;
rho = cnsv[ 0*nCells + tid ];
const int factor = 1;
gForce_x[ tid ] = gField_x * rho * factor;
gForce_y[ tid ] = gField_y * rho * factor;
gForce_z[ tid ] = gField_z * rho * factor;
// gForce_x[ tid ] = gField_x;
// gForce_y[ tid ] = gField_y;
// gForce_z[ tid ] = gField_z;
// //Get momentum for virtual gravitational work
p_x = cnsv[ 1*nCells + tid ];
p_y = cnsv[ 2*nCells + tid ];
p_z = cnsv[ 3*nCells + tid ];
gravWork[ tid ] = (p_x * gField_x + p_y * gField_y + p_z * gField_z )*factor;
}
|
21,108 | #include <iostream>
#include <cuda_runtime.h>
#include <chrono>
#include <string>
#define N 13
//#define TRANSPOSED
typedef std::chrono::high_resolution_clock Clock;
int32_t matrixCGlobal[N][N];
int32_t matrixAGlobal[N * N] = {
14, 39, 117, 89, 111, 73, 79, 102, 52, 81, 123, 70, 39,
82, 29, 125, 85, 51, 60, 102, 39, 120, 106, 19, 15, 58,
124, 31, 32, 23, 19, 69, 60, 61, 10, 33, 72, 1, 91,
96, 112, 32, 111, 90, 12, 63, 77, 47, 105, 115, 38, 90,
13, 35, 23, 78, 57, 109, 122, 89, 21, 116, 86, 123, 113,
27, 14, 80, 69, 9, 23, 106, 26, 115, 31, 6, 73, 112,
53, 70, 64, 118, 121, 17, 6, 113, 30, 8, 5, 116, 66,
12, 113, 71, 94, 98, 116, 2, 95, 66, 107, 54, 11, 34,
90, 36, 81, 124, 73, 41, 105, 14, 127, 109, 87, 29, 2,
84, 77, 56, 81, 21, 81, 110, 110, 123, 104, 113, 39, 54,
75, 102, 44, 79, 61, 55, 90, 125, 52, 45, 4, 120, 12,
20, 20, 105, 41, 20, 44, 108, 74, 72, 62, 76, 34, 111,
38, 97, 124, 5, 97, 87, 85, 106, 12, 31, 87, 6, 77
};
int32_t matrixBGlobal[N * N] = {
69, 96, 71, 89, 127, 108, 96, 121, 64, 65, 62, 91, 73,
9, 67, 113, 48, 47, 53, 96, 66, 7, 63, 17, 9, 8,
107, 45, 112, 33, 114, 48, 102, 70, 52, 47, 34, 81, 17,
38, 15, 61, 1, 104, 82, 68, 53, 69, 110, 12, 25, 46,
111, 89, 54, 0, 107, 81, 127, 124, 36, 17, 99, 117, 75,
125, 72, 48, 67, 31, 104, 64, 98, 94, 57, 81, 15, 16,
111, 16, 127, 119, 88, 41, 75, 125, 22, 50, 120, 6, 81,
75, 7, 78, 38, 35, 115, 114, 37, 66, 106, 64, 91, 97,
75, 102, 84, 112, 65, 76, 87, 22, 45, 100, 19, 18, 89,
27, 25, 109, 18, 116, 19, 116, 33, 103, 31, 29, 78, 8,
24, 12, 86, 20, 32, 53, 31, 13, 51, 36, 100, 56, 44,
13, 8, 54, 24, 101, 73, 115, 120, 56, 23, 63, 39, 93,
77, 50, 108, 56, 106, 58, 121, 74, 70, 88, 19, 49, 83
};
int32_t matrixB_transposed[N * N];
// Calculates AB + A + B
//void naiveMatrixComputation() {
// int8_t c, d, k;
// int32_t sum;
// for (c = 0; c < N; c++) {
// for (d = 0; d < N; d++) {
// sum = 0;
// for (k = 0; k < N; ++k) {
// sum += matrixAGlobal[c][k] * matrixBGlobal[k][d];
// }
// sum += matrixAGlobal[c][d] + matrixBGlobal[c][d];
// matrixCGlobal[c][d] = sum;
// }
// }
//}
// Calculates AB + A + B
__global__ void
gpuMatrixComputation(const int32_t* matrixA, const int32_t* matrixB, int32_t* matrixC) {
int8_t c, d, k;
for (c = 0; c < N; ++c) {
for (d = 0; d < N; ++d) {
matrixC[c * N + d] = 0;
for (k = 0; k < N; ++k) {
matrixC[c * N + d] += matrixA[c * N + k] * matrixB[k * N + d];
}
matrixC[c * N + d] += matrixA[c * N + d] + matrixB[c * N + d];
}
}
}
// Calculates AB + A + B
__global__ void
gpuParallelMatrixComputation(const int32_t* matrixA, const int32_t* matrixB, int32_t* matrixC, const int size) {
int x = blockIdx.x;
int y = threadIdx.x;
int sum = 0;
#pragma unroll
for (int k = 0; k < size; ++k) {
#ifdef TRANSPOSED
sum += matrixA[x * size + k] * matrixB[y * size + k];
#else
sum += matrixA[x * size + k] * matrixB[k * size + y];
#endif
}
sum += matrixA[x * size + y] + matrixB[x * size + y];
matrixC[x * size + y] = sum;
}
int main() {
/*
* Measure the time it takes to execute 1000 times
*/
std::cout << "Malloc device mem" << std::endl;
for (int c = 0; c < N; ++c)
for (int d = 0; d < N; ++d)
matrixB_transposed[c * N + d] = matrixBGlobal[d * N + c];
int32_t* gpu_a, * gpu_b;
int32_t* gpu_c;
int32_t* c_out;
c_out = (int32_t*)malloc(N * N * sizeof(int32_t));
// We need variables accessible to the GPU,
// so cudaMallocManaged provides these
if (cudaMallocManaged(&gpu_a, N * N * sizeof(int32_t)) != 0) {
std::cout << "malloc failed" << std::endl;
}
if (cudaMallocManaged(&gpu_b, N * N * sizeof(int32_t)) != 0) {
std::cout << "malloc failed" << std::endl;
}
if (cudaMallocManaged(&gpu_c, N * N * sizeof(int32_t)) != 0) {
std::cout << "malloc failed" << std::endl;
}
std::cout << "Move to device mem" << std::endl;
if (cudaMemcpy(gpu_a, matrixAGlobal, (N * N * sizeof(int32_t)), cudaMemcpyHostToDevice) != 0) {
std::cout << "memcpy failed" << std::endl;
}
#ifdef TRANSPOSED
if (cudaMemcpy(gpu_b, matrixB_transposed, (N * N * sizeof(int32_t)), cudaMemcpyHostToDevice) != 0) {
std::cout << "memcpy failed" << std::endl;
}
#else
if (cudaMemcpy(gpu_b, matrixBGlobal, (N * N * sizeof(int32_t)), cudaMemcpyHostToDevice) != 0) {
std::cout << "memcpy failed" << std::endl;
}
#endif
std::cout << "Computation" << std::endl;
//Hier een goede keuze maken
dim3 threadsPerBlock = 13; // Should be a factor of 32
dim3 numBlocks = 13; // Very overkill but we now make use of all possible core
unsigned long time_taken = 0;
for (uint16_t i = 0; i < 1e4; i++) {
auto cpu_start = Clock::now();
//88593
// gpuMatrixComputation<<<1, 1>>>(gpu_a, gpu_b, gpu_c);
gpuParallelMatrixComputation <<<numBlocks, threadsPerBlock >>> (gpu_a, gpu_b, gpu_c, N);
cudaDeviceSynchronize();
auto cpu_end = Clock::now();
time_taken += std::chrono::duration_cast<std::chrono::nanoseconds>(cpu_end - cpu_start).count();
}
/*
* Print the resultating matrix
*/
int8_t c, d;
std::cout << "Copy from device to host" << std::endl;
int cudaError = cudaMemcpy(c_out, gpu_c, (N * N * sizeof(int32_t)), cudaMemcpyDeviceToHost);
if (cudaError != 0) {
std::cout << "memcpy output failed: " << cudaError << std::endl;
}
std::cout << "Printing mem" << std::endl;
for (c = 0; c < N; c++) {
for (d = 0; d < N; d++) {
std::cout << std::to_string((int32_t)c_out[c * N + d]) + "\t";
}
std::cout << "\n";
}
std::cout << "Freeing mem" << std::endl;
cudaFree(gpu_a);
cudaFree(gpu_b);
cudaFree(gpu_c);
std::cout << "Calculation took: " << std::to_string(time_taken / 1000) << " nanoseconds" << std::endl;
return 0;
} |
21,109 | //15co154 Yeshwanth R
//15co118 Goutham M
#include<stdio.h>
#include<cuda.h>
__global__ void addition(int *da_in ,int *db_in ,int *d_out){
int idx = blockIdx.x*5 + threadIdx.x;
int idy = blockIdx.y*5 + threadIdx.y;
int in = idx + idy*5;
d_out[in] = da_in[in] + db_in[in];
}
int main()
{
int array_size = 10;
int array_bytes = 10*10*sizeof(int);
int a_in[array_size][array_size],b_in[array_size][array_size];
int h_out[array_size][array_size];
for(int i=0;i<array_size;i++)
for(int j=0;j<array_size;j++)
a_in[i][j] = i;
for(int i=0;i<array_size;i++)
for(int j=0;j<array_size;j++)
b_in[i][j] = j;
int *da_in;
int *db_in;
int *d_out;
cudaMalloc((void **)&da_in,array_bytes);
cudaMalloc((void **)&db_in,array_bytes);
cudaMalloc((void **)&d_out,array_bytes);
cudaMemcpy(da_in,a_in,array_bytes,cudaMemcpyHostToDevice);
cudaMemcpy(db_in,b_in,array_bytes,cudaMemcpyHostToDevice);
addition<<<dim3(2,2,1),dim3(5,5,1)>>>(da_in,db_in,d_out);
cudaMemcpy(h_out,d_out,array_bytes,cudaMemcpyDeviceToHost);
for(int i=0;i<array_size;i++)
{
for(int j=0;j<array_size;j++)
{
printf("%d ",h_out[i*10+j]);
}
printf("\n");
}
cudaFree(da_in);
cudaFree(db_in);
cudaFree(d_out);
} |
21,110 | #include "cuda_runtime.h"
#include "device_launch_parameters.h"
#include <stdio.h>
#include <random>
#include <sys/timeb.h>
#define BLOCK_SIZE 16
__global__ void Evolve(bool* field, float* scores, double b, int size, bool* next_field)
{
int row = blockIdx.y * blockDim.y + threadIdx.y;
int col = blockIdx.x * blockDim.x + threadIdx.x;
int memberIndex;
// Score
if (col >= size || row >= size)
return;
//printf("(%i, %i)\n", col, row);
float score = 0;
for (int i = -1; i <= 1; i++) //Row
{
for (int j = -1; j <= 1; j++) //Col
{
memberIndex = (col + i + size) % size + size * ((row + j + size) % size);
if (field[memberIndex] == true)
score++;
}
}
if (!field[row*size + col])
scores[row*size + col] = score * b;
else
scores[row*size + col] = score;
__syncthreads();
// Strategy
int bestStrategyIndex = row*size + col;
for (int i = -1; i <= 1; i++) //Row
{
for (int j = -1; j <= 1; j++) //Col
{
memberIndex = (col + i + size) % size + size * ((row + j + size) % size);
if (scores[bestStrategyIndex] < scores[memberIndex])
{
bestStrategyIndex = memberIndex;
}
}
}
next_field[row*size + col] = field[bestStrategyIndex];
__syncthreads();
}
void InitField(bool* field, size_t size, int persentage)
{
for (size_t i = 0; i < size*size; i++) {
field[i] = rand() % 100 > persentage;
}
}
void PrintField(bool* field, int size)
{
printf("\n");
for (int i = -1; i < size; i++) {
for (size_t j = 0; j < size; j++)
{
if (i == -1)
printf("_");
else
printf("%s", field[i*size + j]? " " : "#");
}
printf("\n");
}
}
int GetMilliCount() {
timeb tb;
ftime(&tb);
int nCount = tb.millitm + (tb.time & 0xfffff) * 1000;
return nCount;
}
int GetMilliSpan(int nTimeStart) {
int nSpan = GetMilliCount() - nTimeStart;
if (nSpan < 0)
nSpan += 0x100000 * 1000;
return nSpan;
}
int main(int argc, char * argv[])
{
int start;
// Main program
bool* field;
unsigned int size = atoi(argv[1]);
double b = 1.81;
unsigned int steps = 0;
bool *d_field, *d_next_field;
float *d_scores;
field = (bool*)malloc(sizeof(bool)*size*size);
// GPU Memory
cudaMalloc((void**)&d_field, sizeof(bool)*size*size);
cudaMalloc((void**)&d_scores, sizeof(float)*size*size);
cudaMalloc((void**)&d_next_field, sizeof(bool)*size*size);
InitField(field, size, 21);
unsigned int grid_rows = (size + BLOCK_SIZE - 1) / BLOCK_SIZE;
unsigned int grid_cols = (size + BLOCK_SIZE - 1) / BLOCK_SIZE;
dim3 blockSize;
dim3 gridSize;
blockSize = dim3(BLOCK_SIZE, BLOCK_SIZE, 1);
gridSize = dim3(grid_rows, grid_cols, 1);
start = GetMilliCount();
for (size_t i = 0; i < 1000 && GetMilliSpan(start) < 1000; i++)
{
steps++;
// Init scores with zeros in GPU Memory
cudaMemcpy(d_field, field, size * size, cudaMemcpyKind::cudaMemcpyHostToDevice);
cudaMemset(d_scores, 0, size * size);
Evolve<<<gridSize, blockSize>>>(d_field, d_scores, b, size, d_next_field);
//printf("%s\n", cudaGetErrorString(cudaGetLastError()));
cudaMemcpy(field, d_next_field, size*size, cudaMemcpyKind::cudaMemcpyDeviceToHost);
}
printf("[%i, %f, %i]\n", size, GetMilliSpan(start) * 0.001 / steps, steps);
cudaFree(d_field);
cudaFree(d_next_field);
cudaFree(d_scores);
return 0;
}
|
21,111 | #include "dev_ptr.cuh"
#include "device_error.cuh"
#include "cuda_runtime.h"
//template<class T>
//DevPtr<T>::DevPtr()
//{
//
//}
//template<class T>
//DevPtr<T>::DevPtr(const DevPtr& devPtr)
//{
// cudaFree(_data);
// _data = devPtr.Get();
// _size = devPtr.Size();
//}
//
//template<class T>
//DevPtr<T>& DevPtr<T>::operator=(DevPtr<T>& devPtr)
//{
// cudaFree(_data);
// _data = devPtr.Get();
// _size = devPtr.Size();
//
// return this;
//}
//
//template<class T>
//T& DevPtr<T>::operator[](int i)
//{
// return _data[i];
//}
//
//template<class T>
//const T& DevPtr<T>::operator[](int i) const
//{
// return _data[i];
//}
//
//template<class T>
//void DevPtr<T>::CopyFromHost(const T* data)
//{
// cudaError_t result = cudaMemcpy(static_cast<void*>(_data),
// static_cast<void*>(data),
// _size * sizeof(T),
// cudaMemcpyKind::cudaMemcpyHostToDevice);
// if(result != cudaError_t::cudaSuccess)
// throw CopyError();
//}
//
//template<class T>
//void DevPtr<T>::CopyToHost(T* data)
//{
// cudaError_t result = cudaMemcpy((void**)_data,
// (void**)data,
// _size * sizeof(T),
// cudaMemcpyKind::cudaMemcpyHostToDevice);
// if(result != cudaError_t::cudaSuccess)
// throw CopyError();
//}
|
21,112 | #include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <time.h>
#include <cuda.h>
#include <cuda_runtime.h>
// CUDA kernel, Each thread takes care of one element of c
__global__ void vecAdd(double *a, double *b, double *c, int n)
{
// Get global thread ID
int idx = blockIdx.x * blockDim.x + threadIdx.x;
// Make sure not to go out of bounds
if (idx < n)
c[idx] = a[idx] + b[idx];
}
int main (int argc, char **argv)
{
// Size of vectors for addition
int n = 10000000;
// Host vectors
double *h_a, *h_b, *h_c, *h_h;
// Device vectors
double *d_a, *d_b, *d_c;
// Size in bytes for each vector
size_t bytes = n*sizeof(double);
// Allocate memory for each vector on host
h_a = (double *)malloc(bytes);
h_b = (double *)malloc(bytes);
h_c = (double *)malloc(bytes);
h_h = (double *)malloc(bytes);
// Allocate memory for each vector on GPU
cudaMalloc((void **)&d_a, bytes);
cudaMalloc((void **)&d_b, bytes);
cudaMalloc((void **)&d_c, bytes);
// Initialize all vectors on host
int i;
for (i = 0 ; i < n ; i++)
{
h_a[i] = sin(i) * sin(i);
h_b[i] = cos(i) * cos(i);
}
// Copy host vectors to device
cudaMemcpy( d_a, h_a, bytes, cudaMemcpyHostToDevice );
cudaMemcpy( d_b, h_b, bytes, cudaMemcpyHostToDevice );
int blockSize, gridSize;
// Number of threads in each thread block
blockSize = 1024;
// Number of thread blocks in grid
gridSize = (int)ceil((float)n/blockSize);
// Execute on CPU and GPU
clock_t cpu_start, cpu_end;
clock_t gpu_start, gpu_end;
cpu_start = clock();
for (i = 0 ; i < n ; i++)
{
h_h[i] = h_a[i] + h_b[i];
}
cpu_end = clock();
gpu_start = clock();
vecAdd<<<gridSize, blockSize>>>(d_a, d_b, d_c, n);
cudaDeviceSynchronize();
gpu_end = clock();
// Copy array back to host
cudaMemcpy( h_c, d_c, bytes, cudaMemcpyDeviceToHost );
// Sum up vector c and print result divided by n
double sum = 0;
for ( i = 0 ; i < n ; i++ )
sum += h_c[i];
printf("final:result: %f\n", sum/n);
double cpu_time = ((double)cpu_end - cpu_start)/CLOCKS_PER_SEC;
double gpu_time = ((double)gpu_end - gpu_start)/CLOCKS_PER_SEC;
printf("CPU Time: %f\nGPU Time: %f\n", cpu_time, gpu_time);
// Release device memory
cudaFree(d_a);
cudaFree(d_b);
cudaFree(d_c);
// Release host memory
free(h_a);
free(h_b);
free(h_c);
free(h_h);
return 0;
}
|
21,113 | //--------------------------------------------------------------------------
// Project:
// Select the least utilized GPU on a CUDA-enabled system.
// Insert into your code as desired.
//
// Prerequisites:
// Must have installed the CUDA toolkit.
// Must be running on a UNIX machine
//
// Independent testing info:
// Compile on commandline: nvcc least_utilized_GPU.cu -o test
// run on commandline: ./test
//
// Author: Jordan Bonilla
// Date : April 2016
// License: All rights Reserved. See LICENSE.txt
//--------------------------------------------------------------------------
#include <cstdio> // printf
#include <stdlib.h> // popen, pclose, atoi, fread
#include <cuda_runtime.h> // cudaGetDeviceCount, cudaSetDevice
// Select the least utilized GPU on this system. Estimate
// GPU utilization using GPU temperature. UNIX only.
void select_GPU()
{
// Get the number of GPUs on this machine
int num_devices;
cudaGetDeviceCount(&num_devices);
if(num_devices == 1) {
return;
}
// Read GPU info into buffer "output"
const unsigned int MAX_BYTES = 10000;
char output[MAX_BYTES];
FILE *fp = popen("nvidia-smi &> /dev/null", "r");
fread(output, sizeof(char), MAX_BYTES, fp);
pclose(fp);
// array to hold GPU temperatures
int * temperatures = new int[num_devices];
// parse output for temperatures using knowledge of "nvidia-smi" output format
int i = 0;
unsigned int num_temps_parsed = 0;
while(output[i] != '\0') {
if(output[i] == '%') {
unsigned int temp_begin = i + 1;
while(output[i] != 'C') {
++i;
}
unsigned int temp_end = i;
char this_temperature[32];
// Read in the characters cooresponding to this temperature
for(int j = 0; j < temp_end - temp_begin; ++j) {
this_temperature[j] = output[temp_begin + j];
}
this_temperature[temp_end - temp_begin + 1] = '\0';
// Convert the string representation to an int
temperatures[num_temps_parsed] = atoi(this_temperature);
num_temps_parsed++;
}
++i;
}
// Get GPU with lowest temperature
int min_temp = 1e7, index_of_min = -1;
for (int i = 0; i < num_devices; i++)
{
int candidate_min = temperatures[i];
if(candidate_min < min_temp)
{
min_temp = candidate_min;
index_of_min = i;
}
}
// Tell CUDA to use the GPU with the lowest temeprature
printf("Index of the GPU with the lowest temperature: %d (%d C)\n",
index_of_min, min_temp);
cudaSetDevice(index_of_min);
// Free memory and return
delete(temperatures);
return;
}
int main(int argc, char **argv) {
select_GPU();
return 0;
}
|
21,114 | #include "includes.h"
__global__ void Split(int * xi, bool * xb, size_t idxi, size_t idxb, size_t N, float threshold)
{
for (int i = blockIdx.x * blockDim.x + threadIdx.x; i < N; i += blockDim.x * gridDim.x)
{
xb[(idxb)*N+i] = (((float)xi[(idxi-1)*N+i]) == threshold);
}
return;
} |
21,115 | // File: cudaGetDeviceProperties.cu
//
// Compiler Command:
// $ nvcc cudaGetDeviceProperties.cu -o cudaGetDeviceProperties
// Head files
#include <stdio.h>
#include <cuda_runtime.h>
// main function
int main(int argc, char **argv) {
printf("%s Starting...\n", argv[0]);
int deviceCount = 0;
cudaError_t error_id = cudaGetDeviceCount(&deviceCount);
if (error_id != cudaSuccess) {
printf("cudaGetDeviceCount returned %d\n-> %s\n",
(int)error_id, cudaGetErrorString(error_id));
printf("Result = FAIL\n");
exit(EXIT_FAILURE);
}
if (deviceCount == 0) {
printf("There are no available device(s) that support CUDA\n");
} else {
printf("Detected %d CUDA Capable device(s)\n", deviceCount);
}
int dev, driverVersion = 0, runtimeVersion = 0;
dev =0;
cudaSetDevice(dev);
cudaDeviceProp deviceProp;
cudaGetDeviceProperties(&deviceProp, dev);
printf("Device %d: \"%s\"\n", dev, deviceProp.name);
cudaDriverGetVersion(&driverVersion);
cudaRuntimeGetVersion(&runtimeVersion);
printf(" CUDA Driver Version / Runtime Version %d.%d / %d.%d\n",driverVersion/1000, (driverVersion%100)/10,runtimeVersion/1000, (runtimeVersion%100)/10);
printf(" CUDA Capability Major/Minor version number: %d.%d\n",deviceProp.major, deviceProp.minor);
printf(" Total amount of global memory: %.2f MBytes (%llu bytes)\n",(float)deviceProp.totalGlobalMem/(pow(1024.0,3)),(unsigned long long) deviceProp.totalGlobalMem);
printf(" GPU Clock rate: %.0f MHz (%0.2f GHz)\n",deviceProp.clockRate * 1e-3f, deviceProp.clockRate * 1e-6f);
printf(" Memory Clock rate: %.0f Mhz\n",deviceProp.memoryClockRate * 1e-3f);
printf(" Memory Bus Width: %d-bit\n",deviceProp.memoryBusWidth);
if (deviceProp.l2CacheSize) {
printf(" L2 Cache Size: %d bytes\n",
deviceProp.l2CacheSize);
}
printf(" Max Texture Dimension Size (x,y,z) 1D=(%d), 2D=(%d,%d), 3D=(%d,%d,%d)\n",
deviceProp.maxTexture1D , deviceProp.maxTexture2D[0],
deviceProp.maxTexture2D[1],
deviceProp.maxTexture3D[0], deviceProp.maxTexture3D[1],
deviceProp.maxTexture3D[2]);
printf(" Max Layered Texture Size (dim) x layers 1D=(%d) x %d, 2D=(%d,%d) x %d\n",
deviceProp.maxTexture1DLayered[0], deviceProp.maxTexture1DLayered[1],
deviceProp.maxTexture2DLayered[0], deviceProp.maxTexture2DLayered[1],
deviceProp.maxTexture2DLayered[2]);
printf(" Total amount of constant memory: %lu bytes\n",deviceProp.totalConstMem);
printf(" Total amount of shared memory per block: %lu bytes\n",deviceProp.sharedMemPerBlock);
printf(" Total number of registers available per block: %d\n",deviceProp.regsPerBlock);
printf(" Warp size: %d\n", deviceProp.warpSize);
printf(" Maximum number of threads per multiprocessor: %d\n",deviceProp.maxThreadsPerMultiProcessor);
printf(" Maximum number of threads per block: %d\n",deviceProp.maxThreadsPerBlock);
printf(" Maximum sizes of each dimension of a block: %d x %d x %d\n",
deviceProp.maxThreadsDim[0],
deviceProp.maxThreadsDim[1],
deviceProp.maxThreadsDim[2]);
printf(" Maximum sizes of each dimension of a grid: %d x %d x %d\n",
deviceProp.maxGridSize[0],
deviceProp.maxGridSize[1],
deviceProp.maxGridSize[2]);
printf(" Maximum memory pitch: %lu bytes\n", deviceProp.memPitch);
exit(EXIT_SUCCESS);
}
// For a system with multiple GPUs, it's necessary to choose one of these GPUs as our device.
// The stratage is that: the GPU with best performance must has the largest number of SMs.
// Implementation code listed below:
// int numDevices = 0;
// cudaGetDeviceCount(&numDevices);
// if (numDevices > 1) {
// int maxMultiprocessors = 0, maxDevice = 0;
// for (int device=0; device<numDevices; device++) {
// cudaDeviceProp props;
// cudaGetDeviceProperties(&props, device);
// if (maxMultiprocessors < props.multiProcessorCount) {
// maxMultiprocessors = props.multiProcessorCount;
// maxDevice = device;
// }
// }
// cudaSetDevice(maxDevice);
// }
// Runnning result
// yangyang@yangyang-XPS-8900:~/Desktop/cudaCodeDebug/CodeDebug2$ ./cudaGetDeviceProperties
// ./cudaGetDeviceProperties Starting...
// Detected 1 CUDA Capable device(s)
// Device 0: "GeForce GTX 750 Ti"
// CUDA Driver Version / Runtime Version 9.1 / 9.1
// CUDA Capability Major/Minor version number: 5.0
// Total amount of global memory: 1.95 MBytes (2090598400 bytes)
// GPU Clock rate: 1084 MHz (1.08 GHz)
// Memory Clock rate: 2700 Mhz
// Memory Bus Width: 128-bit
// L2 Cache Size: 2097152 bytes
// Max Texture Dimension Size (x,y,z) 1D=(65536), 2D=(65536,65536), 3D=(4096,4096,4096)
// Max Layered Texture Size (dim) x layers 1D=(16384) x 2048, 2D=(16384,16384) x 2048
// Total amount of constant memory: 65536 bytes
// Total amount of shared memory per block: 49152 bytes
// Total number of registers available per block: 65536
// Warp size: 32
// Maximum number of threads per multiprocessor: 2048
// Maximum number of threads per block: 1024
// Maximum sizes of each dimension of a block: 1024 x 1024 x 64
// Maximum sizes of each dimension of a grid: 2147483647 x 65535 x 65535
// Maximum memory pitch: 2147483647 bytes
|
21,116 | #include "includes.h"
__global__ void kern_ConvertBuffer(short* agreement, float* output, int size )
{
int idx = CUDASTDOFFSET;
float locAgreement = (float) agreement[idx];
if( idx < size )
{
output[idx] = locAgreement;
}
} |
21,117 | #include <stdlib.h>
#include <stdio.h>
#include <cuda.h>
#include <time.h>
#include <curand_kernel.h>
#define NUMBER float
#define precision "float"
#define Kernel_cycles 10000
#define Cycles 512
#define Cycles2 512
#define BLOCKS 8
#define THREADS 128
#define Correct_value 187.5
__global__ void gpu_monte_carlo(NUMBER *estimate, curandState *states, int seed){
unsigned int tid = threadIdx.x + blockDim.x * blockIdx.x;
NUMBER ans, ans2 = 0;
NUMBER x, y, a, b, c, d;
a = c = 0;
b = d = 5;
curand_init(seed, tid, 0, &states[tid]);
for (long i = 0; i < Cycles2; i++){
ans = 0;
for (long i = 0; i < Cycles; ++i){
x = (a+(b-a))*curand_uniform(&states[tid]);
y = (c+(d-c))*curand_uniform(&states[tid]);
ans += (2*x+y);
}
ans2 += ans/(NUMBER)Cycles;
}
estimate[tid] = ans2*(((b-a)*(d-c)) / (NUMBER) Cycles2) ;
}
int main(){
clock_t t[2];
cudaStream_t stream1;
cudaStreamCreate(&stream1);
//variables and pointers
NUMBER host[BLOCKS * THREADS];
NUMBER *dev;
curandState *devStates;
int seed = 1;
double integral_gpu;
printf("# of cycles per kernel = %d, # of blocks = %d, # of threads/block = %d.\n",
Kernel_cycles, BLOCKS, THREADS);
cudaMalloc((void **) &dev, BLOCKS * THREADS * sizeof(NUMBER));
cudaMalloc( (void **)&devStates, THREADS * BLOCKS * sizeof(curandState) );
t[0] = clock();
for (long i = 0; i < Kernel_cycles; i++) {
seed +=1;
gpu_monte_carlo<<<BLOCKS, THREADS,1,stream1>>>(dev, devStates, seed);
cudaMemcpy(host, dev, BLOCKS * THREADS * sizeof(NUMBER), cudaMemcpyDeviceToHost);
for (long i = 0; i < BLOCKS * THREADS; ++i){
integral_gpu += host[i];
}
}
t[1] = clock();
integral_gpu /= (BLOCKS * THREADS * (long)Kernel_cycles);
printf("Precision %s\n",precision);
printf("GPU calculation %f s.\n", ((t[1]-t[0]))/(double)CLOCKS_PER_SEC);
printf("CUDA estimate of 2*x+y = %f [error of %f]\n", integral_gpu, integral_gpu - Correct_value);
cudaFree(dev);
cudaFree(devStates);
return 0;
}
|
21,118 | #include <thrust/device_vector.h>
#include <thrust/host_vector.h>
#include <iostream>
#include <chrono>
int main() {
double stocks;
std::cin >> stocks;
thrust::host_vector<double> host;
for(int i =0; i < 2517; i++){
std::cin >> stocks;
host.push_back(stocks);
}
/* na linha abaixo os dados são copiados
para GPU */
auto start = std::chrono::steady_clock::now();
thrust::device_vector<double> dev(host);
auto end = std::chrono::steady_clock::now();
std::chrono::duration<double> elapsed_seconds = end-start;
printf("Host vector: ");
for (auto i = host.begin(); i != host.end(); i++) {
std::cout << *i << " "; // este acesso é rápido -- CPU
}
printf("\n");
printf("Device vector: ");
for (auto i = dev.begin(); i != dev.end(); i++) {
std::cout << *i << " "; // este acesso é lento! -- GPU
}
printf("\n");
std::cerr << "elapsed time: " << elapsed_seconds.count() << "s\n";
}
|
21,119 | #include "includes.h"
__global__ void cudaclaw5_update_q_cuda2(int mbc, int mx, int my, int meqn, double dtdx, double dtdy, double* qold, double* fm, double* fp, double* gm, double* gp)
{
int ix = threadIdx.x + blockIdx.x*blockDim.x;
int iy = threadIdx.y + blockIdx.y*blockDim.y;
if (ix < mx && iy < my)
{
int x_stride = meqn;
int y_stride = (2*mbc + mx)*x_stride;
int I_q = (ix+mbc)*x_stride + (iy+mbc)*y_stride;
int mq;
for(mq = 0; mq < meqn; mq++)
{
int i = I_q+mq;
qold[i] = qold[i] - dtdx * (fm[i+x_stride] - fp[i])
- dtdy * (gm[i+y_stride] - gp[i]);
}
}
} |
21,120 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#define DIM 2 /* Two-dimensional system */
#define X 0 /* x-coordinate subscript */
#define Y 1 /* y-coordinate subscript */
#define START_TIMER \
cudaEvent_t start = cudaEvent_t(); \
cudaEvent_t stop = cudaEvent_t(); \
cudaEventCreate(&start); \
cudaEventCreate(&stop); \
cudaEventRecord(start, 0);
#define END_TIMER \
cudaEventRecord(stop, 0); \
cudaEventSynchronize(stop); \
cudaEventElapsedTime(time, start, stop); \
cudaEventDestroy(start); \
cudaEventDestroy(stop);
const int GRID_SIZE = 192;
const int BLOCK_SIZE = 128;
const double G = 6.673e-11;
const double ACCURACY = 0.01;
typedef double vect_t[DIM]; /* Vector type for position, etc. */
struct particle_s
{
double m; /* Mass */
vect_t s; /* Position */
vect_t v; /* Velocity */
};
void Get_args(int, char *[], int *, int *, double *, int *, char *);
void Get_init_cond(struct particle_s*, int);
void Gen_init_cond(struct particle_s[], int);
void Compute_force(int, vect_t*, struct particle_s*, int);
void Update_part(int, vect_t*, struct particle_s*, int, double);
void Compute_energy(struct particle_s*, int, double *, double *);
void sequential(struct particle_s *, double *, double *, int, int, double, float *);
void parallel_compute_forces(vect_t*, struct particle_s*, int);
void parallel_update_parts(vect_t*, struct particle_s*, int, double);
void parallel_compute_energy(struct particle_s*, int, double *, double *);
void parallel(struct particle_s *, double *, double *, int n, int, double, float *);
int verify_solution(int, struct particle_s*, struct particle_s*, double, double, double, double);
int is_close(double, double, double);
__device__ void indexes(unsigned, unsigned, unsigned*, unsigned*);
int main(int argc, char *argv[])
{
int n; /* Number of particles */
int n_steps; /* Number of timesteps */
int output_freq; /* Frequency of output */
double delta_t; /* Size of timestep */
struct particle_s *sequential_curr, *parallel_curr;
char g_i; /* Generate or input init conds */
double sequential_kinetic_energy, sequential_potential_energy;
double parallel_kinetic_energy, parallel_potential_energy;
float sequential_time, parallel_time;
Get_args(argc, argv, &n, &n_steps, &delta_t, &output_freq, &g_i);
sequential_curr = (struct particle_s*)malloc(n * sizeof(struct particle_s));
parallel_curr = (struct particle_s*)malloc(n * sizeof(struct particle_s));
if (g_i == 'i')
Get_init_cond(sequential_curr, n);
else
Gen_init_cond(sequential_curr, n);
memcpy(parallel_curr, sequential_curr, n * sizeof(struct particle_s));
sequential(sequential_curr, &sequential_kinetic_energy, &sequential_potential_energy, n, n_steps, delta_t, &sequential_time);
parallel(parallel_curr, ¶llel_kinetic_energy, ¶llel_potential_energy, n, n_steps, delta_t, ¶llel_time);
printf("Sequential time: %.15f ms\n", sequential_time);
printf("Parallel time: %.15f ms\n", parallel_time);
printf("Speedup: %.15f\n", sequential_time / parallel_time);
if(verify_solution(n, sequential_curr, parallel_curr, sequential_kinetic_energy, parallel_kinetic_energy, sequential_potential_energy, parallel_potential_energy))
printf("TEST PASSED\n");
else
printf("TEST FAILED\n");
free(sequential_curr);
free(parallel_curr);
return 0;
} /* main */
void Get_args(int argc, char *argv[], int *n_p, int *n_steps_p, double *delta_t_p, int *output_freq_p, char *g_i_p)
{
if (argc != 6)
printf("Bad arguments\n");
*n_p = strtol(argv[1], NULL, 10);
*n_steps_p = strtol(argv[2], NULL, 10);
*delta_t_p = strtod(argv[3], NULL);
*output_freq_p = strtol(argv[4], NULL, 10);
*g_i_p = argv[5][0];
if (*n_p <= 0 || *n_steps_p < 0 || *delta_t_p <= 0)
printf("Bad arguments\n");
if (*g_i_p != 'g' && *g_i_p != 'i')
printf("Bad arguments\n");
} /* Get_args */
void Get_init_cond(struct particle_s* curr, int n)
{
int part;
printf("For each particle, enter (in order):\n");
printf(" its mass, its x-coord, its y-coord, ");
printf("its x-velocity, its y-velocity\n");
for (part = 0; part < n; part++)
{
scanf("%lf", &curr[part].m);
scanf("%lf", &curr[part].s[X]);
scanf("%lf", &curr[part].s[Y]);
scanf("%lf", &curr[part].v[X]);
scanf("%lf", &curr[part].v[Y]);
}
} /* Get_init_cond */
void Gen_init_cond(struct particle_s* curr, int n)
{
int part;
double mass = 5.0e24;
double gap = 1.0e5;
double speed = 3.0e4;
for (part = 0; part < n; part++)
{
curr[part].m = mass;
curr[part].s[X] = part * gap;
curr[part].s[Y] = 0.0;
curr[part].v[X] = 0.0;
if (part % 2 == 0)
curr[part].v[Y] = speed;
else
curr[part].v[Y] = -speed;
}
} /* Gen_init_cond */
void Compute_force(int part, vect_t* forces, struct particle_s* curr, int n)
{
int k;
double mg;
vect_t f_part_k;
double len, len_3, fact;
for (k = part + 1; k < n; k++)
{
f_part_k[X] = curr[part].s[X] - curr[k].s[X];
f_part_k[Y] = curr[part].s[Y] - curr[k].s[Y];
len = sqrt(f_part_k[X] * f_part_k[X] + f_part_k[Y] * f_part_k[Y]);
len_3 = len * len * len;
mg = -G * curr[part].m * curr[k].m;
fact = mg / len_3;
f_part_k[X] *= fact;
f_part_k[Y] *= fact;
forces[part][X] += f_part_k[X];
forces[part][Y] += f_part_k[Y];
forces[k][X] -= f_part_k[X];
forces[k][Y] -= f_part_k[Y];
}
} /* Compute_force */
void Update_part(int part, vect_t* forces, struct particle_s* curr, int n, double delta_t)
{
double fact = delta_t / curr[part].m;
curr[part].s[X] += delta_t * curr[part].v[X];
curr[part].s[Y] += delta_t * curr[part].v[Y];
curr[part].v[X] += fact * forces[part][X];
curr[part].v[Y] += fact * forces[part][Y];
} /* Update_part */
void Compute_energy(struct particle_s* curr, int n, double *kin_en_p, double *pot_en_p)
{
int i, j;
vect_t diff;
double pe = 0.0, ke = 0.0;
double dist, speed_sqr;
for (i = 0; i < n; i++)
{
speed_sqr = curr[i].v[X] * curr[i].v[X] + curr[i].v[Y] * curr[i].v[Y];
ke += curr[i].m * speed_sqr;
}
ke *= 0.5;
for (i = 0; i < n - 1; i++)
{
for (j = i + 1; j < n; j++)
{
diff[X] = curr[i].s[X] - curr[j].s[X];
diff[Y] = curr[i].s[Y] - curr[j].s[Y];
dist = sqrt(diff[X] * diff[X] + diff[Y] * diff[Y]);
pe += -G * curr[i].m * curr[j].m / dist;
}
}
*kin_en_p = ke;
*pot_en_p = pe;
} /* Compute_energy */
void sequential(struct particle_s *curr, double* kinetic_energy, double* potential_energy, int n, int n_steps, double delta_t, float* time)
{
START_TIMER
vect_t *forces = (vect_t*)malloc(n * sizeof(vect_t));
Compute_energy(curr, n, kinetic_energy, potential_energy);
printf(" PE = %e, KE = %e, Total Energy = %e\n", *potential_energy, *kinetic_energy, *kinetic_energy + *potential_energy);
for (int step = 1; step <= n_steps; step++)
{
memset(forces, 0, n * sizeof(vect_t));
for (int part = 0; part < n - 1; part++)
Compute_force(part, forces, curr, n);
for (int part = 0; part < n; part++)
Update_part(part, forces, curr, n, delta_t);
}
Compute_energy(curr, n, kinetic_energy, potential_energy);
printf(" PE = %e, KE = %e, Total Energy = %e\n", *potential_energy, *kinetic_energy, *kinetic_energy + *potential_energy);
free(forces);
END_TIMER
}
__global__ void kernel_forces(vect_t* forces, struct particle_s* curr, int n, vect_t* partial_forces)
{
double mg;
vect_t f_part_k;
double len, len_3, fact;
int idx = blockIdx.x * blockDim.x + threadIdx.x;
vect_t to_add = {0, 0};
struct particle_s my_curr = curr[idx];
if(idx < n - 1)
{
for(int k = idx + 1; k < n; k++)
{
f_part_k[X] = my_curr.s[X] - curr[k].s[X];
f_part_k[Y] = my_curr.s[Y] - curr[k].s[Y];
len = sqrt(f_part_k[X] * f_part_k[X] + f_part_k[Y] * f_part_k[Y]);
len_3 = len * len * len;
mg = -G * my_curr.m * curr[k].m;
fact = mg / len_3;
f_part_k[X] *= fact;
f_part_k[Y] *= fact;
to_add[X] += f_part_k[X];
to_add[Y] += f_part_k[Y];
partial_forces[k * n + idx][X] = -f_part_k[X];
partial_forces[k * n + idx][Y] = -f_part_k[Y];
}
forces[idx][X] += to_add[X];
forces[idx][Y] += to_add[Y];
}
}
__global__ void kernel_add_partials(int n, vect_t* forces, vect_t* partial_forces)
{
int idx = blockIdx.x * blockDim.x + threadIdx.x;
if(idx < n)
{
for(int j = 0; j < n; j++)
{
if(j != idx)
{
forces[idx][X] += partial_forces[idx * n + j][X];
forces[idx][Y] += partial_forces[idx * n + j][Y];
}
}
}
}
void parallel_compute_forces(vect_t* forces, struct particle_s* curr, int n, vect_t* partial_forces)
{
int grid_size = (n + BLOCK_SIZE - 1) / BLOCK_SIZE;
// cudaMemset(partial_forces, 0, n * n * sizeof(vect_t));
kernel_forces<<<grid_size, BLOCK_SIZE>>>(forces, curr, n, partial_forces);
kernel_add_partials<<<grid_size, BLOCK_SIZE>>>(n, forces, partial_forces);
}
__global__ void kernel_update(vect_t* forces, struct particle_s* curr, int n, double delta_t)
{
int idx = blockIdx.x * blockDim.x + threadIdx.x;
if(idx < n)
{
double fact = delta_t / curr[idx].m;
curr[idx].s[X] += delta_t * curr[idx].v[X];
curr[idx].s[Y] += delta_t * curr[idx].v[Y];
curr[idx].v[X] += fact * forces[idx][X];
curr[idx].v[Y] += fact * forces[idx][Y];
}
}
void parallel_update_parts(vect_t* forces, struct particle_s* curr, int n, double delta_t)
{ // deluje da radi
int grid_size = (n + BLOCK_SIZE - 1) / BLOCK_SIZE;
kernel_update<<<grid_size, BLOCK_SIZE>>>(forces, curr, n, delta_t);
}
__global__ void kernel_kinetic_energy(double* partial_sums, int n, struct particle_s* curr)
{
int idx = blockIdx.x * blockDim.x + threadIdx.x;
for(int i = idx; i < n; i += gridDim.x * blockDim.x)
partial_sums[idx] += curr[i].m * (curr[i].v[X] * curr[i].v[X] + curr[i].v[Y] * curr[i].v[Y]);
}
__global__ void kernel_potential_energy(double* partial_sums, int n, struct particle_s* curr)
{
unsigned idx = blockIdx.x * blockDim.x + threadIdx.x, i, j;
unsigned size = n * (n - 1) / 2;
vect_t diff;
double dist;
for(unsigned k = idx; k < size; k += gridDim.x * blockDim.x)
{
indexes(k, n - 1, &i, &j);
j++;
diff[X] = curr[i].s[X] - curr[j].s[X];
diff[Y] = curr[i].s[Y] - curr[j].s[Y];
dist = sqrt(diff[X] * diff[X] + diff[Y] * diff[Y]);
partial_sums[idx] += -G * curr[i].m * curr[j].m / dist;
}
}
void parallel_compute_energy(struct particle_s* curr, int n, double *kin_en_p, double *pot_en_p)
{ // deluje da radi
int i;
double pe = 0.0, ke = 0.0;
double* partial_sums_device, *partial_sums_host;
partial_sums_host = (double*)malloc(GRID_SIZE * BLOCK_SIZE * sizeof(double));
cudaMalloc(&partial_sums_device, GRID_SIZE * BLOCK_SIZE * sizeof(double));
cudaMemset(partial_sums_device, 0, GRID_SIZE * BLOCK_SIZE * sizeof(double));
kernel_kinetic_energy<<<GRID_SIZE, BLOCK_SIZE>>>(partial_sums_device, n, curr);
cudaMemcpy(partial_sums_host, partial_sums_device, GRID_SIZE * BLOCK_SIZE * sizeof(double), cudaMemcpyDeviceToHost);
// razmisliti o redukciji na gpu
for(i = 0; i < GRID_SIZE * BLOCK_SIZE; i++)
ke += partial_sums_host[i];
ke *= 0.5;
cudaMemset(partial_sums_device, 0, GRID_SIZE * BLOCK_SIZE * sizeof(double));
kernel_potential_energy<<<GRID_SIZE, BLOCK_SIZE>>>(partial_sums_device, n, curr);
cudaMemcpy(partial_sums_host, partial_sums_device, GRID_SIZE * BLOCK_SIZE * sizeof(double), cudaMemcpyDeviceToHost);
// razmisliti o redukciji na gpu
for(i = 0; i < GRID_SIZE * BLOCK_SIZE; i++)
pe += partial_sums_host[i];
*kin_en_p = ke;
*pot_en_p = pe;
free(partial_sums_host);
cudaFree(partial_sums_device);
}
void parallel(struct particle_s *curr, double* kinetic_energy, double* potential_energy, int n, int n_steps, double delta_t, float* time)
{
START_TIMER
vect_t *forces, *forces_device, *partial_forces;
struct particle_s* curr_device;
forces = (vect_t*)malloc(n * sizeof(vect_t));
cudaMalloc(&forces_device, n * sizeof(vect_t));
cudaMalloc(&curr_device, n * sizeof(struct particle_s));
cudaMalloc(&partial_forces, n * n * sizeof(vect_t));
cudaMemcpy(forces_device, forces, n * sizeof(vect_t), cudaMemcpyHostToDevice);
cudaMemcpy(curr_device, curr, n * sizeof(struct particle_s), cudaMemcpyHostToDevice);
parallel_compute_energy(curr_device, n, kinetic_energy, potential_energy);
printf(" PE = %e, KE = %e, Total Energy = %e\n", *potential_energy, *kinetic_energy, *kinetic_energy + *potential_energy);
for (int step = 1; step <= n_steps; step++)
{
cudaMemset(forces_device, 0, n * sizeof(vect_t));
parallel_compute_forces(forces_device, curr_device, n, partial_forces);
parallel_update_parts(forces_device, curr_device, n, delta_t);
}
parallel_compute_energy(curr_device, n, kinetic_energy, potential_energy);
printf(" PE = %e, KE = %e, Total Energy = %e\n", *potential_energy, *kinetic_energy, *kinetic_energy + *potential_energy);
cudaMemcpy(curr, curr_device, n * sizeof(struct particle_s), cudaMemcpyDeviceToHost);
cudaFree(forces_device);
cudaFree(curr_device);
cudaFree(partial_forces);
free(forces);
END_TIMER
}
int verify_solution(int n, struct particle_s curr_sequential[], struct particle_s curr_parallel[], double kinetic_energy_sequential, double kinetic_energy_parallel, double potential_energy_sequential, double potential_energy_parallel)
{
if (!is_close(kinetic_energy_sequential, kinetic_energy_parallel, ACCURACY))
return 0;
if (!is_close(potential_energy_sequential, potential_energy_parallel, ACCURACY))
return 0;
for (int i = 0; i < n; i++)
{
if (!is_close(curr_sequential[i].m, curr_parallel[i].m, ACCURACY))
return 0;
for (int j = 0; j < DIM; j++)
{
if(!is_close(curr_sequential[i].s[j], curr_parallel[i].s[j], ACCURACY))
return 0;
if(!is_close(curr_sequential[i].v[j], curr_parallel[i].v[j], ACCURACY))
return 0;
}
}
return 1;
}
inline int is_close(double first, double second, double accuracy)
{
return (fabs(1 - second / first) < accuracy);
}
__device__ void indexes(unsigned k, unsigned N, unsigned* row_ptr, unsigned* col_ptr)
{
double n = N;
double row = (-2 * n - 1 + sqrt((4 * n * (n + 1) - 8 * (double)k - 7))) / -2;
if (row == (double)(int)row)
row -= 1;
*row_ptr = (unsigned)row;
*col_ptr = k - N * *row_ptr + *row_ptr * (*row_ptr + 1) / 2;
} |
21,121 | #include <iostream>
#include <cuda.h>
#include <cuda_runtime.h>
//#include <time.h>
//#include <cutil.h>
using namespace std;
# define r 40
# define M 1000 // number of items
# define N 90 // number of transactions
# define alpha 1 // represents the weight of the support in the first fitness function
# define Beta 1 // represents the weight of the confidence in the first fitness function
# define k 15 // number of bees
struct ligne {int trans[N]; int nb;} *lg;
struct bee {int solution[N]; float cost;} *be;
/**************prototype declaration*******/
void read_trans(ligne T[]);// this function allows to read the transactional data base et insert it into the dataset vector
void display_dataset(ligne T[]); //this function allows to display the transactional data base
void display_solution(bee S); // this function display the current solution with its cost
float support_rule(ligne T[], int s[]); // this function calculates the support of the entire solution s
float support_antecedent(ligne T[], int s[]); // this function computes the support of the antecedent of the solution s
float confidence(int sr, int sa); // it calculates the confidence of the rule
float fitness1(int sr, int sa); // computes the fitness of a given solution s
void create_Sref(bee *s, ligne V[]); // here we create the solution reference sref and initialize it with the random way
bee neighborhood_computation(bee S, bee *V, ligne *D);// this function explores the local region for each bee
void search_area1(bee s, bee *T, int iteration, ligne V [],int flip); //detremines the search area for each bee using the first strategy
void search_area2(bee s, bee *T, int iteration, ligne V[], int flip); //detremines the search area for each bee using the second strategy
void search_area3(bee s, bee *T, int iteration, ligne V[], int distance); //detremines the search area for each bee using the third strategy
int W(int t[]); // indicates the weight of solution representing by a vector t, this function is used on search_area3()
void copy(int t[], int v[]); // it copies the vector t in the vector v
int best_dance(bee *T); // return the best dance after the exploration of search region of each bee
void parallel_fitness(bee *V, ligne *D); // parallelize solution computing
void display_bees(bee T[]); // display solutions
/*************************************************************************************/
__global__ void KernelSupport_rules(bee *N_List_GPU, int **compt_GPU, struct ligne *dataset_GPU){
int thread_idx ;
thread_idx = blockIdx.x * blockDim.x + threadIdx.x;
bool appartient=true;
int indice=blockIdx.x*1000;
indice=thread_idx-indice;
int j=1;
while (j<N){
if (N_List_GPU[blockIdx.x].solution[indice]!=0){
int l=0;
bool existe=false;
while (l< dataset_GPU[thread_idx].nb && existe==false){
if (dataset_GPU[thread_idx].trans[l]==j){
existe=true;
}
l++;
}
if (existe==false){
appartient=false;
}
}
j++;
}
if (appartient==true){
//compt_GPU[blockIdx.x][thread_idx]=1;
}
// }
}
__global__ void KernelSupport_antecedent(bee *N_List_GPU, int **compt_GPU, struct ligne *dataset_GPU){
int thread_idx ;
thread_idx = blockIdx.x * blockDim.x + threadIdx.x;
bool appartient=true;
int indice=blockIdx.x*M;
indice=thread_idx-indice;
int j=1;
while (j<N){
if (N_List_GPU[blockIdx.x].solution[indice]==1){
int l=0;
bool existe=false;
while (l< dataset_GPU[thread_idx].nb && existe==false){
if (dataset_GPU[thread_idx].trans[l]==j){
existe=true;
}
l++;
}
if (existe==false){
appartient=false;
}
}
j++;
}
if (appartient==true){
//compt_GPU[blockIdx.x][thread_idx]=1;
}
//}
}
int main(void){
FILE *f=NULL;
f=fopen("/home/ydjenouri/mesprog/resultat1.txt","a");
struct ligne *dataset_CPU, *dataset_GPU;
struct bee *T_Dance;
struct bee *N_List_CPU;
struct bee Sref;
struct bee best;
int flip=1, distance, IMAX=1;
// int k=5;
cudaEvent_t start, stop;
float elapsedTime;
int j;
/*****************************parallel program***********************/
//allocation de la memoire dans le CPU
dataset_CPU = (ligne *) malloc(M * sizeof(ligne)) ;
T_Dance = (bee *) malloc(k * sizeof(bee)) ;
N_List_CPU=(bee *) malloc(k *sizeof(bee));
////allocation de la memoire dans le GPU
cudaMalloc( (void**) &dataset_GPU, M*sizeof(ligne));
//read transactional database and insert in the dataset_CPU
read_trans(dataset_CPU);
cudaMemcpy(dataset_GPU, dataset_CPU, M * sizeof(ligne), cudaMemcpyHostToDevice);
cudaEventCreate( &start );
cudaEventCreate( &stop );
cudaEventRecord( start, 0 ) ;
create_Sref(&Sref, dataset_GPU); // creer une solution reference
//display_solution(Sref);
search_area1(Sref, T_Dance, IMAX, dataset_GPU, flip);
printf("hello");
// display_bees(T_Dance);
// for ( int k=5; k<=15;k=k+5)
for ( int i=0; i<=IMAX;i++)
{
for ( j=0;j<k;j++) // neighborhood computation for all the solution in tab
{
T_Dance[j]=neighborhood_computation(T_Dance[j], N_List_CPU, dataset_GPU);
}
/*j=best_dance(T_Dance,k);
copy(T_Dance[j].solution,Sref.solution);
Sref.cost=T_Dance[j].cost;
if (Sref.cost > best.cost)//atte o maximisation
{
copy(Sref.solution, best.solution);
best.cost=Sref.cost;
}
*/
//display_bees(T_Dance);
// //average=best.cost+average;
//printf("\nk="+b.k+" IMAX="+b.IMAX+" average fitness="+average);
search_area1(Sref,T_Dance, i, dataset_GPU, flip);
} //Bso ending
cudaEventRecord( stop, 0 ) ;
cudaEventSynchronize( stop ) ;
cudaEventElapsedTime( &elapsedTime,start, stop ) ;
printf("K=%d IMAX=%d Execution Time in GPU : %3.1f ms\n", k,IMAX, elapsedTime );
// fprintf(f,"K=%d IMAX=%d flip=%d Execution Time in GPU : %3.1f ms\n", k,flip,IMAX, elapsedTime );
printf("Yes\n");
cudaEventDestroy( start );
cudaEventDestroy( stop );
//}// end loop IMAX
//} // end loop flip
//} // end loop k
//fclose(f);
cudaFree(dataset_GPU);
return 0;
}
/**********************copry t in v********/
void copy(int t[], int v[])
{
for (int i=0;i<N; i++)
{
v[i]=t[i];
}
}
/*******read transactional data bass and insert it in the data set structure********************************/
void read_trans(ligne T[]){
char c='4';
char t[100];
int j;
int i=0;
int l=0;
FILE *f=NULL;
f=fopen("/home/ydjenouri/mesprog/T_90_1000.txt","r");
if (f!=NULL) {
//cout<<"the file is succefully opened"<<endl;
j=0;
while (c!=EOF){
c=fgetc(f);
if (c==' '){
t[j]='\0';
T[i].trans[l]=atoi(t);
l++;
j=0;
}
if (c=='\n'){
T[i].nb=l;
l=0;
i++;
j=0;
}
if (c!=' ' && c!='\n'){
t[j]=c;
j++;
}
}
fclose(f);
}
}
/*************************compute the support of the solution s**********/
float support_rule(ligne T[], int s[])
{
float compt=0;
for (int i=0; i<M; i++)
{
bool appartient=true;
int j=1;
while (j<N)
{
if (s[j]!=0)
{
int l=0;
bool existe=false;
while (l< T[i].nb && existe==false)
{
if (T[i].trans[l]==j)
{existe=true;}
l++;
}
if (existe==false){appartient=false;}
}
j++;
}
if (appartient==true) {compt++;}
}
compt=compt/M;
return compt;
}
/*****************************support antecedent computing*****************************/
float support_antecedent(ligne T[], int s[])
{
float compt=0;
for (int i=0; i<M; i++)
{
bool appartient=true;
int j=1;
while (j<N)
{
if (s[j]==1 ||s[j]==2)
{
int l=0;
bool existe=false;
while (l< T[i].nb && existe==false)
{
if (T[i].trans[l]==j)
{existe=true;}
l++;
}
if (existe==false){appartient=false;}
}
j++;
}
if (appartient==true) {compt++;}
}
compt=compt/M;
//if(compt!=0)System.out.println("antecedent"+compt);
return compt;
}
/****************************condifence computing**************************/
float confidence(int sr, int sa)
{
float conf=1;
conf=(float)sr/sa;
return conf;
}
/***********************evaluation of the solution s******/
float fitness1(int sr, int sa)
{
float cost=0;
//if (support_rule(sol)<Minsup || confidence(sol)<Minconf){cout=-1;}
float x=(float)alpha*(sr/M);
float y=(float)Beta*confidence(sr,sa);
cost=x+y;
return cost;
}
/**************************display_solution*****************/
void display_solution(bee S)
{
for (int i=0;i<N;i++)
{
printf("%d ", S.solution[i]);
}
printf ("cost is:%f",S.cost);
printf("\n");
}
/*********************create a solution reference Sref******************************************/
void create_Sref(bee *s, ligne V[])
{
for (int i=0;i<N;i++){
if (rand() % 2==0){
(*s).solution[i]=0 ;
}
else {
if (rand() % 2==0){
(*s).solution[i]=0;
}
else {
(*s).solution[i]=rand() % 3;
}
}
}
//parallel_fitness(s, V);
}
/***********************************negihborhood computation************************/
bee neighborhood_computation(bee S, bee *V, ligne *D)
{
bee s;
int indice=0;
int i=0;
bee neighbor, best_neighbor;
float best_cost=0;
//copy(S.solution,best_neighbor);
copy(S.solution,neighbor.solution);
while (i<k)
{
if (neighbor.solution[indice]==0)
{
if (rand()%2==0)
{neighbor.solution[indice]=1;}
else{neighbor.solution[indice]=2;}
}
else {
if (neighbor.solution[indice]==1)
{
if (rand()%2==0)
neighbor.solution[indice]=0;
else {
neighbor.solution[indice]=2;
}
}
else {
if (neighbor.solution[indice]==2)
{
if (rand()%2==0)
neighbor.solution[indice]=0;
else {
neighbor.solution[indice]=1;
}
}
}
}
indice++;
if (indice>=N){indice=0;}
copy(neighbor.solution,V[i].solution);
i++;
/*if (neighbor.cost>best_cost){copy(neighbor.solution,best_neighbor.solution);
best_cost=neighbor.cost;}*/
}
parallel_fitness(V, D);
//copy(best_neighbor.solution, s.solution);
//s.cost=best_cost;
s.cost=0;
return s;
}
/************************determination of search area********************/
void search_area1(bee s, bee *T, int iteration, ligne V[],int flip)
{
int indice=iteration % N;
int i=0;
while (i<k)
{
for (int j=0;j<N;j++)
{
T[i].solution[j]=s.solution[j];
}
if (T[i].solution[indice]==0)
{
if (iteration%4==0)
{T[i].solution[indice]=1;}
else{T[i].solution[indice]=2;}
// }
}
else{
if (T[i].solution[indice]==1)
{ if (iteration%3==0)
{T[i].solution[indice]=0;}
else{T[i].solution[indice]=2;}
}
else{
if (iteration%2==0)
{
T[i].solution[indice]=1;}
else{
T[i].solution[indice]=0;}
}
}
indice=indice+flip;
if (indice>=N){indice=0;}
parallel_fitness(&T[i], V);
//T_Dance[i].cost=fitness1(T_Dance[i].solution);//evaluer solution
i++;
}
}
/**************search 2*********************/
void search_area2(bee s, bee *T, int iteration, ligne V[], int flip)
{
int i=0;
int Nb_sol=0;
bool stop=false;
while (i<N && stop==false)
{
for (int j=0;j<N;j++)
{
T[Nb_sol].solution[j]=s.solution[j];
}
for (int l=i;l<(i+flip)%N;l++)
{
if ( T[Nb_sol].solution[l]==0)
{
if (rand()%2==1)
{ T[Nb_sol].solution[l]=1;}
else{T[Nb_sol].solution[l]=2;}
}
else {
if (T[Nb_sol].solution[l]==1)
{
if (rand()%2==1)
{T[Nb_sol].solution[l]=0;}
else{T[Nb_sol].solution[l]=2;}
}
else {
if (T[Nb_sol].solution[l]==2)
{
if (rand()%2==0)
{T[Nb_sol].solution[l]=0;}
else{T[Nb_sol].solution[l]=1;}
}
}
}
}
parallel_fitness(&T[i], V);
//T_Dance[Nb_sol].cost=fitness1(T_Dance[Nb_sol].solution); //evaluates the solution
Nb_sol++;
if (Nb_sol==k){stop=true;}
}
}
/********search3***************************/
int W(int t[])
{
int w=0;
for (int i=0;i<N; i++)
{
w=w+t[i];
}
return w;
}
/*******search 3 continued****************************/
void search_area3(bee s, bee *T, int iteration, ligne V[], int distance)
{
int Nb_sol=0;
while (Nb_sol!=k)
{
for (int j=0;j<N;j++)
{
T[Nb_sol].solution[j]=s.solution[j];
}
int l=0;
int cpt=0;
while (cpt<distance)
{
if (T[Nb_sol].solution[l]==0)
{
if (rand()%2==1)
{T[Nb_sol].solution[l]=1; cpt++;}
else{T[Nb_sol].solution[l]=2;cpt=cpt+2;}
}
else {
if (T[Nb_sol].solution[l]==1)
{
if (rand()%2==0)
{T[Nb_sol].solution[l]=0;cpt++;}
else{T[Nb_sol].solution[l]=2;cpt++;}
}
else {
if (T[Nb_sol].solution[l]==2)
{
if (rand()%2==0)
{T[Nb_sol].solution[l]=0;cpt=cpt+2;}
else{T[Nb_sol].solution[l]=1;cpt=cpt+1;}
}
}
}
l=(l+1)%N;
} //end the small while
//parallel_fitness(&T[Nb_sol], V);
//T_Dance[Nb_sol].cost=fitness1(T_Dance[Nb_sol].solution);//assecees the solution
Nb_sol++;
} // end the big while
}
/********************************best dance********************/
int best_dance(bee *T)
{
float max=T[0].cost;
int indice=0;
for (int i=1;i<k;i++)
{
if (T[i].cost>max)
{
max=T[i].cost;
indice=i;
}
}
return indice;
}
/***********************paralelize solution computing*******/
void parallel_fitness(bee *N_List_CPU, ligne V[])
{
bee *N_List_GPU;
//int **compt;
//compt = (int **) malloc(k*M*sizeof(int));
/*for (int i=0;i<k;i++){
for (int j=0;i<M;j++){
compt[i][j]=0;
}
}*/
int **compt_GPU;
// cudaEventCreate( &start );
// cudaEventCreate( &stop );
// cudaEventRecord( start, 0 ) ;
cudaMalloc((void**) &N_List_GPU, k*sizeof(bee));
//cudaMalloc( (void**) &compt_GPU, k*M* sizeof(int));
cudaMemcpy(N_List_GPU, N_List_CPU, k *sizeof(bee),cudaMemcpyHostToDevice);
//cudaMemcpy(compt_GPU, compt, k*M *sizeof(int),cudaMemcpyHostToDevice);
KernelSupport_rules<<<20*N,M>>>(N_List_GPU, compt_GPU, V);
//cudaMemcpy(compt, compt_GPU, k*M*sizeof(int),cudaMemcpyDeviceToHost);
/*int sr=0;
for (int i=0;i<M;i++){
sr=sr+compt[i];
}
KernelSupport_antecedent<<<20*N,M>>>(s_GPU, compt_GPU, V);
cudaMemcpy(compt, compt_GPU, M*sizeof(int),cudaMemcpyDeviceToHost);
int sa=0;
for (int i=0;i<M;i++){
sa=sa+compt[i];
}
(*sol).cost=fitness1(sr,sa);*/
}
/*****************************display T_dance************/
void display_bees(bee T[])
{
//FILE *f=NULL;
//f=fopen("/home/ydjenouri/mesprog/resultat1.txt","a");
//if (f!=NULL) {
for (int i=0;i<k;i++)
{
for (int j=0;j<N;j++)
{
printf ("%d ",T[i].solution[j]);
}
printf("%f", T[i].cost);
printf("\n");
}
//fclose(f);
//}
}
|
21,122 | #include <stdio.h>
#include <stdlib.h>
#include <cuda.h>
#include <math.h> // for pow()
#define NUM_THREADS 8
#define NUM_BLOCKS 1
__host__ void generate_rand_data(unsigned int * data, unsigned int num_elements)
{
for(unsigned int i=0; i < num_elements; i++)
{
data[i] = rand() % 4; //PLACE YOUR CODE HERE
}
}
__device__ void copy_data_to_shared(unsigned int * const data,
unsigned int * const shared_tmp,
const unsigned int tid)
{
// Copy data into shared memory
shared_tmp[tid] = data[tid];
__syncthreads();
}
__device__ void simple_squaring_operation(unsigned int * const data,
const unsigned int tid)
{
//square the mem value and overwrite
data[tid] = data[tid] * data[tid]; //PLACE YOUR CODE HERE
}
__global__ void gpu_register_array_operation(unsigned int * const data, const unsigned int num_elements)
{
const unsigned int tid = (blockIdx.x * blockDim.x) + threadIdx.x;
//perform some simple operation
simple_squaring_operation(data, tid);
}
__global__ void gpu_shared_array_operation(unsigned int * const data, const unsigned int num_elements)
{
const unsigned int tid = (blockIdx.x * blockDim.x) + threadIdx.x;
//allocate shared memory
__shared__ unsigned int shared_tmp[NUM_THREADS];
//make a copy of the global device data into the shared device memory
copy_data_to_shared(data, shared_tmp, tid);
//perform some simple operation
simple_squaring_operation(shared_tmp, tid);
//push updated shared mem back to the initial global data mem
data[tid] = shared_tmp[tid];
}
//tier 2 method for printing a specific cuda device properties
//already called by the tier 1 method
void print_all_device_properties(int device_id){
cudaDeviceProp prop;
cudaGetDeviceProperties( &prop, device_id);
// printf("============Start Device %x============\n", device_id);
// printf("Name: %s\n", prop.name);
// printf("Total global memory: %lu\n", prop.totalGlobalMem);
// printf("Total shared memory per block: %lu\n", prop.sharedMemPerBlock);
// printf("Total registers per block: %lu\n", (unsigned long)prop.regsPerBlock);
// printf("Warp size: %lu\n", (unsigned long)prop.warpSize);
// printf("Maximum memory pitch: %lu\n", prop.memPitch);
// printf("Maximum threads per block: %lu\n", (unsigned long)prop.maxThreadsPerBlock);
// for (int i = 0; i < 3; ++i)
// printf("Maximum dimension %d of block: %lu\n", i, (unsigned long)prop.maxThreadsDim[i]);
// for (int i = 0; i < 3; ++i)
// printf("Maximum dimension %d of grid: %lu\n", i, (unsigned long)prop.maxGridSize[i]);
// printf("Total constant memory: %lu\n", prop.totalConstMem);
// printf("Major revision number: %lu\n", (unsigned long)prop.major);
// printf("Minor revision number: %lu\n", (unsigned long)prop.minor);
// printf("Clock rate: %lu\n", (unsigned long)prop.clockRate);
// printf("Texture alignment: %lu\n", prop.textureAlignment);
// printf("Concurrent copy and execution: %s\n", (prop.deviceOverlap ? "Yes" : "No"));
// printf("Number of multiprocessors: %lu\n", (unsigned long)prop.multiProcessorCount);
// printf("Kernel execution timeout: %s\n", (prop.kernelExecTimeoutEnabled ? "Yes" : "No"));
// printf("Integrated: %s\n", (prop.integrated ? "Yes" : "No"));
// printf("Mapable Host Memory: %s\n", (prop.canMapHostMemory ? "Yes" : "No"));
// printf("Compute Mode: %d\n", prop.computeMode);
// printf("Concurrent Kernels: %d\n", prop.concurrentKernels);
// printf("ECC Enabled: %s\n", (prop.ECCEnabled ? "Yes" : "No"));
// printf("pci Bus ID: %lu\n", (unsigned long)prop.pciBusID);
// printf("pci Device ID: %lu\n", (unsigned long)prop.pciDeviceID);
// printf("Using a tcc Driver: %s\n", (prop.tccDriver ? "Yes" : "No"));
// printf("============End Device %x============\n", device_id);
printf("============Start Device %x============\n", device_id);
printf("Name: %s\n", prop.name);
printf("Total global memory: %lu\n", prop.totalGlobalMem);
printf("Total shared memory per block: %lu\n", prop.sharedMemPerBlock);
printf("Total registers per block: %d\n", prop.regsPerBlock);
printf("Warp size: %d\n", prop.warpSize);
printf("Maximum memory pitch: %lu\n", prop.memPitch);
printf("Maximum threads per block: %d\n", prop.maxThreadsPerBlock);
for (int i = 0; i < 3; ++i)
printf("Maximum dimension %d of block: %d\n", i, prop.maxThreadsDim[i]);
for (int i = 0; i < 3; ++i)
printf("Maximum dimension %d of grid: %d\n", i, prop.maxGridSize[i]);
printf("Total constant memory: %lu\n", prop.totalConstMem);
printf("Major revision number: %d\n", prop.major);
printf("Minor revision number: %d\n", prop.minor);
printf("Clock rate: %d\n", prop.clockRate);
printf("Texture alignment: %lu\n", prop.textureAlignment);
printf("Concurrent copy and execution: %s\n", (prop.deviceOverlap ? "Yes" : "No"));
printf("Number of multiprocessors: %d\n", prop.multiProcessorCount);
printf("Kernel execution timeout: %s\n", (prop.kernelExecTimeoutEnabled ? "Yes" : "No"));
printf("Integrated: %s\n", (prop.integrated ? "Yes" : "No"));
printf("Mapable Host Memory: %s\n", (prop.canMapHostMemory ? "Yes" : "No"));
printf("Compute Mode: %d\n", prop.computeMode);
printf("Concurrent Kernels: %d\n", prop.concurrentKernels);
printf("ECC Enabled: %s\n", (prop.ECCEnabled ? "Yes" : "No"));
printf("pci Bus ID: %d\n", prop.pciBusID);
printf("pci Device ID: %d\n", prop.pciDeviceID);
printf("Using a tcc Driver: %s\n", (prop.tccDriver ? "Yes" : "No"));
printf("============End Device %x============\n", device_id);
}
//tier 1 method for printing all cuda devices and their properties
void print_all_CUDA_devices_and_properties() {
int device_id;
cudaGetDeviceCount( &device_id);
printf("Print of all CUDA devices and device properties\n");
for (int i = 0; i < device_id; i++){
//states that cudaDeviceProp returns a 25 data types in a struct
print_all_device_properties(device_id);
}
}
__host__ float execute_register_memory_operations(void)
{
const unsigned int num_elements = NUM_THREADS;
const unsigned int num_bytes = NUM_THREADS * sizeof(unsigned int);
unsigned int * d_data; //device data
unsigned int hi_data[num_elements]; //initial host data
unsigned int hf_data[num_elements]; //final host data
/* Set timing Metrics */
cudaEvent_t kernel_start, kernel_stop;
float delta = 0.0F;
cudaEventCreate(&kernel_start,0);
cudaEventCreate(&kernel_stop,0);
//set CUDA stream
cudaStream_t stream;
cudaStreamCreate(&stream);
//start timing metric
cudaEventRecord(kernel_start, 0);
//device memory alloc
cudaMalloc(&d_data, num_bytes);
//populate the initial host array with random data
generate_rand_data(hi_data, num_elements);
//copy from host memory to device memory
cudaMemcpy(d_data, hi_data, num_bytes, cudaMemcpyHostToDevice);
//Call GPU kernel <<<BLOCK TOTAL, THREADS TOTAL>>>
gpu_register_array_operation<<<NUM_BLOCKS, NUM_THREADS>>>(d_data, num_elements);
cudaStreamSynchronize(stream); // Wait for the GPU launched work to complete
cudaGetLastError();
//copy from device to host memory
cudaMemcpy(hf_data, d_data, num_bytes, cudaMemcpyDeviceToHost);
//end timing metric
cudaEventRecord(kernel_stop, 0);
cudaEventSynchronize(kernel_stop);
cudaEventElapsedTime(&delta, kernel_start, kernel_stop);
cudaEventDestroy(kernel_start);
cudaEventDestroy(kernel_stop);
//console print the host data after the GPU kernal
for (int i = 0; i < num_elements; i++){
printf("Input value: %x, device output: %x\n", hi_data[i], hf_data[i]);
}
//free device and host memory allocations
//PLACE YOUR CODE HERE
return delta;
}
__host__ float execute_shared_memory_operations()
{
const unsigned int num_elements = NUM_THREADS;
const unsigned int num_bytes = NUM_THREADS * sizeof(unsigned int);
unsigned int * d_data; //device data
unsigned int hi_data[num_elements]; //initial host data
unsigned int hf_data[num_elements]; //final host data
/* Set timing Metrics */
cudaEvent_t kernel_start, kernel_stop;
float delta = 0.0F;
cudaEventCreate(&kernel_start,0);
cudaEventCreate(&kernel_stop,0);
//set CUDA stream
cudaStream_t stream; //PLACE YOUR CODE HERE
cudaStreamCreate(&stream);
//start timing metric
cudaEventRecord(kernel_start, 0);
//device memory alloc
cudaMalloc(&d_data, num_bytes);
//populate the initial host array with random data
generate_rand_data(hi_data, num_elements);
//copy from host memory to device memory
cudaMemcpy(d_data, hi_data, num_bytes, cudaMemcpyHostToDevice);
//Call GPU kernels <<<BLOCK TOTAL, THREADS TOTAL>>>
gpu_shared_array_operation<<<NUM_BLOCKS, NUM_THREADS>>>(d_data, num_elements);
//sync the cuda stream
cudaStreamSynchronize(stream); // Wait for the GPU launched work to complete
cudaGetLastError(); //error handling
//copy from device to host memory
cudaMemcpy(hf_data, d_data, num_bytes, cudaMemcpyDeviceToHost);
//end timing metric
cudaEventRecord(kernel_stop, 0);
cudaEventSynchronize(kernel_stop);
cudaEventElapsedTime(&delta, kernel_start, kernel_stop);
cudaEventDestroy(kernel_start);
cudaEventDestroy(kernel_stop);
//console print the host data after the GPU kernal
for (int i = 0; i < num_elements; i++){
printf("Input value: %x, device output: %x\n", hi_data[i], hf_data[i]);
}
//free device and host memory allocations
cudaFree((void* ) d_data); //free devide data
cudaFreeHost(hi_data); //free up the host memory
cudaFreeHost(hf_data); //free up the host memory
cudaDeviceReset();
return delta;
}
/**
* Host function that prepares data array and passes it to the CUDA kernel.
*/
int main(void) {
//print all cuda devices and device properties for kicks
print_all_CUDA_devices_and_properties();
//test harness for timing some kernels using streams and events
float delta_shared = execute_shared_memory_operations(); //PLACE YOUR CODE HERE TO USE SHARED MEMORY FOR OPERATIONS
float delta_register = execute_register_memory_operations();//PLACE YOUR CODE HERE TO USE REGISTER MEMORY FOR OPERATIONS
//print out the results of the time executions returned by the prev methods
printf("========================\n");
printf("Summary\n");
printf("Total Threads: %d\n", NUM_THREADS);
printf("Total Blocks: %d\n", NUM_BLOCKS);
printf("========================\n");
printf("Time to copy global to shared mem, perform simple operation w/ shared memory, copy memory back to global\n");
printf("duration: %fms\n",delta_shared);
printf("========================\n");
printf("Time to copy global to register mem, perform simple operation w/ register memory, copy memory back to global\n");
printf("duration: %fms\n",delta_register);
return 0;
}
|
21,123 | /**
* Copyright 1993-2015 NVIDIA Corporation. All rights reserved.
*
* Please refer to the NVIDIA end user license agreement (EULA) associated
* with this source code for terms and conditions that govern your use of
* this software. Any use, reproduction, disclosure, or distribution of
* this software and related documentation outside the terms of the EULA
* is strictly prohibited.
*
*/
/**
* Vector addition: C = A + B.
*
* This sample is a very basic sample that implements element by element
* vector addition. It is the same as the sample illustrating Chapter 2
* of the programming guide with some additions like error checking.
*/
#include <stdio.h>
// For the CUDA runtime routines (prefixed with "cuda_")
#include <cuda_runtime.h>
#define NUM_CLASSES 32
__device__ class BaseClass {
public:
virtual __device__ float doTheMath(float a, float b) = 0;
};
#define Derived(A) \
__device__ class Class##A : public BaseClass {\
public:\
virtual __device__ float doTheMath( float a, float b ) { \
return a + b;\
}\
}
Derived(0);
Derived(1);
Derived(2);
Derived(3);
Derived(4);
Derived(5);
Derived(6);
Derived(7);
Derived(8);
Derived(9);
Derived(10);
Derived(11);
Derived(12);
Derived(13);
Derived(14);
Derived(15);
Derived(16);
Derived(17);
Derived(18);
Derived(19);
Derived(20);
Derived(21);
Derived(22);
Derived(23);
Derived(24);
Derived(25);
Derived(26);
Derived(27);
Derived(28);
Derived(29);
Derived(30);
Derived(31);
#define ObjCase(A) \
case A: if (NUM_CLASSES > A) { array[i] = new Class##A(); break; }
__global__ void initialize( BaseClass** pointerArray )
{
//*pointerArray = (BaseClass **) malloc( sizeof(BaseClass*)*32 );
BaseClass ** array = pointerArray;
for ( int i=0; i < NUM_CLASSES; ++i ){
switch( i ) {
ObjCase(0);
ObjCase(1);
ObjCase(2);
ObjCase(3);
ObjCase(4);
ObjCase(5);
ObjCase(6);
ObjCase(7);
ObjCase(8);
ObjCase(9);
ObjCase(10);
ObjCase(11);
ObjCase(12);
ObjCase(13);
ObjCase(14);
ObjCase(15);
ObjCase(16);
ObjCase(17);
ObjCase(18);
ObjCase(19);
ObjCase(20);
ObjCase(21);
ObjCase(22);
ObjCase(23);
ObjCase(24);
ObjCase(25);
ObjCase(26);
ObjCase(27);
ObjCase(28);
ObjCase(29);
ObjCase(30);
ObjCase(31);
}
}
}
/**
* CUDA Kernel Device code
*
* Computes the vector addition of A and B into C. The 3 vectors have the same
* number of elements numElements.
*/
__global__ void
ooVectorAdd(const float *A, const float *B, float *C, int numElements, BaseClass** classes)
{
int i = blockDim.x * blockIdx.x + threadIdx.x;
BaseClass* myClass = classes[threadIdx.x % NUM_CLASSES];
if (i < numElements)
{
//C[i] = B[i] + A[i];
C[i] = myClass->doTheMath( B[i], A[i] );
}
}
/**
* Host main routine
*/
int
main(void)
{
// Error code to check return values for CUDA calls
cudaError_t err = cudaSuccess;
// Print the vector length to be used, and compute its size
int numElements = NUM_CLASSES;
size_t size = numElements * sizeof(float);
printf("[Vector addition of %d elements]\n", numElements);
// Allocate the host input vector A
float *h_A = (float *)malloc(size);
// Allocate the host input vector B
float *h_B = (float *)malloc(size);
// Allocate the host output vector C
float *h_C = (float *)malloc(size);
// Verify that allocations succeeded
if (h_A == NULL || h_B == NULL || h_C == NULL)
{
fprintf(stderr, "Failed to allocate host vectors!\n");
exit(EXIT_FAILURE);
}
// Initialize the host input vectors
for (int i = 0; i < numElements; ++i)
{
h_A[i] = rand()/(float)RAND_MAX;
h_B[i] = rand()/(float)RAND_MAX;
}
// Allocate the device input vector A
float *d_A = NULL;
err = cudaMalloc((void **)&d_A, size);
if (err != cudaSuccess)
{
fprintf(stderr, "Failed to allocate device vector A (error code %s)!\n", cudaGetErrorString(err));
exit(EXIT_FAILURE);
}
// Allocate the device input vector B
float *d_B = NULL;
err = cudaMalloc((void **)&d_B, size);
if (err != cudaSuccess)
{
fprintf(stderr, "Failed to allocate device vector B (error code %s)!\n", cudaGetErrorString(err));
exit(EXIT_FAILURE);
}
// Allocate the device output vector C
float *d_C = NULL;
err = cudaMalloc((void **)&d_C, size);
if (err != cudaSuccess)
{
fprintf(stderr, "Failed to allocate device vector C (error code %s)!\n", cudaGetErrorString(err));
exit(EXIT_FAILURE);
}
// Copy the host input vectors A and B in host memory to the device input vectors in
// device memory
printf("Copy input data from the host memory to the CUDA device\n");
err = cudaMemcpy(d_A, h_A, size, cudaMemcpyHostToDevice);
if (err != cudaSuccess)
{
fprintf(stderr, "Failed to copy vector A from host to device (error code %s)!\n", cudaGetErrorString(err));
exit(EXIT_FAILURE);
}
err = cudaMemcpy(d_B, h_B, size, cudaMemcpyHostToDevice);
if (err != cudaSuccess)
{
fprintf(stderr, "Failed to copy vector B from host to device (error code %s)!\n", cudaGetErrorString(err));
exit(EXIT_FAILURE);
}
BaseClass **classes = NULL;
cudaMalloc((void***)&classes, sizeof(BaseClass*)*NUM_CLASSES);
initialize<<<1,1>>>(classes);
err = cudaGetLastError();
if (err != cudaSuccess)
{
fprintf(stderr, "Failed to launch initialize kernel (error code %s)!\n", cudaGetErrorString(err));
exit(EXIT_FAILURE);
}
// Launch the Vector Add CUDA Kernel
int threadsPerBlock = NUM_CLASSES;
int blocksPerGrid =(numElements + threadsPerBlock - 1) / threadsPerBlock;
printf("CUDA kernel launch with %d blocks of %d threads\n", blocksPerGrid, threadsPerBlock);
ooVectorAdd<<<blocksPerGrid, threadsPerBlock>>>(d_A, d_B, d_C, numElements, classes);
err = cudaGetLastError();
if (err != cudaSuccess)
{
fprintf(stderr, "Failed to launch ooVectorAdd kernel (error code %s)!\n", cudaGetErrorString(err));
exit(EXIT_FAILURE);
}
// Copy the device result vector in device memory to the host result vector
// in host memory.
printf("Copy output data from the CUDA device to the host memory\n");
err = cudaMemcpy(h_C, d_C, size, cudaMemcpyDeviceToHost);
if (err != cudaSuccess)
{
fprintf(stderr, "Failed to copy vector C from device to host (error code %s)!\n", cudaGetErrorString(err));
exit(EXIT_FAILURE);
}
// Verify that the result vector is correct
for (int i = 0; i < numElements; ++i)
{
if (fabs(h_A[i] + h_B[i] - h_C[i]) > 1e-5)
{
fprintf(stderr, "Result verification failed at element %d!\n", i);
exit(EXIT_FAILURE);
}
}
printf("Test PASSED\n");
// Free device global memory
err = cudaFree(d_A);
if (err != cudaSuccess)
{
fprintf(stderr, "Failed to free device vector A (error code %s)!\n", cudaGetErrorString(err));
exit(EXIT_FAILURE);
}
err = cudaFree(d_B);
if (err != cudaSuccess)
{
fprintf(stderr, "Failed to free device vector B (error code %s)!\n", cudaGetErrorString(err));
exit(EXIT_FAILURE);
}
err = cudaFree(d_C);
if (err != cudaSuccess)
{
fprintf(stderr, "Failed to free device vector C (error code %s)!\n", cudaGetErrorString(err));
exit(EXIT_FAILURE);
}
// Free host memory
free(h_A);
free(h_B);
free(h_C);
printf("Done\n");
return 0;
}
|
21,124 | #include <cuda.h>
#include <stdio.h>
#include <stdlib.h>
#define BLOCK_WIDTH 2
void fillMatrix(float *A, int A_height, int A_width);
void printMatrix(float *A, int A_height, int A_width);
void tiledMat(float *A, float *result, int A_width, int A_height);
int main(int argc, char const *argv[])
{
// Create matrix
int A_width = 4;
int A_height = 4;
float *A = (float*) malloc(A_width * A_height * sizeof(float));
float *result = (float*) malloc(A_width * A_height * sizeof(float));
fillMatrix(A, A_height, A_width);
printMatrix(A, A_height, A_width);
tiledMat(A, result, A_width, A_height);
printMatrix(result, A_height, A_width);
free(A);
return 0;
}
__global__
void blockTranspose(float *A_elements, int A_width, int A_height)
{
__shared__ float blockA[BLOCK_WIDTH][BLOCK_WIDTH];
int BLOCK_SIZE = BLOCK_WIDTH;
int baseIdx = blockIdx.x * BLOCK_SIZE + threadIdx.x;
baseIdx += (blockIdx.y * BLOCK_SIZE + threadIdx.y) * A_width;
blockA[threadIdx.y][threadIdx.x] = A_elements[baseIdx];
A_elements[baseIdx] = blockA[threadIdx.x][threadIdx.y];
}
void fillMatrix(float *A, int A_height, int A_width)
{
int size = A_height * A_width;
for(int i = 0; i < size; i++)
A[i] = (float) i + 1;
}
void printMatrix(float *A, int A_height, int A_width)
{
for (int i = 0; i < A_height; i++)
{
for (int j = 0; j < A_width; j++)
{
printf("%d\t", (int)A[i * A_width + j]);
}
printf("\n");
}
}
void tiledMat(float *A, float *result, int A_width, int A_height)
{
// Create device matrix
float *d_A;
int A_size = A_width * A_height * sizeof(float);
cudaError_t err = cudaMalloc((void **) &d_A, A_size);
if (err != cudaSuccess)
{
printf("%s in %s at line %d\n", cudaGetErrorString(err), __FILE__, __LINE__);
exit(EXIT_FAILURE);
}
cudaMemcpy(d_A, A, A_size, cudaMemcpyHostToDevice);
// Launch the kernel
dim3 blockDim(BLOCK_WIDTH, BLOCK_WIDTH);
dim3 griDim(A_width / blockDim.x, A_height / blockDim.y);
blockTranspose<<<griDim, blockDim>>>(d_A, A_width, A_height);
cudaMemcpy(result, d_A, A_size, cudaMemcpyDeviceToHost);
cudaFree(d_A);
}
|
21,125 | #include <stdio.h>
#include <stdlib.h>
#include <limits.h>
#include <string.h>
#include <sys/time.h>
#include <time.h>
#include <cuda.h>
#include <math.h>
#include <curand.h>
#include <curand_kernel.h>
#include <cuda_runtime.h>
#include <thrust/host_vector.h>
#include <iostream>
#include <thrust/device_vector.h>
using namespace std;
template<class T>
class Node{
public:
int parent;
T key;
int height;
int left;
int right;
int succ,pred;
bool mark;
__host__ __device__ Node(T key_):key(key_){
parent=left=right=INT_MIN;
succ=pred=INT_MIN;
height=INT_MIN;
mark= false;
}
__host__ __device__ Node(){
new(this)Node(INT_MIN);
}
friend ostream &operator<<(ostream &os, Node& node){
os << node.key;
return os;
}
__host__ __device__ bool operator<(Node &node){
return key<node.key;
}
__host__ __device__ bool operator==(Node& node){
return key==node.key;
}
__host__ __device__ bool operator>(Node &node){
return key>node.key;
}
};
/*Definition of the tree*/
template<class T>
class Tree{
public:
int root,next_index;
int size;
// these three fields useful only when concurrent inserts
// and deletes work
int* succ_locks, * tree_locks;
int *tree_lock_thread;
/*container of the tree*/
//node at index 0 is sentinel node with key INT_MIN
// initialized root with key INT_MAX and index=1
Node<T>* arr;
__host__ __device__ Tree(int size_):root(1),next_index(2),size(size_){
arr= new Node<T>[size];
arr[root].key = INT_MAX;
arr[root].parent = root;
arr[0].right= root;
arr[root].pred= 0;
arr[0].succ= root;
arr[root].height=0;
};
__host__ __device__ Tree(){}
void inorder(int);
void preorder(int);
void postorder(int);
__host__ __device__ int search(Node<T>&);
__host__ __device__ int search(T&);
__host__ __device__ int height(int);
__host__ __device__ void insert(T&);
__host__ __device__ void delete_(T&);
__host__ __device__ void delete_rebalance(int);
__host__ __device__ void init_node(T&, int, int, int, int);
__host__ __device__ int tri_node_restructure(int, int, int);
__host__ __device__ void recompute_height(int);
__host__ __device__ int taller_child(int);
__host__ __device__ bool search_2(T&);
__device__ bool d_insert(T&, int);
__device__ int choose_parent(int, int, int, int);
__device__ int lock_parent(int,int);
__device__ void rebalancing(int, int, int,bool);
__device__ int restart(int, int,int);
__device__ void rotate(int,int,int,bool);
__device__ int get_balance_factor(int);
__device__ bool remove(T&, int);
__device__ int acquire_tree_locks(int, int);
__device__ void remove_from_tree(int,int,int,int);
__device__ bool update_child(int, int, int);
void insert_nodes(char*,int);
};
template<class T>
void Tree<T>::inorder(int index){
if(index==INT_MIN || arr[index].key==INT_MIN)
return;
inorder(arr[index].left);
cout<< arr[index] <<" ";
inorder(arr[index].right);
}
template<class T>
void Tree<T>::preorder(int index){
if(index==INT_MIN || arr[index].key==INT_MIN)
return;
cout << arr[index] <<" ";
preorder(arr[index].left);
preorder(arr[index].right);
}
template<class T>
void Tree<T>::postorder(int index){
if(index==INT_MIN || arr[index].key==INT_MIN)
return;
postorder(arr[index].left);
postorder(arr[index].right);
cout << arr[index] <<" ";
}
template<typename T> __host__ __device__
int Tree<T>::search(Node<T> &node){
int temp=root;
while(temp!=INT_MIN){
if(arr[temp]==node)
return temp;
int child= (arr[temp]<node? arr[temp].right:
arr[temp].left);
if(child==INT_MIN)
return temp;
temp= child;
}
}
template<typename T> __host__ __device__
int Tree<T>::search(T &key_){
int temp= root;
while(temp!=INT_MIN){
if(arr[temp].key == key_)
return temp;
int child= (arr[temp].key <key_?arr[temp].right
:arr[temp].left);
if(child==INT_MIN)
return temp;
temp=child;
}
return INT_MIN;
}
template<typename T> __host__ __device__
void Tree<T>::recompute_height(int x){
while(x!=root){
arr[x].height = max(height(arr[x].right), height(arr[x].left));
x= arr[x].parent;
}
}
template<typename T> __host__ __device__
int Tree<T>::height(int index){
if(index==INT_MIN || arr[index].key==INT_MIN)
return 0;
return arr[index].height+1;
}
template<typename T> __host__ __device__
int Tree<T>::tri_node_restructure(int x, int y, int z){
/*
x= parent(y)
y= parent(z)
*/
bool z_is_left_child= (arr[y].left ==z);
bool y_is_left_child = (arr[x].left== y);
int a,b,c;
int t0,t1,t2,t3;
if(z_is_left_child && y_is_left_child){
a= z; b = y; c= x;
t0 = arr[z].left; t1= arr[z].right;
t2= arr[y].right; t3= arr[x].right;
}else if(!z_is_left_child && y_is_left_child){
a= y; b=z; c= x;
t0= arr[y].left; t1= arr[z].left;
t2= arr[z].right; t3= arr[x].right;
}else if(z_is_left_child && !y_is_left_child){
a= x; c= y; b=z;
t0= arr[x].left; t1= arr[z].left;
t2= arr[z].right; t3= arr[y].right;
}else{
a=x; b=y; c=z;
t0= arr[x].left; t1= arr[y].left;
t2= arr[z].left; t3= arr[z].right;
}
// attach b to the parent of x
if(x==root){
root= b;
arr[b].parent= INT_MIN;
}else{
int parent_x= arr[x].parent;
arr[b].parent=parent_x;
if(arr[parent_x].left == x)
arr[parent_x].left = b;
else arr[parent_x].right = b;
}
/* make b
/ \
a c */
arr[b].left= a;
arr[a].parent= b;
arr[b].right = c;
arr[c].parent =b;
/*attach t0, t1, t2 and t3*/
arr[a].left = t0;
if(t0!=INT_MIN) arr[t0].parent = a;
arr[a].right = t1;
if(t1!=INT_MIN) arr[t1].parent = a;
arr[c].left= t2;
if(t2!=INT_MIN) arr[t2].parent = c;
arr[c].right = t3;
if(t3!=INT_MIN) arr[t3].parent = c;
recompute_height(a);
recompute_height(c);
return b;
}
template<typename T> __host__ __device__
void Tree<T>::init_node(T& key_,int curr_ind, int pred_, int succ_, int parent_){
arr[curr_ind].key=key_;
arr[curr_ind].parent= parent_;
arr[curr_ind].height=0;
arr[curr_ind].pred= pred_;
arr[curr_ind].succ= succ_;
arr[succ_].pred= curr_ind;
arr[pred_].succ= curr_ind;
if(arr[parent_].key < key_)
arr[parent_].right= curr_ind;
else arr[parent_].left= curr_ind;
}
template<typename T> __host__ __device__
void Tree<T>::insert(T &key_){
int p= search(key_);
if(arr[p].key== key_)
return;
int pred_= arr[p].key < key_?p: arr[p].pred;
int succ_= arr[pred_].succ;
init_node(key_,next_index,pred_,succ_,p);
// after insert maximum one node will get imbalanced
recompute_height(p);
int x,y,z;
x=y=z= next_index;
while(x!=root){
if(abs(height(arr[x].left) - height(arr[x].right))<=1){
z=y;
y=x;
x= arr[x].parent;
}else break;
}
if(x!=root)
tri_node_restructure(x,y,z);
++next_index;
}
template<typename T> __host__ __device__
int Tree<T>::taller_child(int x){
return (height(arr[x].left) > height(arr[x].right)?
arr[x].left : arr[x].right);
}
template<typename T> __host__ __device__
void Tree<T>::delete_rebalance(int p){
int x,y,z;
while(p!=root){
if(abs(height(arr[p].left)-height(arr[p].right))>1){
x=p;
y= taller_child(x);
z= taller_child(y);
p= tri_node_restructure(x,y,z);
}
p=arr[p].parent;
}
}
template<typename T> __host__ __device__
void Tree<T>::delete_(T& key_){
int p;
int parent_;
int succ_;
p= search(key_);
if(arr[p].key != key_)
return;
// node has no children
arr[arr[p].succ].pred= arr[p].pred;
arr[arr[p].pred].succ= arr[p].succ;
parent_ = arr[p].parent;
if(arr[p].left==INT_MIN && arr[p].right == INT_MIN){
if(arr[parent_].right == p)
arr[parent_].right= INT_MIN;
else arr[parent_].left = INT_MIN;
recompute_height(parent_);
delete_rebalance(parent_);
return;
}else if(arr[p].left==INT_MIN){ // when deleted node has only right child
if(arr[parent_].left==p)
arr[parent_].left= arr[p].right;
else arr[parent_].right = arr[p].right;
recompute_height(parent_);
delete_rebalance(parent_);
return;
}else if(arr[p].right == INT_MIN){ // when deleted node has only left child
if(arr[parent_].left==p)
arr[parent_].left= arr[p].left;
else arr[parent_].right= arr[p].left;
recompute_height(parent_);
delete_rebalance(parent_);
return;
} // when deleted node has both children
succ_ = arr[p].right;
while(arr[succ_].left!=INT_MIN)
succ_ = arr[succ_].left;
arr[p].key= arr[succ_].key;
parent_= arr[succ_].parent;
arr[parent_].left = arr[succ_].right;
recompute_height(parent_);
delete_rebalance(parent_);
return;
}
template<typename T> __host__ __device__
bool Tree<T>::search_2(T& key_){
int p=search(key_);
while(arr[p].key > key_)
p= arr[p].pred;
int x= p;
while(arr[p].key < key_)
p= arr[p].succ;
int y=p;
return (arr[x].key == key_ || arr[y].key == key_);
}
template<typename T>
void Tree<T>::insert_nodes(char* filename, int max){
FILE* fp= fopen(filename,"r");
int node_;
fscanf(fp,"%d",&size);
Tree<int>*tree= new Tree<int>(size+max);
while(fscanf(fp,"%d",&node_)!=EOF)
tree->insert(node_);
fclose(fp);
*this = *tree;
}
// device code implemented but does not work
// hence came up with another idea which is implemented
// above
template<typename T> __device__
bool Tree<T>::d_insert(T& key_, int thread_id){
while(true){
int node= search(key_);
//printf("came here\n");
int pred_= (arr[node].key < key_?node:arr[node].pred);
bool flag=false;
while(!flag){
if(atomicExch(&(succ_locks[pred_]),1)==0){
// critical section for this type of lock
int succ_= arr[pred_].succ;
if(key_ >arr[pred_].key && key_<= arr[succ_].key && !arr[pred_].mark){
if(arr[succ_].key >= key_){
atomicExch(&(succ_locks[pred_]),0);
return false;
}
printf("%d\n",key_);
int parent_= choose_parent(node,pred_,succ_,thread_id);
init_node(key_,next_index,pred_,succ_,parent_);
arr[parent_].height= max(arr[parent_].right, arr[parent_].left);
++next_index;
atomicExch(&(succ_locks[pred_]),0);
if(parent_!=root){
int grand_parent= lock_parent(parent_,thread_id);
rebalancing(grand_parent,parent_,thread_id, arr[grand_parent].left==parent_);
}else{
// release the lock and remove the thread number from temp array
tree_lock_thread[parent_]=-1;
atomicExch(&(tree_locks[parent_]),0);
}
return true;
}
flag= true;
atomicExch(&(succ_locks[pred_]),0);
}
}
atomicExch(&(succ_locks[pred_]),0);
}
}
template<typename T> __device__
int Tree<T>::choose_parent(int first_cand, int pred_, int succ_, int thread_id){
int candidate= (first_cand==pred_ || first_cand==succ_ ? first_cand:pred_);
// arbitrarily choose pred_ as the parent
while(true){
bool flag=false;
while(!flag){
if(atomicExch(&(tree_locks[candidate]),1)==0){
tree_lock_thread[candidate]= thread_id;
if(candidate==pred_){
if(arr[candidate].right==INT_MIN)
return candidate;
tree_lock_thread[candidate]=-1;
flag=true;
atomicExch(&(tree_locks[candidate]),0);
candidate= succ_;
}else{
if(arr[candidate].left==INT_MIN)
return candidate;
tree_lock_thread[candidate]=-1;
flag=true;
atomicExch(&(tree_locks[candidate]),0);
candidate= pred_;
}
}
}
}
}
template<typename T> __device__
int Tree<T>::lock_parent(int node, int thread_id){
while(true){
int parent_= arr[node].parent;
bool flag=false;
while(!flag){
if(atomicExch(&(tree_locks[parent_]),1)==0){
tree_lock_thread[parent_]=thread_id;
if(arr[node].parent==parent_ && !arr[parent_].mark)
return parent_;
tree_lock_thread[parent_]=-1;
flag=true;
atomicExch(&(tree_locks[parent_]),0);
}
}
}
}
template<typename T> __device__
int Tree<T>::restart(int node, int parent_,int thread_id){
if(parent_!=INT_MIN){
tree_lock_thread[parent_]=-1;
atomicExch(&(tree_locks[parent_]),0);
}
tree_lock_thread[node]=-1;
atomicExch(&tree_locks[node],0);
while(true){
bool flag=false;
while(!flag){
if(atomicExch(&(tree_locks[node]),1)==0){
tree_lock_thread[node]=thread_id;
if(arr[node].mark){
tree_lock_thread[node]=-1;
atomicExch(&(tree_locks[node]),0);
return INT_MIN;
}
int child= get_balance_factor(node)>=2?arr[node].left:arr[node].right;
if(child==INT_MIN)
return INT_MIN;
if(atomicCAS(&(tree_locks[child]),0,1)==0){
tree_lock_thread[child]= thread_id;
return child;
}
tree_lock_thread[node]=-1;
flag=true;
atomicExch(&(tree_locks[node]),0);
}
}
}
}
template<typename T> __device__
void Tree<T>::rebalancing(int node, int child, int thread_id, bool is_left){
// using relaxed balance
if(node==root){
tree_lock_thread[node]=-1;
atomicExch(&(tree_locks[node]),0);
if(child!=INT_MIN){
tree_lock_thread[child]=-1;
atomicExch(&(tree_locks[child]),0);
}
return;
}
int parent_=INT_MIN;
while(node!=root){
int new_height= max(height(arr[node].left),
height(arr[node].right));
int bf= get_balance_factor(node);
if(new_height == arr[node].height && abs(bf) < 2)
return;
while(abs(bf)>=2){
if((is_left && bf <= -2) ||(!is_left && bf >=2)){
if(child!=INT_MIN){
tree_lock_thread[child]=-1;
atomicExch(&(tree_locks[child]),0);
}
child= is_left ? arr[node].right : arr[node].left;
if(atomicCAS(&(tree_locks[child]),0,1)==1){
child=restart(node,parent_,thread_id);
if(tree_locks[node]!=thread_id)
return;
parent_= INT_MIN;
is_left= (arr[node].left==child);
bf = get_balance_factor(node);
continue;
}
is_left = !is_left;
}
int child_bf= get_balance_factor(child);
if((is_left && child_bf < 0) || (!is_left && child_bf > 0)){
int grand_child= is_left?arr[child].right: arr[child].left;
if(atomicCAS(&(tree_locks[grand_child]),0,1)==1){
tree_lock_thread[child]=-1;
atomicExch(&(tree_locks[child]),0);
child= restart(node,parent_,thread_id);
if(tree_lock_thread[node]!=thread_id)
return;
parent_= INT_MIN;
is_left= (arr[node].left ==child);
bf= get_balance_factor(node);
continue;
}
rotate(grand_child,child,node,is_left);
tree_lock_thread[child]=-1;
atomicExch(&(tree_locks[child]),0);
child= grand_child;
}
if(parent_==INT_MIN)
parent_= lock_parent(node,thread_id);
rotate(child,node,parent_,!is_left);
bf= get_balance_factor(node);
if(bf>=2 || bf <= -2){
tree_lock_thread[parent_]=-1;
atomicExch(&(tree_locks[parent_]),0);
parent_= child;
child= INT_MIN;
is_left= bf>=2?false:true;
continue;
}
int temp= child;
child= node;
node= temp;
is_left=(arr[node].left == child);
bf= get_balance_factor(node);
if(child !=INT_MIN){
tree_lock_thread[child]=-1;
atomicExch(&(tree_locks[child]),0);
}
child= node;
node= parent_!=INT_MIN && tree_lock_thread[parent_]==thread_id?
parent_:lock_parent(node,thread_id);
is_left= (arr[node].left==child);
parent_= INT_MIN;
}
}
return;
}
template<typename T> __device__
int Tree<T>::get_balance_factor(int index){
int left_h= height(arr[index].left);
int right_h= height(arr[index].right);
arr[index].height= max(left_h,right_h);
return (left_h - right_h);
}
template<typename T> __device__
void Tree<T>::rotate(int child, int node, int parent_, bool left){
if(left)
arr[parent_].left= child;
else arr[parent_].right= child;
arr[child].parent=parent_;
arr[node].parent= child;
int grand_child= left?arr[child].left : arr[child].right;
if(left){
arr[node].right = grand_child;
if(grand_child!=INT_MIN)
arr[grand_child].parent= node;
arr[child].left= node;
}else{
arr[node].left= grand_child;
if(grand_child!=INT_MIN)
arr[grand_child].parent=node;
arr[child].right= node;
}
arr[node].height= max(height(arr[node].right),height(arr[node].left));
arr[child].height= max(height(arr[child].left),height(arr[child].right));
}
template<typename T> __device__
bool Tree<T>::remove(T &key_, int thread_id){
int node= search(key_);
int pred_= arr[node].key > key_?arr[node].pred:node;
bool flag= false;
while(!flag){
if(atomicExch(&(succ_locks[pred_]),1)==0){
int succ_= arr[pred_].succ;
if(key_ > arr[pred_].key && key_<=arr[succ_].key && !arr[pred_].mark){
if(arr[succ_].key >key_){
atomicExch(&(succ_locks[succ_]),0);
return false;
}
bool succ_flag= false;
while(!succ_flag){
if(atomicExch(&(succ_locks[succ_]),1)==0){
int succ_2= acquire_tree_locks(succ_,thread_id);
int succ_parent= lock_parent(succ_,thread_id);
arr[succ_].mark=true;
int succ_succ= arr[succ_].succ;
arr[succ_succ].pred= pred_;
arr[pred_].succ= succ_succ;
flag= true;
succ_flag= true;
atomicExch(&succ_locks[pred_],0);
atomicExch(&(succ_locks[succ_]),0);
remove_from_tree(succ_,succ_2,succ_parent,thread_id);
return false;
}
}
}
atomicExch(&(succ_locks[pred_]),0);
flag=true;
}
}
return true;
}
template<typename T> __device__
int Tree<T>::acquire_tree_locks(int node, int thread_id){
while(true){
bool node_flag= false;
while(!node_flag){
if(atomicExch(&(tree_locks[node]),1)==0){
tree_lock_thread[node]= thread_id;
int right_= arr[node].right;
int left_= arr[node].left;
if(right_ == INT_MIN || left_ == INT_MIN){
if(right_ != INT_MIN && atomicCAS(&(tree_locks[right_]),0,1)==1){
tree_lock_thread[node]=-1;
node_flag= true;
atomicExch(&(tree_locks[node]),0);
continue;
}
if(left_ == INT_MIN && atomicCAS(&tree_locks[left_],0,1)==1){
tree_lock_thread[node]=-1;
node_flag= true;
atomicExch(&tree_locks[node],0);
continue;
}
return INT_MIN;
}
// if node has two children, lock its successor(s)
// s's parent and it's child if it exists
int succ_= arr[node].succ;
int parent_= arr[succ_].parent;
if(parent_!=node){
if(atomicCAS(&tree_locks[parent_],0,1)==1){
tree_lock_thread[node]= -1;
node_flag= true;
atomicExch(&tree_locks[node],0);
continue;
}
}else if(parent_!= arr[succ_].parent && arr[parent_].mark){
tree_lock_thread[parent_]=-1;
tree_lock_thread[node]= -1;
atomicExch(&tree_locks[parent_],0);
node_flag= true;
atomicExch(&tree_locks[node],0);
continue;
}
if(atomicCAS(&tree_locks[succ_],0,1)==1){
tree_lock_thread[node]= -1;
atomicExch(&tree_locks[node],0);
if(parent_!=node){
tree_lock_thread[parent_]=-1;
atomicExch(&tree_locks[parent_],0);
}
continue;
}
int succ_right= arr[succ_].right;
if(succ_right!=INT_MIN && atomicCAS(&tree_locks[succ_right],0,1)==1){
tree_lock_thread[node]= -1;
node_flag=true;
atomicExch(&tree_locks[node],0);
tree_lock_thread[succ_]= -1;
atomicExch(&tree_locks[succ_],0);
if(parent_!= node){
tree_lock_thread[parent_]=-1;
atomicExch(&tree_locks[parent_],0);
}
continue;
}
return succ_;
}
}
}
}
template<typename T> __device__
void Tree<T>::remove_from_tree(int node, int succ_, int parent_, int thread_id){
if(succ_==INT_MIN){
int right_=arr[node].right;
int child= (arr[node].right==INT_MIN ? arr[node].left : right_);
int left= update_child(parent_,node,child);
tree_lock_thread[node]=-1;
atomicExch(&tree_locks[node],0);
rebalancing(parent_,child,thread_id,left);
return;
}
int old_parent=arr[succ_].parent;
int old_right= arr[succ_].right;
update_child(old_parent,succ_,old_right);
arr[succ_].height= max(height(arr[node].left), height(arr[node].right));
int left_ = arr[node].left;
int right_ = arr[node].right;
arr[succ_].parent= parent_;
arr[succ_].left= left_;
arr[succ_].right = right_;
arr[left_].parent = succ_;
if(right_!=INT_MIN)
arr[right_].parent= succ_;
if(arr[parent_].left==node)
arr[parent_].left=succ_;
else arr[parent_].right= succ_;
bool is_left=(old_parent!=node);
bool violated= abs(get_balance_factor(succ_))>=2;
if(is_left)
old_parent=succ_;
else{
tree_lock_thread[succ_]=-1;
atomicExch(&tree_locks[succ_],0);
}
tree_lock_thread[node]=-1;
atomicExch(&tree_locks[node],0);
tree_lock_thread[parent_]=-1;
atomicExch(&tree_locks[parent_],0);
rebalancing(old_parent,old_right,thread_id,is_left);
if(violated){
bool succ_flag= false;
while(!succ_flag){
if(atomicExch(&tree_locks[succ_],1)==0){
int bf= get_balance_factor(succ_);
if(!arr[succ_].mark && abs(bf)>=2){
rebalancing(succ_,INT_MIN,thread_id, (bf>=2?false:true));
}else{
tree_lock_thread[succ_]=-1;
atomicExch(&tree_locks[succ_],0);
}
}
}
}
}
template<typename T> __device__
bool Tree<T>::update_child(int parent_, int old_child, int new_child){
if(new_child!=INT_MIN)
arr[new_child].parent= parent_;
bool left= arr[parent_].left==old_child;
if(left)
arr[parent_].left= new_child;
else arr[parent_].right= new_child;
return left;
}
|
21,126 | #include <stdio.h>
#include <stdlib.h>
#define THREADSIZE 100
#define BLOCKSIZE 65536
__global__ void demo(int * p){
int tx=threadIdx.x;
int bx=blockIdx.x;
int thid = tx+bx*blockDim.x;
p[thid]=thid;
if(thid<10){
printf("%d elements is %d\n",thid,p[thid]);
}
}
int main(int argc , char **argv){
int * p;
cudaError_t err;
err=cudaMalloc((void**)&p,THREADSIZE*BLOCKSIZE*sizeof(int));
if( err != cudaSuccess)
{
printf("CUDA error: %s\n", cudaGetErrorString(err));
exit(-1);
}
dim3 dimGrid(BLOCKSIZE,1);
dim3 dimBlock(THREADSIZE,1);
// Configuration is not correct.
// x, y, z dimension of thread blocks should not exceed 65535 in compute capability 2.0
demo<<<dimGrid,dimBlock>>>(p);
err=cudaFree(p);
if( err != cudaSuccess)
{
printf("CUDA error: %s\n", cudaGetErrorString(err));
exit(-1);
}
printf("tx\n");
return 0;
}
|
21,127 | #include <cuda.h>
#include <stdio.h>
#define N (32)
#define BLOCK (8)
__global__
void
matrixFill(float *matrix) {
const int x = threadIdx.x + blockDim.x*blockIdx.x;
const int y = threadIdx.y + blockDim.y*blockIdx.y;
const int i = N*y + x;
matrix[i] = blockIdx.y;
}
int
main(void) {
float h_matrix[N][N];
float *d_matrix;
unsigned int i, j;
cudaMalloc(&d_matrix, N * N * sizeof(float));
dim3 dimg(N/BLOCK, N/BLOCK);
dim3 dimb(BLOCK, BLOCK);
matrixFill<<<dimg, dimb>>>(d_matrix);
cudaMemcpy(h_matrix, d_matrix, N * N * sizeof(float), cudaMemcpyDeviceToHost);
for (i = 0; i != N; ++i) {
for (j = 0; j != N; ++j)
printf("%02.0f ", h_matrix[j][i]);
printf("\n");
}
return 0;
}
|
21,128 | #include <cuda.h>
#include <stdio.h>
#include <stdint.h>
// For comparisons
//#include "seqScan.c"
__device__ int sklansky(int i, float* input0, float *output0, uint8_t *sbase,float *maxs) {
uint32_t t2 = ((blockIdx.x*32)+((threadIdx.x&4294967294)|(threadIdx.x&1)));
uint32_t t9 = ((threadIdx.x&4294967292)|(threadIdx.x&3));
uint32_t t14 = ((threadIdx.x&4294967288)|(threadIdx.x&7));
uint32_t t19 = ((threadIdx.x&4294967280)|(threadIdx.x&15));
((float*)sbase)[threadIdx.x] = (((threadIdx.x&1)<1) ? input0[t2] : (input0[((blockIdx.x*32)+((threadIdx.x&4294967294)|0))]+input0[t2]));
//__syncthreads();
((float*)(sbase+128))[threadIdx.x] = (((threadIdx.x&3)<2) ? ((float*)sbase)[t9] : (((float*)sbase)[((threadIdx.x&4294967292)|1)]+((float*)sbase)[t9]));
//__syncthreads();
((float*)sbase)[threadIdx.x] = (((threadIdx.x&7)<4) ? ((float*)(sbase+128))[t14] : (((float*)(sbase+128))[((threadIdx.x&4294967288)|3)]+((float*)(sbase+128))[t14]));
//__syncthreads();
((float*)(sbase+128))[threadIdx.x] = (((threadIdx.x&15)<8) ? ((float*)sbase)[t19] : (((float*)sbase)[((threadIdx.x&4294967280)|7)]+((float*)sbase)[t19]));
//__syncthreads();
((float*)sbase)[threadIdx.x] = ((threadIdx.x<16) ? ((float*)(sbase+128))[threadIdx.x] : (((float*)(sbase+128))[15]+((float*)(sbase+128))[threadIdx.x]));
//__syncthreads();
output0[((blockIdx.x*32)+threadIdx.x)] = ((float*)sbase)[threadIdx.x];
if (threadIdx.x == 0)
maxs[i] = ((float*)sbase)[31];
return 0;
}
__global__ void kernel(float* input0,
float* output0,
float* maxout){
extern __shared__ __attribute__ ((aligned(16))) uint8_t sbase[];
float *maxs = (float*)(sbase+(sizeof(float)*64));
for (int i = 0; i < 32; i ++) {
sklansky(i,input0+i*32,output0+i*32,sbase,maxs);
}
float v; // discard this value
sklansky(0,maxs,maxs,sbase,&v);
// distribute
if (threadIdx.x > 0) {
for (int j = 0; j < 32; j ++) {
output0[threadIdx.x*32+j] += maxs[threadIdx.x-1];
}
}
maxout[threadIdx.x] = maxs[threadIdx.x];
}
#define N 32*32
int main(void) {
float v[N];
float r[N];
//float rc[N];
float m[32];
float *dv;
float *dr;
float *dm;
for (int i = 0; i < N; i ++) {
v[i] = 1.0;
r[i] = 7.0;
}
cudaMalloc((void**)&dv,N*sizeof(float));
cudaMalloc((void**)&dr,N*sizeof(float));
cudaMalloc((void**)&dm,32*sizeof(float));
cudaMemcpy(dv,v,N*sizeof(float),cudaMemcpyHostToDevice);
kernel<<<1,32,32*3*(sizeof(float))>>>(dv,dr,dm);
cudaMemcpy(r,dr,N*sizeof(float),cudaMemcpyDeviceToHost);
cudaMemcpy(m,dm,32*sizeof(float),cudaMemcpyDeviceToHost);
for (int i = 0; i < N; i ++) {
printf("%f ",r[i]);
}
printf("\n ------ \n");
for (int i = 0; i < 32; i ++) {
printf("%f ",m[i]);
}
//seqScan(v,rc,N);
//int s = compare(rc,r,0.01,N);
//printf ("\n%s\n", s? "same" : "not the same");
return 0;
}
|
21,129 | #include <stdio.h>
__global__ void myKernelThatAdds(int *a, int *b, int*c, int n) {
/* global keyword is called from host (CPU) and
is executed on device (GPU).
We use pointers for the variable inputs
since the kernel runs on the device, and so the
variables must point to memory.*/
printf("adding...\n");
// 0. *c = *a + *b;
// 1. c[blockIdx.x] = a[blockIdx.x] + b[blockIdx.x];
// 2. c[threadIdx.x] = a[threadIdx.x] + b[threadIdx.x];
int index = threadIdx.x + blockIdx.x * blockDim.x;
if (index < n) {
c[index] = a[index] + b[index];
}
printf("done adding!\n");
}
int main(void) {
// 1. and 2. length of vector
// static const int N = 512;
// 3. using threads AND blocks
// 3. together
static const int N = (2048 * 2048);
static const int THREADS_PER_BLOCK = 512;
// 0. instatiate host copies of variables
// int a, b, c;
// 1. now instantiate arrays
int *a, *b, *c;
// 0. instantiate device copies of variables
int *d_a, *d_b, *d_c;
static const int sizeOfInt = sizeof(int);
// 0. allocate memory space for device copies of a, b, c
cudaMalloc((void **)&d_a, sizeOfInt);
cudaMalloc((void **)&d_b, sizeOfInt);
cudaMalloc((void **)&d_c, sizeOfInt);
// 0. setup input values
// a = 2;
// b = 7;
// 1. now setup input arrays and alloc space for host copies
a = (int *)malloc(sizeOfInt);
b = (int *)malloc(sizeOfInt);
c = (int *)malloc(sizeOfInt);
// 0. copy inputs to device copies
// cudaMemcpy(d_a, &a, sizeOfInt, cudaMemcpyHostToDevice);
// cudaMemcpy(d_b, &b, sizeOfInt, cudaMemcpyHostToDevice);
cudaMemcpy(d_a, a, sizeOfInt, cudaMemcpyHostToDevice);
cudaMemcpy(d_b, b, sizeOfInt, cudaMemcpyHostToDevice);
// launch kernel on device
// myKernelThatAdds <<< 1 , 1 >>> (d_a, d_b, d_c);
// myKernelThatAdds <<< N , 1 >>> (d_a, d_b, d_c);
// seems like the blocks*threads should equal
// the number of things you want to compute
// in parallel
// myKernelThatAdds <<< 1 , N >>> (d_a, d_b, d_c);
myKernelThatAdds <<< (N + THREADS_PER_BLOCK-1) / THREADS_PER_BLOCK, THREADS_PER_BLOCK >>> (d_a, d_b, d_c, N);
// copy result back to host
// cudaMemcpy(&c, d_c, sizeOfInt, cudaMemcpyDeviceToHost);
cudaMemcpy(c, d_c, sizeOfInt, cudaMemcpyDeviceToHost);
// clean up memory
cudaFree(d_a);
cudaFree(d_b);
cudaFree(d_c);
// now clean up memory copy
free(a);
free(b);
free(c);
return(0);
} |
21,130 | // Tiled dense matrix multiplication routine using shared memory
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string.h>
#include <cuda.h>
#include <cuda_runtime.h>
#define TILE_WIDTH 16
void checkCUDAError(const char *msg);
// Matrix multiplication
__global__ void matrix_multiply(float *a, float *b, float *c, int num, size_t width)
{
// create shorthand names for threadIdx & blockIdx
int tx = threadIdx.x, ty = threadIdx.y;
int bx = blockIdx.x, by = blockIdx.y;
// allocate 2D tiles in __shared__ memory
__shared__ float s_a[TILE_WIDTH][TILE_WIDTH];
__shared__ float s_b[TILE_WIDTH][TILE_WIDTH];
// calculate the row & column index of the element
int row = by * blockDim.y + ty;
int col = bx * blockDim.x + tx;
float result = 0;
// loop over the tiles of the input in phases
for(int i = 0; i < (width - 1)/TILE_WIDTH + 1; ++i)
{
// collaboratively load tiles into __shared__
if (row < width && i*TILE_WIDTH + tx < width)
{
s_a[ty][tx] = a[row*width + i*TILE_WIDTH + tx];
}
else
{
s_a[ty][tx] = 0.0;
}
if (col < width && i*TILE_WIDTH + ty < width)
{
s_b[ty][tx] = b[(i*TILE_WIDTH + ty)*width + col];
}
else
s_b[ty][tx] = 0.0;
// wait until all data is loaded before allowing any thread in this block to continue
__syncthreads();
// do dot product between row of s_a and column of s_b
for(int k = 0; k < TILE_WIDTH; ++k)
{
result += s_a[ty][k] * s_b[k][tx];
}
// wait until all threads are finished with the data before allowing any thread in this block to continue
__syncthreads();
}
if (row < width && col < width)
{
c[row*num + col] = result;
}
}
// To read input files
float* readData(char* filename, int* num)
{
FILE* handle = fopen(filename, "r");
if (handle == NULL)
{
printf("Error opening file: %s\n", filename);
exit(0);
}
int i;
fscanf(handle, "%d", num);
float *data = (float *)malloc(sizeof(float) * *num * (*num));
for (i = 0; i < *num; i++)
{
fscanf(handle, "%f", &data[i]);
}
// printf("%f %f %f\n", data[0], data[1], data[2]);
return data;
}
// Main
int main(int argc, char *argv[])
{
float *h_A = NULL;
float *h_B = NULL;
int i, num;
// parse the input arguments
if(argc != 11)
{
printf("\nUsage: ./TiledMatrixMultiplication_Template -e <expected.raw> -i <input0.raw> , <input1.raw> -o <output.raw> -t matrix\n\n");
return 0;
}
char* input0_filename = argv[4];
char* input1_filename = argv[6];
char* output_filename = argv[8];
// Import host input data
h_A = readData(input0_filename, &num);
h_B = readData(input1_filename, &num);
// Host output declaration and memory allocation
float *h_C = (float *)malloc(sizeof(float) * num * num);
// allocate storage for the device
float *d_a = 0, *d_b = 0, *d_c = 0;
cudaMalloc((void**)&d_a, sizeof(float) * num * num);
cudaMalloc((void**)&d_b, sizeof(float) * num * num);
cudaMalloc((void**)&d_c, sizeof(float) * num * num);
checkCUDAError("CUDA malloc");
// copy host input to the device
cudaMemcpy(d_a, h_A, sizeof(float) * num * num, cudaMemcpyHostToDevice);
cudaMemcpy(d_b, h_B, sizeof(float) * num * num, cudaMemcpyHostToDevice);
checkCUDAError("CUDA memcpy");
// kernel launch
dim3 dimBlock(TILE_WIDTH,TILE_WIDTH, 1);
dim3 dimGrid((num - 1) / TILE_WIDTH + 1, (num - 1) / TILE_WIDTH + 1, 1);
matrix_multiply<<<dimGrid,dimBlock>>>(d_a, d_b, d_c, num, num);
// Copy result from device to host
cudaMemcpy(h_C, d_c, sizeof(float) * num * num, cudaMemcpyDeviceToHost);
checkCUDAError("CUDA memcpy results");
//Cross-verification
float* verifyData = readData(output_filename, &num);
if(num * num != sizeof(verifyData)/sizeof(float))
printf("Size not matching: Output size: %d\tExpected size: %d\n", num * num, sizeof(verifyData)/sizeof(float));
else
for(i=0; i<num * num; i++)
{
if((float)verifyData[i] != (float)h_C[i])
printf("Data not matching: Location: %d\tOutput: %f\tExpected: %f\n", i+1, h_C[i], verifyData[i]);
}
// deallocate device memory
cudaFree(d_a);
cudaFree(d_b);
cudaFree(d_c);
return 0;
}
void checkCUDAError(const char *msg)
{
cudaError_t err = cudaGetLastError();
if (cudaSuccess != err)
{
fprintf(stderr, "CUDA ERROR: %s: %s.\n", msg, cudaGetErrorString(err));
exit(EXIT_FAILURE);
}
}
|
21,131 | #include "includes.h"
__device__ int GetVecIndex(int vecNumber, int dimCount, int *dimSizes, int measCount, int vecCount, int *dims)
{
unsigned long int index = 0;
for (int i = 0; i < dimCount; ++i)
index += (unsigned long int)dimSizes[i] * (unsigned long int)dims[i * vecCount + vecNumber];
return index;
}
__global__ void AddPackKernel(unsigned long int *codes, int *measures, int dimensionsCount, int *dimendionsSizes, int measuresCount, int currentCapacity, int fullCapacity, int packCount, int *packDimensions, int *packMeasures)
{
int currentVec = blockIdx.x * blockDim.x + threadIdx.x;
while (currentVec < packCount)
{
codes[currentCapacity + currentVec] = GetVecIndex(currentVec, dimensionsCount, dimendionsSizes, measuresCount, packCount, packDimensions);
for (int i = 0; i < measuresCount; ++i)
measures[i * fullCapacity + currentCapacity + currentVec] = packMeasures[i * packCount + currentVec];
currentVec += blockDim.x * gridDim.x;
}
} |
21,132 | #include "includes.h"
__global__ void pow_array_gpu(float *a, int power, int array_size)
{
int idx = blockIdx.x * blockDim.x + threadIdx.x;
float result=1;
if (idx<array_size)
{
for(int i=0; i<power; ++i)
result*=a[idx];
a[idx] = result;
}
} |
21,133 | #include <stdio.h>
#include <stdlib.h>
#include <math.h>
// CUDA kernel. Each thread takes care of one element of c
__global__ void vecAdd(double *a, double *b, double *c, int n)
{
// Get our global thread ID
int id = blockIdx.x*blockDim.x+threadIdx.x;
// get global index
// Make sure we do not go out of bounds
if (id < n)
c[id] = a[id] + b[id];
}
int main( int argc, char* argv[] )
{
//int n = 100000;
int n=5;
// Size of vectors
double *h_a;
double *h_b; // Host input vector
// Host input vector
double *h_c; //Host output vector
double *d_a;
double *d_b; // Device input vector
// Device input vector
double *d_c; //Device output vector
size_t bytes = n*sizeof(double);
// Size, in bytes, of each vector
// Allocate memory for each vector on host
h_a = (double*)malloc(bytes);
h_b = (double*)malloc(bytes);
h_c = (double*)malloc(bytes);
// Allocate memory for each vector on GPU
cudaMalloc(&d_a, bytes);
cudaMalloc(&d_b, bytes);
cudaMalloc(&d_c, bytes);
int i;// Initialize vectors on host
for( i = 0; i < n; i++ ) {
h_a[i]=i;
h_b[i]=i;
}
// Copy host vectors to device
cudaMemcpy( d_a, h_a, bytes, cudaMemcpyHostToDevice);
cudaMemcpy( d_b, h_b, bytes, cudaMemcpyHostToDevice);
int blockSize, gridSize;
// Number of threads in each thread block
blockSize = 1024;
// Number of thread blocks in grid
gridSize = (int)ceil((float)n/blockSize);
// Execute the kernel
vecAdd<<<gridSize, blockSize>>>(d_a, d_b, d_c, n);
// Copy array back to host
cudaMemcpy( h_c, d_c, bytes, cudaMemcpyDeviceToHost );
// Sum up vector c and print result divided by n, this should equal 1 within error
double sum = 0;
for(i=0; i<n; i++)
sum += h_c[i];
printf("SIZE of 2 vectors: %d\n", n);
printf("SUM of 2 vectors: %f\n", sum);
printf("Average mean of 2 vectors: %f\n", sum/n);
// Release device memory
cudaFree(d_a);
cudaFree(d_b);
cudaFree(d_c);
// Release host memory
free(h_a);
free(h_b);
free(h_c);
return 0;
}
|
21,134 | // Source: http://docs.nvidia.com/cuda/curand/index.html
#include <thrust/iterator/counting_iterator.h>
#include <thrust/functional.h>
#include <thrust/transform_reduce.h>
#include <curand_kernel.h>
#include <iostream>
#include <iomanip>
// we could vary M & N to find the perf sweet spot
struct estimate_pi :
public thrust::unary_function<unsigned int, float>
{
__device__
float operator()(unsigned int thread_id)
{
float sum = 0;
unsigned int N = 10000; // samples per thread
unsigned int seed = thread_id;
curandState s;
// seed a random number generator
curand_init(seed, 0, 0, &s);
// take N samples in a quarter circle
for(unsigned int i = 0; i < N; ++i)
{
// draw a sample from the unit square
float x = curand_uniform(&s);
float y = curand_uniform(&s);
// measure distance from the origin
float dist = sqrtf(x*x + y*y);
// add 1.0f if (u0,u1) is inside the quarter circle
if(dist <= 1.0f)
sum += 1.0f;
}
// multiply by 4 to get the area of the whole circle
sum *= 4.0f;
// divide by N
return sum / N;
}
};
int main(void)
{
// use 30K independent seeds
int M = 30000;
float estimate = thrust::transform_reduce(
thrust::counting_iterator<int>(0),
thrust::counting_iterator<int>(M),
estimate_pi(),
0.0f,
thrust::plus<float>());
estimate /= M;
std::cout << std::setprecision(4);
std::cout << "pi is approximately ";
std::cout << estimate << std::endl;
return 0;
}
|
21,135 | #include <iostream>
#include <cmath>
#include <chrono>
#define N 256
using namespace std;
using namespace std::chrono;
__global__ void ArraySum(float *array, float *sum){
int index = threadIdx.x + blockIdx.x * blockDim.x;
if(index < N){
atomicAdd(sum, array[index]);
}
}
__global__ void revisedArraySum(float *array, float *sum){
__shared__ float partialSum[256];
int t = threadIdx.x;
for(int stride = 1;stride < blockDim.x; stride *= 2){
__syncthreads();
if(t % (2 * stride) == 0){
partialSum[t] += partialSum[t + stride];
}
}
sum[0] = partialSum[0];
}
void findSum(float *array, float *sum){
auto start = high_resolution_clock::now();
for(int i = 0;i < N;i ++){
*sum += array[i];
}
auto stop = high_resolution_clock::now();
auto time_req = duration_cast<microseconds>(stop - start).count();
cout << endl << "Sum from CPU is: " << *sum << endl;
cout << endl << "Time required for CPU: " << time_req << endl;
}
int main(){
float *hostInput, *deviceInput, *sumCPU, *sumGPU, *sumGPU2CPU;
hostInput = (float*)malloc(N * sizeof(float));
sumCPU = (float*)malloc(sizeof(float));
sumGPU2CPU = (float*)malloc(sizeof(float));
*sumCPU = 0;
for(int i = 0;i < N;i ++){
hostInput[i] = 1.0f;
}
cudaMalloc(&deviceInput, N * sizeof(float));
cudaMalloc(&sumGPU, sizeof(float));
cudaMemcpy(deviceInput, hostInput, N * sizeof(float), cudaMemcpyHostToDevice);
findSum(hostInput, sumCPU);
dim3 threadsPerBlock(256, 1, 1);
dim3 numBlocks(1, 1, 1);
auto start = high_resolution_clock::now();
revisedArraySum<<<numBlocks, threadsPerBlock>>>(deviceInput, sumGPU);
auto stop = high_resolution_clock::now();
auto time_req = duration_cast<microseconds>(stop - start).count();
cudaMemcpy(sumGPU2CPU, sumGPU, sizeof(float), cudaMemcpyDeviceToHost);
cout << endl << "Sum from GPU is: " << *sumGPU2CPU << endl;
cout << endl << "Time required for GPU: " << time_req << endl;
free(hostInput);
free(sumCPU);
free(sumGPU2CPU);
cudaFree(deviceInput);
cudaFree(sumGPU);
} |
21,136 | __global__ void sum_kernel(float *g_odata, float *g_idata, int N)
// Naive kernel
{
// YOUR TASKS:
// - Write a naive kernel where parallel sum reduction is done on a per block basis
// and reduction sum is returned in g_odata.
// - For simplicity, assume kernel only considers a dataset within each block of size 2^p, p=1,2,
//
// access thread id within block
unsigned int t = threadIdx.x;
for(int i = 2; i <= (blockDim.x*blockDim.y); i*=2){
if (t&(i-1) == 0)
g_idata[t + blockDim.x*blockIdx.x] = g_idata[t + blockDim.x*blockIdx.x] + g_idata[t+(i/2) + blockDim.x*blockIdx.x];
__syncthreads();
}
if (t==0) g_odata[blockIdx.x] = g_idata[blockDim.x*blockIdx.x];
}
__global__ void sum_kernel2(float *g_odata, float *g_idata, int N)
// Shared memory kernel
{
// YOUR TASKS:
// - Improve naive kernel to use shared memory per block for reduction
// - Employ dynamic allocation of shared memory where mem block size is determined by host
// - Threads within a block should collaborate on loading data from device to shared memory
// - For simplicity, assume kernel only considers a dataset within each block of size 2^p, p=1,2,
//
// shared mem array
// the size is determined by the host application
// access thread id
//unsigned int t = ????? ;
// read in input data to shared memory from global memory
//?????
unsigned int tid = threadIdx.x;
unsigned int utid = threadIdx.x + blockDim.x * blockIdx.x;
__shared__ float sum[128];
sum[tid] = g_idata[utid];
__syncthreads();
for(int i = 2; i <= (blockDim.x*blockDim.y); i*=2){
if (tid &(i-1) == 0)
sum[tid] = sum[tid] + sum[(i/2) + tid];
__syncthreads();
}
if (tid==0)
g_odata[blockIdx.x] = sum[tid];
// Reduction per block in shared memory
//?????
// Output partial sum
//if (t==0) g_odata[blockIdx.x] = ?????;
}
__global__ void sum_kernel3(float *g_odata, float *g_idata, int N)
{
// YOUR TASKS:
// - Change stride pattern in sum_kernel2 for reduction step.
unsigned int tid = threadIdx.x;
unsigned int size = blockDim.x * blockDim.y;
unsigned int utid = threadIdx.x + blockDim.x * blockIdx.x;
__shared__ float sum[128];
sum[tid] = g_idata[utid];
__syncthreads();
/*for(int i = 0; i < (int) __log2f(size); i++){
if(tid < size/(2*i))
sum[tid] = sum[tid] + sum[size/i - tid];
*/
for (int i = size; i > 0; i = i/2 ) {
if (tid < i/2 )
sum[tid] = sum[tid] + sum[i - tid - 1];
__syncthreads();
}
if (tid==0)
g_odata[blockIdx.x] = sum[tid];
}
__global__ void sum_kernel4(float *g_odata, float *g_idata, int N)
{
// YOUR TASKS:
// - Change stride pattern in sum_kernel3 for reduction step.
unsigned int tid = threadIdx.x;
unsigned int size = blockDim.x * blockDim.y;
unsigned int utid = threadIdx.x + blockDim.x * blockIdx.x;
__shared__ float sum[128];
sum[tid] = g_idata[utid];
__syncthreads();
/*for(int i = 0; i < (int) __log2f(size); i++){
if(tid < size/(2*i))
sum[tid] = sum[tid] + sum[size/i - tid];
*/
for (int i = size; i > 0; i = i/2 ) {
if (tid < i/2 )
sum[tid] = sum[tid] + sum[i - tid -1];
__syncthreads();
}
if (tid==0)
g_odata[blockIdx.x] = sum[tid];
}
__global__ void sum_kernel5(float *g_odata, float *g_idata, int N)
{
// YOUR TASKS:
// - Optimize as much as possible
}
|
21,137 | //#include "cuda_runtime.h"
//#include "device_launch_parameters.h"
//#include "device_functions.h"
//
//#include <opencv2/core/core.hpp>
//#include <opencv2/highgui/highgui.hpp>
//#include <opencv2/core/cuda.hpp>
//
//
//#include <stdio.h>
//#include <iostream>
//#include <math.h>
//#include <vector>
//
//using namespace cv;
//using namespace std;
//
//cudaError_t addWithCuda(int *c, const int *a, const int *b, unsigned int size);
//cudaEvent_t start, stop;
//#define LIBDLL extern "C" __declspec(dllexport)
//
//__global__ void addKernel(int *c, const int *a, const int *b)
//{
// int i = threadIdx.x;
// c[i] = a[i] + b[i];
//}
//
//void imshow_auto(string s, Mat im) {
// double minVal, maxVal;
// Point minLoc, maxLoc;
//
// minMaxLoc(im, &minVal, &maxVal, &minLoc, &maxLoc);
// Mat im_scaled = (im - minVal) * (256.0f / maxVal);
// imshow(s, im_scaled);
//}
//
//void imshow_range(string s, Mat im, int* range) {
// float max_of_type = (float)pow(2, 8*im.elemSize()); // 8 bits * size in bytes
// Mat im_scaled = (im - range[0]) * (max_of_type / (range[1] - range[0]));
// imshow(s, im_scaled);
//}
//
//void make_subsquares_(int im_rows, int im_cols, float* pattern, Mat* ret_Mat_row, Mat* ret_Mat_col, vector<int>* ss_row_start, vector<int>* ss_row_end, vector<int>* ss_col_start, vector<int>* ss_col_end) {
// Mat subsquares_row(im_rows, im_cols, DataType<uint16_t>::type);
// Mat subsquares_col(im_rows, im_cols, DataType<uint16_t>::type);
//
// int ss;
// float pat_start_row = pattern[0];
// float pat_period_rows = pattern[2];
// int mem = 0;
// Mat aux;
//
// ss_row_start->push_back(0);
// for (int i = 0; i < subsquares_row.rows; i++) {
// ss = (int)(i / pat_period_rows + 1.0f / 2.0f - pat_start_row / pat_period_rows); //Cast to int implies floor operation.
// subsquares_row.row(i).setTo((uint16_t)ss);
// if (ss != mem) {
// ss_row_start->push_back(i);
// ss_row_end->push_back(i - 1);
// mem = ss;
// }
// }
// ss_row_end->push_back(subsquares_row.rows - 1);
//
// float pat_start_col = pattern[1];
// float pat_period_cols = pattern[3];
// mem = 0;
//
// ss_col_start->push_back(0);
//
// for (int j = 0; j < subsquares_col.cols; j++) {
// ss = (int)(j / pat_period_cols + 1.0f / 2.0f - pat_start_col / pat_period_cols);
// subsquares_col.col(j).setTo((uint16_t)ss);
// if (ss != mem) {
// ss_col_start->push_back(j);
// ss_col_end->push_back(j - 1);
// mem = ss;
// }
// }
// ss_col_end->push_back(subsquares_row.cols - 1);
//
// //int r[2] = { 0, 20 };
// //namedWindow("Display window", WINDOW_AUTOSIZE);// Create a window for display.
// //imshow_range("Display window", subsquares_row, r); // Show our image inside it.
// //waitKey(0);
//
// subsquares_row.copyTo(*ret_Mat_row);
// subsquares_col.copyTo(*ret_Mat_col);
//
//}
//
//__global__ void Make_Zero(uchar* src, uchar* dst, const int step)
//{
// const int idx = threadIdx.x + blockIdx.x * blockDim.x;
// const int idy = threadIdx.y + blockIdx.y * blockDim.y;
// uchar* loc_src = src + step*idy + idx;
// uchar* loc_dst = dst + step*idy + idx;
// if (blockIdx.y == blockIdx.x)
// *loc_dst = 0;
// else
// *loc_dst = *loc_src;
//}
//
//void make_pinv_im(float sigma, Mat* subsquares_row, Mat* subsquares_col, Mat* pinv_im, float* pattern, vector<int>* ss_row_start, vector<int>* ss_row_end, vector<int>* ss_col_start, vector<int>* ss_col_end) {
// int im_rows = subsquares_row->rows;
// int im_cols = subsquares_row->cols;
// int ss_rows = subsquares_row->at<uint16_t>(subsquares_row->rows - 1, 0) + 1;
// int ss_cols = subsquares_col->at<uint16_t>(0, subsquares_col->cols - 1) + 1;
// float ss_center_row;
// float ss_center_col;
// Mat ss;
// Mat ss_aux;
// Mat ss_vec_inv;
// Mat temp_pinv_im(im_rows, im_cols, DataType<float>::type);
//
// for (int i = 0; i < ss_rows; i++) {
// for (int j = 0; j < ss_cols; j++) {
// ss = temp_pinv_im(Range(ss_row_start->at(i), ss_row_end->at(i) + 1), Range(ss_col_start->at(j), ss_col_end->at(j) + 1));
// ss_center_row = pattern[0] + i * pattern[2] - ss_row_start->at(i);
// ss_center_col = pattern[1] + j * pattern[3] - ss_col_start->at(j);
// for (int k = 0; k < ss.rows; k++) {
// for (int l = 0; l < ss.cols; l++) {
// ss.at<float>(k, l) = exp(-(pow(k - ss_center_row, 2) + pow(l - ss_center_col, 2)) / (2 * pow(sigma, 2)));
// }
// }
// ss.copyTo(ss_aux);
// ss_vec_inv = ss_aux.reshape(0, 1).inv(cv::DECOMP_SVD);
// ss_vec_inv.reshape(0, ss.rows).copyTo(ss);
// }
// }
// temp_pinv_im.copyTo(*pinv_im);
//}
//
//__global__ void pixelwise_signal_extraction(uchar* dev_data,
// uchar* dev_coeff,
// uchar* dev_ss_row,
// uchar* dev_ss_col,
// uchar* dev_pinv_im,
// int im_rows,
// int im_cols,
// const int data_step,
// const int ss_row_step,
// const int ss_col_step,
// const int pinv_im_step,
// const int coeff_step) {
//
//
// float prod;
// const int idx = threadIdx.x + blockIdx.x * blockDim.x;
// const int idy = threadIdx.y + blockIdx.y * blockDim.y;
//
// int data_elem_size = 2;
// int ss_elem_size = 2;
// int pinv_elem_size = 4;
// int coeff_elem_size = 4;
//
// if (idy < im_rows && idx < im_cols) {
//
// uint16_t* pix_loc_data = (uint16_t*)(dev_data + data_step*idy + data_elem_size*idx);
// uint16_t* pix_loc_ss_row = (uint16_t*)(dev_ss_row + ss_row_step*idy + ss_elem_size*idx);
// uint16_t* pix_loc_ss_col = (uint16_t*)(dev_ss_col + ss_col_step*idy + ss_elem_size*idx);
// float* pix_loc_pinv_im = (float*)(dev_pinv_im + pinv_im_step*idy + pinv_elem_size*idx);
//
// float* pix_loc_coeff = (float*)(dev_coeff + coeff_step * *pix_loc_ss_row + coeff_elem_size * *pix_loc_ss_col);
// prod = (float)*pix_loc_data * *pix_loc_pinv_im;
// //printf("Idx = %d, Idy = %d, coeff_idx = %d, coeff_idy = %d, data = %d, pinv_v = %f, proKCd in kernel is: %f\n", idx, idy, *pix_loc_ss_col, *pix_loc_ss_row, *pix_loc_data, *pix_loc_pinv_im, prod);
// atomicAdd(pix_loc_coeff, prod);
// }
//
//}
//
//
//
//LIBDLL void extract_signal(int im_rows, int im_cols, uchar* rawdata_ptr, uchar* ss_row_ptr, uchar* ss_col_ptr, uchar* pinv_im_ptr, uchar* coeffs_ptr, float* elapsed) {
// cudaEventCreate(&start);
// cudaEventCreate(&stop);
//
// Mat rawdata(im_rows, im_cols, CV_16U, rawdata_ptr);
// Mat ss_row(im_rows, im_cols, CV_16U, ss_row_ptr);
// Mat ss_col(im_rows, im_cols, CV_16U, ss_col_ptr);
// Mat pinv_im(im_rows, im_cols, CV_32F, pinv_im_ptr);
// int coeff_rows = ss_row.at<uint16_t>(ss_row.rows - 1, 0) + 1;
// int coeff_cols = ss_col.at<uint16_t>(0, ss_col.cols - 1) + 1;
// Mat coeffs(coeff_rows, coeff_cols, CV_32F, coeffs_ptr);
//
// dim3 block(32, 32);
// dim3 grid((im_cols + block.x - 1) / block.x, (im_rows + block.y - 1) / block.y);
//
// cuda::GpuMat dev_ss_row;
// cuda::GpuMat dev_ss_col;
// cuda::GpuMat dev_pinv_im;
//
// dev_ss_row.upload(ss_row);
// dev_ss_col.upload(ss_col);
// dev_pinv_im.upload(pinv_im);
//
// cuda::GpuMat dev_data;
// cuda::GpuMat dev_coeff(coeff_rows, coeff_cols, CV_32F);
// cudaEventRecord(start);
// dev_data.upload(rawdata);
// cudaDeviceSynchronize();
// cudaEventRecord(stop);
// pixelwise_signal_extraction << < grid, block >> > (dev_data.data, dev_coeff.data, dev_ss_row.data, dev_ss_col.data, dev_pinv_im.data, im_rows, im_cols, dev_data.step, dev_ss_row.step, dev_ss_col.step, dev_pinv_im.step, dev_coeff.step);
// cudaDeviceSynchronize();
//
// dev_coeff.download(coeffs);
//
// cudaEventElapsedTime(elapsed, start, stop);
//}
//
//LIBDLL void extract_signal_stack(int im_rows, int im_cols, int im_slices, uchar** rawdata_ptr, uchar* ss_row_ptr, uchar* ss_col_ptr, uchar* pinv_im_ptr, uchar** coeffs_ptr, float* elapsed) {
// cudaEventCreate(&start);
// cudaEventCreate(&stop);
//
// int ndims = 3;
// int sizes[3] = { im_rows, im_cols, im_slices };
//
// Mat ss_row(im_rows, im_cols, CV_16U, ss_row_ptr);
// Mat ss_col(im_rows, im_cols, CV_16U, ss_col_ptr);
// Mat pinv_im(im_rows, im_cols, CV_32F, pinv_im_ptr);
// int coeff_rows = ss_row.at<uint16_t>(ss_row.rows - 1, 0) + 1;
// int coeff_cols = ss_col.at<uint16_t>(0, ss_col.cols - 1) + 1;
//
//
// dim3 block(32, 32);
// dim3 grid((im_cols + block.x - 1) / block.x, (im_rows + block.y - 1) / block.y);
//
// cuda::GpuMat dev_ss_row;
// cuda::GpuMat dev_ss_col;
// cuda::GpuMat dev_pinv_im;
//
// dev_ss_row.upload(ss_row);
// dev_ss_col.upload(ss_col);
// dev_pinv_im.upload(pinv_im);
//
// cuda::GpuMat dev_data;
// cuda::GpuMat dev_coeff(coeff_rows, coeff_cols, CV_32F);
//
//
// for (int i = 0; i < im_slices; i++) {
// Mat rawdata(im_rows, im_cols, CV_16U, rawdata_ptr[i]);
// Mat coeffs(coeff_rows, coeff_cols, CV_32F, coeffs_ptr[i]);
// dev_data.upload(rawdata);
//
// pixelwise_signal_extraction << < grid, block >> > (dev_data.data, dev_coeff.data, dev_ss_row.data, dev_ss_col.data, dev_pinv_im.data, im_rows, im_cols, dev_data.step, dev_ss_row.step, dev_ss_col.step, dev_pinv_im.step, dev_coeff.step);
// cudaDeviceSynchronize();
//
// dev_coeff.download(coeffs);
// }
// cudaEventElapsedTime(elapsed, start, stop);
//}
//
//LIBDLL void init_sig_extraction(int im_rows, int im_cols, int* coeff_rows_ptr, int* coeff_cols_ptr, uchar* ss_row_ptr, uchar* ss_col_ptr, uchar* pinv_im_ptr, float* pattern_ptr, float sigma_px) {
//
// Mat ss_row(im_rows, im_cols, CV_16U, ss_row_ptr);
// Mat ss_col(im_rows, im_cols, CV_16U, ss_col_ptr);
//
// Mat pinv_im(im_rows, im_cols, CV_32F, pinv_im_ptr);
//
// vector<int> ss_row_start;
// vector<int> ss_row_end;
// vector<int> ss_col_start;
// vector<int> ss_col_end;
//
// make_subsquares(im_rows, im_cols, pattern_ptr, &ss_row, &ss_col, &ss_row_start, &ss_row_end, &ss_col_start, &ss_col_end);
// make_pinv_im(sigma_px, &ss_row, &ss_col, &pinv_im, pattern_ptr, &ss_row_start, &ss_row_end, &ss_col_start, &ss_col_end);
//
// *coeff_rows_ptr = ss_row.at<uint16_t>(ss_row.rows - 1, 0) + 1;
// *coeff_cols_ptr = ss_col.at<uint16_t>(0, ss_col.cols - 1) + 1;
//
//}
//
//
//LIBDLL unsigned char* GPU_image_proc(unsigned char *dataImg, unsigned char *resImg, int im_rows, int im_cols/*, float* pattern*/)
//{
// //cout << cv::getBuildInformation() << endl;
// //*out = in;
// Mat image2;
// Mat image = imread("Lena.jpg", CV_LOAD_IMAGE_ANYDEPTH); // Read the file
// if (!image.data) // Check for invalid input
// {
// cout << "Could not open or find the image" << std::endl;
// }
// if (image.empty())
// std::cout << "failed to open img.jpg" << std::endl;
// else
// std::cout << "img.jpg loaded OK" << std::endl;
//
// cuda::GpuMat src;
// src.upload(image);
// cuda::GpuMat dst(src.rows, src.cols, 0); //Initialize with same size as src, type is OpenCV specific numbers specifying data type, 0 is 8 bit uint.
//
// dim3 block(32, 32);
// dim3 grid((src.cols + block.x - 1) / block.x, (src.rows + block.y - 1) / block.y);
//
// Make_Zero << <grid, block >> > (src.data, dst.data, src.step);
// cudaDeviceSynchronize();
//
// dst.download(image2);
// Mat im(512, 512, CV_8UC1, resImg);
// image2.copyTo(im);
//
// //namedWindow("Display window", WINDOW_AUTOSIZE);// Create a window for display.
// //imshow("Display window", image2); // Show our image inside it.
//
// //waitKey(0); // Wait for a keystroke in the window
// return image.data;
//}
//
//int main_test() {
//
// Mat image_raw = imread("04_pr_slice2.tif", CV_LOAD_IMAGE_ANYDEPTH); // Read the file
// Mat image(image_raw.rows, image_raw.cols, CV_16U);
// image_raw.convertTo(image, CV_16U);
// if (!image.data) // Check for invalid input
// {
// cout << "Could not open or find the image" << std::endl;
// }
// if (image.empty())
// std::cout << "failed to open img.jpg" << std::endl;
// else
// std::cout << "img.jpg loaded OK" << std::endl;
//
// int im_rows = image.rows;
// int im_cols = image.cols;
// int im_slices = 1;
//
//
// //Mat res(im_rows, im_cols, CV_8UC1);
// //Mat data(im_rows, im_cols, CV_16UC1, dataImg);
// //data.copyTo(res);
//
// Mat ss_row(im_rows, im_cols, CV_16U);
// Mat ss_col(im_rows, im_cols, CV_16U);
// Mat pinv_im(im_rows, im_cols, CV_32F);
// vector<int> ss_row_start;
// vector<int> ss_row_end;
// vector<int> ss_col_start;
// vector<int> ss_col_end;
//
// int coeff_rows;
// int coeff_cols;
// float pattern[4] = { 0.0f, 0.0f, 16.0f, 16.0f };
// float sigma = 3.2;
// float elapsed;
//
// init_sig_extraction(im_rows, im_cols, &coeff_rows, &coeff_cols, (uchar*)ss_row.data, (uchar*)ss_col.data, (uchar*)pinv_im.data, pattern, sigma);
//
// Mat coeffs(coeff_rows, coeff_cols, CV_32F);
//
// extract_signal_stack(im_rows, im_cols, im_slices, (uchar**)&image.data, (uchar*)ss_row.data, (uchar*)ss_col.data, (uchar*)pinv_im.data, (uchar**)&coeffs.data, &elapsed);
// //coeffs.copyTo(res);
// //for(int i = 0; i < res.rows; i++) {
// // for (int j = 0; j < res.cols; j++) {
// // printf("Coeff value is: %f\n", res.at<float>(i, j));
// // }
// //}
////
//// Mat res_8bit(res.rows, res.cols, CV_8U);
//// res.convertTo(res_8bit, CV_8U);
////
// int r[2] = { 0, 500 };
// printf("Coeffs(1,1) = %f", coeffs.at<float>(1, 1));
// namedWindow("Display window", WINDOW_AUTOSIZE);// Create a window for display.
// imshow_range("Display window", coeffs, r); // Show our image inside it.
// waitKey(0);
// //int r[2] = { 0, 50 };
// //namedWindow("Display window", WINDOW_AUTOSIZE);// Create a window for display.
// //imshow_range("Display window", ss_col(Range(0,250), Range(0,250)), r); // Show our image inside it.
//
// //waitKey(0);
//
//
// //const int arraySize = 5;
// //const int a[arraySize] = { 1, 2, 3, 4, 5 };
// //const int b[arraySize] = { 10, 20, 30, 40, 50 };
// //int c[arraySize] = { 0 };
//
// //// Add vectors in parallel.
// //cudaError_t cudaStatus = addWithCuda(c, a, b, arraySize);
// //if (cudaStatus != cudaSuccess) {
// // fprintf(stderr, "addWithCuda failed!");
// // return 1;
// //}
//
// //printf("{1,2,3,4,5} + {10,20,30,40,50} = {%d,%d,%d,%d,%d}\n",
// // c[0], c[1], c[2], c[3], c[4]);
//
// //// cudaDeviceReset must be called before exiting in order for profiling and
// //// tracing tools such as Nsight and Visual Profiler to show complete traces.
// //cudaStatus = cudaDeviceReset();
// //if (cudaStatus != cudaSuccess) {
// // fprintf(stderr, "cudaDeviceReset failed!");
// // return 1;
// //}
//
// return 0;
//}
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//// Helper function for using CUDA to add vectors in parallel.
////cudaError_t addWithCuda(int *c, const int *a, const int *b, unsigned int size)
////{
//// int *dev_a = 0;
//// int *dev_b = 0;
//// int *dev_c = 0;
//// cudaError_t cudaStatus;
////
//// // Choose which GPU to run on, change this on a multi-GPU system.
//// cudaStatus = cudaSetDevice(0);
//// if (cudaStatus != cudaSuccess) {
//// fprintf(stderr, "cudaSetDevice failed! Do you have a CUDA-capable GPU installed?");
//// goto Error;
//// }
////
//// // Allocate GPU buffers for three vectors (two input, one output) .
//// cudaStatus = cudaMalloc((void**)&dev_c, size * sizeof(int));
//// if (cudaStatus != cudaSuccess) {
//// fprintf(stderr, "cudaMalloc failed!");
//// goto Error;
//// }
////
//// cudaStatus = cudaMalloc((void**)&dev_a, size * sizeof(int));
//// if (cudaStatus != cudaSuccess) {
//// fprintf(stderr, "cudaMalloc failed!");
//// goto Error;
//// }
////
//// cudaStatus = cudaMalloc((void**)&dev_b, size * sizeof(int));
//// if (cudaStatus != cudaSuccess) {
//// fprintf(stderr, "cudaMalloc failed!");
//// goto Error;
//// }
////
//// // Copy input vectors from host memory to GPU buffers.
//// cudaStatus = cudaMemcpy(dev_a, a, size * sizeof(int), cudaMemcpyHostToDevice);
//// if (cudaStatus != cudaSuccess) {
//// fprintf(stderr, "cudaMemcpy failed!");
//// goto Error;
//// }
////
//// cudaStatus = cudaMemcpy(dev_b, b, size * sizeof(int), cudaMemcpyHostToDevice);
//// if (cudaStatus != cudaSuccess) {
//// fprintf(stderr, "cudaMemcpy failed!");
//// goto Error;
//// }
////
//// // Launch a kernel on the GPU with one thread for each element.
//// addKernel<<<1, size>>>(dev_c, dev_a, dev_b);
////
//// // Check for any errors launching the kernel
//// cudaStatus = cudaGetLastError();
//// if (cudaStatus != cudaSuccess) {
//// fprintf(stderr, "addKernel launch failed: %s\n", cudaGetErrorString(cudaStatus));
//// goto Error;
//// }
////
//// // cudaDeviceSynchronize waits for the kernel to finish, and returns
//// // any errors encountered during the launch.
//// cudaStatus = cudaDeviceSynchronize();
//// if (cudaStatus != cudaSuccess) {
//// fprintf(stderr, "cudaDeviceSynchronize returned error code %d after launching addKernel!\n", cudaStatus);
//// goto Error;
//// }
////
//// // Copy output vector from GPU buffer to host memory.
//// cudaStatus = cudaMemcpy(c, dev_c, size * sizeof(int), cudaMemcpyDeviceToHost);
//// if (cudaStatus != cudaSuccess) {
//// fprintf(stderr, "cudaMemcpy failed!");
//// goto Error;
//// }
////
////Error:
//// cudaFree(dev_c);
//// cudaFree(dev_a);
//// cudaFree(dev_b);
////
//// return cudaStatus;
////}
//
|
21,138 | /*
* Hello world cuda
*
* compile: nvcc hello_cuda.cu -o hello
*
*/
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <cuda.h>
__global__
void cuda_hello(){
// thread id of current block (on x axis)
int tid = threadIdx.x;
// block id (on x axis)
int bid = blockIdx.x;
printf("Ciao belli from block %d core %d!\n", bid, tid);
}
int main() {
// Launch GPU kernel
dim3 g(2,2,1);
dim3 t(2,4,1);
cuda_hello<<<g,t>>>();
// cuda synch barrier
cudaDeviceSynchronize();
return 0;
}
|
21,139 | //note: please do not modify this file manually!
// this file has been generated automatically by BOAST version 0.99996
// by: make boast_kernels
/*
!=====================================================================
!
! S p e c f e m 3 D G l o b e V e r s i o n 7 . 0
! --------------------------------------------------
!
! Main historical authors: Dimitri Komatitsch and Jeroen Tromp
! Princeton University, USA
! and CNRS / University of Marseille, France
! (there are currently many more authors!)
! (c) Princeton University and CNRS / University of Marseille, April 2014
!
! This program is free software; you can redistribute it and/or modify
! it under the terms of the GNU General Public License as published by
! the Free Software Foundation; either version 2 of the License, or
! (at your option) any later version.
!
! This program is distributed in the hope that it will be useful,
! but WITHOUT ANY WARRANTY; without even the implied warranty of
! MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
! GNU General Public License for more details.
!
! You should have received a copy of the GNU General Public License along
! with this program; if not, write to the Free Software Foundation, Inc.,
! 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
!
!=====================================================================
*/
#ifndef INDEX2
#define INDEX2(isize,i,j) i + isize*j
#endif
#ifndef INDEX3
#define INDEX3(isize,jsize,i,j,k) i + isize*(j + jsize*k)
#endif
#ifndef INDEX4
#define INDEX4(isize,jsize,ksize,i,j,k,x) i + isize*(j + jsize*(k + ksize*x))
#endif
#ifndef INDEX5
#define INDEX5(isize,jsize,ksize,xsize,i,j,k,x,y) i + isize*(j + jsize*(k + ksize*(x + xsize*y)))
#endif
#ifndef NDIM
#define NDIM 3
#endif
#ifndef NGLLX
#define NGLLX 5
#endif
#ifndef NGLL2
#define NGLL2 25
#endif
#ifndef NGLL3
#define NGLL3 125
#endif
#ifndef NGLL3_PADDED
#define NGLL3_PADDED 128
#endif
#ifndef N_SLS
#define N_SLS 3
#endif
#ifndef IREGION_CRUST_MANTLE
#define IREGION_CRUST_MANTLE 1
#endif
#ifndef IREGION_INNER_CORE
#define IREGION_INNER_CORE 3
#endif
#ifndef IFLAG_IN_FICTITIOUS_CUBE
#define IFLAG_IN_FICTITIOUS_CUBE 11
#endif
#ifndef R_EARTH_KM
#define R_EARTH_KM 6371.0f
#endif
#ifndef COLORING_MIN_NSPEC_INNER_CORE
#define COLORING_MIN_NSPEC_INNER_CORE 1000
#endif
#ifndef COLORING_MIN_NSPEC_OUTER_CORE
#define COLORING_MIN_NSPEC_OUTER_CORE 1000
#endif
#ifndef BLOCKSIZE_TRANSFER
#define BLOCKSIZE_TRANSFER 256
#endif
__global__ void compute_stacey_elastic_kernel(const float * veloc, float * accel, const int interface_type, const int num_abs_boundary_faces, const int * abs_boundary_ispec, const int * nkmin_xi, const int * nkmin_eta, const int * njmin, const int * njmax, const int * nimin, const int * nimax, const float * abs_boundary_normal, const float * abs_boundary_jacobian2D, const float * wgllwgll, const int * ibool, const float * rho_vp, const float * rho_vs, const int SAVE_FORWARD, float * b_absorb_field){
int igll;
int iface;
int i;
int j;
int k;
int iglob;
int ispec;
float vx;
float vy;
float vz;
float vn;
float nx;
float ny;
float nz;
float rho_vp_temp;
float rho_vs_temp;
float tx;
float ty;
float tz;
float jacobianw;
float fac1;
igll = threadIdx.x;
iface = blockIdx.x + (blockIdx.y) * (gridDim.x);
if (iface < num_abs_boundary_faces) {
ispec = abs_boundary_ispec[iface] - (1);
switch (interface_type) {
case 0 :
if (nkmin_xi[INDEX2(2, 0, iface)] == 0 || njmin[INDEX2(2, 0, iface)] == 0) {
return ;
}
i = 0;
k = (igll) / (NGLLX);
j = igll - ((k) * (NGLLX));
if (k < nkmin_xi[INDEX2(2, 0, iface)] - (1) || k > NGLLX - (1)) {
return ;
}
if (j < njmin[INDEX2(2, 0, iface)] - (1) || j > NGLLX - (1)) {
return ;
}
fac1 = wgllwgll[(k) * (NGLLX) + j];
break;
case 1 :
if (nkmin_xi[INDEX2(2, 1, iface)] == 0 || njmin[INDEX2(2, 1, iface)] == 0) {
return ;
}
i = NGLLX - (1);
k = (igll) / (NGLLX);
j = igll - ((k) * (NGLLX));
if (k < nkmin_xi[INDEX2(2, 1, iface)] - (1) || k > NGLLX - (1)) {
return ;
}
if (j < njmin[INDEX2(2, 1, iface)] - (1) || j > njmax[INDEX2(2, 1, iface)] - (1)) {
return ;
}
fac1 = wgllwgll[(k) * (NGLLX) + j];
break;
case 2 :
if (nkmin_eta[INDEX2(2, 0, iface)] == 0 || nimin[INDEX2(2, 0, iface)] == 0) {
return ;
}
j = 0;
k = (igll) / (NGLLX);
i = igll - ((k) * (NGLLX));
if (k < nkmin_eta[INDEX2(2, 0, iface)] - (1) || k > NGLLX - (1)) {
return ;
}
if (i < nimin[INDEX2(2, 0, iface)] - (1) || i > nimax[INDEX2(2, 0, iface)] - (1)) {
return ;
}
fac1 = wgllwgll[(k) * (NGLLX) + i];
break;
case 3 :
if (nkmin_eta[INDEX2(2, 1, iface)] == 0 || nimin[INDEX2(2, 1, iface)] == 0) {
return ;
}
j = NGLLX - (1);
k = (igll) / (NGLLX);
i = igll - ((k) * (NGLLX));
if (k < nkmin_eta[INDEX2(2, 1, iface)] - (1) || k > NGLLX - (1)) {
return ;
}
if (i < nimin[INDEX2(2, 1, iface)] - (1) || i > nimax[INDEX2(2, 1, iface)] - (1)) {
return ;
}
fac1 = wgllwgll[(k) * (NGLLX) + i];
break;
}
iglob = ibool[INDEX4(NGLLX, NGLLX, NGLLX, i, j, k, ispec)] - (1);
vx = veloc[(iglob) * (3) + 0];
vy = veloc[(iglob) * (3) + 1];
vz = veloc[(iglob) * (3) + 2];
nx = abs_boundary_normal[INDEX3(NDIM, NGLL2, 0, igll, iface)];
ny = abs_boundary_normal[INDEX3(NDIM, NGLL2, 1, igll, iface)];
nz = abs_boundary_normal[INDEX3(NDIM, NGLL2, 2, igll, iface)];
vn = (vx) * (nx) + (vy) * (ny) + (vz) * (nz);
rho_vp_temp = rho_vp[INDEX4(NGLLX, NGLLX, NGLLX, i, j, k, ispec)];
rho_vs_temp = rho_vs[INDEX4(NGLLX, NGLLX, NGLLX, i, j, k, ispec)];
tx = ((rho_vp_temp) * (vn)) * (nx) + (rho_vs_temp) * (vx - ((vn) * (nx)));
ty = ((rho_vp_temp) * (vn)) * (ny) + (rho_vs_temp) * (vy - ((vn) * (ny)));
tz = ((rho_vp_temp) * (vn)) * (nz) + (rho_vs_temp) * (vz - ((vn) * (nz)));
jacobianw = (abs_boundary_jacobian2D[INDEX2(NGLL2, igll, iface)]) * (fac1);
atomicAdd(accel + (iglob) * (3) + 0, ( -(tx)) * (jacobianw));
atomicAdd(accel + (iglob) * (3) + 1, ( -(ty)) * (jacobianw));
atomicAdd(accel + (iglob) * (3) + 2, ( -(tz)) * (jacobianw));
if (SAVE_FORWARD) {
b_absorb_field[INDEX3(NDIM, NGLL2, 0, igll, iface)] = (tx) * (jacobianw);
b_absorb_field[INDEX3(NDIM, NGLL2, 1, igll, iface)] = (ty) * (jacobianw);
b_absorb_field[INDEX3(NDIM, NGLL2, 2, igll, iface)] = (tz) * (jacobianw);
}
}
}
|
21,140 | /******************************************************************************
* File: gpgpuPrimes.cu
*
* Authors: Savoy Schuler
*
* Date: November 2, 2016
*
* Functions Included:
*
* gpuProperties
* countPrimes <kernel>
* isPrime <kernal>
* gpgpuSearch
*
* Description:
*
* This files contains all functions needed for parallelizing a range
* inclusive prime number count using GPGPU, Cuda, and an Nvidia graphics
* card. Thie file contains one hose function that calls two kernels on the
* device; one to check if a number is a prime (storing a 1 on an
* associative array if true) and one to count the number of 1's in an
* array in parallel.
*
* Modified: Original
*
*
******************************************************************************/
/**************************** Library Includes *******************************/
#include <iostream>
#include <string.h>
#include <cstdlib>
#include <ctime>
#include <iomanip>
#include <chrono>
/******************************* Name Space **********************************/
using namespace std;
/******************************************************************************
* Author: Savoy Schuler
*
* Function: gpuProperties
*
* Description:
*
* This function get GPU device information and prints it to the terminal.
*
* Parameters: None
*
******************************************************************************/
int gpuProperties()
{
//Variable for storing the number of GPU devices.
int devCount;
//Get the number of GPU devices.
cudaGetDeviceCount(&devCount);
//Get and print the properties for each device to the terminal.
for(int i = 0; i < devCount; ++i)
{
//Get GPU device properties.
cudaDeviceProp props;
cudaGetDeviceProperties(&props, i);
//GPU device name
cout << "GPGPU: " << props.name << ", CUDA "
//Cuda version
<< props.major << "." << props.minor
//Global memory
<< ", " << props.totalGlobalMem / 1048576
<< " Mbytes global memory, "
//Number of Cuda cores
<< props.maxThreadsDim[1] << " CUDA cores" << endl;
}
//Note successful completion of function.
return 0;
}
/******************************************************************************
* Author: Savoy Schuler
*
* Function: countPrimes
*
* Description:
*
* This function allows counting the number of primes found to be done in
* parallel.
*
* countPrimes is a Cuda kernel that uses the GPU to sum indices in the first
* half of an array with the respective indices in the second half of the
* array. The purpose of this kernel is to be called in a loop that decreases
* the passed in size of the array by half each time. This will let the kernel
* sum the first and second half of the array, then the first and second
* quarter of the array, then the first and second eighth og the array, etc.,
* until the first element of the post-process array holds the sum of the
* original.
*
* Parameters:
*
* *d_primeArray - Pointer to the device memory allocated to hold an array
* where the contents of the array indices represent
* whether or not a number was found to be prime.
*
* arraySize - The working size of the primeArray.
*
******************************************************************************/
__global__ void countPrimes( int *d_primeArray, int arraySize)
{
/*Index the thread number. Add 1 to avoid errors caused by multiplying zero
by half the array size. Note that this does mean subtracting one from i when
indexing d_primeArray.*/
int i = threadIdx.x + blockIdx.x * blockDim.x+1;
//Case for even length arrays.
if ((arraySize % 2) == 0)
{
//Perform addition only if i is in the first half of the array.
if ( i <= arraySize/2 )
{
/*Add the contents at an array index in the first half of an array
to the contents at the same index in the second half of the array.
Store results at index i in the first half of the array.*/
d_primeArray[i-1] += d_primeArray[(i-1)+arraySize/2];
}
}
//Case for odd length arrays.
else
{
/*Perform the same operation as above, but only for elements less than
half the size of the array. This is done because the array is an odd
length and including the index at half the size of the array (with
integer division) will cause trying to add an index that is out of the
scope of the working array.*/
if ( i*2 < arraySize)
{
/*Add the contents at an array index in the first half of an array
to the contents at the same index in the second half of the array.
Store results at index i in the first half of the array.*/
d_primeArray[i-1] += d_primeArray[(i-1)+(arraySize+1)/2];
}
}
/*Because d_primeArray is stored on the GPU, it can be copied back to the
host by referecing its address in memory and the size of the working
array.*/
}
/******************************************************************************
* Author: Savoy Schuler
*
* Function: isPrime
*
* Description:
*
* This function allows checking which numbers in a range are prime to be done
* in parallel on a GPU using fine and course grain parallelizing.
*
* isPrime is a Cuda kernel that dedicates each block on a GPU to checking the
* primality of an individual element (course grain parallelizing).
*
* Within each block, the allocated threads available are used to check if the
* number is divisible by any numbers between 2 and element/2. If there are
* more divisors to search than threads, the divisors wrap around the threads
* so that each thread checks a set of divisors (this is the element of fine
* grain parallelizing).
*
* If any divisors for a number are found, the number's location in the results
* array (d_primeArray) is set to 0 to indicate that it was found to be not
* prime. Any elements still set to 1 by the end of the search are prime.
*
* Parameters:
*
* *d_primeArray - Pointer to the device memory allocated for holding an
* array the size of the search range. Presently filled
* with zeros. At the end of the search, any numbers that
* are prime will have their index in the array set to one.
*
* lowNum - Lowerbound of inclusive prime search.
*
* highNum - Upperbound of inclusive prime search.
*
******************************************************************************/
__global__ void isPrime( int *d_primeArray, int lowNum, int highNum)
{
//Dedicate the block to checking one number in the search range.
int i = blockIdx.x + lowNum;
/* Dedicate each thread to checking one possible divisor of the integer
being examined by the block. */
int divisor = threadIdx.x + 2;
/*Wrap the divisors to check around the number of threads until the possible
divisors (from 2 to element/2) have been checked. */
for (int div = divisor ; div <= i/2 ; div = div + blockDim.x)
{
//If the divisor evenly divides the element being checked...
if ( i % div == 0 )
{
/*Set that element's result in the results array to 0 to indicate
that is has been found to be not prime.*/
d_primeArray[i-lowNum] = 0;
}
}
//End thread.
}
/******************************************************************************
* Author: Savoy Schuler
*
* Function: gpgpuSearch
*
* Description:
*
* This function functions acts as a main for running prime search in parallel
* on a GPU.
*
* gpgpuSearch is divided into three sections. First, the function sets up host
* and device variables needed for searching for the number of primes in a
* given range. Second, it calls Cuda kernels to find and sum the number of
* primes in the search range. Last, the function will free host and device
* memory allocations.
*
* The memory addresses for holding the number of primes
* found are declared in main and passed to functions for updating.
*
* Parameters:
*
* lowNum - Lowerbound of inclusive prime search.
*
* highNum - Upperbound of inclusive prime search.
*
* *gpgpuCount - Address of location in memory to store number of primes found.
*
******************************************************************************/
int gpgpuSearch( int lowNum, int highNum, int *gpgpuCount )
{
/*--------------------------------Set Up----------------------------------*/
//Store the numerical value of the range of the inclusive search.
int n = highNum - lowNum+1;
//Set up kernels to run on GPU with specified numner of threads per block.
//Reminder: Threads should be a multiple of 32 up to 1024
//Best timing found with thread count of:
int nThreads = 1024;
/*Set the the number of blocks so that nThreads*nBlocks is greater than but
as close to n as possible (while still being a multiple of 32). This
guarantees the program will have enough threads for the search while
"wasting" as few as possible, i.e. threads that will be indexed to be
greater than the upper bound of the search.*/
int nBlocks = ( n + nThreads - 1 ) / nThreads;
/*Allocate host memory for an array to store values 0 or 1 for all numbers
in the range to be checked (Where 1 denotes prime, 0 not prime).*/
int size = n * sizeof( int );
int *primeArray = ( int * )malloc( size );
//Set up the results array to be filled with default value 1.
for ( int i = 0; i < n; i++ )
primeArray[i] = 1;
/*If the search range includes 0 and 1 or 1, set their corresponding result
array values to 0 as these numbers do not get checked as they are
ineligible for being considered prime.*/
if ( lowNum == 0 )
{
primeArray[0] = 0;
primeArray[1] = 0;
}
else if ( lowNum == 1 ) primeArray[0] = 0;
//Allocate device memory for the device copy of primeArray.
int *d_primeArray;
cudaMalloc( ( void ** )&d_primeArray, size );
//Copy primeArray to device (presently filled with zeros).
cudaMemcpy( d_primeArray, primeArray, size, cudaMemcpyHostToDevice );
/*-------------------------GPGPU Prime Search-----------------------------*/
/* This program uses course grain and fine grain parallelizing techniques.
For the search, each number in the search range gets its own dedicated block
for searching (this is the course grain parallelizing). Within each block,
the allocated threads available are used to check if the number is divisible
by any numbers between 2 and element/2. If there are more divisors to search
than threads, the divisors wrap around the threads so that each thread
checks a set of divisors (this is the element of fine grain parallelizing).
If any divisors for a number are found, the number's location in the results
array (d_primeArray) is set to 0 to indicate that it was found to be not
prime. Any elements still set to 1 by the end of the search are prime. */
isPrime<<< n, nThreads >>>(d_primeArray, lowNum, highNum);
//Wait for kernel completion before proceeding.
cudaError_t cudaerror = cudaDeviceSynchronize();
/* The number of primes found must be counted. This is accomplished in
parallel by using a for loop around the countPrimes kernel. This for loop
will pass the working size of the results array to the device and the kernel
will generate a thread for each number in the first half of the array. These
threads are used to add the contents of their index in the first half of
d_primeArray to the contents of the thread's respective index in the second
half of d_PrimeArray, storing the result in the original index in the
first half of the array.
At each iteration, the for loop with half the working size of the array
until the sum of the original is stored in the first element (the [0]
index.) */
for (int arraySize = n; arraySize > 1; arraySize -= arraySize/2)
{
nBlocks = ( arraySize/2 + nThreads - 1 ) / nThreads;
countPrimes<<< nBlocks, nThreads >>>(d_primeArray, arraySize);
//Wait for kernel completion before proceeding.
cudaError_t cudaerror = cudaDeviceSynchronize();
}
/*Copy the first element of the results array back to the host to retrieve
the count of primes. */
cudaMemcpy( primeArray, d_primeArray, sizeof(int), cudaMemcpyDeviceToHost );
//Store the sum of primes at the address passed in from main.
*gpgpuCount = primeArray[0];
/*-----------------------------Clean Up-----------------------------------*/
//Clean up allocated memory on host.
free( primeArray );
//Clean up allocated memory on device.
cudaFree( d_primeArray );
//Note successful completion of program.
return 0;
}
|
21,141 | /* Daniel Willen, 2019
*
* Solve the transient heat conduction problem with homogeneous Dirichlet
* boundary conditions:
*
* u(x={0,L}) = u(y={0,L}) = 0
*
* and initial condition:
*
* u(x,y,0) = sin(x) * sin(y)
*
* on the domain 0 <= x,y <= L, with L = pi.
*
* This program solves the above problem on a single GPU with the Jacobi method.
*
*/
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <math.h>
#include <cuda.h>
#include <thrust/device_ptr.h>
#include <thrust/reduce.h>
#define PI 3.14159265358979323846
#define MAX_THREADS_DIM 16 // Note that this depends on the hardware
/* Note on the structure of this file:
* - Cuda device constant memory declarations are at the top
* - Functions definitions are in the middle. Functions include:
* - - parse_cmdline: Read command-line arguments for domain size
* - - jacobi_solver: Advance the soln to the next time step using Jacobi
* - - check_error: Calculate the error b/t the numeric and analytic solns
* - The `main' function is at the bottom
*
* Note that it is good practice to use header files and break functions out
* into separate files. This has not been done here for simplicity.
*/
/*** Auxiliary Functions ***/
/* Read the command line inputs */
// - argv[0] is the program name
// - argv[1] is the first input (number of points)
int parse_cmdline(int argc, char *argv[]) {
int nx;
if (argc == 2) {
nx = atoi(argv[1]); // Number of grid points
if (nx < MAX_THREADS_DIM) {
printf("Expecting a number of grid cells in one dimension to be at least %d\n", MAX_THREADS_DIM);
exit(EXIT_FAILURE);
}
printf("Grid is %d by %d\n\n", nx, nx);
} else {
printf("Input error. Run like: \n\n");
printf(" $ ./parallel.c n\n\n");
printf(" where n is the number of grid cells in one dimension\n");
exit(EXIT_FAILURE);
}
return nx;
}
/*******************************************************************************
* Step IV: Launch the GPU kernel to advance to the next time step with the *
* Jacobi method here. *
******************************************************************************/
__global__ void computeNextJacobiStep(int nx, int ny, double pref, double* _u, double* _u_new) {
int ti = blockDim.x * blockIdx.x + threadIdx.x;
int tj = blockDim.y * blockIdx.y + threadIdx.y;
if (ti < (nx-1) && ti > 0 && tj < (ny-1) && tj > 0) {
double leftTerm = _u[tj*nx + ti];
double rightTerm = pref * (
_u[tj*nx + (ti+1)] +
_u[tj*nx + (ti-1)] +
_u[(tj+1)*nx + ti] +
_u[(tj-1)*nx + ti] -
4*_u[tj*nx + ti]
);
_u_new[tj*nx + ti] = leftTerm + rightTerm;
}
}
/******************************************************************************
* Step V: Launch the GPU kernel to calculate the error at each grid point *
* here. *
*****************************************************************************/
__global__ void computeJacobiError(int nx, int ny, double dx, double dy, double D, double t, double* _u, double* _error) {
int ti = blockDim.x * blockIdx.x + threadIdx.x;
int tj = blockDim.y * blockIdx.y + threadIdx.y;
if (ti < (nx-1) && ti > 0 && tj < (ny-1) && tj > 0) {
double discretizedValue = _u[tj*nx + ti];
double analyticalValue = sin(dx * ti)*sin(dy * tj)*exp(-2*D*t);
_error[tj*nx + ti] = abs(discretizedValue - analyticalValue);
}
}
/*** Main Function ***/
int main(int argc, char *argv[])
{
/* Variable declaration */
double Lx = PI; // Domain length in x-direction
double Ly = PI; // Domain length in y-direction
double D = 1.; // Diffusion constant
int nx, ny; // Grid points (grid cells + 1)
double dx, dy; // Grid spacing
double dt; // Time step size
double sim_time; // Length of sim time, arbitrary for simplicity
double pref; // Pre-factor in the Jacobi method
double error = 0.; // Mean percent-difference at each grid point
error = error; // To prevent compiler warning
/* Parse command-line for problem size */
nx = parse_cmdline(argc, argv);
ny = nx; // Assume a square grid
/* Initialize variables */
dx = Lx / (nx - 1); // Cell width in x-direction
dy = Ly / (ny - 1); // Cell width in y-direction
dt = 0.25*dx*dy/D; // Limited by diffusive stability
sim_time = 0.5*Lx*Ly/D; // Arbitrary simulation length
pref = D*dt/(dx*dx); // Jacobi pre-factor
/*****************************************************************************
* Step I: Declare, allocate, and initialize memory for the field variable *
* u on the CPU. *
****************************************************************************/
double* u = (double*) malloc(nx*ny * sizeof(double));
for (int j = 0; j < ny; ++j) {
for (int i = 0; i < nx; ++i) {
u[j*nx + i] = sin(i * dx) * sin(j * dy);
}
}
/*****************************************************************************
* Step II: Declare and allocate GPU memory for _u, _u_new, and _error. Copy *
* the initial condition to the GPU. *
****************************************************************************/
double *_u, *_u_new, *_error;
cudaMalloc(&_u, nx*ny * sizeof(double));
cudaMemcpy(_u, u, nx*ny * sizeof(double), cudaMemcpyHostToDevice);
cudaMalloc(&_u_new, nx*ny * sizeof(double));
cudaMalloc(&_error, nx*ny * sizeof(double));
// Set the new soln and error to 0
cudaMemset(_u_new, 0., nx*ny * sizeof(double));
cudaMemset(_error, 0., nx*ny * sizeof(double));
// Create thrust pointers to device memory for error calculation
thrust::device_ptr<double> t_error(_error);
/*****************************************************************************
* Step III: Set up the kernel execution configuration for the domain based *
* on the input domain size and the MAX_THREADS_DIM variable. *
****************************************************************************/
int tx = MAX_THREADS_DIM;
int ty = MAX_THREADS_DIM;
int bx = (int) ceil((double) nx / tx);
int by = (int) ceil((double) ny / ty);
dim3 dimBlocks(tx, ty);
dim3 numBlocks(bx, by);
/***************************/
/* Main Time-Stepping Loop */
/***************************/
for (double time = 0.; time <= sim_time; time += dt) {
/***************************************************************************
* Step IV: Launch the GPU kernel to advance to the next time step with *
* the Jacobi method here. *
**************************************************************************/
computeNextJacobiStep<<<numBlocks, dimBlocks>>>(nx, ny, pref, _u, _u_new);
cudaDeviceSynchronize();
/***************************************************************************
* Step V: Launch the GPU kernel to calculate the error at each grid point *
* here. *
**************************************************************************/
computeJacobiError<<<numBlocks, dimBlocks>>>(nx, ny, dx, dy, D, time, _u, _error);
cudaDeviceSynchronize();
// Use thrust to do a parallel reduction on the error
error = thrust::reduce(t_error, t_error + nx*ny, 0., thrust::plus<double>());
printf("Error at t* = %.5lf is %e\n", time*D/(Lx*Lx), error/(nx*ny));
// Copy new soln to old. This also blocks to ensure computations are finished.
cudaMemcpy(_u, _u_new, nx*ny * sizeof(double), cudaMemcpyDeviceToDevice);
}
/*****************************************************************************
* Step VI: Copy the memory back to the CPU. *
****************************************************************************/
cudaMemcpy(u, _u, nx*ny * sizeof(double), cudaMemcpyDeviceToHost);
/*****************************************************************************
* Step I and Step II: Free the memory that you declared and allocated *
* earlier in the program. *
****************************************************************************/
free(u);
cudaFree(_u);
cudaFree(_u_new);
cudaFree(_error);
return EXIT_SUCCESS;
}
|
21,142 | #include "includes.h"
__global__ void FilmGradeKernelD( float* p_Input, float* p_Output, int p_Width, int p_Height, float p_Pivot, int p_Display) {
const int x = blockIdx.x * blockDim.x + threadIdx.x;
const int y = blockIdx.y * blockDim.y + threadIdx.y;
float height = p_Height;
float width = p_Width;
float X = x;
float Y = y;
const float RES = width / 1920.0f;
float overlay = 0.0f;
if (x < p_Width && y < p_Height) {
const int index = (y * p_Width + x) * 4;
if (p_Display == 1) {
overlay = Y / height >= p_Pivot && Y / height <= p_Pivot + 0.005f * RES ? (fmodf(X, 2.0f) != 0.0f ? 1.0f : 0.0f) :
p_Output[index] >= (Y - 5.0f * RES) / height && p_Output[index] <= (Y + 5.0f * RES) / height ? 1.0f : 0.0f;
p_Output[index] = overlay;
}
if (p_Display == 2) {
overlay = Y / height >= p_Pivot && Y / height <= p_Pivot + 0.005f * RES ? (fmodf(X, 2.0f) != 0.0f ? 1.0f : 0.0f) :
p_Input[index] >= (Y - 5.0f * RES) / height && p_Input[index] <= (Y + 5.0f * RES) / height ? 1.0f : 0.0f;
p_Output[index] = overlay == 0.0f ? p_Output[index] : overlay;
}}} |
21,143 | /*
hello world : add two vectors
*/
#include <stdio.h>
/* ceiling `m' to `n' (returns the smallest `A' such n*A is not less
than `m') */
#define ceiln(m, n) ( ((m) + (n) - 1)/(n) )
/* a common kernel execution configuration */
#define k_cnf(n) ceiln((n), 128), 128
#define n 5 /* number of elements */
float h_A[n], h_B[n], h_C[n]; /* host */
float *d_A, *d_B, *d_C; /* device */
#define sz ((n)*sizeof(h_A[0]))
__global__ void add(float *A, float *B, float *C) {
int i = blockDim.x * blockIdx.x + threadIdx.x;
if (i < n) C[i] = A[i] + B[i];
}
void h_ini() {
int i;
for (i = 0; i < n; ++i) {
h_A[i] = i;
h_B[i] = 10*i;
}
}
void d_ini() {
cudaMalloc(&d_A, sz);
cudaMalloc(&d_B, sz);
cudaMalloc(&d_C, sz);
}
void h2d() {
cudaMemcpy(d_A, h_A, sz, cudaMemcpyHostToDevice);
cudaMemcpy(d_B, h_B, sz, cudaMemcpyHostToDevice);
}
void d2h() {
cudaMemcpy(h_C, d_C, sz, cudaMemcpyDeviceToHost);
}
int main() {
h_ini();
d_ini();
h2d();
add<<<k_cnf(n)>>>(d_A, d_B, d_C);
d2h();
int i;
for (i = 0; i < n; i++)
printf("c[%d] = %2g\n", i, h_C[i]);
}
|
21,144 |
/* This is a automatically generated test. Do not modify */
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
__global__
void compute(float comp, int var_1,int var_2,float var_3,float var_4,float var_5,float var_6,float var_7,float var_8,float var_9,float var_10,float var_11,float var_12,float* var_13,float* var_14,float var_15,float var_16,float var_17,float var_18,float* var_19,float var_20,float var_21,float var_22) {
comp = +1.9693E-12f * (-1.6217E-27f - var_3);
float tmp_1 = -1.1476E20f;
float tmp_2 = -1.4052E17f;
comp = tmp_2 - tmp_1 + atan2f(+1.0054E35f, -1.1269E16f);
if (comp >= (var_4 / +0.0f - -1.2436E25f)) {
comp += (+1.3861E-17f / var_5 - var_6);
comp += (+1.4150E35f + +1.4644E26f - (var_7 - (var_8 - acosf(var_9 + var_10))));
float tmp_3 = -1.5285E35f;
comp += tmp_3 * var_11 / var_12;
}
for (int i=0; i < var_1; ++i) {
var_13[i] = logf((+1.9498E-22f - (var_15 - (+0.0f - -0.0f + (+1.0670E34f - var_16)))));
var_14[i] = +0.0f;
comp += var_14[i] - var_13[i] - var_17 * coshf((var_18 - +1.3579E-36f + +1.9518E-43f));
}
for (int i=0; i < var_2; ++i) {
var_19[i] = +1.0360E-42f;
comp += var_19[i] / var_20 + var_21 / (var_22 + -1.4828E-36f);
}
printf("%.17g\n", comp);
}
float* initPointer(float v) {
float *ret = (float*) malloc(sizeof(float)*10);
for(int i=0; i < 10; ++i)
ret[i] = v;
return ret;
}
int main(int argc, char** argv) {
/* Program variables */
float tmp_1 = atof(argv[1]);
int tmp_2 = atoi(argv[2]);
int tmp_3 = atoi(argv[3]);
float tmp_4 = atof(argv[4]);
float tmp_5 = atof(argv[5]);
float tmp_6 = atof(argv[6]);
float tmp_7 = atof(argv[7]);
float tmp_8 = atof(argv[8]);
float tmp_9 = atof(argv[9]);
float tmp_10 = atof(argv[10]);
float tmp_11 = atof(argv[11]);
float tmp_12 = atof(argv[12]);
float tmp_13 = atof(argv[13]);
float* tmp_14 = initPointer( atof(argv[14]) );
float* tmp_15 = initPointer( atof(argv[15]) );
float tmp_16 = atof(argv[16]);
float tmp_17 = atof(argv[17]);
float tmp_18 = atof(argv[18]);
float tmp_19 = atof(argv[19]);
float* tmp_20 = initPointer( atof(argv[20]) );
float tmp_21 = atof(argv[21]);
float tmp_22 = atof(argv[22]);
float tmp_23 = atof(argv[23]);
compute<<<1,1>>>(tmp_1,tmp_2,tmp_3,tmp_4,tmp_5,tmp_6,tmp_7,tmp_8,tmp_9,tmp_10,tmp_11,tmp_12,tmp_13,tmp_14,tmp_15,tmp_16,tmp_17,tmp_18,tmp_19,tmp_20,tmp_21,tmp_22,tmp_23);
cudaDeviceSynchronize();
return 0;
}
|
21,145 | #include <stdio.h>
#include <sys/time.h>
#include <cuda.h>
const int THREADS = 512;
static void CudaTest(const char *msg)
{
cudaError_t e;
cudaDeviceSynchronize();
if (cudaSuccess != (e = cudaGetLastError())) {
fprintf(stderr, "%s: %d\n", msg, e);
fprintf(stderr, "%s\n", cudaGetErrorString(e));
exit(-1);
}
}
__global__ void matrixMult(const int N, int part, double *d_A, double *d_B, double *d_C)
{
int index = threadIdx.x + blockIdx.x * blockDim.x;
double pSum = 0.0;
if (index < part * N)
{
int r = index / N;
int c = index % N;
for (int i = 0; i < N; i++) {
pSum += d_A[r * N + i] * d_B[i * N + c];
}
d_C[index] = pSum;
}
}
int main(int argc, char* argv[])
{
if(argc != 3) {fprintf(stderr, "usage: <exe>, size_of_array, num_groups\n"); exit(-1);}
const int N = atoi(argv[1]);
double *d_A, *d_B, *d_C; //device variables
cudaDeviceProp prop;
cudaGetDeviceProperties(&prop, 0);
printf("Running on %s\n", prop.name);
//timing
struct timeval start, end;
double runtime = 0.0, total = 0.0;
const int factor = atoi(argv[2]);
int part = N / factor;
//allocate on CPU
double *arrayA = (double *)malloc(N * N * sizeof(double));
double *arrayB = (double *)malloc(N * N * sizeof(double));
double *arrayC = (double *)malloc(N * N * sizeof(double));
//fill array inputs on CPU
for (int i = 0; i < N; i++)
for (int j = 0; j < N; j++) {
arrayA[i * N + j] = (i * N + j) + rand() % 100000 / 100000.0;
arrayB[i * N + j] = 2 * rand() % 100000 / 100000.0;
}
//allocate space on GPU
cudaMalloc((void**) &d_A, part * N * sizeof(double)); CudaTest("failed allocation");
cudaMalloc((void**) &d_B, N * N * sizeof(double)); CudaTest("failed allocation");
cudaMalloc((void**) &d_C, part * N * sizeof(double)); CudaTest("failed allocation");
cudaMemcpy(d_B, &arrayB, N * N * sizeof(double), cudaMemcpyHostToDevice); CudaTest("failed to send data to GPU");
for(int i = 0; i < factor; i++) {
//send part data to GPU for MM
cudaMemcpy(d_A, &arrayA[(i * part) * N], part * N * sizeof(double), cudaMemcpyHostToDevice); CudaTest("failed to send data to GPU");
//run first kernel
gettimeofday(&start, NULL);
matrixMult<<<((part * N + THREADS -1)/THREADS), THREADS>>> (N, part, d_A, d_B, d_C); CudaTest("failed kernel");
gettimeofday(&end, NULL);
runtime = end.tv_sec + (end.tv_usec / 1000000.0) - start.tv_sec - (start.tv_usec / 1000000.0);
total += runtime;
//send part data back to CPU for MM
cudaMemcpy(&arrayC[(i * part) * N], d_C, part * N * sizeof(double), cudaMemcpyDeviceToHost); CudaTest("failed to send data back");
}
printf("\nCompute time for Matrix Multiply: %.4f s\n", total);
/*
//check result
for (int i = 0; i < N; i++)
for(int j = 0; j < N; j++)
{
printf("Array C: %.2lf \n", arrayC[i * N + j]);
printf("Array B: %.2lf \n", arrayB[i * N + j]);
}
*/
//free memory
cudaFree(d_A); cudaFree(d_B); cudaFree(d_C);
free(arrayA); free(arrayB); free(arrayC);
return 0;
}
|
21,146 | #include <cuda.h>
#include <cuda_runtime.h>
#include <time.h>
#include <algorithm>
#include <iostream>
#include <cuda_fp16.h>
using namespace std;
#define N 32 * 1024 * 1024
// elementwise implementation copyed from https://github.com/Oneflow-Inc/oneflow/blob/master/oneflow/core/cuda/elementwise.cuh
constexpr int kBlockSize = 256;
constexpr int kNumWaves = 32;
inline cudaError_t GetNumBlocks(int64_t n, int* num_blocks) {
int dev;
{
cudaError_t err = cudaGetDevice(&dev);
if (err != cudaSuccess) { return err; }
}
int sm_count;
{
cudaError_t err = cudaDeviceGetAttribute(&sm_count, cudaDevAttrMultiProcessorCount, dev);
if (err != cudaSuccess) { return err; }
}
int tpm;
{
cudaError_t err = cudaDeviceGetAttribute(&tpm, cudaDevAttrMaxThreadsPerMultiProcessor, dev);
if (err != cudaSuccess) { return err; }
}
*num_blocks = std::max<int>(1, std::min<int64_t>((n + kBlockSize - 1) / kBlockSize,
sm_count * tpm / kBlockSize * kNumWaves));
return cudaSuccess;
}
template<typename T, int pack_size>
struct GetPackType {
using type = typename std::aligned_storage<pack_size * sizeof(T), pack_size * sizeof(T)>::type;
};
template<typename T, int pack_size>
using PackType = typename GetPackType<T, pack_size>::type;
template<typename T, int pack_size>
union Pack {
static_assert(sizeof(PackType<T, pack_size>) == sizeof(T) * pack_size, "");
__device__ Pack() {
// do nothing
}
PackType<T, pack_size> storage;
T elem[pack_size];
};
template<typename T, int pack_size>
struct alignas(sizeof(T) * pack_size) Packed {
__device__ Packed() {
// do nothing
}
union {
T elem[pack_size];
};
};
constexpr int kMaxPackBytes = 128 / 8;
constexpr int kMaxPackSize = 8;
constexpr int Min(int a, int b) { return a < b ? a : b; }
template<typename T>
constexpr int PackSize() {
return Min(kMaxPackBytes / sizeof(T), kMaxPackSize);
}
template<typename T, typename U, typename... Args>
constexpr int PackSize() {
return Min(PackSize<T>(), PackSize<U, Args...>());
}
template<typename T>
class HasApply2 {
typedef char one;
struct two {
char x[2];
};
template<typename C>
static one test(decltype(&C::Apply2));
template<typename C>
static two test(...);
public:
enum { value = sizeof(test<T>(0)) == sizeof(char) };
};
template<int pack_size, typename FunctorT, typename R, typename... IN>
__device__ typename std::enable_if<HasApply2<FunctorT>::value == true && pack_size % 2 == 0,
Packed<R, pack_size>>::type
ApplyPack(const FunctorT& functor, const Packed<IN, pack_size>... in) {
Packed<R, pack_size> ret;
#pragma unroll
for (int j = 0; j < pack_size; j += 2) { functor.Apply2(ret.elem + j, (in.elem + j)...); }
return ret;
}
template<int pack_size, typename FunctorT, typename R, typename... IN>
__device__ typename std::enable_if<HasApply2<FunctorT>::value == false || pack_size % 2 != 0,
Packed<R, pack_size>>::type
ApplyPack(const FunctorT& functor, const Packed<IN, pack_size>... in) {
Packed<R, pack_size> ret;
#pragma unroll
for (int j = 0; j < pack_size; ++j) { ret.elem[j] = functor((in.elem[j])...); }
return ret;
}
template<int pack_size, typename FactoryT, typename R, typename... IN>
__global__ void __launch_bounds__(kBlockSize)
ApplyGeneric(FactoryT factory, int64_t n_pack, Packed<R, pack_size>* pack_r,
const Packed<IN, pack_size>*... pack_in, int64_t n_tail, R* tail_r,
const IN*... tail_in) {
auto functor = factory();
const int global_tid = blockIdx.x * kBlockSize + threadIdx.x;
for (int64_t i = global_tid; i < n_pack; i += blockDim.x * gridDim.x) {
pack_r[i] = ApplyPack<pack_size, decltype(functor), R, IN...>(functor, (pack_in[i])...);
}
if (global_tid < n_tail) { tail_r[global_tid] = functor((tail_in[global_tid])...); }
}
template<typename FunctorT>
struct SimpleFactory {
explicit SimpleFactory(FunctorT functor) : tpl(functor) {}
__device__ FunctorT operator()() const { return tpl; }
private:
FunctorT tpl;
};
template<size_t pack_size>
bool IsAlignedForPack() {
return true;
}
template<size_t pack_size, typename T, typename... Args>
bool IsAlignedForPack(const T* ptr, const Args*... others) {
return reinterpret_cast<uintptr_t>(ptr) % sizeof(Pack<T, pack_size>) == 0
&& IsAlignedForPack<pack_size, Args...>(others...);
}
template<size_t pack_size, typename FactoryT, typename R, typename... IN>
cudaError_t LaunchKernel(FactoryT factory, int64_t n, R* r, const IN*... in) {
const int64_t n_pack = n / pack_size;
const int64_t tail_offset = n_pack * pack_size;
const int64_t n_tail = n - tail_offset;
int num_blocks;
{
cudaError_t err = GetNumBlocks(n_pack, &num_blocks);
if (err != cudaSuccess) { return err; }
}
ApplyGeneric<pack_size, FactoryT, R, IN...><<<num_blocks, kBlockSize, 0>>>(
factory, n_pack, reinterpret_cast<Packed<R, pack_size>*>(r),
(reinterpret_cast<const Packed<IN, pack_size>*>(in))..., n_tail, r + tail_offset,
(in + tail_offset)...);
return cudaPeekAtLastError();
}
template<typename FactoryT, typename R, typename... IN>
struct GenericLauncher {
static cudaError_t Launch(FactoryT factory, int64_t n, R* r, const IN*... in) {
constexpr int max_pack_size = PackSize<R, IN...>();
if (IsAlignedForPack<max_pack_size, R, IN...>(r, in...)) {
return LaunchKernel<max_pack_size, FactoryT, R, IN...>(factory, n, r, in...);
} else {
return LaunchKernel<1, FactoryT, R, IN...>(factory, n, r, in...);
}
}
};
template<typename FactoryT, typename R, typename A>
inline cudaError_t UnaryWithFactory(FactoryT factory, int64_t n, R* r, const A* a) {
return GenericLauncher<FactoryT, R, A>::Launch(factory, n, r, a);
}
template<typename FunctorT, typename R, typename A>
inline cudaError_t Unary(FunctorT functor, int64_t n, R* r, const A* a) {
return UnaryWithFactory(SimpleFactory<FunctorT>(functor), n, r, a);
}
template<typename FactoryT, typename R, typename A, typename B>
inline cudaError_t BinaryWithFactory(FactoryT factory, int64_t n, R* r, const A* a, const B* b) {
return GenericLauncher<FactoryT, R, A, B>::Launch(factory, n, r, a, b);
}
template<typename FunctorT, typename R, typename A, typename B>
inline cudaError_t Binary(FunctorT functor, int64_t n, R* r, const A* a, const B* b) {
return BinaryWithFactory(SimpleFactory<FunctorT>(functor), n, r, a, b);
}
template<typename FactoryT, typename R, typename A, typename B, typename C>
inline cudaError_t TernaryWithFactory(FactoryT factory, int64_t n, R* r, const A* a, const B* b,
const C* c) {
return GenericLauncher<FactoryT, R, A, B, C>::Launch(factory, n, r, a, b, c);
}
template<typename FunctorT, typename R, typename A, typename B, typename C>
inline cudaError_t Ternary(FunctorT functor, int64_t n, R* r, const A* a, const B* b, const C* c) {
return TernaryWithFactory(SimpleFactory<FunctorT>(functor), n, r, a, b, c);
}
template<typename T>
struct MultiplyFunctor {
__device__ T operator()(T x, T y) const {
return x*y;
}
};
template<>
struct MultiplyFunctor<half> {
__device__ half operator()(half x, half y) const {
return x*y;
}
#if (__CUDA_ARCH__ >= 750 && CUDA_VERSION >= 11000)
__device__ void Apply2(half* z, const half* x, const half* y) const {
const half2 x2 = *(reinterpret_cast<const half2*>(x));
const half2 y2 = *(reinterpret_cast<const half2*>(y));
*reinterpret_cast<half2*>(z) = __hmul2(x2, y2);
}
#endif // (__CUDA_ARCH__ >= 750 && CUDA_VERSION >= 11000)
};
template<typename T>
__global__ void mul(T *x, T *y, T* z){
int idx = threadIdx.x + blockIdx.x * blockDim.x;
z[idx] = x[idx] * y[idx];
}
template<>
__global__ void mul(half *x, half *y, half* z){
int idx = threadIdx.x + blockIdx.x * blockDim.x;
z[idx] = x[idx] * y[idx];
}
int main(){
half *x_host = (half*)malloc(N*sizeof(half));
half *x_device;
cudaMalloc((void **)&x_device, N*sizeof(half));
for (int i = 0; i < N; i++) x_host[i] = 2.0;
cudaMemcpy(x_device, x_host, N*sizeof(half), cudaMemcpyHostToDevice);
half *y_host = (half*)malloc(N*sizeof(half));
half *y_device;
cudaMalloc((void **)&y_device, N*sizeof(half));
for (int i = 0; i < N; i++) y_host[i] = 2.0;
cudaMemcpy(y_device, y_host, N*sizeof(half), cudaMemcpyHostToDevice);
half *output_host = (half*)malloc(N * sizeof(half));
half *output_device;
cudaMalloc((void **)&output_device, N * sizeof(half));
// naive elementwise
int32_t block_num = (N + kBlockSize - 1) / kBlockSize;
dim3 grid(block_num, 1);
dim3 block(kBlockSize, 1);
mul<half><<<grid, block>>>(x_device, y_device, output_device);
cudaMemcpy(output_host, output_device, N * sizeof(half), cudaMemcpyDeviceToHost);
// elementwise template
Binary(MultiplyFunctor<half>(), N, output_device, x_device, y_device);
cudaMemcpy(output_host, output_device, N * sizeof(half), cudaMemcpyDeviceToHost);
free(x_host);
free(y_host);
free(output_host);
cudaFree(x_device);
cudaFree(y_device);
cudaFree(output_device);
return 0;
}
// float dtype
// int main(){
// float *x_host = (float*)malloc(N*sizeof(float));
// float *x_device;
// cudaMalloc((void **)&x_device, N*sizeof(float));
// for (int i = 0; i < N; i++) x_host[i] = 2.0;
// cudaMemcpy(x_device, x_host, N*sizeof(float), cudaMemcpyHostToDevice);
// float *y_host = (float*)malloc(N*sizeof(float));
// float *y_device;
// cudaMalloc((void **)&y_device, N*sizeof(float));
// for (int i = 0; i < N; i++) y_host[i] = 2.0;
// cudaMemcpy(y_device, y_host, N*sizeof(float), cudaMemcpyHostToDevice);
// float *output_host = (float*)malloc(N * sizeof(float));
// float *output_device;
// cudaMalloc((void **)&output_device, N * sizeof(float));
// // naive elementwise
// int32_t block_num = (N + kBlockSize - 1) / kBlockSize;
// dim3 grid(block_num, 1);
// dim3 block(kBlockSize, 1);
// mul<float><<<grid, block>>>(x_device, y_device, output_device);
// cudaMemcpy(output_host, output_device, N * sizeof(float), cudaMemcpyDeviceToHost);
// // elementwise template
// Binary(MultiplyFunctor<float>(), N, output_device, x_device, y_device);
// cudaMemcpy(output_host, output_device, N * sizeof(float), cudaMemcpyDeviceToHost);
// free(x_host);
// free(y_host);
// free(output_host);
// cudaFree(x_device);
// cudaFree(y_device);
// cudaFree(output_device);
// return 0;
// }
|
21,147 | // Output of "python3 circuit2.py prefix_sum.crc" is pasted in as the kernel
// along with some boilerplate code to test this out.
// Expected output: "0 1 3 6 10 15 21 28\n".
#include <iostream>
__global__ void kogge_stone(int *x0, int *x1){
int tid = threadIdx.x;
x1[tid] = x0[tid];
switch(tid){
case 1:
x1[1] += x0[0];
break;
case 2:
x1[2] += x0[1];
break;
case 3:
x1[3] += x0[2];
break;
case 4:
x1[4] += x0[3];
break;
case 5:
x1[5] += x0[4];
break;
case 6:
x1[6] += x0[5];
break;
case 7:
x1[7] += x0[6];
break;
}
__syncthreads();
x0[tid] = x1[tid];
switch(tid){
case 2:
x0[2] += x1[0];
break;
case 3:
x0[3] += x1[1];
break;
case 4:
x0[4] += x1[2];
break;
case 5:
x0[5] += x1[3];
break;
case 6:
x0[6] += x1[4];
break;
case 7:
x0[7] += x1[5];
break;
}
__syncthreads();
x1[tid] = x0[tid];
switch(tid){
case 4:
x1[4] += x0[0];
break;
case 5:
x1[5] += x0[1];
break;
case 6:
x1[6] += x0[2];
break;
case 7:
x1[7] += x0[3];
break;
}
__syncthreads();
x0[tid] = x1[tid];
switch(tid){
}
}
int main(){
int *x;
x = (int *) malloc(8 * sizeof(int));
for(int i = 0; i < 8; i++){
x[i] = i;
}
int *d_x0, *d_x1;
cudaMalloc(&d_x0, 8 * sizeof(int));
cudaMalloc(&d_x1, 8 * sizeof(int));
cudaMemcpy(d_x0, x, 8 * sizeof(int), cudaMemcpyHostToDevice);
kogge_stone<<<1, 8>>>(d_x0, d_x1);
cudaDeviceSynchronize();
cudaMemcpy(x, d_x0, 8 * sizeof(int), cudaMemcpyDeviceToHost);
for(int i = 0; i < 8; i++){
std::cout << x[i] << ' ';
}
std::cout << '\n';
}
|
21,148 | #include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <time.h>
#include <cuda.h>
// Thread block size
#define BLOCK_SIZE 64
// Size of Array
#define SOA 512
// Allocates an array with random integer entries.
void randomInit(int* data, int size)
{
for (int i = 0; i < size; ++i)
data[i] = rand()%size;
}
__global__ void ReductionMin2(int *input, int *results, int n) //take thread divergence into account
{
__shared__ int sdata[BLOCK_SIZE];
unsigned int i = blockIdx.x * blockDim.x + threadIdx.x;
unsigned int tx = threadIdx.x;
//load input into __shared__ memory
int x = -INT_MAX;
if(i < n)
x = input[i];
sdata[tx] = x;
__syncthreads();
// block-wide reduction
for(unsigned int offset = blockDim.x>>1; offset > 0; offset >>= 1)
{
__syncthreads();
if(tx < offset)
{
if(sdata[tx + offset] < sdata[tx])
sdata[tx] = sdata[tx + offset];
}
}
// finally, thread 0 writes the result
if(threadIdx.x == 0)
{
// the result is per-block
results[blockIdx.x] = sdata[0];
}
}
// get global max element via per-block reductions
int main()
{
int num_blocks = SOA / BLOCK_SIZE;
int num_threads=BLOCK_SIZE,i;
//allocate host memory for array a
unsigned int mem_size_a = sizeof(int) * SOA;
int* h_a = (int*)malloc(mem_size_a);
//initialize host memory
randomInit(h_a,SOA);
//allocate device memory
int* d_a;
cudaMalloc((void**) &d_a, mem_size_a);
//copy host memory to device
cudaMemcpy(d_a, h_a, mem_size_a, cudaMemcpyHostToDevice);
//allocate device memory for temporary results
unsigned int mem_size_b = sizeof(int) * num_blocks;
int* d_b;
cudaMalloc((void**) &d_b, mem_size_b);
int* h_b = (int*)malloc(mem_size_b);
//allocate device memory for final result
unsigned int mem_size_c = sizeof(int) ;
int* d_c;
cudaMalloc((void**) &d_c, mem_size_c);
//setup execution parameters
//dim3 block(1,BLOCK_SIZE);
//dim3 grid(4,4);
//execute the kernel
//first reduce per-block partial maxs
ReductionMin2<<<num_blocks, num_threads>>>(d_a,d_b,SOA);
cudaMemcpy(h_b, d_b, mem_size_b, cudaMemcpyDeviceToHost);
//then reduce partial maxs to a final max
ReductionMin2<<<1, num_blocks>>>(d_b,d_c,num_blocks);
// allocate host memory for the result
int* h_c = (int*)malloc(mem_size_c);
//copy final result from device to host
cudaMemcpy(h_c, d_c, mem_size_c, cudaMemcpyDeviceToHost);
//print the result
for(i=0;i<SOA;i++)
{
printf("%d\t",h_a[i]);
}
printf("\n");
for(i=0;i<num_blocks;i++)
{
printf("%d\t",h_b[i]);
}
//print Final result
printf("\nparallel min =%d\t",*h_c);
//clean up memory
free(h_a);
free(h_c);
cudaFree(d_a);
cudaFree(d_b);
cudaFree(d_c);
cudaThreadExit();
}
|
21,149 | //#include "opencv2/highgui/highgui.hpp"
//#include <cstdio>
//#include <time.h>
//#include <sstream>
//#include <iostream>
//
//using namespace cv;
//using namespace std;
//
//#define MAX_THREADS_BY_BLOCK 1024
//#define DIM_BLOCK_X 32
//#define DIM_BLOCK_Y 32
//
//__device__ int cuGPos(int y, int x, int cuCols) {
// return y * cuCols + x;
//}
//
//__global__ void cudaConvolutionImage(int *cuPoRows, int *cuPoCols, int *cuInImage, int *cuResImage, int* sizeKer, float* kernel){
// int threadIdGlob = threadIdx.x + blockIdx.x * blockDim.x;
//
// int cuRows = *cuPoRows;
// int cuCols = *cuPoCols;
//
// if (threadIdGlob < cuRows * cuCols) {
// int y = threadIdGlob / cuCols;
// int x = threadIdGlob % cuCols;
// float pixel = 0;
// for (int i = (*sizeKer) / -2; i <= (*sizeKer) / 2; i++) {
// for (int j = (*sizeKer) / -2; j <= (*sizeKer) / 2; j++) {
// if (y + j >= 0 && x + i >= 0) {
// pixel += cuInImage[cuGPos(y + j, x + i, cuCols)] * kernel[(j + (*sizeKer / 2)*(*sizeKer) + (i + (*sizeKer / 2)))];
// }
// }
// }
//
// pixel = pixel > 255 ? 255 : pixel;
// pixel = pixel < 0 ? 0 : pixel;
// cuResImage[cuGPos(y, x, cuCols)] = pixel;
// if (cuResImage[cuGPos(y, x, cuCols)] == 0 && x == 0 && y == 0)
// printf("es igual de cero\n");
// }
//}
//
//Mat generateConvolutionCUDAGrayImage(Mat inMatIn, float** kernel, int siKe, string nameFile) {
// Mat inMatImage = inMatIn.clone();
// float time = 0.0;
// int nRows = inMatImage.rows;
// int nCols = inMatImage.cols;
//
// cudaEvent_t start, stop;
// cudaEventCreate(&start);
// cudaEventCreate(&stop);
//
// int* inImage = new int[nRows * nCols];
// float* kerArray = new float[siKe * siKe];
//
// for (int x = 0; x < nCols; x++)
// for (int y = 0; y < nRows; y++)
// inImage[y*nCols + x] = 0;
//
// // split in RedGreenBlue channels
// for (int y = 0; y < nRows; y++){
// for (int x = 0; x < nCols; x++){
// inImage[y * nCols + x] = inMatImage.at<uchar>(y, x);
// }
// }
//
// //gen array1d of kernel
// for (int i = 0; i < siKe; i++)
// for (int j = 0; j< siKe; j++){
// kerArray[i*siKe + j] = kernel[i][j];
// }
//
// int *cuPoRows, *cuPoCols, *cuN, *cuInImage, *cuResImage;
// float* cuKernel;
//
//
// cudaEventRecord(start, 0);
// cudaMalloc((void**)&cuPoRows, sizeof(int));
// cudaMalloc((void**)&cuPoCols, sizeof(int));
// cudaMalloc((void**)&cuN, sizeof(int));
// cudaMalloc((void**)&cuKernel, siKe * siKe * sizeof(float));
// cudaMalloc((void**)&cuInImage, nCols * nRows * sizeof(int));
// cudaMalloc((void**)&cuResImage, nCols * nRows * sizeof(int));
//
// cudaMemcpy(cuPoRows, &nRows, sizeof(int), cudaMemcpyHostToDevice);
// cudaMemcpy(cuPoCols, &nCols, sizeof(int), cudaMemcpyHostToDevice);
// cudaMemcpy(cuN, &siKe, sizeof(int), cudaMemcpyHostToDevice);
// cudaMemcpy(cuKernel, kerArray, siKe * siKe * sizeof(float), cudaMemcpyHostToDevice);
// cudaMemcpy(cuInImage, inImage, nCols * nRows * sizeof(int), cudaMemcpyHostToDevice);
//
// int N = nRows * nCols;
// dim3 blockDim(MAX_THREADS_BY_BLOCK, 1, 1);
// dim3 gridDim((N + MAX_THREADS_BY_BLOCK - 1) / MAX_THREADS_BY_BLOCK, 1, 1);
//
// cudaConvolutionImage << <gridDim, blockDim >> >(cuPoRows, cuPoCols, cuInImage, cuResImage, cuN, cuKernel);
//
// cudaMemcpy(inImage, cuResImage, nRows * nCols * sizeof(int), cudaMemcpyDeviceToHost);
//
// cudaFree(cuPoRows);
// cudaFree(cuPoCols);
// cudaFree(cuN);
// cudaFree(cuKernel);
// cudaFree(cuInImage);
// cudaFree(cuResImage);
//
// cudaEventRecord(stop, 0);
// cudaEventSynchronize(stop);
// cudaEventElapsedTime(&time, start, stop);
// cudaEventDestroy(start);
// cudaEventDestroy(stop);
//
// for (int y = 0; y < nRows; y++)
// for (int x = 0; x < nCols; x++)
// inMatImage.at<uchar>(y, x) = inImage[y*nCols + x];
//
// printf("%f \t", time / 1000.0);
// return inMatImage;
//}
//
//Mat generateConvolutionCUDARGBImage(Mat inMatImage, float** kernel, int siKe, string nameFile){
// float time = 0.0;
// int nRows = inMatImage.rows;
// int nCols = inMatImage.cols;
//
// cudaEvent_t start, stop;
// cudaEventCreate(&start);
// cudaEventCreate(&stop);
//
// int** inImage = new int*[3];
// float* kerArray = new float[siKe * siKe];
// for (int i = 0; i < 3; i++)
// inImage[i] = new int[nRows * nCols];
//
// Mat bgr[3];
// split(inMatImage, bgr);
//
// // split in RedGreenBlue channels
// for (int y = 0; y < nRows; y++){
// for (int x = 0; x < nCols; x++){
// inImage[0][y * nCols + x] = bgr[0].at<uchar>(y, x);
// inImage[1][y * nCols + x] = bgr[1].at<uchar>(y, x);
// inImage[2][y * nCols + x] = bgr[2].at<uchar>(y, x);
// }
// }
//
// //gen array1d of kernel
// for (int i = 0; i < siKe; i++)
// for (int j = 0; j< siKe; j++)
// kerArray[i*siKe + j] = kernel[i][j];
//
// int *cuPoRows, *cuPoCols, *cuN;
// int *cuInImageR, *cuInImageG, *cuInImageB;
// int *cuResImageR, *cuResImageG, *cuResImageB;
// float *cuKernel;
//
// cudaEventRecord(start, 0);
// cudaMalloc((void**)&cuPoRows, sizeof(int));
// cudaMalloc((void**)&cuPoCols, sizeof(int));
// cudaMalloc((void**)&cuN, sizeof(int));
// cudaMalloc((void**)&cuKernel, siKe * siKe * sizeof(float));
// cudaMalloc((void**)&cuInImageR, nCols * nRows * sizeof(int));
// cudaMalloc((void**)&cuInImageG, nCols * nRows * sizeof(int));
// cudaMalloc((void**)&cuInImageB, nCols * nRows * sizeof(int));
// cudaMalloc((void**)&cuResImageR, nCols * nRows * sizeof(int));
// cudaMalloc((void**)&cuResImageG, nCols * nRows * sizeof(int));
// cudaMalloc((void**)&cuResImageB, nCols * nRows * sizeof(int));
//
// cudaMemcpy(cuPoRows, &nRows, sizeof(int), cudaMemcpyHostToDevice);
// cudaMemcpy(cuPoCols, &nCols, sizeof(int), cudaMemcpyHostToDevice);
// cudaMemcpy(cuN, &siKe, sizeof(int), cudaMemcpyHostToDevice);
// cudaMemcpy(cuKernel, kerArray, siKe * siKe * sizeof(int), cudaMemcpyHostToDevice);
// cudaMemcpy(cuInImageB, inImage[0], nCols * nRows * sizeof(int), cudaMemcpyHostToDevice);
// cudaMemcpy(cuInImageG, inImage[1], nCols * nRows * sizeof(int), cudaMemcpyHostToDevice);
// cudaMemcpy(cuInImageR, inImage[2], nCols * nRows * sizeof(int), cudaMemcpyHostToDevice);
//
// int N = nRows * nCols;
// int nBloq = (N + MAX_THREADS_BY_BLOCK - 1) / MAX_THREADS_BY_BLOCK;
//
// dim3 blockDim(DIM_BLOCK_X, DIM_BLOCK_Y, 1);
// dim3 gridDim(nBloq, 1, 1);
//
// cudaConvolutionImage << <gridDim, blockDim >> >(cuPoRows, cuPoCols, cuInImageB, cuResImageB, cuN, cuKernel);
// cudaConvolutionImage << <gridDim, blockDim >> >(cuPoRows, cuPoCols, cuInImageG, cuResImageG, cuN, cuKernel);
// cudaConvolutionImage << <gridDim, blockDim >> >(cuPoRows, cuPoCols, cuInImageR, cuResImageR, cuN, cuKernel);
//
// cudaMemcpy(cuInImageB, inImage[0], nRows * nCols * sizeof(int), cudaMemcpyDeviceToHost);
// cudaMemcpy(cuInImageG, inImage[1], nRows * nCols * sizeof(int), cudaMemcpyDeviceToHost);
// cudaMemcpy(cuInImageR, inImage[2], nRows * nCols * sizeof(int), cudaMemcpyDeviceToHost);
//
// cudaFree(cuPoRows);
// cudaFree(cuPoCols);
// cudaFree(cuN);
// cudaFree(cuKernel);
// cudaFree(cuInImageB);
// cudaFree(cuInImageG);
// cudaFree(cuInImageR);
// cudaFree(cuResImageB);
// cudaFree(cuResImageG);
// cudaFree(cuResImageR);
//
// cudaEventRecord(stop, 0);
// cudaEventSynchronize(stop);
// cudaEventElapsedTime(&time, start, stop);
// cudaEventDestroy(start);
// cudaEventDestroy(stop);
//
// for (int y = 0; y < nRows; y++)
// for (int x = 0; x < nCols; x++){
// bgr[0].at<uchar>(y, x) = inImage[0][y*nCols + x];
// bgr[1].at<uchar>(y, x) = inImage[0][y*nCols + x];
// bgr[2].at<uchar>(y, x) = inImage[0][y*nCols + x];
// }
// merge(bgr, 3, inMatImage);
// printf("Convolucin de CUDA RGB Image:%s Mascara: %d Tiempo %f\n", nameFile.c_str(), siKe, time / 1000.0);
// return inMatImage;
//}
//
//string intToString(int n){
// ostringstream ss;
// ss << n;
// string a = n <= 9 ? "0" : "";
// return a + ss.str();
//}
//
//
//int main111() {
// string path = "D://temp//convolution//";
// string imagens[15] = { "gordo.jpg"};
// string dirOut[15] = { "tekken"};
//
// // string imagens[2] = {"wallPaper08.jpeg"};
// // string dirOut[1] = {"wallPaper08"};
//
// int arrayKernel[13] = { 3, 5, 9, 13, 19, 25, 31, 39, 47, 57, 67, 75, 85 };
// int nImages = 15, nKernels = 13;
//
// for (int i = 0; i < nImages; i++) {
// Mat inMatGrayImage = imread(path + imagens[i], CV_LOAD_IMAGE_GRAYSCALE);
// printf("%s,%dx%d,%ld \n", imagens[i].c_str(), inMatGrayImage.rows, inMatGrayImage.cols, (long)inMatGrayImage.cols * (long)inMatGrayImage.rows);
// imwrite(path + dirOut[i] + "/grayScale" + imagens[i], inMatGrayImage);
// for (int j = 0; j < nKernels; j++) {
// float **kernel = new float*[arrayKernel[j]];
// for (int k = 0; k < arrayKernel[j]; k++) {
// kernel[k] = new float[arrayKernel[j]];
// for (int l = 0; l < arrayKernel[j]; l++)
// kernel[k][l] = 1.0 / (arrayKernel[j] * arrayKernel[j]);
// }
// Mat outMatImage = generateConvolutionCUDAGrayImage(inMatGrayImage, kernel, arrayKernel[j], imagens[i]);
// string fullpath = path + dirOut[i] + "//grayCuda_" + intToString(arrayKernel[j]) + "_" + imagens[i];
// cout << "kernel : " << arrayKernel[j] << " - fullpath : " << fullpath << endl;
// imwrite(fullpath, outMatImage);
// }
// printf("\n");
// }
//
// return 0;
//}
|
21,150 | #include "matrix.cuh"
__device__ matrix_t* device_matrix_constructor(buffer_t* buffer, unsigned int rows, unsigned int cols)
{
//assert(rows > 0 && cols > 0);
matrix_t* m = (matrix_t*)buffer_malloc(buffer, sizeof(matrix_t) + sizeof(float) * rows * cols);
m->rows = rows;
m->cols = cols;
device_set_matrix(m, 0.0);
return m;
}
__device__ matrix_t* device_matrix_add(buffer_t* buffer, matrix_t* m1, matrix_t* m2)
{
//assert(m1 != NULL && m2 != NULL);
//assert(m1->rows > 0 && m2->rows > 0 && m1->cols > 0 && m2->cols > 0);
//assert(m1->rows == m2->rows && m1->cols == m2->cols);
matrix_t* sum = device_matrix_constructor(buffer, m1->rows, m1->cols);
int i, j;
for(i=0; i<m1->rows; i++)
{
for(j=0; j<m1->cols; j++)
{
device_matrix_set(sum, i, j, device_matrix_get(m1, i, j) + device_matrix_get(m2, i, j));
}
}
return sum;
}
__device__ matrix_t* device_matrix_subtract(buffer_t* buffer, matrix_t* m1, matrix_t* m2)
{
//assert(m1 != NULL && m2 != NULL);
//assert(m1->rows > 0 && m2->rows > 0 && m1->cols > 0 && m2->cols > 0);
//assert(m1->rows == m2->rows && m1->cols == m2->cols);
matrix_t* difference = device_matrix_constructor(buffer, m1->rows, m1->cols);
int i, j;
for(i=0; i<m1->rows; i++)
{
for(j=0; j<m1->cols; j++)
{
device_matrix_set(difference, i, j, device_matrix_get(m1, i, j) - device_matrix_get(m2, i , j));
}
}
return difference;
}
__device__ matrix_t* device_matrix_multiply(buffer_t* buffer, matrix_t* m1, matrix_t* m2)
{
if(!(m1->rows > 0 && m2->rows > 0 && m1->cols > 0 && m2->cols > 0))
{
//printf("%d %d %d %d", m1->rows, m2->rows, m1->cols, m2->cols);
}
//assert(m1 != NULL && m2 != NULL);
//assert(m1->rows > 0 && m2->rows > 0 && m1->cols > 0 && m2->cols > 0);
//assert(m1->cols == m2->rows);
matrix_t* product = device_matrix_constructor(buffer, m1->rows, m2->cols);
int i, j, k;
for(i=0; i<product->rows; i++)
{
for(j=0; j<product->cols; j++)
{
for(k=0; k<m1->cols; k++)
{
device_matrix_set(product, i, j, device_matrix_get(product, i, j) + device_matrix_get(m1, i, k) * device_matrix_get(m2, k, j));
}
}
}
return product;
}
__device__ matrix_t* device_matrix_scalar_multiply(buffer_t* buffer, matrix_t* m, float scalar)
{
//assert(m!= NULL);
//assert(m->rows > 0 && m->cols > 0);
matrix_t* product = device_matrix_constructor(buffer, m->rows, m->cols);
int i, j;
for(i=0; i<m->rows; i++)
{
for(j=0; j<m->cols; j++)
{
device_matrix_set(product, i, j, device_matrix_get(m, i, j) * scalar);
}
}
return product;
}
__device__ matrix_t* device_matrix_sigmoid(buffer_t* buffer, matrix_t* m)
{
matrix_t* copy = device_copy_matrix(buffer, m);
int i, j;
for(i=0; i<m->rows; i++)
{
for(j=0; j<m->cols; j++)
{
device_matrix_set(copy, i, j, 1.0 / (1.0 + exp(-1.0 * device_matrix_get(copy, i, j))));
}
}
return copy;
}
__device__ matrix_t* device_matrix_sigmoid_gradient(buffer_t* buffer, matrix_t* m)
{
float sig;
matrix_t* copy = device_copy_matrix(buffer, m);
int i, j;
for(i=0; i<m->rows; i++)
{
for(j=0; j<m->cols; j++)
{
sig = 1.0 / (1.0 + exp(-1.0 * device_matrix_get(copy, i, j)));
device_matrix_set(copy, i, j, sig * (1-sig));
}
}
return copy;
}
__device__ matrix_t* device_matrix_square(buffer_t* buffer, matrix_t* m)
{
matrix_t* copy = device_copy_matrix(buffer, m);
int i, j;
for(i=0; i<m->rows; i++)
{
for(j=0; j<m->cols; j++)
{
device_matrix_set(copy, i, j, pow(device_matrix_get(copy, i, j), 2));
}
}
return copy;
}
__device__ matrix_t* device_matrix_cell_multiply(buffer_t* buffer, matrix_t* m1, matrix_t* m2)
{
//assert(m1 != NULL && m2 != NULL);
//assert(m1->rows > 0 && m2->rows > 0 && m1->cols > 0 && m2->cols > 0);
//assert(m1->rows == m2->rows && m1->cols == m2->cols);
matrix_t* product = device_matrix_constructor(buffer, m1->rows, m1->cols);
int i, j;
for(i=0; i<m1->rows; i++)
{
for(j=0; j<m1->cols; j++)
{
device_matrix_set(product, i, j, device_matrix_get(m1, i, j) * device_matrix_get(m2, i , j));
}
}
return product;
}
__device__ matrix_t* device_matrix_transpose(buffer_t* buffer, matrix_t* m)
{
//assert(m!= NULL);
//assert(m->rows > 0 && m->cols > 0);
matrix_t* transpose = device_copy_matrix(buffer, m);
transpose->rows = m->cols;
transpose->cols = m->rows;
int i, j;
for(i=0; i<m->rows; i++)
{
for(j=0; j<m->cols; j++)
{
device_matrix_set(transpose, j, i, device_matrix_get(m, i, j));
}
}
return transpose;
}
__device__ matrix_t* device_copy_matrix(buffer_t* buffer, matrix_t* m)
{
matrix_t* copy = device_matrix_constructor(buffer, m->rows, m->cols);
memcpy(copy->matrix, m->matrix, sizeof(float)*m->rows*m->cols);
return copy;
}
__device__ void device_free_matrix(matrix_t* m)
{
}
__device__ float device_matrix_get(matrix_t* m, unsigned int x, unsigned int y)
{
//assert(m != NULL);
////assert(x >= 0 && x < m->rows && y >= 0 && y < m->cols);
return (m->matrix[x * m->cols + y]);
}
__device__ void device_matrix_set(matrix_t* m, unsigned int x, unsigned int y, float value)
{
//assert(m != NULL);
////assert(x >= 0 && x < m->rows && y >= 0 && y < m->cols);
m->matrix[x * m->cols + y] = value;
}
__device__ void device_set_matrix(matrix_t* m, float val)
{
//assert(m != NULL);
//assert(m->rows > 0 && m->cols > 0);
int i, j;
for(i=0; i<m->rows; i++)
{
for(j=0; j<m->cols; j++)
{
device_matrix_set(m, i, j, val);
}
}
}
__device__ void device_set_matrix_index(matrix_t* m)
{
//assert(m != NULL);
//assert(m->rows > 0 && m->cols > 0);
int i, j;
for(i=0; i<m->rows; i++)
{
for(j=0; j<m->cols; j++)
{
device_matrix_set(m, i, j, i * m->cols + j);
}
}
}
__device__ unsigned int device_matrix_memory_size(matrix_t* m)
{
return sizeof(matrix_t) + sizeof(float) * m->rows * m->cols;
}
__device__ unsigned int device_matrix_list_memory_size(matrix_list_t* m)
{
unsigned int memory_size = sizeof(matrix_list_t);
unsigned int i;
for(i=0; i<m->num; i++)
{
memory_size += device_matrix_memory_size(m->matrix_list[i]);
}
return memory_size;
}
__device__ matrix_t* device_row_to_vector(buffer_t* buffer, matrix_t* m, unsigned int row)
{
matrix_t* v = device_matrix_constructor(buffer, 1, m->cols);
unsigned int i;
for(i=0; i<m->cols; i++)
{
device_vector_set(v, i, device_matrix_get(m, row, i));
}
return v;
}
__device__ matrix_t* device_col_to_vector(buffer_t* buffer, matrix_t* m, unsigned int col)
{
matrix_t* v = device_matrix_constructor(buffer, 1, m->rows);
unsigned int i;
for(i=0; i<m->rows; i++)
{
device_vector_set(v, i, device_matrix_get(m, i, col));
}
return v;
}
__device__ matrix_t* device_matrix_prepend_col(buffer_t* buffer, matrix_t* m, float value)
{
matrix_t* result = device_matrix_constructor(buffer, m->rows, m->cols+1);
unsigned int i, j;
for(i=0; i<result->rows; i++)
{
device_matrix_set(result, i, 0, value);
}
for(i=0; i<m->rows; i++)
{
for(j=0; j<m->cols; j++)
{
device_matrix_set(result, i, j+1, device_matrix_get(m, i, j));
}
}
return result;
}
__device__ matrix_t* device_matrix_remove_col(buffer_t* buffer, matrix_t* m)
{
matrix_t* result = device_matrix_constructor(buffer, m->rows, m->cols-1);
unsigned int i, j;
for(i=0; i<result->rows; i++)
{
for(j=0; j<result->cols; j++)
{
device_matrix_set(result, i, j, device_matrix_get(m, i, j+1));
}
}
return result;
}
__device__ matrix_t* device_matrix_prepend_row(buffer_t* buffer, matrix_t* m, float value)
{
matrix_t* result = device_matrix_constructor(buffer, m->rows+1, m->cols);
unsigned int i, j;
for(i=0; i<result->cols; i++)
{
device_matrix_set(result, 0, i, value);
}
for(i=0; i<m->rows; i++)
{
for(j=0; j<m->cols; j++)
{
device_matrix_set(result, i+1, j, device_matrix_get(m, i, j));
}
}
return result;
}
__device__ matrix_t* device_matrix_remove_row(buffer_t* buffer, matrix_t* m)
{
matrix_t* result = device_matrix_constructor(buffer, m->rows-1, m->cols);
unsigned int i, j;
for(i=0; i<result->rows; i++)
{
for(j=0; j<result->cols; j++)
{
device_matrix_set(result, i, j, device_matrix_get(m, i+1, j));
}
}
return result;
}
__device__ void device_matrix_add_to(matrix_t* m1, matrix_t* m2)
{
int i, j;
for(i=0; i<m1->rows; i++)
{
for(j=0; j<m1->cols; j++)
{
device_matrix_set(m1, i, j, device_matrix_get(m1, i, j) + device_matrix_get(m2, i, j));
}
}
}
|
21,151 | #include "cuda_runtime.h"
#include "device_launch_parameters.h"
//#include "cuda_common.cuh"
#include <cstdio>
#include <cstdlib>
#include <ctime>
#include <cstring>
__global__ void sum_array_gpu(int* a, int* b, int* c, int size)
{
int gid = blockIdx.x * blockDim.x + threadIdx.x;
if (gid < size) {
c[gid] = a[gid] + b[gid];
}
}
void sum_array_cpu(int* a, int* b, int* c, int size)
{
for ( int i = 0;i < size;i++ ) {
c[i] = a[i] + b[i];
}
}
void compare_arrays(int* a, int* b, int size)
{
for ( int i = 0;i < size;i++ ) {
if (a[i] != b[i]) {
printf("Arrays are different!");
return;
}
}
printf("Arrays are same\n");
}
int main(void)
{
int size = 10000;
int block_size = 128;
int NO_BYTES = size * sizeof(int);
// host pointer
int* h_a, *h_b, *gpu_results;
int* h_c;
h_a = (int*)malloc(NO_BYTES);
h_b = (int*)malloc(NO_BYTES);
h_c = (int*)malloc(NO_BYTES);
gpu_results = (int*)malloc(NO_BYTES);
time_t t;
srand((unsigned)time(&t));
for (int i = 0;i < size;i++) {
h_a[i] = (int)(rand() & 0xff);
h_b[i] = (int)(rand() & 0xff);
}
sum_array_cpu(h_a, h_b, h_c, size);
memset(gpu_results, 0, NO_BYTES);
// device pointer
int* d_a, *d_b, *d_c;
cudaMalloc((int**)&d_a, NO_BYTES);
cudaMalloc((int**)&d_b, NO_BYTES);
cudaMalloc((int**)&d_c, NO_BYTES);
cudaMemcpy(d_a, h_a, NO_BYTES, cudaMemcpyHostToDevice);
cudaMemcpy(d_b, h_b, NO_BYTES, cudaMemcpyHostToDevice);
// launching the grid
dim3 block(block_size);
dim3 grid((size / block.x) + 1);
sum_array_gpu<<<grid, block>>> (d_a, d_b, d_c, size);
cudaDeviceSynchronize();
cudaMemcpy(gpu_results, d_c, NO_BYTES, cudaMemcpyDeviceToHost);
// array comparison
compare_arrays(h_c, gpu_results, size);
cudaFree(d_a);
cudaFree(d_b);
cudaFree(d_c);
free(gpu_results);
cudaDeviceReset();
return 0;
}
|
21,152 | #include <iostream>
#include <stdio.h>
#include <ctime>
#define BLOCK_SIZE 256
#define MAX_FLOAT 1.0e+127
#define WARP_SIZE 32
#define DEBUG
#ifdef DEBUG
#define cudaCheckError(ans) { cudaAssert((ans), __FILE__, __LINE__); }
inline void cudaAssert(cudaError_t code, const char *file, int line, bool abort=true)
{
if (code != cudaSuccess)
{
fprintf(stderr, "CUDA Error: %s at %s:%d\n",
cudaGetErrorString(code), file, line);
if (abort) exit(code);
}
}
#else
#define cudaCheckError(ans) ans
#endif
inline __device__ float Min(const float first, const float second) {
if (first < second) {
return first;
}
return second;
}
__global__ void ReduceBlocks(float * out_data, const float * in_data, const size_t data_size) {
extern __shared__ float in_data_shared[];
size_t thread_id_local = threadIdx.x;
size_t thread_id_global = blockIdx.x * 2 * blockDim.x + thread_id_local;
float left_data = MAX_FLOAT;
float right_data = MAX_FLOAT;
if (thread_id_global < data_size) {
left_data = in_data[thread_id_global];
}
if (thread_id_global + blockDim.x < data_size) {
right_data = in_data[thread_id_global + blockDim.x];
}
in_data_shared[thread_id_local] = Min(left_data, right_data);
__syncthreads();
for (size_t stride = blockDim.x / 2; stride > WARP_SIZE; stride >>= 1) {
if (thread_id_local < stride) {
in_data_shared[thread_id_local] = Min(in_data_shared[thread_id_local], in_data_shared[thread_id_local + stride]);
}
__syncthreads();
}
if (thread_id_local < WARP_SIZE) {
in_data_shared[thread_id_local] = Min(in_data_shared[thread_id_local], in_data_shared[thread_id_local + 32]);
in_data_shared[thread_id_local] = Min(in_data_shared[thread_id_local], in_data_shared[thread_id_local + 16]);
in_data_shared[thread_id_local] = Min(in_data_shared[thread_id_local], in_data_shared[thread_id_local + 8]);
in_data_shared[thread_id_local] = Min(in_data_shared[thread_id_local], in_data_shared[thread_id_local + 4]);
in_data_shared[thread_id_local] = Min(in_data_shared[thread_id_local], in_data_shared[thread_id_local + 2]);
in_data_shared[thread_id_local] = Min(in_data_shared[thread_id_local], in_data_shared[thread_id_local + 1]);
}
if (thread_id_local == 0) {
out_data[blockIdx.x] = in_data_shared[0];
}
}
__host__ float ReduceBlockResults(const float * block_reduces, const size_t num_blocks) {
float min = MAX_FLOAT;
for (size_t idx = 0; idx < num_blocks; ++idx) {
min = std::min(block_reduces[idx], min);
}
return min;
}
void TotalReduceGPU(const float * data, float * min, size_t data_size) {
float * d_data;
float * d_block_mins;
size_t num_blocks = ((data_size + 2 * BLOCK_SIZE - 1) / (2 * BLOCK_SIZE));
size_t shared_size = BLOCK_SIZE * sizeof(float);
float * block_mins = (float *) malloc(num_blocks * sizeof(float));
cudaCheckError( cudaMalloc(&d_data, data_size * sizeof(float)) );
cudaCheckError( cudaMalloc(&d_block_mins, num_blocks * sizeof(float)) );
cudaMemcpy(d_data, data, data_size * sizeof(float), cudaMemcpyHostToDevice);
ReduceBlocks<<<num_blocks, BLOCK_SIZE, shared_size>>>(d_block_mins, d_data, data_size);
cudaMemcpy(block_mins, d_block_mins, num_blocks * sizeof(float), cudaMemcpyDeviceToHost);
*min = ReduceBlockResults(block_mins, num_blocks);
cudaFree(d_block_mins);
cudaFree(d_data);
free(block_mins);
}
void TotalReduceCPU(const float * data, float * min, size_t data_size) {
float min_here = MAX_FLOAT;
for (size_t idx = 0; idx < data_size; ++idx) {
min_here = std::min(min_here, data[idx]);
}
*min = min_here;
}
int main(int argc, char * argv[]) {
float * data;
float min;
size_t logsize = atoi(argv[1]);
size_t num_elements = (1 << logsize);
// size_t num_elements = 7;
data = (float *) malloc(num_elements * sizeof(float));
for (size_t idx = 0; idx < num_elements; ++idx) {
data[idx] = -1.0 * idx * idx + 100.0;
}
size_t num_runs = 100;
float runtimes[100];
float gpu_mean = 0.0;
float gpu_std = 0.0;
for (size_t run = 0; run < num_runs; ++run) {
cudaEvent_t start, stop;
cudaEventCreate(&start);
cudaEventCreate(&stop);
// cudaEventRecord(start);
const clock_t begin_time = clock();
TotalReduceGPU(data, &min, num_elements);
float milliseconds = float(clock () - begin_time) / 1000;
// cudaEventRecord(stop);
// cudaEventSynchronize(stop);
// float milliseconds = 0;
// cudaEventElapsedTime(&milliseconds, start, stop);
// std::cout << "GPU run took " << milliseconds << " ms" << std::endl;
runtimes[run] = milliseconds;
gpu_mean += milliseconds / num_runs;
}
std::cout << runtimes[0] << std::endl;
for (size_t run = 0; run < num_runs; ++run) {
gpu_std += (gpu_mean - runtimes[run]) * (gpu_mean - runtimes[run]) / num_runs;
}
gpu_std = sqrt(gpu_std);
/*
float true_answer = 0.0;
bool correct = true;
for (size_t idx = 0; idx < num_elements - 1; ++idx) {
true_answer += idx;
if (true_answer != partial_sums[idx + 1]) {
correct = false;
std::cout << idx << " " << partial_sums[idx + 1] << " " << true_answer << std::endl;
}
}
if (!correct) {
std::cout << "incorrect" << std::endl;
}
*/
float cpu_mean = 0.0;
float cpu_std = 0.0;
for (size_t run = 0; run < num_runs; ++run) {
cudaEvent_t start, stop;
cudaEventCreate(&start);
cudaEventCreate(&stop);
// cudaEventRecord(start);
const clock_t begin_time = clock();
TotalReduceCPU(data, &min, num_elements);
float milliseconds = float(clock () - begin_time) / 1000;
// cudaEventRecord(stop);
// cudaEventSynchronize(stop);
// float milliseconds = 0;
// cudaEventElapsedTime(&milliseconds, start, stop);
// std::cout << "GPU run took " << milliseconds << " ms" << std::endl;
runtimes[run] = milliseconds;
cpu_mean += milliseconds / num_runs;
}
std::cout << runtimes[0] << std::endl;
for (size_t run = 0; run < num_runs; ++run) {
cpu_std += (cpu_mean - runtimes[run]) * (cpu_mean - runtimes[run]) / num_runs;
}
cpu_std = sqrt(cpu_std);
std::cout << num_elements << " " << gpu_mean << " " << gpu_std << " " << cpu_mean << " " << cpu_std << std::endl;
free(data);
return 0;
}
|
21,153 | #include "includes.h"
__global__ void weight_update( int* postsyn_neuron, bool* neuron_in_plasticity_set, float* current_weight, float* weight_divisor, int* d_plastic_synapse_indices, size_t total_number_of_plastic_synapses){
// Global Index
int indx = threadIdx.x + blockIdx.x * blockDim.x;
while (indx < total_number_of_plastic_synapses) {
int idx = d_plastic_synapse_indices[indx];
int postneuron = postsyn_neuron[idx];
if (neuron_in_plasticity_set[postneuron]){
float division_value = weight_divisor[postneuron];
//if (division_value != 1.0)
//printf("%f, %f, %f wat \n", division_value, current_weight[idx], (current_weight[idx] / division_value));
if (division_value != 1.0)
current_weight[idx] /= division_value;
}
indx += blockDim.x * gridDim.x;
}
} |
21,154 | #include "includes.h"
__global__ void mat_transpose_regular_kernel(int *mat, int *res) {
// Square tile
int tile_dim = 32;
// 32 Blocks across for 1024 mat
int blocks_per_row = 32;
int rows_per_block_iter = 64;
// Each iter has 2 "block-rows"
for (int block_iter = 0; block_iter < 16; block_iter++) {
int tile_row = blockIdx.x / blocks_per_row;
int tile_col = blockIdx.x % blocks_per_row;
int intile_row = threadIdx.x / tile_dim;
int intile_col = threadIdx.x % tile_dim;
int my_row = (tile_row * tile_dim) + intile_row + (rows_per_block_iter * block_iter);
int my_col = (tile_col * tile_dim) + intile_col;
res[(my_col * 1024) + my_row] = mat[(my_row * 1024) + my_col];
}
} |
21,155 | extern "C"
__global__
void saxpy2(float a, float *x, float *y, float* r, unsigned int n)
{
for (int i = blockIdx.x * blockDim.x + threadIdx.x;
i < n;
i += blockDim.x * gridDim.x)
{
r[i] = a * x[i] + y[i];
}
} |
21,156 | #include "includes.h"
using namespace std;
/*** Definitions ***/
// Block width for CUDA kernels
#define BW 128
#define RANDOM_SEED -1
#ifdef USE_GFLAGS
#ifndef _WIN32
#define gflags google
#endif
#else
// Constant versions of gflags
#define DEFINE_int32(flag, default_value, description) const int FLAGS_##flag = (default_value)
#define DEFINE_uint64(flag, default_value, description) const unsigned long long FLAGS_##flag = (default_value)
#define DEFINE_bool(flag, default_value, description) const bool FLAGS_##flag = (default_value)
#define DEFINE_double(flag, default_value, description) const double FLAGS_##flag = (default_value)
#define DEFINE_string(flag, default_value, description) const std::string FLAGS_##flag ((default_value))
#endif
__global__ void MSELossBackprop(float *grad_data, float *output, float *target, float *mask, int batch_size)
{
int idx = blockIdx.x * blockDim.x + threadIdx.x;
if (idx >= batch_size)
return;
// const int label_value = static_cast<int>(label[idx]);
// For each item in the batch, decrease the result of the label's value by 1
// diff[idx * num_labels + label_value] -= 1.0f;
if(mask[idx] == -1.0)
grad_data[idx] = 0.05 * (output[idx] - target[idx]);
else if(mask[idx] == 1.0)
grad_data[idx] = 5.0 * (output[idx] - target[idx]);
else
grad_data[idx] = 0.0;
} |
21,157 | extern "C"
__global__ void setValue_kernel()
{
int idx = blockIdx.x * blockDim.x + threadIdx.x;
}
|
21,158 | #include <stdio.h>
#include <time.h>
#define N 100000000
#define THREADS_PER_BLOCK 512
__global__ void gpu_block_add(int *a, int *b, int *c)
{
c[blockIdx.x] = a[blockIdx.x] + b[blockIdx.x];
}
__global__ void gpu_thread_add(int *a, int *b, int *c)
{
c[threadIdx.x] = a[threadIdx.x] + b[threadIdx.x];
}
__global__ void gpu_both_add(int *a, int *b, int *c, int n)
{
int index = threadIdx.x + blockIdx.x * blockDim.x;
if (index < n)
{
c[index] = a[index] + b[index];
}
}
void cpu_add(int *a, int *b, int *c, long n)
{
for (int i = 0; i < n-1; i++)
{
c[i] = a[i] + b[i];
}
}
void random_array(int *a, long n)
{
for (long i = 0; i < n-1; i++)
{
a[i] = rand() % 1000;
}
}
int main(void)
{
int *a, *b, *c;
int *d_a, *d_b, *d_c;
long size = sizeof(int)*N;
clock_t initial, final;
double elapsed;
//Allocate space on host for copies of a, b, and c
a = (int *)malloc(size);
b = (int *)malloc(size);
c = (int *)malloc(size);
//Allocate space on device for copies of a, b, and c
cudaMalloc((void **)&d_a, size);
cudaMalloc((void **)&d_b, size);
cudaMalloc((void **)&d_c, size);
//Initialize a and b with random values
random_array(a, N);
random_array(b, N);
//Copy a and b to device
cudaMemcpy(d_a, a, size, cudaMemcpyHostToDevice);
cudaMemcpy(d_b, b, size, cudaMemcpyHostToDevice);
//Wait for copy to finish before trying to time anything
cudaDeviceSynchronize();
//Comparing only the time taken for the actual addition
//Ignoring the time taken to copy vectors to and from device
printf("\nCPU vs. GPU: Adding Two %dx1 Vectors\n", N);
printf("=================================================\n");
//Add a and b on the device in parallel using only blocks
initial = clock();
gpu_block_add<<<N,1>>>(d_a, d_b, d_c);
cudaDeviceSynchronize(); //Hangs up until device has finished (to get more accurate reading of time for kernel execution)
final = clock();
elapsed = (double)(final - initial) / CLOCKS_PER_SEC;
printf("GPU blocks only:\t\t%.3e seconds\n", elapsed);
//Add a and b on the device in parallel using only threads
initial = clock();
gpu_thread_add<<<1,N>>>(d_a, d_b, d_c);
cudaDeviceSynchronize();
final = clock();
elapsed = (double)(final - initial) / CLOCKS_PER_SEC;
printf("GPU threads only:\t\t%.3e seconds\n", elapsed);
//Add a and b on the device in parallel using blocks and threads
initial = clock();
gpu_both_add<<<(N+THREADS_PER_BLOCK-1)/THREADS_PER_BLOCK,THREADS_PER_BLOCK>>>(d_a, d_b, d_c, N);
cudaDeviceSynchronize();
final = clock();
elapsed = (double)(final - initial) / CLOCKS_PER_SEC;
printf("GPU blocks and threads:\t\t%.3e seconds\n", elapsed);
//Add a and b on the host
initial = clock();
cpu_add(a, b, c, N);
final = clock();
elapsed = (double)(final - initial) / CLOCKS_PER_SEC;
printf("CPU:\t\t\t\t%.3e seconds\n\n", elapsed);
//Free memory
free(a); free(b); free(c);
cudaFree(d_a); cudaFree(d_b); cudaFree(d_c);
return 0;
} |
21,159 | #include "3d-test.cuh"
#include<iostream>
#include<stdio.h>
__host__ __device__
void scalingFunction(int array[]) {
for(int i=0; i<8; i++) {
array[i] = array[i] * 2;
}
}
__host__ __device__
void distributeFunction(int array[],int x,int y){
pencilComputation p2;
for(int z=0; z<8; z++) {
p2.outputMatrix[x][y][z] = p2.pencilVector[z];
}
}
__global__
void pencilComputationFunction(){
pencilComputation p1;
int i = threadIdx.x ;//+ blockIdx.x * blockDim.x;
int j = threadIdx.y ; // + blockIdx.y * blockDim.y;
int z = threadIdx.z;
//for(int k=0; k<8 ; k++) {
//for(int x=0;x <2; x++) {
//for(int y=0; y<2; y++) {
// for(int l=0; l<2; l++) {
printf("%d\t",p1.inputMatrix[i][j][z]);
//}
printf("\n");
//}
// printf("\n********************************************\n"); // }
// p1.pencilVector[k] = p1.inputMatrix[i][j][k];
// }
// scalingFunction(p1.pencilVector);
// distributeFunction(p1.pencilVector,i,j);
// printf("**************************************\n");
}
void pencilComputation::launcher(){
cudaMallocManaged((void**)&inputMatrix,8*sizeof(int));
for(int i=0; i<2; i++) {
for(int j=0; j<2; j++) {
for(int k=0; k<2; k++) {
inputMatrix[i][j][k] = 10;
}
}
}
for(int i=0; i<2; i++) {
for(int j=0; j<2; j++) {
for(int k=0; k<2; k++) {
printf("%d\t",inputMatrix[i][j][k]);
}
printf("\n");
}
printf("\n*********************cu**********************************************\n");}
dim3 grid(1,1,1);
dim3 block(2,2,2);
// #pragma acc enter data copyin(inputMatrix) copyout(outputMatrix)
pencilComputationFunction<<<grid,block>>>();
//pencilComputationFunction<<<1,3>>>();
cudaDeviceSynchronize();
}
|
21,160 | //#pragma comment (lib, "cublas.lib")
//#include "stdio.h"
//#include <cuda.h>
//using namespace std;
//#include <ctime>
//#include "cuda_runtime.h"
//#include "curand_kernel.h"
//#include "device_launch_parameters.h"
//#include <stdio.h>
//#include <stdlib.h>
//
//#include <string>
//#include <iomanip>
//#include <time.h>
//#include <iostream>
//#include <cmath>
//#include <math.h>
//
//#define TRAIN_NUM 60000
//#define TEST_NUM 10000
//#define ROW 28
//#define COL 28
//#define CONV_SIZE 24
//#define POOL_SIZE 12
//#define FC1_SIZE 5
//#define FC2_SIZE 10
//#define CONV_W_SIZE 5
//#define CONV_W_NUM 6
//#define N_STREAM 16
//cudaStream_t* stream;
//float conv_w[CONV_W_NUM][CONV_W_SIZE][CONV_W_SIZE];
//float conv_b[CONV_W_NUM];
//float fc1_b[FC1_SIZE];
//float fc1_w[FC1_SIZE][CONV_W_NUM][POOL_SIZE][POOL_SIZE];
//float fc2_b[FC2_SIZE];
//float fc2_w[FC2_SIZE][FC1_SIZE];
//
//__constant__ float _alpha;
//__constant__ int _minibatch;
//__constant__ int _epochs;
//
//__device__ int _correct_cnt;
//__device__ float _avg_error;
//
//int correct_cnt;
//float avg_error;
//float max_acc;
//
//float alpha = 0.2;
//int epochs = 5;
//int minibatch = 1;
//
//float train_image[TRAIN_NUM][ROW][COL];
//int train_label[TRAIN_NUM];
//float test_image[TEST_NUM][ROW][COL];
//int test_label[TEST_NUM];
//
//__device__ float _train_image[TRAIN_NUM][ROW][COL];
//__device__ int _train_label[TRAIN_NUM];
//__device__ float _test_image[TEST_NUM][ROW][COL];
//__device__ int _test_label[TEST_NUM];
//
//
//
//__device__ float _conv_w[CONV_W_NUM][CONV_W_SIZE][CONV_W_SIZE];
//__device__ float _conv_b[CONV_W_NUM];
//__device__ float _fc1_b[FC1_SIZE];
//__device__ float _fc1_w[FC1_SIZE][CONV_W_NUM][POOL_SIZE][POOL_SIZE];
//__device__ float _fc2_b[FC2_SIZE];
//__device__ float _fc2_w[FC2_SIZE][FC1_SIZE];
//
//__device__ float _input1[N_STREAM][ROW][COL];
//__device__ float _conv_z1[N_STREAM][CONV_W_NUM][CONV_SIZE][CONV_SIZE];
//__device__ float _conv_a1[N_STREAM][CONV_W_NUM][CONV_SIZE][CONV_SIZE];
//
//__device__ float _input[ROW][COL];
//__device__ float _conv_z[CONV_W_NUM][CONV_SIZE][CONV_SIZE];
//__device__ float _conv_a[CONV_W_NUM][CONV_SIZE][CONV_SIZE];
//__device__ int _pool_pos[CONV_W_NUM][POOL_SIZE][POOL_SIZE];
//__device__ float _pool[CONV_W_NUM][POOL_SIZE][POOL_SIZE];
//__device__ float _fc1_z[FC1_SIZE];
//__device__ float _fc1_a[FC1_SIZE];
//__device__ float _fc2_z[FC2_SIZE];
//__device__ float _fc2_a[FC2_SIZE];
//__device__ float _output[FC2_SIZE];
//__device__ int _answer[FC2_SIZE];
//
//__device__ float _conv_dw[CONV_W_NUM][CONV_W_SIZE][CONV_W_SIZE];
//__device__ float _conv_db[CONV_W_NUM];
//__device__ float _fc1_db[FC1_SIZE];
//__device__ float _fc1_dw[FC1_SIZE][CONV_W_NUM][POOL_SIZE][POOL_SIZE];
//__device__ float _fc2_db[FC2_SIZE];
//__device__ float _fc2_dw[FC2_SIZE][FC1_SIZE];
//__device__ float _C[FC2_SIZE];
//__device__ float _fc2_delta[FC2_SIZE];
//__device__ float _fc1_delta[FC1_SIZE];
//__device__ float _conv_sigma_delta[CONV_W_NUM];
//__device__ float _conv_delta[CONV_W_NUM][POOL_SIZE][POOL_SIZE];
//
//__device__ int tmp;
//int swap_endian(int val)
//{
// unsigned char c1, c2, c3, c4;
// c1 = val & 255;
// c2 = (val >> 8) & 255;
// c3 = (val >> 16) & 255;
// c4 = (val >> 24) & 255;
// return ((int)c1 << 24) + ((int)c2 << 16) + ((int)c3 << 8) + c4;
//}
//void load_data()
//{
// FILE* f_images = fopen("D:\\\\Zufar\\\\CUDA-CNN\\\\CudaCNN2\\\\CudaCNN2\\\\data\\\\train-images.idx3-ubyte", "rb");
// FILE* f_labels = fopen("D:\\\\Zufar\\\\CUDA-CNN\\\\CudaCNN2\\\\CudaCNN2\\\\data\\\\train-labels.idx1-ubyte", "rb");
//
// int tmp;
//
// int magic_num;
// fread(&magic_num, sizeof(int), 1, f_images);
// fread(&magic_num, sizeof(int), 1, f_labels);
//
// printf("debug:%d\n",swap_endian(magic_num));
//
// int train_size;
// fread(&train_size, sizeof(int), 1, f_images);
// fread(&train_size, sizeof(int), 1, f_labels);
// train_size = swap_endian(train_size);
//
// printf("debug:%d\n",swap_endian(train_size));
//
// int rows, cols;
// fread(&rows, sizeof(int), 1, f_images);
// fread(&cols, sizeof(int), 1, f_images);
// rows = swap_endian(rows);
// cols = swap_endian(cols);
//
// printf("debug:%d\n",swap_endian(rows));
// printf("debug:%d\n",swap_endian(cols));
//
// for (int i = 0;i < train_size;i++)
// {
// fread(&train_label[i], 1, 1, f_labels);
// if (i % 1000 == 0)
// printf("Training labels : Already read %5d labels\r", i);
// printf("%d:debug:%d\r",i,train_label[i]);
// system("pause");
// }
// printf("Training labels : Already read %5d labels\n", train_size);
//
// for (int i = 0;i < train_size;i++)
// {
// for (int j = 0;j < rows;j++)
// for (int k = 0;k < cols;k++)
// {
// tmp = 0;
// fread(&tmp, 1, 1, f_images);
// train_image[i][j][k] = tmp;
// train_image[i][j][k] /= 255;
// printf("%d %d %d debug: %f\n",i,j,k,train_image[i][j][k]);
// system("pause");
// }
// if (i % 1000 == 0)
// printf("Training images : Already read %5d images\r", i);
// }
// printf("Training images : Already read %5d images\n", train_size);
//
// fclose(f_images);
// fclose(f_labels);
//
// f_images = fopen("D:\\\\Zufar\\\\CUDA-CNN\\\\CudaCNN2\\\\CudaCNN2\\\\data\\\\t10k-images.idx3-ubyte", "rb");
// f_labels = fopen("D:\\\\Zufar\\\\CUDA-CNN\\\\CudaCNN2\\\\CudaCNN2\\\\data\\\\t10k-labels.idx1-ubyte", "rb");
//
// fread(&magic_num, sizeof(int), 1, f_images);
// fread(&magic_num, sizeof(int), 1, f_labels);
//
// int test_size;
// fread(&test_size, sizeof(int), 1, f_images);
// fread(&test_size, sizeof(int), 1, f_labels);
// test_size = swap_endian(test_size);
//
// fread(&rows, sizeof(int), 1, f_images);
// fread(&cols, sizeof(int), 1, f_images);
// rows = swap_endian(rows);
// cols = swap_endian(cols);
//
// for (int i = 0;i < test_size;i++)
// {
// fread(&test_label[i], 1, 1, f_labels);
// if (i % 1000 == 0)
// printf("Testing labels : Already read %5d labels\r", i);
// }
// printf("Testing labels : Already read %5d labels\n", test_size);
//
// for (int i = 0;i < test_size;i++)
// {
// for (int j = 0;j < rows;j++)
// for (int k = 0;k < cols;k++)
// {
// tmp = 0;
// fread(&tmp, 1, 1, f_images);
// test_image[i][j][k] = tmp;
// test_image[i][j][k] /= 255;
// }
// if (i % 1000 == 0)
// printf("Testing images : Already read %5d images\r", i);
// }
// printf("Testing images : Already read %5d images\n\n", test_size);
//
// fclose(f_images);
// fclose(f_labels);
//}
//__device__ float _sigmoid(float x)
//{
// return (1 / (1 + exp(-1 * x)));
//}
//
//__global__ void _set_input_train(int idx)
//{
// int ix = threadIdx.x + blockDim.x * blockIdx.x;
// int iy = threadIdx.y + blockDim.y * blockIdx.y;
// if (ix < ROW && iy < COL)
// {
// _input[ix][iy] = _train_image[idx][ix][iy];
// }
//}
//
//__global__ void _set_input_test(int idx)
//{
// int ix = threadIdx.x + blockDim.x * blockIdx.x;
// int iy = threadIdx.y + blockDim.y * blockIdx.y;
// if (ix < ROW && iy < COL)
// {
// _input[ix][iy] = _test_image[idx][ix][iy];
// }
//}
//
//void set_input_gpu_train(int idx)
//{
// dim3 block(32, 32);
// dim3 grid((ROW - 1) / block.x + 1, (COL - 1) / block.y + 1);
// _set_input_train << <block, grid >> > (idx);
// cudaDeviceSynchronize();
//}
//
//void set_input_gpu_test(int idx)
//{
// dim3 block(32, 32);
// dim3 grid((ROW - 1) / block.x + 1, (COL - 1) / block.y + 1);
// _set_input_test << <block, grid >> > (idx);
// cudaDeviceSynchronize();
//}
//
//__global__ void _input_conv()
//{
//
// int ix = threadIdx.x + blockDim.x * blockIdx.x;
// int iy = threadIdx.y + blockDim.y * blockIdx.y;
// int iz = threadIdx.z + blockDim.z * blockIdx.z;
// if (ix < CONV_W_NUM && iy < CONV_SIZE && iz < CONV_SIZE)
// {
// _conv_z[ix][iy][iz] = 0;
// #pragma unroll
// for (int l = 0;l < CONV_W_SIZE;l++)
// for (int m = 0;m < CONV_W_SIZE;m++)
// _conv_z[ix][iy][iz] += _input[iy + l][iz + m] * _conv_w[ix][l][m];
// _conv_z[ix][iy][iz] += _conv_b[ix];
// _conv_a[ix][iy][iz] = _sigmoid(_conv_z[ix][iy][iz]);
// }
//}
//
//void input_conv_gpu()
//{
// dim3 block(8, 8, 8);
// dim3 grid((CONV_W_NUM - 1) / block.x + 1, (CONV_SIZE - 1) / block.y + 1, (CONV_SIZE - 1) / block.z + 1);
// _input_conv << <block, grid >> > ();
// cudaDeviceSynchronize();
//}
//
//__global__ void _conv_pool()
//{
// int i = threadIdx.x + blockDim.x * blockIdx.x;
// int j = threadIdx.y + blockDim.y * blockIdx.y;
// int k = threadIdx.z + blockDim.z * blockIdx.z;
// if (i < CONV_W_NUM && j < POOL_SIZE && k < POOL_SIZE)
// {
// float _max = _conv_a[i][j * 2][k * 2];
// _pool_pos[i][j][k] = 0;
// if (_conv_a[i][j * 2][k * 2 + 1] > _max)
// {
// _max = _conv_a[i][j * 2][k * 2 + 1];
// _pool_pos[i][j][k] = 1;
// }
// if (_conv_a[i][j * 2 + 1][k * 2] > _max)
// {
// _max = _conv_a[i][j * 2 + 1][k * 2];
// _pool_pos[i][j][k] = 2;
// }
// if (_conv_a[i][j * 2 + 1][k * 2 + 1] > _max)
// {
// _max = _conv_a[i][j * 2 + 1][k * 2 + 1];
// _pool_pos[i][j][k] = 3;
// }
// _pool[i][j][k] = _max;
// }
//}
//
//void conv_pool_gpu()
//{
// dim3 block(8, 8, 8);
// dim3 grid((CONV_W_NUM - 1) / block.x + 1, (POOL_SIZE - 1) / block.y + 1, (POOL_SIZE - 1) / block.z + 1);
// _conv_pool << <block, grid >> > ();
// cudaDeviceSynchronize();
//}
//
//__global__ void _pool_fc1()
//{
// int i = threadIdx.x + blockDim.x * blockIdx.x;
// if (i < FC1_SIZE)
// {
// _fc1_z[i] = 0;
// for (int j = 0;j < CONV_W_NUM;j++)
// for (int k = 0;k < POOL_SIZE;k++)
// for (int l = 0;l < POOL_SIZE;l++)
// _fc1_z[i] += _pool[j][k][l] * _fc1_w[i][j][k][l];
// _fc1_z[i] += _fc1_b[i];
// _fc1_a[i] = _sigmoid(_fc1_z[i]);
// }
//}
//
//void pool_fc1_gpu()
//{
// dim3 block(32);
// dim3 grid((FC1_SIZE - 1) / block.x + 1);
// _pool_fc1 << <block, grid >> > ();
// cudaDeviceSynchronize();
//}
//
//__global__ void _fc1_fc2()
//{
// int i = threadIdx.x + blockDim.x * blockIdx.x;
// if (i < FC2_SIZE)
// {
// _fc2_z[i] = 0;
// for (int j = 0;j < FC1_SIZE;j++)
// _fc2_z[i] += _fc1_a[j] * _fc2_w[i][j];
// _fc2_z[i] += _fc2_b[i];
// _fc2_a[i] = _sigmoid(_fc2_z[i]);
// }
//}
//
//void fc1_fc2_gpu()
//{
// dim3 block(32);
// dim3 grid((FC2_SIZE - 1) / block.x + 1);
// _fc1_fc2 << <block, grid >> > ();
// cudaDeviceSynchronize();
//}
//
//__global__ void _set_answer_train(int idx)
//{
// int i = threadIdx.x + blockDim.x * blockIdx.x;
// if (i < FC2_SIZE)
// {
// _output[i] = _fc2_a[i];
// _answer[i] = (_train_label[idx] == i) ? 1 : 0;
// }
//}
//
//__global__ void _set_answer_test(int idx)
//{
// int i = threadIdx.x + blockDim.x * blockIdx.x;
// if (i < FC2_SIZE)
// {
// _output[i] = _fc2_a[i];
// _answer[i] = (_test_label[idx] == i) ? 1 : 0;
// }
//}
//
//void set_answer_gpu_train(int idx)
//{
// dim3 block(32);
// dim3 grid((FC2_SIZE - 1) / block.x + 1);
// _set_answer_train << <block, grid >> > (idx);
// cudaDeviceSynchronize();
//}
//
//void set_answer_gpu_test(int idx)
//{
// dim3 block(32);
// dim3 grid((FC2_SIZE - 1) / block.x + 1);
// _set_answer_test << <block, grid >> > (idx);
// cudaDeviceSynchronize();
//}
//
//__global__ void _check_answer_get_error()
//{
// float _max = _output[0];
// int max_pos = 0;
// for (int i = 0;i < FC2_SIZE;i++)
// {
// if (_max < _output[i])
// {
// _max = _output[i];
// max_pos = i;
// }
// }
// if (_answer[max_pos])
// _correct_cnt++;
// for (int i = 0;i < FC2_SIZE;i++)
// {
// _C[i] = _output[i] - _answer[i];
// _avg_error += _C[i] * _C[i] * 0.5;
// }
//}
//
//void check_answer_get_error_gpu()
//{
// _check_answer_get_error << <1, 1 >> > ();
// cudaDeviceSynchronize();
//}
////#include "bp_gpu.cuh"
//
//__global__ void _update_fc2_b()
//{
// int i = threadIdx.x + blockDim.x * blockIdx.x;
// if (i < FC2_SIZE)
// {
// _fc2_delta[i] = _alpha * _C[i] * (_fc2_a[i] * (1.0 - _fc2_a[i]));
// _fc2_db[i] += _fc2_delta[i];
// }
//}
//
//void update_fc2_b_gpu()
//{
// dim3 block(32);
// dim3 grid((FC2_SIZE - 1) / block.x + 1);
// _update_fc2_b << <block, grid >> > ();
// cudaDeviceSynchronize();
//}
//
//__global__ void _update_fc2_w()
//{
// int i = threadIdx.x + blockDim.x * blockIdx.x;
// int j = threadIdx.y + blockDim.y * blockIdx.y;
// if (i < FC2_SIZE && j < FC1_SIZE)
// _fc2_dw[i][j] += _fc2_delta[i] * _fc1_a[j];
//}
//
//void update_fc2_w_gpu()
//{
// dim3 block(32, 32);
// dim3 grid((FC2_SIZE - 1) / block.x + 1, (FC1_SIZE - 1) / block.x + 1);
// _update_fc2_w << <block, grid >> > ();
// cudaDeviceSynchronize();
//}
//
//__global__ void _update_fc1_b()
//{
// int i = threadIdx.x + blockDim.x * blockIdx.x;
// if (i < FC1_SIZE)
// {
// float error = 0;
// for (int j = 0;j < FC2_SIZE;j++)
// error += _fc2_delta[j] * _fc2_w[j][i];
// _fc1_delta[i] = error * (_fc1_a[i] * (1.0 - _fc1_a[i]));
// _fc1_db[i] += _fc1_delta[i];
// }
//}
//
//void update_fc1_b_gpu()
//{
// dim3 block(32);
// dim3 grid((FC1_SIZE - 1) / block.x + 1);
// _update_fc1_b << <block, grid >> > ();
// cudaDeviceSynchronize();
//}
//
//__global__ void _update_fc1_w(int j)
//{
// int i = threadIdx.x + blockDim.x * blockIdx.x;
// int k = threadIdx.y + blockDim.y * blockIdx.y;
// int l = threadIdx.z + blockDim.z * blockIdx.z;
// if (i < FC1_SIZE && k < POOL_SIZE && l < POOL_SIZE)
// _fc1_dw[i][j][k][l] += _fc1_delta[i] * _pool[j][k][l];
//}
//
//void update_fc1_w_gpu()
//{
// dim3 block(8, 8, 8);
// dim3 grid((FC1_SIZE - 1) / block.x + 1, (POOL_SIZE - 1) / block.y + 1, (POOL_SIZE - 1) / block.z + 1);
//
// #pragma omp parallel for
// for (int j = 0;j < CONV_W_NUM;j++)
// _update_fc1_w << <block, grid >> > (j);
// cudaDeviceSynchronize();
//}
//
//__global__ void _update_conv_b()
//{
// int i = threadIdx.x + blockDim.x * blockIdx.x;
// if (i < CONV_W_NUM)
// {
// _conv_sigma_delta[i] = 0;
// for (int j = 0;j < POOL_SIZE;j++)
// for (int k = 0;k < POOL_SIZE;k++)
// {
// float error = 0;
// _conv_delta[i][j][k] = 0;
// for (int l = 0;l < FC1_SIZE;l++)
// error += _fc1_delta[l] * _fc1_w[l][i][j][k];
// _conv_delta[i][j][k] = error * (_pool[i][j][k] * (1.0 - _pool[i][j][k]));
// _conv_sigma_delta[i] += error * (_pool[i][j][k] * (1.0 - _pool[i][j][k]));
// }
// _conv_db[i] += _conv_sigma_delta[i];
// }
//}
//
//void update_conv_b_gpu()
//{
// dim3 block(32);
// dim3 grid((CONV_W_NUM - 1) / block.x + 1);
// _update_conv_b << <block, grid >> > ();
// cudaDeviceSynchronize();
//}
//
//__global__ void _update_conv_w()
//{
// int i = threadIdx.x + blockDim.x * blockIdx.x;
// int j = threadIdx.y + blockDim.y * blockIdx.y;
// int k = threadIdx.z + blockDim.z * blockIdx.z;
// if (i < CONV_W_NUM && j < CONV_W_SIZE && k < CONV_W_SIZE)
// {
// float error = 0;
// for (int m = 0;m < POOL_SIZE;m++)
// for (int n = 0;n < POOL_SIZE;n++)
// {
// int x = _pool_pos[i][m][n] / 2;
// int y = _pool_pos[i][m][n] % 2;
// error += _conv_delta[i][m][n] * _input[2 * m + j + x][2 * n + k + y];
// }
// _conv_dw[i][j][k] += error;
// }
//}
//
//void update_conv_w_gpu()
//{
// dim3 block(8, 8, 8);
// dim3 grid((CONV_W_NUM - 1) / block.x + 1, (CONV_W_SIZE - 1) / block.y + 1, (CONV_W_SIZE - 1) / block.z + 1);
// _update_conv_w << <block, grid >> > ();
// cudaDeviceSynchronize();
//}
//
//__global__ void assign_fc2_b()
//{
// int i = threadIdx.x + blockDim.x * blockIdx.x;
// if (i < FC2_SIZE)
// {
// _fc2_b[i] -= (_fc2_db[i] / _minibatch);
// _fc2_db[i] = 0;
// }
//}
//
//__global__ void assign_fc2_w()
//{
// int i = threadIdx.x + blockDim.x * blockIdx.x;
// int j = threadIdx.y + blockDim.y * blockIdx.y;
// if (i < FC2_SIZE && j < FC1_SIZE)
// {
// _fc2_w[i][j] -= (_fc2_dw[i][j] / _minibatch);
// _fc2_dw[i][j] = 0;
// }
//}
//
//__global__ void assign_fc1_b()
//{
// int i = threadIdx.x + blockDim.x * blockIdx.x;
// if (i < FC1_SIZE)
// {
// _fc1_b[i] -= (_fc1_db[i] / _minibatch);
// _fc1_db[i] = 0;
// }
//}
//
//__global__ void assign_fc1_w(int j)
//{
// int i = threadIdx.x + blockDim.x * blockIdx.x;
// int k = threadIdx.y + blockDim.y * blockIdx.y;
// int l = threadIdx.z + blockDim.z * blockIdx.z;
// if (i < FC1_SIZE && k < POOL_SIZE && l < POOL_SIZE)
// {
// _fc1_w[i][j][k][l] -= (_fc1_dw[i][j][k][l] / _minibatch);
// _fc1_dw[i][j][k][l] = 0;
// }
//}
//
//__global__ void assign_conv_b()
//{
// int i = threadIdx.x + blockDim.x * blockIdx.x;
// if (i < CONV_W_NUM)
// {
// _conv_b[i] -= (_conv_db[i] / _minibatch);
// _conv_db[i] = 0;
// }
//}
//
//__global__ void assign_conv_w()
//{
// int i = threadIdx.x + blockDim.x * blockIdx.x;
// int l = threadIdx.y + blockDim.y * blockIdx.y;
// int m = threadIdx.z + blockDim.z * blockIdx.z;
// if (i < CONV_W_NUM && l < CONV_W_SIZE && m < CONV_W_SIZE)
// {
// _conv_w[i][l][m] -= (_conv_dw[i][l][m] / _minibatch);
// _conv_dw[i][l][m] = 0;
// }
//}
//
//void assign_grads_gpu()
//{
// dim3 block1(32);
// dim3 grid1((FC2_SIZE - 1) / block1.x + 1);
// assign_fc2_b << <block1, grid1 >> > ();
//
// dim3 block2(32, 32);
// dim3 grid2((FC2_SIZE - 1) / block2.x + 1, (FC1_SIZE - 1) / block2.y + 1);
// assign_fc2_w << <block2, grid2 >> > ();
//
// dim3 block3(32);
// dim3 grid3((FC1_SIZE - 1) / block3.x + 1);
// assign_fc1_b << <block3, grid3 >> > ();
//
// dim3 block4(8, 8, 8);
// dim3 grid4((FC1_SIZE - 1) / block4.x + 1, (POOL_SIZE - 1) / block4.y + 1, (POOL_SIZE - 1) / block4.z + 1);
// for (int j = 0;j < CONV_W_NUM;j++)
// assign_fc1_w << <block4, grid4 >> > (j);
//
// dim3 block5(32);
// dim3 grid5((CONV_W_NUM - 1) / block5.x + 1);
// assign_conv_b << <block5, grid5 >> > ();
//
// dim3 block6(8, 8, 8);
// dim3 grid6((CONV_W_NUM - 1) / block6.x + 1, (CONV_W_SIZE - 1) / block6.y + 1, (CONV_W_SIZE - 1) / block6.z + 1);
// assign_conv_w << <block6, grid6 >> > ();
//
// cudaDeviceSynchronize();
//}
//void init_data_gpu()
//{
// cudaMemcpyToSymbol(_train_image, train_image, TRAIN_NUM * ROW * COL * sizeof(float));
// cudaMemcpyToSymbol(_train_label, train_label, sizeof(train_label));
// cudaMemcpyToSymbol(_test_image, test_image, TEST_NUM * ROW * COL * sizeof(float));
// cudaMemcpyToSymbol(_test_label, test_label, sizeof(test_label));
//}
//float get_rand(float fan_in)
//{
// float sum = 0;
// for (int i = 0;i < 12;i++)
// sum += (float)rand() / RAND_MAX;
// sum -= 6;
// sum *= 1 / sqrt(fan_in);
// return sum;
//}
//void init_params()
//{
// for (int i = 0;i < CONV_W_NUM;i++)
// {
// for (int j = 0;j < CONV_W_SIZE;j++)
// for (int k = 0;k < CONV_W_SIZE;k++)
// conv_w[i][j][k] = get_rand(CONV_W_SIZE * CONV_W_SIZE);
// conv_b[i] = get_rand(CONV_W_SIZE * CONV_W_SIZE);
// }
//
// for (int i = 0;i < FC1_SIZE;i++)
// {
// for (int j = 0;j < CONV_W_NUM;j++)
// for (int k = 0;k < POOL_SIZE;k++)
// for (int l = 0;l < POOL_SIZE;l++)
// fc1_w[i][j][k][l] = get_rand(POOL_SIZE * POOL_SIZE * CONV_W_NUM);
// fc1_b[i] = get_rand(POOL_SIZE * POOL_SIZE * CONV_W_NUM);
// }
//
// for (int i = 0;i < FC2_SIZE;i++)
// {
// for (int j = 0;j < FC1_SIZE;j++)
// fc2_w[i][j] = get_rand(FC1_SIZE);
// fc2_b[i] = get_rand(FC1_SIZE);
// }
//}
//__global__ void _set_input_train1(int idx)
//{
// int ix = threadIdx.x + blockDim.x * blockIdx.x;
// int iy = threadIdx.y + blockDim.y * blockIdx.y;
// if (ix < ROW && iy < COL)
// {
// _input1[idx % N_STREAM][ix][iy] = _train_image[idx][ix][iy];
// }
//}
//__global__ void _input_conv1(int idx)
//{
// __shared__ float tile[CONV_SIZE][CONV_SIZE];
// int ix = threadIdx.x + blockDim.x * blockIdx.x;
// int iy = threadIdx.y + blockDim.y * blockIdx.y;
// int iz = threadIdx.z + blockDim.z * blockIdx.z;
// if (ix < CONV_W_NUM && iy < CONV_SIZE && iz < CONV_SIZE)
// {
// tile[iy][iz] = 0;
// for (int l = 0;l < CONV_W_SIZE;l++)
// for (int m = 0;m < CONV_W_SIZE;m++)
// tile[iy][iz] += __ldg(&_input1[idx % N_STREAM][iy + l][iz + m]) * _conv_w[ix][l][m];
// tile[iy][iz] += _conv_b[ix];
// _conv_z1[idx % N_STREAM][ix][iy][iz] = tile[iy][iz];
// _conv_a1[idx % N_STREAM][ix][iy][iz] = _sigmoid(tile[iy][iz]);
// }
//}
//int main() {
//
// load_data();
// clock_t t = clock();
// cudaMemcpyToSymbol(_alpha, &alpha, sizeof(float));
// cudaMemcpyToSymbol(_minibatch, &minibatch, sizeof(int));
// cudaMemcpyToSymbol(_epochs, &epochs, sizeof(int));
// init_data_gpu();
// init_params();
// cudaMemcpyToSymbol(_conv_w, conv_w, CONV_W_NUM * CONV_W_SIZE * CONV_W_SIZE * sizeof(float));
// cudaMemcpyToSymbol(_conv_b, conv_b, CONV_W_NUM * sizeof(float));
// cudaMemcpyToSymbol(_fc1_b, fc1_b, FC1_SIZE* sizeof(float));
// cudaMemcpyToSymbol(_fc1_w, fc1_w, FC1_SIZE*CONV_W_NUM*POOL_SIZE*POOL_SIZE* sizeof(float));
// cudaMemcpyToSymbol(_fc2_b, fc2_b, FC2_SIZE* sizeof(float));
// cudaMemcpyToSymbol(_fc2_w, fc2_w, FC1_SIZE * FC2_SIZE * sizeof(float));
// dim3 block_set_input(1, 1);
// dim3 grid_set_input((ROW - 1) / block_set_input.x + 1, (COL - 1) / block_set_input.y + 1);
// dim3 grid_set_input(28,28);
// dim3 block_input(8, 8, 8);
// dim3 grid((CONV_W_NUM - 1) / block.x + 1, (CONV_SIZE - 1) / block.y + 1, (CONV_SIZE - 1) / block.z + 1);
// dim3 grid_input(1,24,24);
// int n_stream = 16;
//
// stream = (cudaStream_t*)malloc(n_stream * sizeof(cudaStream_t));
// for (int i = 0;i < n_stream;i++)
// cudaStreamCreateWithFlags(&stream[i],cudaStreamNonBlocking);
// cudaStreamCreate(&stream[i]);
// for (int i = 1;i <= epochs;i++)
// {
// int value1 = 0;
// float value2 = 0;
// cudaMemcpyToSymbol(_correct_cnt, &value1, sizeof(int));
// cudaMemcpyToSymbol(_avg_error, &value2, sizeof(float));
// cudaDeviceSynchronize();
//
// for (int j = 0;j < TRAIN_NUM;j++)
// {
//
// _set_input_train1 << <1, grid_set_input>> > (j);
// _set_input_train << <1,1>> > (j);
//
//
// _input_conv1 << <6, grid_input>> > (j);
//
// input_conv_gpu();
// /*conv_pool_gpu();
// pool_fc1_gpu();
// fc1_fc2_gpu();
// set_answer_gpu_train(j);
// check_answer_get_error_gpu();
//
// update_fc2_b_gpu();
// update_fc2_w_gpu();
// update_fc1_b_gpu();
// update_fc1_w_gpu();
// update_conv_b_gpu();
// update_conv_w_gpu();
// if ((j + 1) % minibatch == 0)
// assign_grads_gpu();*/
//
// if (j && j % 100 == 0)
// {
//
// /* cudaMemcpyFromSymbol(&correct_cnt, _correct_cnt, sizeof(int));
// cudaMemcpyFromSymbol(&avg_error, _avg_error, sizeof(float));*/
// printf("Training Time spent : %.0fs Image count : %d Accuracy : %0.4f%% Error : %0.4f%% Epoch : %d \r", floor(((float)(clock() - t)) / CLOCKS_PER_SEC), j, ((float)correct_cnt / j) * 100, (avg_error / j) * 100, i);
// }
// }
// cudaMemcpyFromSymbol(&correct_cnt, _correct_cnt, sizeof(int));
// cudaMemcpyFromSymbol(&avg_error, _avg_error, sizeof(float));
// printf("Training Time spent : %.0fs Image count : %d Accuracy : %0.4f%% Error : %0.4f%% Epoch : %d \n", floor(((float)(clock() - t)) / CLOCKS_PER_SEC), TRAIN_NUM, ((float)correct_cnt / TRAIN_NUM) * 100, (avg_error / TRAIN_NUM) * 100, i);
//
// correct_cnt = 0;
// avg_error = 0;
// cudaMemcpyToSymbol(_correct_cnt, &correct_cnt, sizeof(int));
// cudaMemcpyToSymbol(_avg_error, &avg_error, sizeof(float));
//
// for (int j = 0;j < TEST_NUM;j++)
// {
// set_input_gpu_test(j);
// input_conv_gpu();
// conv_pool_gpu();
// pool_fc1_gpu();
// fc1_fc2_gpu();
// set_answer_gpu_test(j);
// check_answer_get_error_gpu();
//
// if (j && j % 100 == 0)
// {
// cudaMemcpyFromSymbol(&correct_cnt, _correct_cnt, sizeof(int));
// cudaMemcpyFromSymbol(&avg_error, _avg_error, sizeof(float));
// printf("Testing Time spent : %.0fs Image count : %d Accuracy : %0.4f%% Error : %0.4f%% \r", floor(((float)(clock() - t)) / CLOCKS_PER_SEC), j, ((float)correct_cnt / j) * 100, (avg_error / j) * 100);
// }
// }
// cudaMemcpyFromSymbol(&correct_cnt, _correct_cnt, sizeof(int));
// cudaMemcpyFromSymbol(&avg_error, _avg_error, sizeof(float));
// printf("Testing Time spent : %.0fs Image count : %d Accuracy : %0.4f%% Error : %0.4f%% \n", floor(((float)(clock() - t)) / CLOCKS_PER_SEC), TEST_NUM, ((float)correct_cnt / TEST_NUM) * 100, (avg_error / TEST_NUM) * 100);
//
// if ((float)correct_cnt / TEST_NUM * 100 > max_acc)
// {
// max_acc = (float)correct_cnt / TEST_NUM * 100;
// export_params();
// printf("The new model has been exported.Accuracy has reached to %0.5f%%\n\n", max_acc);
// }
// else
// {
// alpha = alpha - (alpha / 3);
// cudaMemcpyToSymbol(_alpha, &alpha, sizeof(float));
// printf("Learning rate has been reduced to %f\n\n", alpha);
// }
// }
//
//
//
// float train_image[ROW][COL] = {
// { 3, 1, 2, 4, 3, 3 },
// { 2, 4, 3, 1, 1, 4 },
// { 1, 5, 2, 3, 2, 5 },
// { 2, 3, 4, 1, 4, 1 },
// { 1, 4, 2, 1, 2, 3 },
// { 2, 3, 6, 5, 4, 1 }, };
// float conv_w[CONV_W_NUM][CONV_W_SIZE][CONV_W_SIZE] = { {
// {1, 2, 3},
// {4, 3, 1},
// {1, 2, 4}},
// {{4, 2, 5},
// {2, 3, 1},
// {1, 2, 3}} };
//
// //float conv_z[CONV_W_NUM][CONV_SIZE][CONV_SIZE];
// float conv_z[2][2][2];
// float train_label[2] = { 3,2 };
//
// cudaMemcpyToSymbol(_train_image, train_image, ROW * COL * sizeof(float));
// cudaMemcpyToSymbol(_conv_w, conv_w, CONV_W_NUM * CONV_W_SIZE * CONV_W_SIZE * sizeof(float));
// //cudaMemcpy(_train_label, train_label, 2 * sizeof(float), cudaMemcpyHostToDevice);
// //cudaMemcpy(_train_image, train_image, ROW * COL * sizeof(float), cudaMemcpyHostToDevice);
// //cudaMemcpy(_conv_w, conv_w, CONV_W_NUM*CONV_W_SIZE*CONV_W_SIZE*sizeof(float), cudaMemcpyHostToDevice);
// dim3 grid2(2, 4, 4);
//
// //_input_conv << <1, grid2>> > ((float (*)[4])_train_image, (float (*)[3][3])_conv_w, (float (*)[2][2])_conv_z);
// _input_conv << <1, grid2 >> > ();
// _conv_pool << <1, grid2 >> > ();
// //cudaMemcpyFromSymbol(&conv_z, _pool, CONV_W_NUM * CONV_SIZE * CONV_SIZE * sizeof(float));
// cudaMemcpyFromSymbol(&conv_z, _pool, 8 * sizeof(float));
// for (int i = 0;i < 2;i++) {
// for (int j = 0;j <2;j++) {
// cout << conv_z[0][i][j] << " ";
// }
// cout << endl;
// }
// for (int i = 0;i < 2;i++) {
// for (int j = 0;j < 2;j++) {
// cout << conv_z[1][i][j] << " ";
// }
// cout << endl;
// }
// return 0;
//} |
21,161 | #include <stdio.h>
#include <stdlib.h>
#include <time.h>
extern "C" {
void * alloc_gpu_mem( size_t N)
{
void*d;
int size = N *sizeof(float);
int err;
err = cudaMalloc(&d, size);
if (err != 0) printf("cuda malloc error: %d\n", err);
return d;
}}
// see kernels.cu for launch_kernel functions
extern "C" {
void host2gpu(float * a, void * da, size_t N)
{
int size = N * sizeof(float);
int err;
err = cudaMemcpy(da, a, size, cudaMemcpyHostToDevice);
if (err != 0) printf("load mem: %d\n", err);
}}
extern "C"{
void gpu2host(float *c, void *d_c, size_t N)
{
cudaError_t err;
int size = N*sizeof(float);
// copy result back
err = cudaMemcpy(c, d_c, size, cudaMemcpyDeviceToHost);
if (err != 0) {printf("cpy mem back %d\n", err);
//cudaError_t cudaGetLastError(void);
printf("%s\n", cudaGetErrorString(cudaGetLastError()));
}
}}
extern "C"{
void free_gpu_mem(void *d)
{
cudaFree(d);
}}
extern "C"{
void free_mem(void *d)
{
free(d);
}}
extern "C"{
void get_cuda_info()
{
int count, i;
const int kb = 1024;
const int mb = kb*kb;
cudaGetDeviceCount(&count);
for(i=0; i<count;i++)
{
cudaDeviceProp props;
cudaGetDeviceProperties(&props, i);
printf("\nDevice Details:\n");
printf("%d : %s : %d : %d\n", i, props.name, props.major, props.minor);
printf("Number of Processors: %d\n", props.multiProcessorCount);
printf("Global Memory: %f mb\n", (float) props.totalGlobalMem /mb);
printf("Shared Memory: %f kb \n", (float) props.sharedMemPerBlock / kb);
printf("Constant Memory: %f kb\n", (float) props.totalConstMem / kb);
printf("Block registers: %d\n", props.regsPerBlock);
printf("Warp size: %d\n", props.warpSize);
printf("Threads per block: %d\n", props.maxThreadsPerBlock);
printf("Max block dimensions: [%d, %d, %d]\n", props.maxThreadsDim[0], props.maxThreadsDim[1], props.maxThreadsDim[2]);
printf("Max grid dimensions: [%d, %d, %d]\n", props.maxGridSize[0], props.maxGridSize[1], props.maxGridSize[2]);
printf("Clock Rate: %d\n", props.memoryClockRate);
printf("Memory Bus Widths %d\n", props.memoryBusWidth);
printf("\n");
}
}}
extern "C"{
void distance3D(float *x, float *y, float *dist, size_t nx, size_t ny, size_t T, size_t k)
{
int n, m, i, j;
float d, d_;
for (n=0; n<nx; n++){
for (m=0; m<ny; m++){
d = 0;
for (i=0; i<T; i++){
d_ = 0;
for (j =0; j<k; j++){
d_ += pow((x[n*T*k + i*k + j] - y[m*T*k + i*k + j]), 2);
}
d += sqrt(d_);
}
dist[n*ny + m] = d;
}
}
}}
|
21,162 | #include "includes.h"
__device__ unsigned int shared_reduce(unsigned int p, volatile unsigned int * s) {
// Assumes values in 'p' are either 1 or 0
// Assumes s[0:31] are allocated
// Sums p across warp, returning the result. Suggest you put
// result in s[0] and return it
// You may change any value in s
// You should execute no more than 5 + operations (if you're doing
// 31, you're doing it wrong)
//
// TODO: Fill in the rest of this function
return s[0];
}
__global__ void reduce(unsigned int * d_out_shared, const unsigned int * d_in)
{
extern __shared__ unsigned int s[];
int t = threadIdx.x;
int p = d_in[t];
unsigned int sr = shared_reduce(p, s);
if (t == 0)
{
*d_out_shared = sr;
}
} |
21,163 | /*
Matthew Dempsky
Public domain.
Derived from public domain code by D. J. Bernstein.
*/
// Modified very slightly for ZeroTier One by Adam Ierymenko
// This code remains in the public domain.
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
//#include "Constants.hpp"
#include "C25519.cuh"
#include "sha5.cuh"
#define crypto_int32 int32_t
#define crypto_uint32 uint32_t
#define crypto_int64 int64_t
#define crypto_uint64 uint64_t
#define crypto_hash_sha512_BYTES 64
//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
typedef uint8_t u8;
typedef int32_t s32;
typedef int64_t limb;
__device__ static inline void fsum(limb *output, const limb *in) {
unsigned i;
for (i = 0; i < 10; i += 2) {
output[0+i] = output[0+i] + in[0+i];
output[1+i] = output[1+i] + in[1+i];
}
}
__device__ static inline void fdifference(limb *output, const limb *in) {
unsigned i;
for (i = 0; i < 10; ++i) {
output[i] = in[i] - output[i];
}
}
__device__ static inline void fscalar_product(limb *output, const limb *in, const limb scalar) {
unsigned i;
for (i = 0; i < 10; ++i) {
output[i] = in[i] * scalar;
}
}
__device__ static inline void fproduct(limb *output, const limb *in2, const limb *in) {
output[0] = ((limb) ((s32) in2[0])) * ((s32) in[0]);
output[1] = ((limb) ((s32) in2[0])) * ((s32) in[1]) +
((limb) ((s32) in2[1])) * ((s32) in[0]);
output[2] = 2 * ((limb) ((s32) in2[1])) * ((s32) in[1]) +
((limb) ((s32) in2[0])) * ((s32) in[2]) +
((limb) ((s32) in2[2])) * ((s32) in[0]);
output[3] = ((limb) ((s32) in2[1])) * ((s32) in[2]) +
((limb) ((s32) in2[2])) * ((s32) in[1]) +
((limb) ((s32) in2[0])) * ((s32) in[3]) +
((limb) ((s32) in2[3])) * ((s32) in[0]);
output[4] = ((limb) ((s32) in2[2])) * ((s32) in[2]) +
2 * (((limb) ((s32) in2[1])) * ((s32) in[3]) +
((limb) ((s32) in2[3])) * ((s32) in[1])) +
((limb) ((s32) in2[0])) * ((s32) in[4]) +
((limb) ((s32) in2[4])) * ((s32) in[0]);
output[5] = ((limb) ((s32) in2[2])) * ((s32) in[3]) +
((limb) ((s32) in2[3])) * ((s32) in[2]) +
((limb) ((s32) in2[1])) * ((s32) in[4]) +
((limb) ((s32) in2[4])) * ((s32) in[1]) +
((limb) ((s32) in2[0])) * ((s32) in[5]) +
((limb) ((s32) in2[5])) * ((s32) in[0]);
output[6] = 2 * (((limb) ((s32) in2[3])) * ((s32) in[3]) +
((limb) ((s32) in2[1])) * ((s32) in[5]) +
((limb) ((s32) in2[5])) * ((s32) in[1])) +
((limb) ((s32) in2[2])) * ((s32) in[4]) +
((limb) ((s32) in2[4])) * ((s32) in[2]) +
((limb) ((s32) in2[0])) * ((s32) in[6]) +
((limb) ((s32) in2[6])) * ((s32) in[0]);
output[7] = ((limb) ((s32) in2[3])) * ((s32) in[4]) +
((limb) ((s32) in2[4])) * ((s32) in[3]) +
((limb) ((s32) in2[2])) * ((s32) in[5]) +
((limb) ((s32) in2[5])) * ((s32) in[2]) +
((limb) ((s32) in2[1])) * ((s32) in[6]) +
((limb) ((s32) in2[6])) * ((s32) in[1]) +
((limb) ((s32) in2[0])) * ((s32) in[7]) +
((limb) ((s32) in2[7])) * ((s32) in[0]);
output[8] = ((limb) ((s32) in2[4])) * ((s32) in[4]) +
2 * (((limb) ((s32) in2[3])) * ((s32) in[5]) +
((limb) ((s32) in2[5])) * ((s32) in[3]) +
((limb) ((s32) in2[1])) * ((s32) in[7]) +
((limb) ((s32) in2[7])) * ((s32) in[1])) +
((limb) ((s32) in2[2])) * ((s32) in[6]) +
((limb) ((s32) in2[6])) * ((s32) in[2]) +
((limb) ((s32) in2[0])) * ((s32) in[8]) +
((limb) ((s32) in2[8])) * ((s32) in[0]);
output[9] = ((limb) ((s32) in2[4])) * ((s32) in[5]) +
((limb) ((s32) in2[5])) * ((s32) in[4]) +
((limb) ((s32) in2[3])) * ((s32) in[6]) +
((limb) ((s32) in2[6])) * ((s32) in[3]) +
((limb) ((s32) in2[2])) * ((s32) in[7]) +
((limb) ((s32) in2[7])) * ((s32) in[2]) +
((limb) ((s32) in2[1])) * ((s32) in[8]) +
((limb) ((s32) in2[8])) * ((s32) in[1]) +
((limb) ((s32) in2[0])) * ((s32) in[9]) +
((limb) ((s32) in2[9])) * ((s32) in[0]);
output[10] = 2 * (((limb) ((s32) in2[5])) * ((s32) in[5]) +
((limb) ((s32) in2[3])) * ((s32) in[7]) +
((limb) ((s32) in2[7])) * ((s32) in[3]) +
((limb) ((s32) in2[1])) * ((s32) in[9]) +
((limb) ((s32) in2[9])) * ((s32) in[1])) +
((limb) ((s32) in2[4])) * ((s32) in[6]) +
((limb) ((s32) in2[6])) * ((s32) in[4]) +
((limb) ((s32) in2[2])) * ((s32) in[8]) +
((limb) ((s32) in2[8])) * ((s32) in[2]);
output[11] = ((limb) ((s32) in2[5])) * ((s32) in[6]) +
((limb) ((s32) in2[6])) * ((s32) in[5]) +
((limb) ((s32) in2[4])) * ((s32) in[7]) +
((limb) ((s32) in2[7])) * ((s32) in[4]) +
((limb) ((s32) in2[3])) * ((s32) in[8]) +
((limb) ((s32) in2[8])) * ((s32) in[3]) +
((limb) ((s32) in2[2])) * ((s32) in[9]) +
((limb) ((s32) in2[9])) * ((s32) in[2]);
output[12] = ((limb) ((s32) in2[6])) * ((s32) in[6]) +
2 * (((limb) ((s32) in2[5])) * ((s32) in[7]) +
((limb) ((s32) in2[7])) * ((s32) in[5]) +
((limb) ((s32) in2[3])) * ((s32) in[9]) +
((limb) ((s32) in2[9])) * ((s32) in[3])) +
((limb) ((s32) in2[4])) * ((s32) in[8]) +
((limb) ((s32) in2[8])) * ((s32) in[4]);
output[13] = ((limb) ((s32) in2[6])) * ((s32) in[7]) +
((limb) ((s32) in2[7])) * ((s32) in[6]) +
((limb) ((s32) in2[5])) * ((s32) in[8]) +
((limb) ((s32) in2[8])) * ((s32) in[5]) +
((limb) ((s32) in2[4])) * ((s32) in[9]) +
((limb) ((s32) in2[9])) * ((s32) in[4]);
output[14] = 2 * (((limb) ((s32) in2[7])) * ((s32) in[7]) +
((limb) ((s32) in2[5])) * ((s32) in[9]) +
((limb) ((s32) in2[9])) * ((s32) in[5])) +
((limb) ((s32) in2[6])) * ((s32) in[8]) +
((limb) ((s32) in2[8])) * ((s32) in[6]);
output[15] = ((limb) ((s32) in2[7])) * ((s32) in[8]) +
((limb) ((s32) in2[8])) * ((s32) in[7]) +
((limb) ((s32) in2[6])) * ((s32) in[9]) +
((limb) ((s32) in2[9])) * ((s32) in[6]);
output[16] = ((limb) ((s32) in2[8])) * ((s32) in[8]) +
2 * (((limb) ((s32) in2[7])) * ((s32) in[9]) +
((limb) ((s32) in2[9])) * ((s32) in[7]));
output[17] = ((limb) ((s32) in2[8])) * ((s32) in[9]) +
((limb) ((s32) in2[9])) * ((s32) in[8]);
output[18] = 2 * ((limb) ((s32) in2[9])) * ((s32) in[9]);
}
__device__ static inline void freduce_degree(limb *output) {
output[8] += output[18] << 4;
output[8] += output[18] << 1;
output[8] += output[18];
output[7] += output[17] << 4;
output[7] += output[17] << 1;
output[7] += output[17];
output[6] += output[16] << 4;
output[6] += output[16] << 1;
output[6] += output[16];
output[5] += output[15] << 4;
output[5] += output[15] << 1;
output[5] += output[15];
output[4] += output[14] << 4;
output[4] += output[14] << 1;
output[4] += output[14];
output[3] += output[13] << 4;
output[3] += output[13] << 1;
output[3] += output[13];
output[2] += output[12] << 4;
output[2] += output[12] << 1;
output[2] += output[12];
output[1] += output[11] << 4;
output[1] += output[11] << 1;
output[1] += output[11];
output[0] += output[10] << 4;
output[0] += output[10] << 1;
output[0] += output[10];
}
#if (-1 & 3) != 3
#error "This code only works on a two's complement system"
#endif
__device__ static inline limb div_by_2_26(const limb v)
{
/* High word of v; no shift needed. */
const uint32_t highword = (uint32_t) (((uint64_t) v) >> 32);
/* Set to all 1s if v was negative; else set to 0s. */
const int32_t sign = ((int32_t) highword) >> 31;
/* Set to 0x3ffffff if v was negative; else set to 0. */
const int32_t roundoff = ((uint32_t) sign) >> 6;
/* Should return v / (1<<26) */
return (v + roundoff) >> 26;
}
__device__ static inline limb div_by_2_25(const limb v)
{
/* High word of v; no shift needed*/
const uint32_t highword = (uint32_t) (((uint64_t) v) >> 32);
/* Set to all 1s if v was negative; else set to 0s. */
const int32_t sign = ((int32_t) highword) >> 31;
/* Set to 0x1ffffff if v was negative; else set to 0. */
const int32_t roundoff = ((uint32_t) sign) >> 7;
/* Should return v / (1<<25) */
return (v + roundoff) >> 25;
}
__device__ static inline void freduce_coefficients(limb *output) {
unsigned i;
output[10] = 0;
for (i = 0; i < 10; i += 2) {
limb over = div_by_2_26(output[i]);
/* The entry condition (that |output[i]| < 280*2^54) means that over is, at
* most, 280*2^28 in the first iteration of this loop. This is added to the
* next limb and we can approximate the resulting bound of that limb by
* 281*2^54. */
output[i] -= over << 26;
output[i+1] += over;
/* For the first iteration, |output[i+1]| < 281*2^54, thus |over| <
* 281*2^29. When this is added to the next limb, the resulting bound can
* be approximated as 281*2^54.
*
* For subsequent iterations of the loop, 281*2^54 remains a conservative
* bound and no overflow occurs. */
over = div_by_2_25(output[i+1]);
output[i+1] -= over << 25;
output[i+2] += over;
}
/* Now |output[10]| < 281*2^29 and all other coefficients are reduced. */
output[0] += output[10] << 4;
output[0] += output[10] << 1;
output[0] += output[10];
output[10] = 0;
/* Now output[1..9] are reduced, and |output[0]| < 2^26 + 19*281*2^29
* So |over| will be no more than 2^16. */
{
limb over = div_by_2_26(output[0]);
output[0] -= over << 26;
output[1] += over;
}
/* Now output[0,2..9] are reduced, and |output[1]| < 2^25 + 2^16 < 2^26. The
* bound on |output[1]| is sufficient to meet our needs. */
}
__device__ static inline void fmul(limb *output, const limb *in, const limb *in2) {
limb t[19];
fproduct(t, in, in2);
/* |t[i]| < 14*2^54 */
freduce_degree(t);
freduce_coefficients(t);
/* |t[i]| < 2^26 */
memcpy(output, t, sizeof(limb) * 10);
}
__device__ static inline void fsquare_inner(limb *output, const limb *in) {
output[0] = ((limb) ((s32) in[0])) * ((s32) in[0]);
output[1] = 2 * ((limb) ((s32) in[0])) * ((s32) in[1]);
output[2] = 2 * (((limb) ((s32) in[1])) * ((s32) in[1]) +
((limb) ((s32) in[0])) * ((s32) in[2]));
output[3] = 2 * (((limb) ((s32) in[1])) * ((s32) in[2]) +
((limb) ((s32) in[0])) * ((s32) in[3]));
output[4] = ((limb) ((s32) in[2])) * ((s32) in[2]) +
4 * ((limb) ((s32) in[1])) * ((s32) in[3]) +
2 * ((limb) ((s32) in[0])) * ((s32) in[4]);
output[5] = 2 * (((limb) ((s32) in[2])) * ((s32) in[3]) +
((limb) ((s32) in[1])) * ((s32) in[4]) +
((limb) ((s32) in[0])) * ((s32) in[5]));
output[6] = 2 * (((limb) ((s32) in[3])) * ((s32) in[3]) +
((limb) ((s32) in[2])) * ((s32) in[4]) +
((limb) ((s32) in[0])) * ((s32) in[6]) +
2 * ((limb) ((s32) in[1])) * ((s32) in[5]));
output[7] = 2 * (((limb) ((s32) in[3])) * ((s32) in[4]) +
((limb) ((s32) in[2])) * ((s32) in[5]) +
((limb) ((s32) in[1])) * ((s32) in[6]) +
((limb) ((s32) in[0])) * ((s32) in[7]));
output[8] = ((limb) ((s32) in[4])) * ((s32) in[4]) +
2 * (((limb) ((s32) in[2])) * ((s32) in[6]) +
((limb) ((s32) in[0])) * ((s32) in[8]) +
2 * (((limb) ((s32) in[1])) * ((s32) in[7]) +
((limb) ((s32) in[3])) * ((s32) in[5])));
output[9] = 2 * (((limb) ((s32) in[4])) * ((s32) in[5]) +
((limb) ((s32) in[3])) * ((s32) in[6]) +
((limb) ((s32) in[2])) * ((s32) in[7]) +
((limb) ((s32) in[1])) * ((s32) in[8]) +
((limb) ((s32) in[0])) * ((s32) in[9]));
output[10] = 2 * (((limb) ((s32) in[5])) * ((s32) in[5]) +
((limb) ((s32) in[4])) * ((s32) in[6]) +
((limb) ((s32) in[2])) * ((s32) in[8]) +
2 * (((limb) ((s32) in[3])) * ((s32) in[7]) +
((limb) ((s32) in[1])) * ((s32) in[9])));
output[11] = 2 * (((limb) ((s32) in[5])) * ((s32) in[6]) +
((limb) ((s32) in[4])) * ((s32) in[7]) +
((limb) ((s32) in[3])) * ((s32) in[8]) +
((limb) ((s32) in[2])) * ((s32) in[9]));
output[12] = ((limb) ((s32) in[6])) * ((s32) in[6]) +
2 * (((limb) ((s32) in[4])) * ((s32) in[8]) +
2 * (((limb) ((s32) in[5])) * ((s32) in[7]) +
((limb) ((s32) in[3])) * ((s32) in[9])));
output[13] = 2 * (((limb) ((s32) in[6])) * ((s32) in[7]) +
((limb) ((s32) in[5])) * ((s32) in[8]) +
((limb) ((s32) in[4])) * ((s32) in[9]));
output[14] = 2 * (((limb) ((s32) in[7])) * ((s32) in[7]) +
((limb) ((s32) in[6])) * ((s32) in[8]) +
2 * ((limb) ((s32) in[5])) * ((s32) in[9]));
output[15] = 2 * (((limb) ((s32) in[7])) * ((s32) in[8]) +
((limb) ((s32) in[6])) * ((s32) in[9]));
output[16] = ((limb) ((s32) in[8])) * ((s32) in[8]) +
4 * ((limb) ((s32) in[7])) * ((s32) in[9]);
output[17] = 2 * ((limb) ((s32) in[8])) * ((s32) in[9]);
output[18] = 2 * ((limb) ((s32) in[9])) * ((s32) in[9]);
}
__device__ static void fsquare(limb *output, const limb *in) {
limb t[19];
fsquare_inner(t, in);
/* |t[i]| < 14*2^54 because the largest product of two limbs will be <
* 2^(27+27) and fsquare_inner adds together, at most, 14 of those
* products. */
freduce_degree(t);
freduce_coefficients(t);
/* |t[i]| < 2^26 */
memcpy(output, t, sizeof(limb) * 10);
}
__device__ static inline void fexpand(limb *output, const u8 *input) {
#define F(n,start,shift,mask) \
output[n] = ((((limb) input[start + 0]) | \
((limb) input[start + 1]) << 8 | \
((limb) input[start + 2]) << 16 | \
((limb) input[start + 3]) << 24) >> shift) & mask;
F(0, 0, 0, 0x3ffffff);
F(1, 3, 2, 0x1ffffff);
F(2, 6, 3, 0x3ffffff);
F(3, 9, 5, 0x1ffffff);
F(4, 12, 6, 0x3ffffff);
F(5, 16, 0, 0x1ffffff);
F(6, 19, 1, 0x3ffffff);
F(7, 22, 3, 0x1ffffff);
F(8, 25, 4, 0x3ffffff);
F(9, 28, 6, 0x1ffffff);
#undef F
}
#if (-32 >> 1) != -16
#error "This code only works when >> does sign-extension on negative numbers"
#endif
__device__ static inline s32 s32_eq(s32 a, s32 b) {
a = ~(a ^ b);
a &= a << 16;
a &= a << 8;
a &= a << 4;
a &= a << 2;
a &= a << 1;
return a >> 31;
}
__device__ static inline s32 s32_gte(s32 a, s32 b) {
a -= b;
/* a >= 0 iff a >= b. */
return ~(a >> 31);
}
__device__ static inline void fcontract(u8 *output, limb *input_limbs) {
int i;
int j;
s32 input[10];
s32 mask;
/* |input_limbs[i]| < 2^26, so it's valid to convert to an s32. */
for (i = 0; i < 10; i++) {
input[i] = input_limbs[i];
}
for (j = 0; j < 2; ++j) {
for (i = 0; i < 9; ++i) {
if ((i & 1) == 1) {
/* This calculation is a time-invariant way to make input[i]
* non-negative by borrowing from the next-larger limb. */
const s32 mask = input[i] >> 31;
const s32 carry = -((input[i] & mask) >> 25);
input[i] = input[i] + (carry << 25);
input[i+1] = input[i+1] - carry;
} else {
const s32 mask = input[i] >> 31;
const s32 carry = -((input[i] & mask) >> 26);
input[i] = input[i] + (carry << 26);
input[i+1] = input[i+1] - carry;
}
}
/* There's no greater limb for input[9] to borrow from, but we can multiply
* by 19 and borrow from input[0], which is valid mod 2^255-19. */
{
const s32 mask = input[9] >> 31;
const s32 carry = -((input[9] & mask) >> 25);
input[9] = input[9] + (carry << 25);
input[0] = input[0] - (carry * 19);
}
/* After the first iteration, input[1..9] are non-negative and fit within
* 25 or 26 bits, depending on position. However, input[0] may be
* negative. */
}
/* The first borrow-propagation pass above ended with every limb
except (possibly) input[0] non-negative.
If input[0] was negative after the first pass, then it was because of a
carry from input[9]. On entry, input[9] < 2^26 so the carry was, at most,
one, since (2**26-1) >> 25 = 1. Thus input[0] >= -19.
In the second pass, each limb is decreased by at most one. Thus the second
borrow-propagation pass could only have wrapped around to decrease
input[0] again if the first pass left input[0] negative *and* input[1]
through input[9] were all zero. In that case, input[1] is now 2^25 - 1,
and this last borrow-propagation step will leave input[1] non-negative. */
{
const s32 mask = input[0] >> 31;
const s32 carry = -((input[0] & mask) >> 26);
input[0] = input[0] + (carry << 26);
input[1] = input[1] - carry;
}
/* All input[i] are now non-negative. However, there might be values between
* 2^25 and 2^26 in a limb which is, nominally, 25 bits wide. */
for (j = 0; j < 2; j++) {
for (i = 0; i < 9; i++) {
if ((i & 1) == 1) {
const s32 carry = input[i] >> 25;
input[i] &= 0x1ffffff;
input[i+1] += carry;
} else {
const s32 carry = input[i] >> 26;
input[i] &= 0x3ffffff;
input[i+1] += carry;
}
}
{
const s32 carry = input[9] >> 25;
input[9] &= 0x1ffffff;
input[0] += 19*carry;
}
}
/* If the first carry-chain pass, just above, ended up with a carry from
* input[9], and that caused input[0] to be out-of-bounds, then input[0] was
* < 2^26 + 2*19, because the carry was, at most, two.
*
* If the second pass carried from input[9] again then input[0] is < 2*19 and
* the input[9] -> input[0] carry didn't push input[0] out of bounds. */
/* It still remains the case that input might be between 2^255-19 and 2^255.
* In this case, input[1..9] must take their maximum value and input[0] must
* be >= (2^255-19) & 0x3ffffff, which is 0x3ffffed. */
mask = s32_gte(input[0], 0x3ffffed);
for (i = 1; i < 10; i++) {
if ((i & 1) == 1) {
mask &= s32_eq(input[i], 0x1ffffff);
} else {
mask &= s32_eq(input[i], 0x3ffffff);
}
}
/* mask is either 0xffffffff (if input >= 2^255-19) and zero otherwise. Thus
* this conditionally subtracts 2^255-19. */
input[0] -= mask & 0x3ffffed;
for (i = 1; i < 10; i++) {
if ((i & 1) == 1) {
input[i] -= mask & 0x1ffffff;
} else {
input[i] -= mask & 0x3ffffff;
}
}
input[1] <<= 2;
input[2] <<= 3;
input[3] <<= 5;
input[4] <<= 6;
input[6] <<= 1;
input[7] <<= 3;
input[8] <<= 4;
input[9] <<= 6;
#define F(i, s) \
output[s+0] |= input[i] & 0xff; \
output[s+1] = (input[i] >> 8) & 0xff; \
output[s+2] = (input[i] >> 16) & 0xff; \
output[s+3] = (input[i] >> 24) & 0xff;
output[0] = 0;
output[16] = 0;
F(0,0);
F(1,3);
F(2,6);
F(3,9);
F(4,12);
F(5,16);
F(6,19);
F(7,22);
F(8,25);
F(9,28);
#undef F
}
__device__ static inline void fmonty(limb *x2, limb *z2, /* output 2Q */
limb *x3, limb *z3, /* output Q + Q' */
limb *x, limb *z, /* input Q */
limb *xprime, limb *zprime, /* input Q' */
const limb *qmqp /* input Q - Q' */) {
limb origx[10], origxprime[10], zzz[19], xx[19], zz[19], xxprime[19],
zzprime[19], zzzprime[19], xxxprime[19];
memcpy(origx, x, 10 * sizeof(limb));
fsum(x, z);
/* |x[i]| < 2^27 */
fdifference(z, origx); /* does x - z */
/* |z[i]| < 2^27 */
memcpy(origxprime, xprime, sizeof(limb) * 10);
fsum(xprime, zprime);
/* |xprime[i]| < 2^27 */
fdifference(zprime, origxprime);
/* |zprime[i]| < 2^27 */
fproduct(xxprime, xprime, z);
/* |xxprime[i]| < 14*2^54: the largest product of two limbs will be <
* 2^(27+27) and fproduct adds together, at most, 14 of those products.
* (Approximating that to 2^58 doesn't work out.) */
fproduct(zzprime, x, zprime);
/* |zzprime[i]| < 14*2^54 */
freduce_degree(xxprime);
freduce_coefficients(xxprime);
/* |xxprime[i]| < 2^26 */
freduce_degree(zzprime);
freduce_coefficients(zzprime);
/* |zzprime[i]| < 2^26 */
memcpy(origxprime, xxprime, sizeof(limb) * 10);
fsum(xxprime, zzprime);
/* |xxprime[i]| < 2^27 */
fdifference(zzprime, origxprime);
/* |zzprime[i]| < 2^27 */
fsquare(xxxprime, xxprime);
/* |xxxprime[i]| < 2^26 */
fsquare(zzzprime, zzprime);
/* |zzzprime[i]| < 2^26 */
fproduct(zzprime, zzzprime, qmqp);
/* |zzprime[i]| < 14*2^52 */
freduce_degree(zzprime);
freduce_coefficients(zzprime);
/* |zzprime[i]| < 2^26 */
memcpy(x3, xxxprime, sizeof(limb) * 10);
memcpy(z3, zzprime, sizeof(limb) * 10);
fsquare(xx, x);
/* |xx[i]| < 2^26 */
fsquare(zz, z);
/* |zz[i]| < 2^26 */
fproduct(x2, xx, zz);
/* |x2[i]| < 14*2^52 */
freduce_degree(x2);
freduce_coefficients(x2);
/* |x2[i]| < 2^26 */
fdifference(zz, xx); // does zz = xx - zz
/* |zz[i]| < 2^27 */
memset(zzz + 10, 0, sizeof(limb) * 9);
fscalar_product(zzz, zz, 121665);
/* |zzz[i]| < 2^(27+17) */
/* No need to call freduce_degree here:
fscalar_product doesn't increase the degree of its input. */
freduce_coefficients(zzz);
/* |zzz[i]| < 2^26 */
fsum(zzz, xx);
/* |zzz[i]| < 2^27 */
fproduct(z2, zz, zzz);
/* |z2[i]| < 14*2^(26+27) */
freduce_degree(z2);
freduce_coefficients(z2);
/* |z2|i| < 2^26 */
}
__device__ static inline void swap_conditional(limb a[19], limb b[19], limb iswap) {
unsigned i;
const s32 swap = (s32) -iswap;
for (i = 0; i < 10; ++i) {
const s32 x = swap & ( ((s32)a[i]) ^ ((s32)b[i]) );
a[i] = ((s32)a[i]) ^ x;
b[i] = ((s32)b[i]) ^ x;
}
}
__device__ static inline void cmult(limb *resultx, limb *resultz, const u8 *n, const limb *q) {
limb a[19] = {0}, b[19] = {1}, c[19] = {1}, d[19] = {0};
limb *nqpqx = a, *nqpqz = b, *nqx = c, *nqz = d, *t;
limb e[19] = {0}, f[19] = {1}, g[19] = {0}, h[19] = {1};
limb *nqpqx2 = e, *nqpqz2 = f, *nqx2 = g, *nqz2 = h;
unsigned i, j;
memcpy(nqpqx, q, sizeof(limb) * 10);
for (i = 0; i < 32; ++i) {
u8 byte = n[31 - i];
for (j = 0; j < 8; ++j) {
const limb bit = byte >> 7;
swap_conditional(nqx, nqpqx, bit);
swap_conditional(nqz, nqpqz, bit);
fmonty(nqx2, nqz2,
nqpqx2, nqpqz2,
nqx, nqz,
nqpqx, nqpqz,
q);
swap_conditional(nqx2, nqpqx2, bit);
swap_conditional(nqz2, nqpqz2, bit);
t = nqx;
nqx = nqx2;
nqx2 = t;
t = nqz;
nqz = nqz2;
nqz2 = t;
t = nqpqx;
nqpqx = nqpqx2;
nqpqx2 = t;
t = nqpqz;
nqpqz = nqpqz2;
nqpqz2 = t;
byte <<= 1;
}
}
memcpy(resultx, nqx, sizeof(limb) * 10);
memcpy(resultz, nqz, sizeof(limb) * 10);
}
__device__ static inline void crecip(limb *out, const limb *z) {
limb z2[10];
limb z9[10];
limb z11[10];
limb z2_5_0[10];
limb z2_10_0[10];
limb z2_20_0[10];
limb z2_50_0[10];
limb z2_100_0[10];
limb t0[10];
limb t1[10];
int i;
/* 2 */ fsquare(z2,z);
/* 4 */ fsquare(t1,z2);
/* 8 */ fsquare(t0,t1);
/* 9 */ fmul(z9,t0,z);
/* 11 */ fmul(z11,z9,z2);
/* 22 */ fsquare(t0,z11);
/* 2^5 - 2^0 = 31 */ fmul(z2_5_0,t0,z9);
/* 2^6 - 2^1 */ fsquare(t0,z2_5_0);
/* 2^7 - 2^2 */ fsquare(t1,t0);
/* 2^8 - 2^3 */ fsquare(t0,t1);
/* 2^9 - 2^4 */ fsquare(t1,t0);
/* 2^10 - 2^5 */ fsquare(t0,t1);
/* 2^10 - 2^0 */ fmul(z2_10_0,t0,z2_5_0);
/* 2^11 - 2^1 */ fsquare(t0,z2_10_0);
/* 2^12 - 2^2 */ fsquare(t1,t0);
/* 2^20 - 2^10 */ for (i = 2;i < 10;i += 2) { fsquare(t0,t1); fsquare(t1,t0); }
/* 2^20 - 2^0 */ fmul(z2_20_0,t1,z2_10_0);
/* 2^21 - 2^1 */ fsquare(t0,z2_20_0);
/* 2^22 - 2^2 */ fsquare(t1,t0);
/* 2^40 - 2^20 */ for (i = 2;i < 20;i += 2) { fsquare(t0,t1); fsquare(t1,t0); }
/* 2^40 - 2^0 */ fmul(t0,t1,z2_20_0);
/* 2^41 - 2^1 */ fsquare(t1,t0);
/* 2^42 - 2^2 */ fsquare(t0,t1);
/* 2^50 - 2^10 */ for (i = 2;i < 10;i += 2) { fsquare(t1,t0); fsquare(t0,t1); }
/* 2^50 - 2^0 */ fmul(z2_50_0,t0,z2_10_0);
/* 2^51 - 2^1 */ fsquare(t0,z2_50_0);
/* 2^52 - 2^2 */ fsquare(t1,t0);
/* 2^100 - 2^50 */ for (i = 2;i < 50;i += 2) { fsquare(t0,t1); fsquare(t1,t0); }
/* 2^100 - 2^0 */ fmul(z2_100_0,t1,z2_50_0);
/* 2^101 - 2^1 */ fsquare(t1,z2_100_0);
/* 2^102 - 2^2 */ fsquare(t0,t1);
/* 2^200 - 2^100 */ for (i = 2;i < 100;i += 2) { fsquare(t1,t0); fsquare(t0,t1); }
/* 2^200 - 2^0 */ fmul(t1,t0,z2_100_0);
/* 2^201 - 2^1 */ fsquare(t0,t1);
/* 2^202 - 2^2 */ fsquare(t1,t0);
/* 2^250 - 2^50 */ for (i = 2;i < 50;i += 2) { fsquare(t0,t1); fsquare(t1,t0); }
/* 2^250 - 2^0 */ fmul(t0,t1,z2_50_0);
/* 2^251 - 2^1 */ fsquare(t1,t0);
/* 2^252 - 2^2 */ fsquare(t0,t1);
/* 2^253 - 2^3 */ fsquare(t1,t0);
/* 2^254 - 2^4 */ fsquare(t0,t1);
/* 2^255 - 2^5 */ fsquare(t1,t0);
/* 2^255 - 21 */ fmul(out,t1,z11);
}
__device__ static void crypto_scalarmult(u8 *mypublic, const u8 *secret, const u8 *basepoint) {
limb bp[10], x[10], z[11], zmone[10];
uint8_t e[32];
int i;
for (i = 0; i < 32; ++i) e[i] = secret[i];
e[0] &= 248;
e[31] &= 127;
e[31] |= 64;
fexpand(bp, basepoint);
cmult(x, z, e, bp);
crecip(zmone, z);
fmul(z, x, zmone);
fcontract(mypublic, z);
}
__device__ static const unsigned char base[32] = {9};
__device__ static inline void crypto_scalarmult_base(unsigned char *q,const unsigned char *n)
{
crypto_scalarmult(q,n,base);
}
//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
// Ed25519 ref from: http://bench.cr.yp.to/supercop.html
typedef struct
{
crypto_uint32 v[32];
}
fe25519;
typedef struct
{
crypto_uint32 v[32];
}
sc25519;
typedef struct
{
crypto_uint32 v[16];
}
shortsc25519;
typedef struct
{
fe25519 x;
fe25519 y;
fe25519 z;
fe25519 t;
} ge25519;
#define ge25519_p3 ge25519
typedef struct
{
fe25519 x;
fe25519 z;
fe25519 y;
fe25519 t;
} ge25519_p1p1;
typedef struct
{
fe25519 x;
fe25519 y;
fe25519 z;
} ge25519_p2;
typedef struct
{
fe25519 x;
fe25519 y;
} ge25519_aff;
__device__ static inline void fe25519_sub(fe25519 *r, const fe25519 *x, const fe25519 *y);
__device__ static inline crypto_uint32 equal(crypto_uint32 a,crypto_uint32 b) /* 16-bit inputs */
{
crypto_uint32 x = a ^ b; /* 0: yes; 1..65535: no */
x -= 1; /* 4294967295: yes; 0..65534: no */
x >>= 31; /* 1: yes; 0: no */
return x;
}
__device__ static inline crypto_uint32 ge(crypto_uint32 a,crypto_uint32 b) /* 16-bit inputs */
{
unsigned int x = a;
x -= (unsigned int) b; /* 0..65535: yes; 4294901761..4294967295: no */
x >>= 31; /* 0: yes; 1: no */
x ^= 1; /* 1: yes; 0: no */
return x;
}
__device__ static inline crypto_uint32 times19(crypto_uint32 a)
{
return (a << 4) + (a << 1) + a;
}
__device__ static inline crypto_uint32 times38(crypto_uint32 a)
{
return (a << 5) + (a << 2) + (a << 1);
}
__device__ static inline void reduce_add_sub(fe25519 *r)
{
crypto_uint32 t;
int i,rep;
for(rep=0;rep<4;rep++)
{
t = r->v[31] >> 7;
r->v[31] &= 127;
t = times19(t);
r->v[0] += t;
for(i=0;i<31;i++)
{
t = r->v[i] >> 8;
r->v[i+1] += t;
r->v[i] &= 255;
}
}
}
__device__ static inline void reduce_mul(fe25519 *r)
{
crypto_uint32 t;
int i,rep;
for(rep=0;rep<2;rep++)
{
t = r->v[31] >> 7;
r->v[31] &= 127;
t = times19(t);
r->v[0] += t;
for(i=0;i<31;i++)
{
t = r->v[i] >> 8;
r->v[i+1] += t;
r->v[i] &= 255;
}
}
}
/* reduction modulo 2^255-19 */
__device__ static inline void fe25519_freeze(fe25519 *r)
{
int i;
crypto_uint32 m = equal(r->v[31],127);
for(i=30;i>0;i--)
m &= equal(r->v[i],255);
m &= ge(r->v[0],237);
m = -m;
r->v[31] -= m&127;
for(i=30;i>0;i--)
r->v[i] -= m&255;
r->v[0] -= m&237;
}
__device__ static inline void fe25519_unpack(fe25519 *r, const unsigned char x[32])
{
int i;
for(i=0;i<32;i++) r->v[i] = x[i];
r->v[31] &= 127;
}
/* Assumes input x being reduced below 2^255 */
__device__ static inline void fe25519_pack(unsigned char r[32], const fe25519 *x)
{
int i;
fe25519 y = *x;
fe25519_freeze(&y);
for(i=0;i<32;i++)
r[i] = y.v[i];
}
__device__ static inline int fe25519_iseq_vartime(const fe25519 *x, const fe25519 *y)
{
int i;
fe25519 t1 = *x;
fe25519 t2 = *y;
fe25519_freeze(&t1);
fe25519_freeze(&t2);
for(i=0;i<32;i++)
if(t1.v[i] != t2.v[i]) return 0;
return 1;
}
__device__ static inline void fe25519_cmov(fe25519 *r, const fe25519 *x, unsigned char b)
{
int i;
crypto_uint32 mask = b;
mask = -mask;
for(i=0;i<32;i++) r->v[i] ^= mask & (x->v[i] ^ r->v[i]);
}
__device__ static inline unsigned char fe25519_getparity(const fe25519 *x)
{
fe25519 t = *x;
fe25519_freeze(&t);
return t.v[0] & 1;
}
__device__ static inline void fe25519_setone(fe25519 *r)
{
int i;
r->v[0] = 1;
for(i=1;i<32;i++) r->v[i]=0;
}
__device__ static inline void fe25519_setzero(fe25519 *r)
{
int i;
for(i=0;i<32;i++) r->v[i]=0;
}
__device__ static inline void fe25519_neg(fe25519 *r, const fe25519 *x)
{
fe25519 t;
int i;
for(i=0;i<32;i++) t.v[i]=x->v[i];
fe25519_setzero(r);
fe25519_sub(r, r, &t);
}
__device__ static inline void fe25519_add(fe25519 *r, const fe25519 *x, const fe25519 *y)
{
int i;
for(i=0;i<32;i++) r->v[i] = x->v[i] + y->v[i];
reduce_add_sub(r);
}
__device__ static inline void fe25519_sub(fe25519 *r, const fe25519 *x, const fe25519 *y)
{
int i;
crypto_uint32 t[32];
t[0] = x->v[0] + 0x1da;
t[31] = x->v[31] + 0xfe;
for(i=1;i<31;i++) t[i] = x->v[i] + 0x1fe;
for(i=0;i<32;i++) r->v[i] = t[i] - y->v[i];
reduce_add_sub(r);
}
__device__ static inline void fe25519_mul(fe25519 *r, const fe25519 *x, const fe25519 *y)
{
int i,j;
crypto_uint32 t[63];
for(i=0;i<63;i++)t[i] = 0;
for(i=0;i<32;i++)
for(j=0;j<32;j++)
t[i+j] += x->v[i] * y->v[j];
for(i=32;i<63;i++)
r->v[i-32] = t[i-32] + times38(t[i]);
r->v[31] = t[31]; /* result now in r[0]...r[31] */
reduce_mul(r);
}
__device__ static inline void fe25519_square(fe25519 *r, const fe25519 *x)
{
fe25519_mul(r, x, x);
}
__device__ static inline void fe25519_invert(fe25519 *r, const fe25519 *x)
{
fe25519 z2;
fe25519 z9;
fe25519 z11;
fe25519 z2_5_0;
fe25519 z2_10_0;
fe25519 z2_20_0;
fe25519 z2_50_0;
fe25519 z2_100_0;
fe25519 t0;
fe25519 t1;
int i;
/* 2 */ fe25519_square(&z2,x);
/* 4 */ fe25519_square(&t1,&z2);
/* 8 */ fe25519_square(&t0,&t1);
/* 9 */ fe25519_mul(&z9,&t0,x);
/* 11 */ fe25519_mul(&z11,&z9,&z2);
/* 22 */ fe25519_square(&t0,&z11);
/* 2^5 - 2^0 = 31 */ fe25519_mul(&z2_5_0,&t0,&z9);
/* 2^6 - 2^1 */ fe25519_square(&t0,&z2_5_0);
/* 2^7 - 2^2 */ fe25519_square(&t1,&t0);
/* 2^8 - 2^3 */ fe25519_square(&t0,&t1);
/* 2^9 - 2^4 */ fe25519_square(&t1,&t0);
/* 2^10 - 2^5 */ fe25519_square(&t0,&t1);
/* 2^10 - 2^0 */ fe25519_mul(&z2_10_0,&t0,&z2_5_0);
/* 2^11 - 2^1 */ fe25519_square(&t0,&z2_10_0);
/* 2^12 - 2^2 */ fe25519_square(&t1,&t0);
/* 2^20 - 2^10 */ for (i = 2;i < 10;i += 2) { fe25519_square(&t0,&t1); fe25519_square(&t1,&t0); }
/* 2^20 - 2^0 */ fe25519_mul(&z2_20_0,&t1,&z2_10_0);
/* 2^21 - 2^1 */ fe25519_square(&t0,&z2_20_0);
/* 2^22 - 2^2 */ fe25519_square(&t1,&t0);
/* 2^40 - 2^20 */ for (i = 2;i < 20;i += 2) { fe25519_square(&t0,&t1); fe25519_square(&t1,&t0); }
/* 2^40 - 2^0 */ fe25519_mul(&t0,&t1,&z2_20_0);
/* 2^41 - 2^1 */ fe25519_square(&t1,&t0);
/* 2^42 - 2^2 */ fe25519_square(&t0,&t1);
/* 2^50 - 2^10 */ for (i = 2;i < 10;i += 2) { fe25519_square(&t1,&t0); fe25519_square(&t0,&t1); }
/* 2^50 - 2^0 */ fe25519_mul(&z2_50_0,&t0,&z2_10_0);
/* 2^51 - 2^1 */ fe25519_square(&t0,&z2_50_0);
/* 2^52 - 2^2 */ fe25519_square(&t1,&t0);
/* 2^100 - 2^50 */ for (i = 2;i < 50;i += 2) { fe25519_square(&t0,&t1); fe25519_square(&t1,&t0); }
/* 2^100 - 2^0 */ fe25519_mul(&z2_100_0,&t1,&z2_50_0);
/* 2^101 - 2^1 */ fe25519_square(&t1,&z2_100_0);
/* 2^102 - 2^2 */ fe25519_square(&t0,&t1);
/* 2^200 - 2^100 */ for (i = 2;i < 100;i += 2) { fe25519_square(&t1,&t0); fe25519_square(&t0,&t1); }
/* 2^200 - 2^0 */ fe25519_mul(&t1,&t0,&z2_100_0);
/* 2^201 - 2^1 */ fe25519_square(&t0,&t1);
/* 2^202 - 2^2 */ fe25519_square(&t1,&t0);
/* 2^250 - 2^50 */ for (i = 2;i < 50;i += 2) { fe25519_square(&t0,&t1); fe25519_square(&t1,&t0); }
/* 2^250 - 2^0 */ fe25519_mul(&t0,&t1,&z2_50_0);
/* 2^251 - 2^1 */ fe25519_square(&t1,&t0);
/* 2^252 - 2^2 */ fe25519_square(&t0,&t1);
/* 2^253 - 2^3 */ fe25519_square(&t1,&t0);
/* 2^254 - 2^4 */ fe25519_square(&t0,&t1);
/* 2^255 - 2^5 */ fe25519_square(&t1,&t0);
/* 2^255 - 21 */ fe25519_mul(r,&t1,&z11);
}
__device__ static inline void fe25519_pow2523(fe25519 *r, const fe25519 *x)
{
fe25519 z2;
fe25519 z9;
fe25519 z11;
fe25519 z2_5_0;
fe25519 z2_10_0;
fe25519 z2_20_0;
fe25519 z2_50_0;
fe25519 z2_100_0;
fe25519 t;
int i;
/* 2 */ fe25519_square(&z2,x);
/* 4 */ fe25519_square(&t,&z2);
/* 8 */ fe25519_square(&t,&t);
/* 9 */ fe25519_mul(&z9,&t,x);
/* 11 */ fe25519_mul(&z11,&z9,&z2);
/* 22 */ fe25519_square(&t,&z11);
/* 2^5 - 2^0 = 31 */ fe25519_mul(&z2_5_0,&t,&z9);
/* 2^6 - 2^1 */ fe25519_square(&t,&z2_5_0);
/* 2^10 - 2^5 */ for (i = 1;i < 5;i++) { fe25519_square(&t,&t); }
/* 2^10 - 2^0 */ fe25519_mul(&z2_10_0,&t,&z2_5_0);
/* 2^11 - 2^1 */ fe25519_square(&t,&z2_10_0);
/* 2^20 - 2^10 */ for (i = 1;i < 10;i++) { fe25519_square(&t,&t); }
/* 2^20 - 2^0 */ fe25519_mul(&z2_20_0,&t,&z2_10_0);
/* 2^21 - 2^1 */ fe25519_square(&t,&z2_20_0);
/* 2^40 - 2^20 */ for (i = 1;i < 20;i++) { fe25519_square(&t,&t); }
/* 2^40 - 2^0 */ fe25519_mul(&t,&t,&z2_20_0);
/* 2^41 - 2^1 */ fe25519_square(&t,&t);
/* 2^50 - 2^10 */ for (i = 1;i < 10;i++) { fe25519_square(&t,&t); }
/* 2^50 - 2^0 */ fe25519_mul(&z2_50_0,&t,&z2_10_0);
/* 2^51 - 2^1 */ fe25519_square(&t,&z2_50_0);
/* 2^100 - 2^50 */ for (i = 1;i < 50;i++) { fe25519_square(&t,&t); }
/* 2^100 - 2^0 */ fe25519_mul(&z2_100_0,&t,&z2_50_0);
/* 2^101 - 2^1 */ fe25519_square(&t,&z2_100_0);
/* 2^200 - 2^100 */ for (i = 1;i < 100;i++) { fe25519_square(&t,&t); }
/* 2^200 - 2^0 */ fe25519_mul(&t,&t,&z2_100_0);
/* 2^201 - 2^1 */ fe25519_square(&t,&t);
/* 2^250 - 2^50 */ for (i = 1;i < 50;i++) { fe25519_square(&t,&t); }
/* 2^250 - 2^0 */ fe25519_mul(&t,&t,&z2_50_0);
/* 2^251 - 2^1 */ fe25519_square(&t,&t);
/* 2^252 - 2^2 */ fe25519_square(&t,&t);
/* 2^252 - 3 */ fe25519_mul(r,&t,x);
}
__device__ static const crypto_uint32 m[32] = {0xED, 0xD3, 0xF5, 0x5C, 0x1A, 0x63, 0x12, 0x58, 0xD6, 0x9C, 0xF7, 0xA2, 0xDE, 0xF9, 0xDE, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10};
__device__ static const crypto_uint32 mu[33] = {0x1B, 0x13, 0x2C, 0x0A, 0xA3, 0xE5, 0x9C, 0xED, 0xA7, 0x29, 0x63, 0x08, 0x5D, 0x21, 0x06, 0x21, 0xEB, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x0F};
__device__ static inline crypto_uint32 lt(crypto_uint32 a,crypto_uint32 b) /* 16-bit inputs */
{
unsigned int x = a;
x -= (unsigned int) b; /* 0..65535: no; 4294901761..4294967295: yes */
x >>= 31; /* 0: no; 1: yes */
return x;
}
/* Reduce coefficients of r before calling reduce_add_sub */
__device__ static inline void reduce_add_sub(sc25519 *r)
{
crypto_uint32 pb = 0;
crypto_uint32 b;
crypto_uint32 mask;
int i;
unsigned char t[32];
for(i=0;i<32;i++)
{
pb += m[i];
b = lt(r->v[i],pb);
t[i] = r->v[i]-pb+(b<<8);
pb = b;
}
mask = b - 1;
for(i=0;i<32;i++)
r->v[i] ^= mask & (r->v[i] ^ t[i]);
}
/* Reduce coefficients of x before calling barrett_reduce */
__device__ static inline void barrett_reduce(sc25519 *r, const crypto_uint32 x[64])
{
/* See HAC, Alg. 14.42 */
int i,j;
crypto_uint32 q2[66];
crypto_uint32 *q3 = q2 + 33;
crypto_uint32 r1[33];
crypto_uint32 r2[33];
crypto_uint32 carry;
crypto_uint32 pb = 0;
crypto_uint32 b;
for (i = 0;i < 66;++i) q2[i] = 0;
for (i = 0;i < 33;++i) r2[i] = 0;
for(i=0;i<33;i++)
for(j=0;j<33;j++)
if(i+j >= 31) q2[i+j] += mu[i]*x[j+31];
carry = q2[31] >> 8;
q2[32] += carry;
carry = q2[32] >> 8;
q2[33] += carry;
for(i=0;i<33;i++)r1[i] = x[i];
for(i=0;i<32;i++)
for(j=0;j<33;j++)
if(i+j < 33) r2[i+j] += m[i]*q3[j];
for(i=0;i<32;i++)
{
carry = r2[i] >> 8;
r2[i+1] += carry;
r2[i] &= 0xff;
}
for(i=0;i<32;i++)
{
pb += r2[i];
b = lt(r1[i],pb);
r->v[i] = r1[i]-pb+(b<<8);
pb = b;
}
/* XXX: Can it really happen that r<0?, See HAC, Alg 14.42, Step 3
* If so: Handle it here!
*/
reduce_add_sub(r);
reduce_add_sub(r);
}
__device__ static inline void sc25519_from32bytes(sc25519 *r, const unsigned char x[32])
{
int i;
crypto_uint32 t[64];
for(i=0;i<32;i++) t[i] = x[i];
for(i=32;i<64;++i) t[i] = 0;
barrett_reduce(r, t);
}
__device__ static inline void sc25519_from64bytes(sc25519 *r, const unsigned char x[64])
{
int i;
crypto_uint32 t[64];
for(i=0;i<64;i++) t[i] = x[i];
barrett_reduce(r, t);
}
__device__ static inline void sc25519_to32bytes(unsigned char r[32], const sc25519 *x)
{
int i;
for(i=0;i<32;i++) r[i] = x->v[i];
}
__device__ static inline void sc25519_add(sc25519 *r, const sc25519 *x, const sc25519 *y)
{
int i, carry;
for(i=0;i<32;i++) r->v[i] = x->v[i] + y->v[i];
for(i=0;i<31;i++)
{
carry = r->v[i] >> 8;
r->v[i+1] += carry;
r->v[i] &= 0xff;
}
reduce_add_sub(r);
}
__device__ static inline void sc25519_mul(sc25519 *r, const sc25519 *x, const sc25519 *y)
{
int i,j,carry;
crypto_uint32 t[64];
for(i=0;i<64;i++)t[i] = 0;
for(i=0;i<32;i++)
for(j=0;j<32;j++)
t[i+j] += x->v[i] * y->v[j];
for(i=0;i<63;i++)
{
carry = t[i] >> 8;
t[i+1] += carry;
t[i] &= 0xff;
}
barrett_reduce(r, t);
}
__device__ static inline void sc25519_window3(signed char r[85], const sc25519 *s)
{
char carry;
int i;
for(i=0;i<10;i++)
{
r[8*i+0] = s->v[3*i+0] & 7;
r[8*i+1] = (s->v[3*i+0] >> 3) & 7;
r[8*i+2] = (s->v[3*i+0] >> 6) & 7;
r[8*i+2] ^= (s->v[3*i+1] << 2) & 7;
r[8*i+3] = (s->v[3*i+1] >> 1) & 7;
r[8*i+4] = (s->v[3*i+1] >> 4) & 7;
r[8*i+5] = (s->v[3*i+1] >> 7) & 7;
r[8*i+5] ^= (s->v[3*i+2] << 1) & 7;
r[8*i+6] = (s->v[3*i+2] >> 2) & 7;
r[8*i+7] = (s->v[3*i+2] >> 5) & 7;
}
r[8*i+0] = s->v[3*i+0] & 7;
r[8*i+1] = (s->v[3*i+0] >> 3) & 7;
r[8*i+2] = (s->v[3*i+0] >> 6) & 7;
r[8*i+2] ^= (s->v[3*i+1] << 2) & 7;
r[8*i+3] = (s->v[3*i+1] >> 1) & 7;
r[8*i+4] = (s->v[3*i+1] >> 4) & 7;
/* Making it signed */
carry = 0;
for(i=0;i<84;i++)
{
r[i] += carry;
r[i+1] += r[i] >> 3;
r[i] &= 7;
carry = r[i] >> 2;
r[i] -= carry<<3;
}
r[84] += carry;
}
__device__ static inline void sc25519_2interleave2(unsigned char r[127], const sc25519 *s1, const sc25519 *s2)
{
int i;
for(i=0;i<31;i++)
{
r[4*i] = ( s1->v[i] & 3) ^ (( s2->v[i] & 3) << 2);
r[4*i+1] = ((s1->v[i] >> 2) & 3) ^ (((s2->v[i] >> 2) & 3) << 2);
r[4*i+2] = ((s1->v[i] >> 4) & 3) ^ (((s2->v[i] >> 4) & 3) << 2);
r[4*i+3] = ((s1->v[i] >> 6) & 3) ^ (((s2->v[i] >> 6) & 3) << 2);
}
r[124] = ( s1->v[31] & 3) ^ (( s2->v[31] & 3) << 2);
r[125] = ((s1->v[31] >> 2) & 3) ^ (((s2->v[31] >> 2) & 3) << 2);
r[126] = ((s1->v[31] >> 4) & 3) ^ (((s2->v[31] >> 4) & 3) << 2);
}
/* d */
__device__ static const fe25519 ge25519_ecd = {{0xA3, 0x78, 0x59, 0x13, 0xCA, 0x4D, 0xEB, 0x75, 0xAB, 0xD8, 0x41, 0x41, 0x4D, 0x0A, 0x70, 0x00,
0x98, 0xE8, 0x79, 0x77, 0x79, 0x40, 0xC7, 0x8C, 0x73, 0xFE, 0x6F, 0x2B, 0xEE, 0x6C, 0x03, 0x52}};
/* 2*d */
__device__ static const fe25519 ge25519_ec2d = {{0x59, 0xF1, 0xB2, 0x26, 0x94, 0x9B, 0xD6, 0xEB, 0x56, 0xB1, 0x83, 0x82, 0x9A, 0x14, 0xE0, 0x00,
0x30, 0xD1, 0xF3, 0xEE, 0xF2, 0x80, 0x8E, 0x19, 0xE7, 0xFC, 0xDF, 0x56, 0xDC, 0xD9, 0x06, 0x24}};
/* sqrt(-1) */
__device__ static const fe25519 ge25519_sqrtm1 = {{0xB0, 0xA0, 0x0E, 0x4A, 0x27, 0x1B, 0xEE, 0xC4, 0x78, 0xE4, 0x2F, 0xAD, 0x06, 0x18, 0x43, 0x2F,
0xA7, 0xD7, 0xFB, 0x3D, 0x99, 0x00, 0x4D, 0x2B, 0x0B, 0xDF, 0xC1, 0x4F, 0x80, 0x24, 0x83, 0x2B}};
/* Packed coordinates of the base point */
__device__ static const ge25519 ge25519_base = {{{0x1A, 0xD5, 0x25, 0x8F, 0x60, 0x2D, 0x56, 0xC9, 0xB2, 0xA7, 0x25, 0x95, 0x60, 0xC7, 0x2C, 0x69,
0x5C, 0xDC, 0xD6, 0xFD, 0x31, 0xE2, 0xA4, 0xC0, 0xFE, 0x53, 0x6E, 0xCD, 0xD3, 0x36, 0x69, 0x21}},
{{0x58, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66,
0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66}},
{{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
{{0xA3, 0xDD, 0xB7, 0xA5, 0xB3, 0x8A, 0xDE, 0x6D, 0xF5, 0x52, 0x51, 0x77, 0x80, 0x9F, 0xF0, 0x20,
0x7D, 0xE3, 0xAB, 0x64, 0x8E, 0x4E, 0xEA, 0x66, 0x65, 0x76, 0x8B, 0xD7, 0x0F, 0x5F, 0x87, 0x67}}};
/* Multiples of the base point in affine representation */
__device__ static const ge25519_aff ge25519_base_multiples_affine[425] = {
{{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
{{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
{{{0x1a, 0xd5, 0x25, 0x8f, 0x60, 0x2d, 0x56, 0xc9, 0xb2, 0xa7, 0x25, 0x95, 0x60, 0xc7, 0x2c, 0x69, 0x5c, 0xdc, 0xd6, 0xfd, 0x31, 0xe2, 0xa4, 0xc0, 0xfe, 0x53, 0x6e, 0xcd, 0xd3, 0x36, 0x69, 0x21}} ,
{{0x58, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66}}},
{{{0x0e, 0xce, 0x43, 0x28, 0x4e, 0xa1, 0xc5, 0x83, 0x5f, 0xa4, 0xd7, 0x15, 0x45, 0x8e, 0x0d, 0x08, 0xac, 0xe7, 0x33, 0x18, 0x7d, 0x3b, 0x04, 0x3d, 0x6c, 0x04, 0x5a, 0x9f, 0x4c, 0x38, 0xab, 0x36}} ,
{{0xc9, 0xa3, 0xf8, 0x6a, 0xae, 0x46, 0x5f, 0x0e, 0x56, 0x51, 0x38, 0x64, 0x51, 0x0f, 0x39, 0x97, 0x56, 0x1f, 0xa2, 0xc9, 0xe8, 0x5e, 0xa2, 0x1d, 0xc2, 0x29, 0x23, 0x09, 0xf3, 0xcd, 0x60, 0x22}}},
{{{0x5c, 0xe2, 0xf8, 0xd3, 0x5f, 0x48, 0x62, 0xac, 0x86, 0x48, 0x62, 0x81, 0x19, 0x98, 0x43, 0x63, 0x3a, 0xc8, 0xda, 0x3e, 0x74, 0xae, 0xf4, 0x1f, 0x49, 0x8f, 0x92, 0x22, 0x4a, 0x9c, 0xae, 0x67}} ,
{{0xd4, 0xb4, 0xf5, 0x78, 0x48, 0x68, 0xc3, 0x02, 0x04, 0x03, 0x24, 0x67, 0x17, 0xec, 0x16, 0x9f, 0xf7, 0x9e, 0x26, 0x60, 0x8e, 0xa1, 0x26, 0xa1, 0xab, 0x69, 0xee, 0x77, 0xd1, 0xb1, 0x67, 0x12}}},
{{{0x70, 0xf8, 0xc9, 0xc4, 0x57, 0xa6, 0x3a, 0x49, 0x47, 0x15, 0xce, 0x93, 0xc1, 0x9e, 0x73, 0x1a, 0xf9, 0x20, 0x35, 0x7a, 0xb8, 0xd4, 0x25, 0x83, 0x46, 0xf1, 0xcf, 0x56, 0xdb, 0xa8, 0x3d, 0x20}} ,
{{0x2f, 0x11, 0x32, 0xca, 0x61, 0xab, 0x38, 0xdf, 0xf0, 0x0f, 0x2f, 0xea, 0x32, 0x28, 0xf2, 0x4c, 0x6c, 0x71, 0xd5, 0x80, 0x85, 0xb8, 0x0e, 0x47, 0xe1, 0x95, 0x15, 0xcb, 0x27, 0xe8, 0xd0, 0x47}}},
{{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
{{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
{{{0xc8, 0x84, 0xa5, 0x08, 0xbc, 0xfd, 0x87, 0x3b, 0x99, 0x8b, 0x69, 0x80, 0x7b, 0xc6, 0x3a, 0xeb, 0x93, 0xcf, 0x4e, 0xf8, 0x5c, 0x2d, 0x86, 0x42, 0xb6, 0x71, 0xd7, 0x97, 0x5f, 0xe1, 0x42, 0x67}} ,
{{0xb4, 0xb9, 0x37, 0xfc, 0xa9, 0x5b, 0x2f, 0x1e, 0x93, 0xe4, 0x1e, 0x62, 0xfc, 0x3c, 0x78, 0x81, 0x8f, 0xf3, 0x8a, 0x66, 0x09, 0x6f, 0xad, 0x6e, 0x79, 0x73, 0xe5, 0xc9, 0x00, 0x06, 0xd3, 0x21}}},
{{{0xf8, 0xf9, 0x28, 0x6c, 0x6d, 0x59, 0xb2, 0x59, 0x74, 0x23, 0xbf, 0xe7, 0x33, 0x8d, 0x57, 0x09, 0x91, 0x9c, 0x24, 0x08, 0x15, 0x2b, 0xe2, 0xb8, 0xee, 0x3a, 0xe5, 0x27, 0x06, 0x86, 0xa4, 0x23}} ,
{{0xeb, 0x27, 0x67, 0xc1, 0x37, 0xab, 0x7a, 0xd8, 0x27, 0x9c, 0x07, 0x8e, 0xff, 0x11, 0x6a, 0xb0, 0x78, 0x6e, 0xad, 0x3a, 0x2e, 0x0f, 0x98, 0x9f, 0x72, 0xc3, 0x7f, 0x82, 0xf2, 0x96, 0x96, 0x70}}},
{{{0x81, 0x6b, 0x88, 0xe8, 0x1e, 0xc7, 0x77, 0x96, 0x0e, 0xa1, 0xa9, 0x52, 0xe0, 0xd8, 0x0e, 0x61, 0x9e, 0x79, 0x2d, 0x95, 0x9c, 0x8d, 0x96, 0xe0, 0x06, 0x40, 0x5d, 0x87, 0x28, 0x5f, 0x98, 0x70}} ,
{{0xf1, 0x79, 0x7b, 0xed, 0x4f, 0x44, 0xb2, 0xe7, 0x08, 0x0d, 0xc2, 0x08, 0x12, 0xd2, 0x9f, 0xdf, 0xcd, 0x93, 0x20, 0x8a, 0xcf, 0x33, 0xca, 0x6d, 0x89, 0xb9, 0x77, 0xc8, 0x93, 0x1b, 0x4e, 0x60}}},
{{{0x26, 0x4f, 0x7e, 0x97, 0xf6, 0x40, 0xdd, 0x4f, 0xfc, 0x52, 0x78, 0xf9, 0x90, 0x31, 0x03, 0xe6, 0x7d, 0x56, 0x39, 0x0b, 0x1d, 0x56, 0x82, 0x85, 0xf9, 0x1a, 0x42, 0x17, 0x69, 0x6c, 0xcf, 0x39}} ,
{{0x69, 0xd2, 0x06, 0x3a, 0x4f, 0x39, 0x2d, 0xf9, 0x38, 0x40, 0x8c, 0x4c, 0xe7, 0x05, 0x12, 0xb4, 0x78, 0x8b, 0xf8, 0xc0, 0xec, 0x93, 0xde, 0x7a, 0x6b, 0xce, 0x2c, 0xe1, 0x0e, 0xa9, 0x34, 0x44}}},
{{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
{{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
{{{0x0b, 0xa4, 0x3c, 0xb0, 0x0f, 0x7a, 0x51, 0xf1, 0x78, 0xd6, 0xd9, 0x6a, 0xfd, 0x46, 0xe8, 0xb8, 0xa8, 0x79, 0x1d, 0x87, 0xf9, 0x90, 0xf2, 0x9c, 0x13, 0x29, 0xf8, 0x0b, 0x20, 0x64, 0xfa, 0x05}} ,
{{0x26, 0x09, 0xda, 0x17, 0xaf, 0x95, 0xd6, 0xfb, 0x6a, 0x19, 0x0d, 0x6e, 0x5e, 0x12, 0xf1, 0x99, 0x4c, 0xaa, 0xa8, 0x6f, 0x79, 0x86, 0xf4, 0x72, 0x28, 0x00, 0x26, 0xf9, 0xea, 0x9e, 0x19, 0x3d}}},
{{{0x87, 0xdd, 0xcf, 0xf0, 0x5b, 0x49, 0xa2, 0x5d, 0x40, 0x7a, 0x23, 0x26, 0xa4, 0x7a, 0x83, 0x8a, 0xb7, 0x8b, 0xd2, 0x1a, 0xbf, 0xea, 0x02, 0x24, 0x08, 0x5f, 0x7b, 0xa9, 0xb1, 0xbe, 0x9d, 0x37}} ,
{{0xfc, 0x86, 0x4b, 0x08, 0xee, 0xe7, 0xa0, 0xfd, 0x21, 0x45, 0x09, 0x34, 0xc1, 0x61, 0x32, 0x23, 0xfc, 0x9b, 0x55, 0x48, 0x53, 0x99, 0xf7, 0x63, 0xd0, 0x99, 0xce, 0x01, 0xe0, 0x9f, 0xeb, 0x28}}},
{{{0x47, 0xfc, 0xab, 0x5a, 0x17, 0xf0, 0x85, 0x56, 0x3a, 0x30, 0x86, 0x20, 0x28, 0x4b, 0x8e, 0x44, 0x74, 0x3a, 0x6e, 0x02, 0xf1, 0x32, 0x8f, 0x9f, 0x3f, 0x08, 0x35, 0xe9, 0xca, 0x16, 0x5f, 0x6e}} ,
{{0x1c, 0x59, 0x1c, 0x65, 0x5d, 0x34, 0xa4, 0x09, 0xcd, 0x13, 0x9c, 0x70, 0x7d, 0xb1, 0x2a, 0xc5, 0x88, 0xaf, 0x0b, 0x60, 0xc7, 0x9f, 0x34, 0x8d, 0xd6, 0xb7, 0x7f, 0xea, 0x78, 0x65, 0x8d, 0x77}}},
{{{0x56, 0xa5, 0xc2, 0x0c, 0xdd, 0xbc, 0xb8, 0x20, 0x6d, 0x57, 0x61, 0xb5, 0xfb, 0x78, 0xb5, 0xd4, 0x49, 0x54, 0x90, 0x26, 0xc1, 0xcb, 0xe9, 0xe6, 0xbf, 0xec, 0x1d, 0x4e, 0xed, 0x07, 0x7e, 0x5e}} ,
{{0xc7, 0xf6, 0x6c, 0x56, 0x31, 0x20, 0x14, 0x0e, 0xa8, 0xd9, 0x27, 0xc1, 0x9a, 0x3d, 0x1b, 0x7d, 0x0e, 0x26, 0xd3, 0x81, 0xaa, 0xeb, 0xf5, 0x6b, 0x79, 0x02, 0xf1, 0x51, 0x5c, 0x75, 0x55, 0x0f}}},
{{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
{{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
{{{0x0a, 0x34, 0xcd, 0x82, 0x3c, 0x33, 0x09, 0x54, 0xd2, 0x61, 0x39, 0x30, 0x9b, 0xfd, 0xef, 0x21, 0x26, 0xd4, 0x70, 0xfa, 0xee, 0xf9, 0x31, 0x33, 0x73, 0x84, 0xd0, 0xb3, 0x81, 0xbf, 0xec, 0x2e}} ,
{{0xe8, 0x93, 0x8b, 0x00, 0x64, 0xf7, 0x9c, 0xb8, 0x74, 0xe0, 0xe6, 0x49, 0x48, 0x4d, 0x4d, 0x48, 0xb6, 0x19, 0xa1, 0x40, 0xb7, 0xd9, 0x32, 0x41, 0x7c, 0x82, 0x37, 0xa1, 0x2d, 0xdc, 0xd2, 0x54}}},
{{{0x68, 0x2b, 0x4a, 0x5b, 0xd5, 0xc7, 0x51, 0x91, 0x1d, 0xe1, 0x2a, 0x4b, 0xc4, 0x47, 0xf1, 0xbc, 0x7a, 0xb3, 0xcb, 0xc8, 0xb6, 0x7c, 0xac, 0x90, 0x05, 0xfd, 0xf3, 0xf9, 0x52, 0x3a, 0x11, 0x6b}} ,
{{0x3d, 0xc1, 0x27, 0xf3, 0x59, 0x43, 0x95, 0x90, 0xc5, 0x96, 0x79, 0xf5, 0xf4, 0x95, 0x65, 0x29, 0x06, 0x9c, 0x51, 0x05, 0x18, 0xda, 0xb8, 0x2e, 0x79, 0x7e, 0x69, 0x59, 0x71, 0x01, 0xeb, 0x1a}}},
{{{0x15, 0x06, 0x49, 0xb6, 0x8a, 0x3c, 0xea, 0x2f, 0x34, 0x20, 0x14, 0xc3, 0xaa, 0xd6, 0xaf, 0x2c, 0x3e, 0xbd, 0x65, 0x20, 0xe2, 0x4d, 0x4b, 0x3b, 0xeb, 0x9f, 0x4a, 0xc3, 0xad, 0xa4, 0x3b, 0x60}} ,
{{0xbc, 0x58, 0xe6, 0xc0, 0x95, 0x2a, 0x2a, 0x81, 0x9a, 0x7a, 0xf3, 0xd2, 0x06, 0xbe, 0x48, 0xbc, 0x0c, 0xc5, 0x46, 0xe0, 0x6a, 0xd4, 0xac, 0x0f, 0xd9, 0xcc, 0x82, 0x34, 0x2c, 0xaf, 0xdb, 0x1f}}},
{{{0xf7, 0x17, 0x13, 0xbd, 0xfb, 0xbc, 0xd2, 0xec, 0x45, 0xb3, 0x15, 0x31, 0xe9, 0xaf, 0x82, 0x84, 0x3d, 0x28, 0xc6, 0xfc, 0x11, 0xf5, 0x41, 0xb5, 0x8b, 0xd3, 0x12, 0x76, 0x52, 0xe7, 0x1a, 0x3c}} ,
{{0x4e, 0x36, 0x11, 0x07, 0xa2, 0x15, 0x20, 0x51, 0xc4, 0x2a, 0xc3, 0x62, 0x8b, 0x5e, 0x7f, 0xa6, 0x0f, 0xf9, 0x45, 0x85, 0x6c, 0x11, 0x86, 0xb7, 0x7e, 0xe5, 0xd7, 0xf9, 0xc3, 0x91, 0x1c, 0x05}}},
{{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
{{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
{{{0xea, 0xd6, 0xde, 0x29, 0x3a, 0x00, 0xb9, 0x02, 0x59, 0xcb, 0x26, 0xc4, 0xba, 0x99, 0xb1, 0x97, 0x2f, 0x8e, 0x00, 0x92, 0x26, 0x4f, 0x52, 0xeb, 0x47, 0x1b, 0x89, 0x8b, 0x24, 0xc0, 0x13, 0x7d}} ,
{{0xd5, 0x20, 0x5b, 0x80, 0xa6, 0x80, 0x20, 0x95, 0xc3, 0xe9, 0x9f, 0x8e, 0x87, 0x9e, 0x1e, 0x9e, 0x7a, 0xc7, 0xcc, 0x75, 0x6c, 0xa5, 0xf1, 0x91, 0x1a, 0xa8, 0x01, 0x2c, 0xab, 0x76, 0xa9, 0x59}}},
{{{0xde, 0xc9, 0xb1, 0x31, 0x10, 0x16, 0xaa, 0x35, 0x14, 0x6a, 0xd4, 0xb5, 0x34, 0x82, 0x71, 0xd2, 0x4a, 0x5d, 0x9a, 0x1f, 0x53, 0x26, 0x3c, 0xe5, 0x8e, 0x8d, 0x33, 0x7f, 0xff, 0xa9, 0xd5, 0x17}} ,
{{0x89, 0xaf, 0xf6, 0xa4, 0x64, 0xd5, 0x10, 0xe0, 0x1d, 0xad, 0xef, 0x44, 0xbd, 0xda, 0x83, 0xac, 0x7a, 0xa8, 0xf0, 0x1c, 0x07, 0xf9, 0xc3, 0x43, 0x6c, 0x3f, 0xb7, 0xd3, 0x87, 0x22, 0x02, 0x73}}},
{{{0x64, 0x1d, 0x49, 0x13, 0x2f, 0x71, 0xec, 0x69, 0x87, 0xd0, 0x42, 0xee, 0x13, 0xec, 0xe3, 0xed, 0x56, 0x7b, 0xbf, 0xbd, 0x8c, 0x2f, 0x7d, 0x7b, 0x9d, 0x28, 0xec, 0x8e, 0x76, 0x2f, 0x6f, 0x08}} ,
{{0x22, 0xf5, 0x5f, 0x4d, 0x15, 0xef, 0xfc, 0x4e, 0x57, 0x03, 0x36, 0x89, 0xf0, 0xeb, 0x5b, 0x91, 0xd6, 0xe2, 0xca, 0x01, 0xa5, 0xee, 0x52, 0xec, 0xa0, 0x3c, 0x8f, 0x33, 0x90, 0x5a, 0x94, 0x72}}},
{{{0x8a, 0x4b, 0xe7, 0x38, 0xbc, 0xda, 0xc2, 0xb0, 0x85, 0xe1, 0x4a, 0xfe, 0x2d, 0x44, 0x84, 0xcb, 0x20, 0x6b, 0x2d, 0xbf, 0x11, 0x9c, 0xd7, 0xbe, 0xd3, 0x3e, 0x5f, 0xbf, 0x68, 0xbc, 0xa8, 0x07}} ,
{{0x01, 0x89, 0x28, 0x22, 0x6a, 0x78, 0xaa, 0x29, 0x03, 0xc8, 0x74, 0x95, 0x03, 0x3e, 0xdc, 0xbd, 0x07, 0x13, 0xa8, 0xa2, 0x20, 0x2d, 0xb3, 0x18, 0x70, 0x42, 0xfd, 0x7a, 0xc4, 0xd7, 0x49, 0x72}}},
{{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
{{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
{{{0x02, 0xff, 0x32, 0x2b, 0x5c, 0x93, 0x54, 0x32, 0xe8, 0x57, 0x54, 0x1a, 0x8b, 0x33, 0x60, 0x65, 0xd3, 0x67, 0xa4, 0xc1, 0x26, 0xc4, 0xa4, 0x34, 0x1f, 0x9b, 0xa7, 0xa9, 0xf4, 0xd9, 0x4f, 0x5b}} ,
{{0x46, 0x8d, 0xb0, 0x33, 0x54, 0x26, 0x5b, 0x68, 0xdf, 0xbb, 0xc5, 0xec, 0xc2, 0xf9, 0x3c, 0x5a, 0x37, 0xc1, 0x8e, 0x27, 0x47, 0xaa, 0x49, 0x5a, 0xf8, 0xfb, 0x68, 0x04, 0x23, 0xd1, 0xeb, 0x40}}},
{{{0x65, 0xa5, 0x11, 0x84, 0x8a, 0x67, 0x9d, 0x9e, 0xd1, 0x44, 0x68, 0x7a, 0x34, 0xe1, 0x9f, 0xa3, 0x54, 0xcd, 0x07, 0xca, 0x79, 0x1f, 0x54, 0x2f, 0x13, 0x70, 0x4e, 0xee, 0xa2, 0xfa, 0xe7, 0x5d}} ,
{{0x36, 0xec, 0x54, 0xf8, 0xce, 0xe4, 0x85, 0xdf, 0xf6, 0x6f, 0x1d, 0x90, 0x08, 0xbc, 0xe8, 0xc0, 0x92, 0x2d, 0x43, 0x6b, 0x92, 0xa9, 0x8e, 0xab, 0x0a, 0x2e, 0x1c, 0x1e, 0x64, 0x23, 0x9f, 0x2c}}},
{{{0xa7, 0xd6, 0x2e, 0xd5, 0xcc, 0xd4, 0xcb, 0x5a, 0x3b, 0xa7, 0xf9, 0x46, 0x03, 0x1d, 0xad, 0x2b, 0x34, 0x31, 0x90, 0x00, 0x46, 0x08, 0x82, 0x14, 0xc4, 0xe0, 0x9c, 0xf0, 0xe3, 0x55, 0x43, 0x31}} ,
{{0x60, 0xd6, 0xdd, 0x78, 0xe6, 0xd4, 0x22, 0x42, 0x1f, 0x00, 0xf9, 0xb1, 0x6a, 0x63, 0xe2, 0x92, 0x59, 0xd1, 0x1a, 0xb7, 0x00, 0x54, 0x29, 0xc9, 0xc1, 0xf6, 0x6f, 0x7a, 0xc5, 0x3c, 0x5f, 0x65}}},
{{{0x27, 0x4f, 0xd0, 0x72, 0xb1, 0x11, 0x14, 0x27, 0x15, 0x94, 0x48, 0x81, 0x7e, 0x74, 0xd8, 0x32, 0xd5, 0xd1, 0x11, 0x28, 0x60, 0x63, 0x36, 0x32, 0x37, 0xb5, 0x13, 0x1c, 0xa0, 0x37, 0xe3, 0x74}} ,
{{0xf1, 0x25, 0x4e, 0x11, 0x96, 0x67, 0xe6, 0x1c, 0xc2, 0xb2, 0x53, 0xe2, 0xda, 0x85, 0xee, 0xb2, 0x9f, 0x59, 0xf3, 0xba, 0xbd, 0xfa, 0xcf, 0x6e, 0xf9, 0xda, 0xa4, 0xb3, 0x02, 0x8f, 0x64, 0x08}}},
{{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
{{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
{{{0x34, 0x94, 0xf2, 0x64, 0x54, 0x47, 0x37, 0x07, 0x40, 0x8a, 0x20, 0xba, 0x4a, 0x55, 0xd7, 0x3f, 0x47, 0xba, 0x25, 0x23, 0x14, 0xb0, 0x2c, 0xe8, 0x55, 0xa8, 0xa6, 0xef, 0x51, 0xbd, 0x6f, 0x6a}} ,
{{0x71, 0xd6, 0x16, 0x76, 0xb2, 0x06, 0xea, 0x79, 0xf5, 0xc4, 0xc3, 0x52, 0x7e, 0x61, 0xd1, 0xe1, 0xad, 0x70, 0x78, 0x1d, 0x16, 0x11, 0xf8, 0x7c, 0x2b, 0xfc, 0x55, 0x9f, 0x52, 0xf8, 0xf5, 0x16}}},
{{{0x34, 0x96, 0x9a, 0xf6, 0xc5, 0xe0, 0x14, 0x03, 0x24, 0x0e, 0x4c, 0xad, 0x9e, 0x9a, 0x70, 0x23, 0x96, 0xb2, 0xf1, 0x2e, 0x9d, 0xc3, 0x32, 0x9b, 0x54, 0xa5, 0x73, 0xde, 0x88, 0xb1, 0x3e, 0x24}} ,
{{0xf6, 0xe2, 0x4c, 0x1f, 0x5b, 0xb2, 0xaf, 0x82, 0xa5, 0xcf, 0x81, 0x10, 0x04, 0xef, 0xdb, 0xa2, 0xcc, 0x24, 0xb2, 0x7e, 0x0b, 0x7a, 0xeb, 0x01, 0xd8, 0x52, 0xf4, 0x51, 0x89, 0x29, 0x79, 0x37}}},
{{{0x74, 0xde, 0x12, 0xf3, 0x68, 0xb7, 0x66, 0xc3, 0xee, 0x68, 0xdc, 0x81, 0xb5, 0x55, 0x99, 0xab, 0xd9, 0x28, 0x63, 0x6d, 0x8b, 0x40, 0x69, 0x75, 0x6c, 0xcd, 0x5c, 0x2a, 0x7e, 0x32, 0x7b, 0x29}} ,
{{0x02, 0xcc, 0x22, 0x74, 0x4d, 0x19, 0x07, 0xc0, 0xda, 0xb5, 0x76, 0x51, 0x2a, 0xaa, 0xa6, 0x0a, 0x5f, 0x26, 0xd4, 0xbc, 0xaf, 0x48, 0x88, 0x7f, 0x02, 0xbc, 0xf2, 0xe1, 0xcf, 0xe9, 0xdd, 0x15}}},
{{{0xed, 0xb5, 0x9a, 0x8c, 0x9a, 0xdd, 0x27, 0xf4, 0x7f, 0x47, 0xd9, 0x52, 0xa7, 0xcd, 0x65, 0xa5, 0x31, 0x22, 0xed, 0xa6, 0x63, 0x5b, 0x80, 0x4a, 0xad, 0x4d, 0xed, 0xbf, 0xee, 0x49, 0xb3, 0x06}} ,
{{0xf8, 0x64, 0x8b, 0x60, 0x90, 0xe9, 0xde, 0x44, 0x77, 0xb9, 0x07, 0x36, 0x32, 0xc2, 0x50, 0xf5, 0x65, 0xdf, 0x48, 0x4c, 0x37, 0xaa, 0x68, 0xab, 0x9a, 0x1f, 0x3e, 0xff, 0x89, 0x92, 0xa0, 0x07}}},
{{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
{{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
{{{0x7d, 0x4f, 0x9c, 0x19, 0xc0, 0x4a, 0x31, 0xec, 0xf9, 0xaa, 0xeb, 0xb2, 0x16, 0x9c, 0xa3, 0x66, 0x5f, 0xd1, 0xd4, 0xed, 0xb8, 0x92, 0x1c, 0xab, 0xda, 0xea, 0xd9, 0x57, 0xdf, 0x4c, 0x2a, 0x48}} ,
{{0x4b, 0xb0, 0x4e, 0x6e, 0x11, 0x3b, 0x51, 0xbd, 0x6a, 0xfd, 0xe4, 0x25, 0xa5, 0x5f, 0x11, 0x3f, 0x98, 0x92, 0x51, 0x14, 0xc6, 0x5f, 0x3c, 0x0b, 0xa8, 0xf7, 0xc2, 0x81, 0x43, 0xde, 0x91, 0x73}}},
{{{0x3c, 0x8f, 0x9f, 0x33, 0x2a, 0x1f, 0x43, 0x33, 0x8f, 0x68, 0xff, 0x1f, 0x3d, 0x73, 0x6b, 0xbf, 0x68, 0xcc, 0x7d, 0x13, 0x6c, 0x24, 0x4b, 0xcc, 0x4d, 0x24, 0x0d, 0xfe, 0xde, 0x86, 0xad, 0x3b}} ,
{{0x79, 0x51, 0x81, 0x01, 0xdc, 0x73, 0x53, 0xe0, 0x6e, 0x9b, 0xea, 0x68, 0x3f, 0x5c, 0x14, 0x84, 0x53, 0x8d, 0x4b, 0xc0, 0x9f, 0x9f, 0x89, 0x2b, 0x8c, 0xba, 0x86, 0xfa, 0xf2, 0xcd, 0xe3, 0x2d}}},
{{{0x06, 0xf9, 0x29, 0x5a, 0xdb, 0x3d, 0x84, 0x52, 0xab, 0xcc, 0x6b, 0x60, 0x9d, 0xb7, 0x4a, 0x0e, 0x36, 0x63, 0x91, 0xad, 0xa0, 0x95, 0xb0, 0x97, 0x89, 0x4e, 0xcf, 0x7d, 0x3c, 0xe5, 0x7c, 0x28}} ,
{{0x2e, 0x69, 0x98, 0xfd, 0xc6, 0xbd, 0xcc, 0xca, 0xdf, 0x9a, 0x44, 0x7e, 0x9d, 0xca, 0x89, 0x6d, 0xbf, 0x27, 0xc2, 0xf8, 0xcd, 0x46, 0x00, 0x2b, 0xb5, 0x58, 0x4e, 0xb7, 0x89, 0x09, 0xe9, 0x2d}}},
{{{0x54, 0xbe, 0x75, 0xcb, 0x05, 0xb0, 0x54, 0xb7, 0xe7, 0x26, 0x86, 0x4a, 0xfc, 0x19, 0xcf, 0x27, 0x46, 0xd4, 0x22, 0x96, 0x5a, 0x11, 0xe8, 0xd5, 0x1b, 0xed, 0x71, 0xc5, 0x5d, 0xc8, 0xaf, 0x45}} ,
{{0x40, 0x7b, 0x77, 0x57, 0x49, 0x9e, 0x80, 0x39, 0x23, 0xee, 0x81, 0x0b, 0x22, 0xcf, 0xdb, 0x7a, 0x2f, 0x14, 0xb8, 0x57, 0x8f, 0xa1, 0x39, 0x1e, 0x77, 0xfc, 0x0b, 0xa6, 0xbf, 0x8a, 0x0c, 0x6c}}},
{{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
{{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
{{{0x77, 0x3a, 0xd4, 0xd8, 0x27, 0xcf, 0xe8, 0xa1, 0x72, 0x9d, 0xca, 0xdd, 0x0d, 0x96, 0xda, 0x79, 0xed, 0x56, 0x42, 0x15, 0x60, 0xc7, 0x1c, 0x6b, 0x26, 0x30, 0xf6, 0x6a, 0x95, 0x67, 0xf3, 0x0a}} ,
{{0xc5, 0x08, 0xa4, 0x2b, 0x2f, 0xbd, 0x31, 0x81, 0x2a, 0xa6, 0xb6, 0xe4, 0x00, 0x91, 0xda, 0x3d, 0xb2, 0xb0, 0x96, 0xce, 0x8a, 0xd2, 0x8d, 0x70, 0xb3, 0xd3, 0x34, 0x01, 0x90, 0x8d, 0x10, 0x21}}},
{{{0x33, 0x0d, 0xe7, 0xba, 0x4f, 0x07, 0xdf, 0x8d, 0xea, 0x7d, 0xa0, 0xc5, 0xd6, 0xb1, 0xb0, 0xe5, 0x57, 0x1b, 0x5b, 0xf5, 0x45, 0x13, 0x14, 0x64, 0x5a, 0xeb, 0x5c, 0xfc, 0x54, 0x01, 0x76, 0x2b}} ,
{{0x02, 0x0c, 0xc2, 0xaf, 0x96, 0x36, 0xfe, 0x4a, 0xe2, 0x54, 0x20, 0x6a, 0xeb, 0xb2, 0x9f, 0x62, 0xd7, 0xce, 0xa2, 0x3f, 0x20, 0x11, 0x34, 0x37, 0xe0, 0x42, 0xed, 0x6f, 0xf9, 0x1a, 0xc8, 0x7d}}},
{{{0xd8, 0xb9, 0x11, 0xe8, 0x36, 0x3f, 0x42, 0xc1, 0xca, 0xdc, 0xd3, 0xf1, 0xc8, 0x23, 0x3d, 0x4f, 0x51, 0x7b, 0x9d, 0x8d, 0xd8, 0xe4, 0xa0, 0xaa, 0xf3, 0x04, 0xd6, 0x11, 0x93, 0xc8, 0x35, 0x45}} ,
{{0x61, 0x36, 0xd6, 0x08, 0x90, 0xbf, 0xa7, 0x7a, 0x97, 0x6c, 0x0f, 0x84, 0xd5, 0x33, 0x2d, 0x37, 0xc9, 0x6a, 0x80, 0x90, 0x3d, 0x0a, 0xa2, 0xaa, 0xe1, 0xb8, 0x84, 0xba, 0x61, 0x36, 0xdd, 0x69}}},
{{{0x6b, 0xdb, 0x5b, 0x9c, 0xc6, 0x92, 0xbc, 0x23, 0xaf, 0xc5, 0xb8, 0x75, 0xf8, 0x42, 0xfa, 0xd6, 0xb6, 0x84, 0x94, 0x63, 0x98, 0x93, 0x48, 0x78, 0x38, 0xcd, 0xbb, 0x18, 0x34, 0xc3, 0xdb, 0x67}} ,
{{0x96, 0xf3, 0x3a, 0x09, 0x56, 0xb0, 0x6f, 0x7c, 0x51, 0x1e, 0x1b, 0x39, 0x48, 0xea, 0xc9, 0x0c, 0x25, 0xa2, 0x7a, 0xca, 0xe7, 0x92, 0xfc, 0x59, 0x30, 0xa3, 0x89, 0x85, 0xdf, 0x6f, 0x43, 0x38}}},
{{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
{{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
{{{0x79, 0x84, 0x44, 0x19, 0xbd, 0xe9, 0x54, 0xc4, 0xc0, 0x6e, 0x2a, 0xa8, 0xa8, 0x9b, 0x43, 0xd5, 0x71, 0x22, 0x5f, 0xdc, 0x01, 0xfa, 0xdf, 0xb3, 0xb8, 0x47, 0x4b, 0x0a, 0xa5, 0x44, 0xea, 0x29}} ,
{{0x05, 0x90, 0x50, 0xaf, 0x63, 0x5f, 0x9d, 0x9e, 0xe1, 0x9d, 0x38, 0x97, 0x1f, 0x6c, 0xac, 0x30, 0x46, 0xb2, 0x6a, 0x19, 0xd1, 0x4b, 0xdb, 0xbb, 0x8c, 0xda, 0x2e, 0xab, 0xc8, 0x5a, 0x77, 0x6c}}},
{{{0x2b, 0xbe, 0xaf, 0xa1, 0x6d, 0x2f, 0x0b, 0xb1, 0x8f, 0xe3, 0xe0, 0x38, 0xcd, 0x0b, 0x41, 0x1b, 0x4a, 0x15, 0x07, 0xf3, 0x6f, 0xdc, 0xb8, 0xe9, 0xde, 0xb2, 0xa3, 0x40, 0x01, 0xa6, 0x45, 0x1e}} ,
{{0x76, 0x0a, 0xda, 0x8d, 0x2c, 0x07, 0x3f, 0x89, 0x7d, 0x04, 0xad, 0x43, 0x50, 0x6e, 0xd2, 0x47, 0xcb, 0x8a, 0xe6, 0x85, 0x1a, 0x24, 0xf3, 0xd2, 0x60, 0xfd, 0xdf, 0x73, 0xa4, 0x0d, 0x73, 0x0e}}},
{{{0xfd, 0x67, 0x6b, 0x71, 0x9b, 0x81, 0x53, 0x39, 0x39, 0xf4, 0xb8, 0xd5, 0xc3, 0x30, 0x9b, 0x3b, 0x7c, 0xa3, 0xf0, 0xd0, 0x84, 0x21, 0xd6, 0xbf, 0xb7, 0x4c, 0x87, 0x13, 0x45, 0x2d, 0xa7, 0x55}} ,
{{0x5d, 0x04, 0xb3, 0x40, 0x28, 0x95, 0x2d, 0x30, 0x83, 0xec, 0x5e, 0xe4, 0xff, 0x75, 0xfe, 0x79, 0x26, 0x9d, 0x1d, 0x36, 0xcd, 0x0a, 0x15, 0xd2, 0x24, 0x14, 0x77, 0x71, 0xd7, 0x8a, 0x1b, 0x04}}},
{{{0x5d, 0x93, 0xc9, 0xbe, 0xaa, 0x90, 0xcd, 0x9b, 0xfb, 0x73, 0x7e, 0xb0, 0x64, 0x98, 0x57, 0x44, 0x42, 0x41, 0xb1, 0xaf, 0xea, 0xc1, 0xc3, 0x22, 0xff, 0x60, 0x46, 0xcb, 0x61, 0x81, 0x70, 0x61}} ,
{{0x0d, 0x82, 0xb9, 0xfe, 0x21, 0xcd, 0xc4, 0xf5, 0x98, 0x0c, 0x4e, 0x72, 0xee, 0x87, 0x49, 0xf8, 0xa1, 0x95, 0xdf, 0x8f, 0x2d, 0xbd, 0x21, 0x06, 0x7c, 0x15, 0xe8, 0x12, 0x6d, 0x93, 0xd6, 0x38}}},
{{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
{{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
{{{0x91, 0xf7, 0x51, 0xd9, 0xef, 0x7d, 0x42, 0x01, 0x13, 0xe9, 0xb8, 0x7f, 0xa6, 0x49, 0x17, 0x64, 0x21, 0x80, 0x83, 0x2c, 0x63, 0x4c, 0x60, 0x09, 0x59, 0x91, 0x92, 0x77, 0x39, 0x51, 0xf4, 0x48}} ,
{{0x60, 0xd5, 0x22, 0x83, 0x08, 0x2f, 0xff, 0x99, 0x3e, 0x69, 0x6d, 0x88, 0xda, 0xe7, 0x5b, 0x52, 0x26, 0x31, 0x2a, 0xe5, 0x89, 0xde, 0x68, 0x90, 0xb6, 0x22, 0x5a, 0xbd, 0xd3, 0x85, 0x53, 0x31}}},
{{{0xd8, 0xce, 0xdc, 0xf9, 0x3c, 0x4b, 0xa2, 0x1d, 0x2c, 0x2f, 0x36, 0xbe, 0x7a, 0xfc, 0xcd, 0xbc, 0xdc, 0xf9, 0x30, 0xbd, 0xff, 0x05, 0xc7, 0xe4, 0x8e, 0x17, 0x62, 0xf8, 0x4d, 0xa0, 0x56, 0x79}} ,
{{0x82, 0xe7, 0xf6, 0xba, 0x53, 0x84, 0x0a, 0xa3, 0x34, 0xff, 0x3c, 0xa3, 0x6a, 0xa1, 0x37, 0xea, 0xdd, 0xb6, 0x95, 0xb3, 0x78, 0x19, 0x76, 0x1e, 0x55, 0x2f, 0x77, 0x2e, 0x7f, 0xc1, 0xea, 0x5e}}},
{{{0x83, 0xe1, 0x6e, 0xa9, 0x07, 0x33, 0x3e, 0x83, 0xff, 0xcb, 0x1c, 0x9f, 0xb1, 0xa3, 0xb4, 0xc9, 0xe1, 0x07, 0x97, 0xff, 0xf8, 0x23, 0x8f, 0xce, 0x40, 0xfd, 0x2e, 0x5e, 0xdb, 0x16, 0x43, 0x2d}} ,
{{0xba, 0x38, 0x02, 0xf7, 0x81, 0x43, 0x83, 0xa3, 0x20, 0x4f, 0x01, 0x3b, 0x8a, 0x04, 0x38, 0x31, 0xc6, 0x0f, 0xc8, 0xdf, 0xd7, 0xfa, 0x2f, 0x88, 0x3f, 0xfc, 0x0c, 0x76, 0xc4, 0xa6, 0x45, 0x72}}},
{{{0xbb, 0x0c, 0xbc, 0x6a, 0xa4, 0x97, 0x17, 0x93, 0x2d, 0x6f, 0xde, 0x72, 0x10, 0x1c, 0x08, 0x2c, 0x0f, 0x80, 0x32, 0x68, 0x27, 0xd4, 0xab, 0xdd, 0xc5, 0x58, 0x61, 0x13, 0x6d, 0x11, 0x1e, 0x4d}} ,
{{0x1a, 0xb9, 0xc9, 0x10, 0xfb, 0x1e, 0x4e, 0xf4, 0x84, 0x4b, 0x8a, 0x5e, 0x7b, 0x4b, 0xe8, 0x43, 0x8c, 0x8f, 0x00, 0xb5, 0x54, 0x13, 0xc5, 0x5c, 0xb6, 0x35, 0x4e, 0x9d, 0xe4, 0x5b, 0x41, 0x6d}}},
{{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
{{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
{{{0x15, 0x7d, 0x12, 0x48, 0x82, 0x14, 0x42, 0xcd, 0x32, 0xd4, 0x4b, 0xc1, 0x72, 0x61, 0x2a, 0x8c, 0xec, 0xe2, 0xf8, 0x24, 0x45, 0x94, 0xe3, 0xbe, 0xdd, 0x67, 0xa8, 0x77, 0x5a, 0xae, 0x5b, 0x4b}} ,
{{0xcb, 0x77, 0x9a, 0x20, 0xde, 0xb8, 0x23, 0xd9, 0xa0, 0x0f, 0x8c, 0x7b, 0xa5, 0xcb, 0xae, 0xb6, 0xec, 0x42, 0x67, 0x0e, 0x58, 0xa4, 0x75, 0x98, 0x21, 0x71, 0x84, 0xb3, 0xe0, 0x76, 0x94, 0x73}}},
{{{0xdf, 0xfc, 0x69, 0x28, 0x23, 0x3f, 0x5b, 0xf8, 0x3b, 0x24, 0x37, 0xf3, 0x1d, 0xd5, 0x22, 0x6b, 0xd0, 0x98, 0xa8, 0x6c, 0xcf, 0xff, 0x06, 0xe1, 0x13, 0xdf, 0xb9, 0xc1, 0x0c, 0xa9, 0xbf, 0x33}} ,
{{0xd9, 0x81, 0xda, 0xb2, 0x4f, 0x82, 0x9d, 0x43, 0x81, 0x09, 0xf1, 0xd2, 0x01, 0xef, 0xac, 0xf4, 0x2d, 0x7d, 0x01, 0x09, 0xf1, 0xff, 0xa5, 0x9f, 0xe5, 0xca, 0x27, 0x63, 0xdb, 0x20, 0xb1, 0x53}}},
{{{0x67, 0x02, 0xe8, 0xad, 0xa9, 0x34, 0xd4, 0xf0, 0x15, 0x81, 0xaa, 0xc7, 0x4d, 0x87, 0x94, 0xea, 0x75, 0xe7, 0x4c, 0x94, 0x04, 0x0e, 0x69, 0x87, 0xe7, 0x51, 0x91, 0x10, 0x03, 0xc7, 0xbe, 0x56}} ,
{{0x32, 0xfb, 0x86, 0xec, 0x33, 0x6b, 0x2e, 0x51, 0x2b, 0xc8, 0xfa, 0x6c, 0x70, 0x47, 0x7e, 0xce, 0x05, 0x0c, 0x71, 0xf3, 0xb4, 0x56, 0xa6, 0xdc, 0xcc, 0x78, 0x07, 0x75, 0xd0, 0xdd, 0xb2, 0x6a}}},
{{{0xc6, 0xef, 0xb9, 0xc0, 0x2b, 0x22, 0x08, 0x1e, 0x71, 0x70, 0xb3, 0x35, 0x9c, 0x7a, 0x01, 0x92, 0x44, 0x9a, 0xf6, 0xb0, 0x58, 0x95, 0xc1, 0x9b, 0x02, 0xed, 0x2d, 0x7c, 0x34, 0x29, 0x49, 0x44}} ,
{{0x45, 0x62, 0x1d, 0x2e, 0xff, 0x2a, 0x1c, 0x21, 0xa4, 0x25, 0x7b, 0x0d, 0x8c, 0x15, 0x39, 0xfc, 0x8f, 0x7c, 0xa5, 0x7d, 0x1e, 0x25, 0xa3, 0x45, 0xd6, 0xab, 0xbd, 0xcb, 0xc5, 0x5e, 0x78, 0x77}}},
{{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
{{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
{{{0xd0, 0xd3, 0x42, 0xed, 0x1d, 0x00, 0x3c, 0x15, 0x2c, 0x9c, 0x77, 0x81, 0xd2, 0x73, 0xd1, 0x06, 0xd5, 0xc4, 0x7f, 0x94, 0xbb, 0x92, 0x2d, 0x2c, 0x4b, 0x45, 0x4b, 0xe9, 0x2a, 0x89, 0x6b, 0x2b}} ,
{{0xd2, 0x0c, 0x88, 0xc5, 0x48, 0x4d, 0xea, 0x0d, 0x4a, 0xc9, 0x52, 0x6a, 0x61, 0x79, 0xe9, 0x76, 0xf3, 0x85, 0x52, 0x5c, 0x1b, 0x2c, 0xe1, 0xd6, 0xc4, 0x0f, 0x18, 0x0e, 0x4e, 0xf6, 0x1c, 0x7f}}},
{{{0xb4, 0x04, 0x2e, 0x42, 0xcb, 0x1f, 0x2b, 0x11, 0x51, 0x7b, 0x08, 0xac, 0xaa, 0x3e, 0x9e, 0x52, 0x60, 0xb7, 0xc2, 0x61, 0x57, 0x8c, 0x84, 0xd5, 0x18, 0xa6, 0x19, 0xfc, 0xb7, 0x75, 0x91, 0x1b}} ,
{{0xe8, 0x68, 0xca, 0x44, 0xc8, 0x38, 0x38, 0xcc, 0x53, 0x0a, 0x32, 0x35, 0xcc, 0x52, 0xcb, 0x0e, 0xf7, 0xc5, 0xe7, 0xec, 0x3d, 0x85, 0xcc, 0x58, 0xe2, 0x17, 0x47, 0xff, 0x9f, 0xa5, 0x30, 0x17}}},
{{{0xe3, 0xae, 0xc8, 0xc1, 0x71, 0x75, 0x31, 0x00, 0x37, 0x41, 0x5c, 0x0e, 0x39, 0xda, 0x73, 0xa0, 0xc7, 0x97, 0x36, 0x6c, 0x5b, 0xf2, 0xee, 0x64, 0x0a, 0x3d, 0x89, 0x1e, 0x1d, 0x49, 0x8c, 0x37}} ,
{{0x4c, 0xe6, 0xb0, 0xc1, 0xa5, 0x2a, 0x82, 0x09, 0x08, 0xad, 0x79, 0x9c, 0x56, 0xf6, 0xf9, 0xc1, 0xd7, 0x7c, 0x39, 0x7f, 0x93, 0xca, 0x11, 0x55, 0xbf, 0x07, 0x1b, 0x82, 0x29, 0x69, 0x95, 0x5c}}},
{{{0x87, 0xee, 0xa6, 0x56, 0x9e, 0xc2, 0x9a, 0x56, 0x24, 0x42, 0x85, 0x4d, 0x98, 0x31, 0x1e, 0x60, 0x4d, 0x87, 0x85, 0x04, 0xae, 0x46, 0x12, 0xf9, 0x8e, 0x7f, 0xe4, 0x7f, 0xf6, 0x1c, 0x37, 0x01}} ,
{{0x73, 0x4c, 0xb6, 0xc5, 0xc4, 0xe9, 0x6c, 0x85, 0x48, 0x4a, 0x5a, 0xac, 0xd9, 0x1f, 0x43, 0xf8, 0x62, 0x5b, 0xee, 0x98, 0x2a, 0x33, 0x8e, 0x79, 0xce, 0x61, 0x06, 0x35, 0xd8, 0xd7, 0xca, 0x71}}},
{{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
{{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
{{{0x72, 0xd3, 0xae, 0xa6, 0xca, 0x8f, 0xcd, 0xcc, 0x78, 0x8e, 0x19, 0x4d, 0xa7, 0xd2, 0x27, 0xe9, 0xa4, 0x3c, 0x16, 0x5b, 0x84, 0x80, 0xf9, 0xd0, 0xcc, 0x6a, 0x1e, 0xca, 0x1e, 0x67, 0xbd, 0x63}} ,
{{0x7b, 0x6e, 0x2a, 0xd2, 0x87, 0x48, 0xff, 0xa1, 0xca, 0xe9, 0x15, 0x85, 0xdc, 0xdb, 0x2c, 0x39, 0x12, 0x91, 0xa9, 0x20, 0xaa, 0x4f, 0x29, 0xf4, 0x15, 0x7a, 0xd2, 0xf5, 0x32, 0xcc, 0x60, 0x04}}},
{{{0xe5, 0x10, 0x47, 0x3b, 0xfa, 0x90, 0xfc, 0x30, 0xb5, 0xea, 0x6f, 0x56, 0x8f, 0xfb, 0x0e, 0xa7, 0x3b, 0xc8, 0xb2, 0xff, 0x02, 0x7a, 0x33, 0x94, 0x93, 0x2a, 0x03, 0xe0, 0x96, 0x3a, 0x6c, 0x0f}} ,
{{0x5a, 0x63, 0x67, 0xe1, 0x9b, 0x47, 0x78, 0x9f, 0x38, 0x79, 0xac, 0x97, 0x66, 0x1d, 0x5e, 0x51, 0xee, 0x24, 0x42, 0xe8, 0x58, 0x4b, 0x8a, 0x03, 0x75, 0x86, 0x37, 0x86, 0xe2, 0x97, 0x4e, 0x3d}}},
{{{0x3f, 0x75, 0x8e, 0xb4, 0xff, 0xd8, 0xdd, 0xd6, 0x37, 0x57, 0x9d, 0x6d, 0x3b, 0xbd, 0xd5, 0x60, 0x88, 0x65, 0x9a, 0xb9, 0x4a, 0x68, 0x84, 0xa2, 0x67, 0xdd, 0x17, 0x25, 0x97, 0x04, 0x8b, 0x5e}} ,
{{0xbb, 0x40, 0x5e, 0xbc, 0x16, 0x92, 0x05, 0xc4, 0xc0, 0x4e, 0x72, 0x90, 0x0e, 0xab, 0xcf, 0x8a, 0xed, 0xef, 0xb9, 0x2d, 0x3b, 0xf8, 0x43, 0x5b, 0xba, 0x2d, 0xeb, 0x2f, 0x52, 0xd2, 0xd1, 0x5a}}},
{{{0x40, 0xb4, 0xab, 0xe6, 0xad, 0x9f, 0x46, 0x69, 0x4a, 0xb3, 0x8e, 0xaa, 0xea, 0x9c, 0x8a, 0x20, 0x16, 0x5d, 0x8c, 0x13, 0xbd, 0xf6, 0x1d, 0xc5, 0x24, 0xbd, 0x90, 0x2a, 0x1c, 0xc7, 0x13, 0x3b}} ,
{{0x54, 0xdc, 0x16, 0x0d, 0x18, 0xbe, 0x35, 0x64, 0x61, 0x52, 0x02, 0x80, 0xaf, 0x05, 0xf7, 0xa6, 0x42, 0xd3, 0x8f, 0x2e, 0x79, 0x26, 0xa8, 0xbb, 0xb2, 0x17, 0x48, 0xb2, 0x7a, 0x0a, 0x89, 0x14}}},
{{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
{{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
{{{0x20, 0xa8, 0x88, 0xe3, 0x91, 0xc0, 0x6e, 0xbb, 0x8a, 0x27, 0x82, 0x51, 0x83, 0xb2, 0x28, 0xa9, 0x83, 0xeb, 0xa6, 0xa9, 0x4d, 0x17, 0x59, 0x22, 0x54, 0x00, 0x50, 0x45, 0xcb, 0x48, 0x4b, 0x18}} ,
{{0x33, 0x7c, 0xe7, 0x26, 0xba, 0x4d, 0x32, 0xfe, 0x53, 0xf4, 0xfa, 0x83, 0xe3, 0xa5, 0x79, 0x66, 0x73, 0xef, 0x80, 0x23, 0x68, 0xc2, 0x60, 0xdd, 0xa9, 0x33, 0xdc, 0x03, 0x7a, 0xe0, 0xe0, 0x3e}}},
{{{0x34, 0x5c, 0x13, 0xfb, 0xc0, 0xe3, 0x78, 0x2b, 0x54, 0x58, 0x22, 0x9b, 0x76, 0x81, 0x7f, 0x93, 0x9c, 0x25, 0x3c, 0xd2, 0xe9, 0x96, 0x21, 0x26, 0x08, 0xf5, 0xed, 0x95, 0x11, 0xae, 0x04, 0x5a}} ,
{{0xb9, 0xe8, 0xc5, 0x12, 0x97, 0x1f, 0x83, 0xfe, 0x3e, 0x94, 0x99, 0xd4, 0x2d, 0xf9, 0x52, 0x59, 0x5c, 0x82, 0xa6, 0xf0, 0x75, 0x7e, 0xe8, 0xec, 0xcc, 0xac, 0x18, 0x21, 0x09, 0x67, 0x66, 0x67}}},
{{{0xb3, 0x40, 0x29, 0xd1, 0xcb, 0x1b, 0x08, 0x9e, 0x9c, 0xb7, 0x53, 0xb9, 0x3b, 0x71, 0x08, 0x95, 0x12, 0x1a, 0x58, 0xaf, 0x7e, 0x82, 0x52, 0x43, 0x4f, 0x11, 0x39, 0xf4, 0x93, 0x1a, 0x26, 0x05}} ,
{{0x6e, 0x44, 0xa3, 0xf9, 0x64, 0xaf, 0xe7, 0x6d, 0x7d, 0xdf, 0x1e, 0xac, 0x04, 0xea, 0x3b, 0x5f, 0x9b, 0xe8, 0x24, 0x9d, 0x0e, 0xe5, 0x2e, 0x3e, 0xdf, 0xa9, 0xf7, 0xd4, 0x50, 0x71, 0xf0, 0x78}}},
{{{0x3e, 0xa8, 0x38, 0xc2, 0x57, 0x56, 0x42, 0x9a, 0xb1, 0xe2, 0xf8, 0x45, 0xaa, 0x11, 0x48, 0x5f, 0x17, 0xc4, 0x54, 0x27, 0xdc, 0x5d, 0xaa, 0xdd, 0x41, 0xbc, 0xdf, 0x81, 0xb9, 0x53, 0xee, 0x52}} ,
{{0xc3, 0xf1, 0xa7, 0x6d, 0xb3, 0x5f, 0x92, 0x6f, 0xcc, 0x91, 0xb8, 0x95, 0x05, 0xdf, 0x3c, 0x64, 0x57, 0x39, 0x61, 0x51, 0xad, 0x8c, 0x38, 0x7b, 0xc8, 0xde, 0x00, 0x34, 0xbe, 0xa1, 0xb0, 0x7e}}},
{{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
{{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
{{{0x25, 0x24, 0x1d, 0x8a, 0x67, 0x20, 0xee, 0x42, 0xeb, 0x38, 0xed, 0x0b, 0x8b, 0xcd, 0x46, 0x9d, 0x5e, 0x6b, 0x1e, 0x24, 0x9d, 0x12, 0x05, 0x1a, 0xcc, 0x05, 0x4e, 0x92, 0x38, 0xe1, 0x1f, 0x50}} ,
{{0x4e, 0xee, 0x1c, 0x91, 0xe6, 0x11, 0xbd, 0x8e, 0x55, 0x1a, 0x18, 0x75, 0x66, 0xaf, 0x4d, 0x7b, 0x0f, 0xae, 0x6d, 0x85, 0xca, 0x82, 0x58, 0x21, 0x9c, 0x18, 0xe0, 0xed, 0xec, 0x22, 0x80, 0x2f}}},
{{{0x68, 0x3b, 0x0a, 0x39, 0x1d, 0x6a, 0x15, 0x57, 0xfc, 0xf0, 0x63, 0x54, 0xdb, 0x39, 0xdb, 0xe8, 0x5c, 0x64, 0xff, 0xa0, 0x09, 0x4f, 0x3b, 0xb7, 0x32, 0x60, 0x99, 0x94, 0xfd, 0x94, 0x82, 0x2d}} ,
{{0x24, 0xf6, 0x5a, 0x44, 0xf1, 0x55, 0x2c, 0xdb, 0xea, 0x7c, 0x84, 0x7c, 0x01, 0xac, 0xe3, 0xfd, 0xc9, 0x27, 0xc1, 0x5a, 0xb9, 0xde, 0x4f, 0x5a, 0x90, 0xdd, 0xc6, 0x67, 0xaa, 0x6f, 0x8a, 0x3a}}},
{{{0x78, 0x52, 0x87, 0xc9, 0x97, 0x63, 0xb1, 0xdd, 0x54, 0x5f, 0xc1, 0xf8, 0xf1, 0x06, 0xa6, 0xa8, 0xa3, 0x88, 0x82, 0xd4, 0xcb, 0xa6, 0x19, 0xdd, 0xd1, 0x11, 0x87, 0x08, 0x17, 0x4c, 0x37, 0x2a}} ,
{{0xa1, 0x0c, 0xf3, 0x08, 0x43, 0xd9, 0x24, 0x1e, 0x83, 0xa7, 0xdf, 0x91, 0xca, 0xbd, 0x69, 0x47, 0x8d, 0x1b, 0xe2, 0xb9, 0x4e, 0xb5, 0xe1, 0x76, 0xb3, 0x1c, 0x93, 0x03, 0xce, 0x5f, 0xb3, 0x5a}}},
{{{0x1d, 0xda, 0xe4, 0x61, 0x03, 0x50, 0xa9, 0x8b, 0x68, 0x18, 0xef, 0xb2, 0x1c, 0x84, 0x3b, 0xa2, 0x44, 0x95, 0xa3, 0x04, 0x3b, 0xd6, 0x99, 0x00, 0xaf, 0x76, 0x42, 0x67, 0x02, 0x7d, 0x85, 0x56}} ,
{{0xce, 0x72, 0x0e, 0x29, 0x84, 0xb2, 0x7d, 0xd2, 0x45, 0xbe, 0x57, 0x06, 0xed, 0x7f, 0xcf, 0xed, 0xcd, 0xef, 0x19, 0xd6, 0xbc, 0x15, 0x79, 0x64, 0xd2, 0x18, 0xe3, 0x20, 0x67, 0x3a, 0x54, 0x0b}}},
{{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
{{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
{{{0x52, 0xfd, 0x04, 0xc5, 0xfb, 0x99, 0xe7, 0xe8, 0xfb, 0x8c, 0xe1, 0x42, 0x03, 0xef, 0x9d, 0xd9, 0x9e, 0x4d, 0xf7, 0x80, 0xcf, 0x2e, 0xcc, 0x9b, 0x45, 0xc9, 0x7b, 0x7a, 0xbc, 0x37, 0xa8, 0x52}} ,
{{0x96, 0x11, 0x41, 0x8a, 0x47, 0x91, 0xfe, 0xb6, 0xda, 0x7a, 0x54, 0x63, 0xd1, 0x14, 0x35, 0x05, 0x86, 0x8c, 0xa9, 0x36, 0x3f, 0xf2, 0x85, 0x54, 0x4e, 0x92, 0xd8, 0x85, 0x01, 0x46, 0xd6, 0x50}}},
{{{0x53, 0xcd, 0xf3, 0x86, 0x40, 0xe6, 0x39, 0x42, 0x95, 0xd6, 0xcb, 0x45, 0x1a, 0x20, 0xc8, 0x45, 0x4b, 0x32, 0x69, 0x04, 0xb1, 0xaf, 0x20, 0x46, 0xc7, 0x6b, 0x23, 0x5b, 0x69, 0xee, 0x30, 0x3f}} ,
{{0x70, 0x83, 0x47, 0xc0, 0xdb, 0x55, 0x08, 0xa8, 0x7b, 0x18, 0x6d, 0xf5, 0x04, 0x5a, 0x20, 0x0c, 0x4a, 0x8c, 0x60, 0xae, 0xae, 0x0f, 0x64, 0x55, 0x55, 0x2e, 0xd5, 0x1d, 0x53, 0x31, 0x42, 0x41}}},
{{{0xca, 0xfc, 0x88, 0x6b, 0x96, 0x78, 0x0a, 0x8b, 0x83, 0xdc, 0xbc, 0xaf, 0x40, 0xb6, 0x8d, 0x7f, 0xef, 0xb4, 0xd1, 0x3f, 0xcc, 0xa2, 0x74, 0xc9, 0xc2, 0x92, 0x55, 0x00, 0xab, 0xdb, 0xbf, 0x4f}} ,
{{0x93, 0x1c, 0x06, 0x2d, 0x66, 0x65, 0x02, 0xa4, 0x97, 0x18, 0xfd, 0x00, 0xe7, 0xab, 0x03, 0xec, 0xce, 0xc1, 0xbf, 0x37, 0xf8, 0x13, 0x53, 0xa5, 0xe5, 0x0c, 0x3a, 0xa8, 0x55, 0xb9, 0xff, 0x68}}},
{{{0xe4, 0xe6, 0x6d, 0x30, 0x7d, 0x30, 0x35, 0xc2, 0x78, 0x87, 0xf9, 0xfc, 0x6b, 0x5a, 0xc3, 0xb7, 0x65, 0xd8, 0x2e, 0xc7, 0xa5, 0x0c, 0xc6, 0xdc, 0x12, 0xaa, 0xd6, 0x4f, 0xc5, 0x38, 0xbc, 0x0e}} ,
{{0xe2, 0x3c, 0x76, 0x86, 0x38, 0xf2, 0x7b, 0x2c, 0x16, 0x78, 0x8d, 0xf5, 0xa4, 0x15, 0xda, 0xdb, 0x26, 0x85, 0xa0, 0x56, 0xdd, 0x1d, 0xe3, 0xb3, 0xfd, 0x40, 0xef, 0xf2, 0xd9, 0xa1, 0xb3, 0x04}}},
{{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
{{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
{{{0xdb, 0x49, 0x0e, 0xe6, 0x58, 0x10, 0x7a, 0x52, 0xda, 0xb5, 0x7d, 0x37, 0x6a, 0x3e, 0xa1, 0x78, 0xce, 0xc7, 0x1c, 0x24, 0x23, 0xdb, 0x7d, 0xfb, 0x8c, 0x8d, 0xdc, 0x30, 0x67, 0x69, 0x75, 0x3b}} ,
{{0xa9, 0xea, 0x6d, 0x16, 0x16, 0x60, 0xf4, 0x60, 0x87, 0x19, 0x44, 0x8c, 0x4a, 0x8b, 0x3e, 0xfb, 0x16, 0x00, 0x00, 0x54, 0xa6, 0x9e, 0x9f, 0xef, 0xcf, 0xd9, 0xd2, 0x4c, 0x74, 0x31, 0xd0, 0x34}}},
{{{0xa4, 0xeb, 0x04, 0xa4, 0x8c, 0x8f, 0x71, 0x27, 0x95, 0x85, 0x5d, 0x55, 0x4b, 0xb1, 0x26, 0x26, 0xc8, 0xae, 0x6a, 0x7d, 0xa2, 0x21, 0xca, 0xce, 0x38, 0xab, 0x0f, 0xd0, 0xd5, 0x2b, 0x6b, 0x00}} ,
{{0xe5, 0x67, 0x0c, 0xf1, 0x3a, 0x9a, 0xea, 0x09, 0x39, 0xef, 0xd1, 0x30, 0xbc, 0x33, 0xba, 0xb1, 0x6a, 0xc5, 0x27, 0x08, 0x7f, 0x54, 0x80, 0x3d, 0xab, 0xf6, 0x15, 0x7a, 0xc2, 0x40, 0x73, 0x72}}},
{{{0x84, 0x56, 0x82, 0xb6, 0x12, 0x70, 0x7f, 0xf7, 0xf0, 0xbd, 0x5b, 0xa9, 0xd5, 0xc5, 0x5f, 0x59, 0xbf, 0x7f, 0xb3, 0x55, 0x22, 0x02, 0xc9, 0x44, 0x55, 0x87, 0x8f, 0x96, 0x98, 0x64, 0x6d, 0x15}} ,
{{0xb0, 0x8b, 0xaa, 0x1e, 0xec, 0xc7, 0xa5, 0x8f, 0x1f, 0x92, 0x04, 0xc6, 0x05, 0xf6, 0xdf, 0xa1, 0xcc, 0x1f, 0x81, 0xf5, 0x0e, 0x9c, 0x57, 0xdc, 0xe3, 0xbb, 0x06, 0x87, 0x1e, 0xfe, 0x23, 0x6c}}},
{{{0xd8, 0x2b, 0x5b, 0x16, 0xea, 0x20, 0xf1, 0xd3, 0x68, 0x8f, 0xae, 0x5b, 0xd0, 0xa9, 0x1a, 0x19, 0xa8, 0x36, 0xfb, 0x2b, 0x57, 0x88, 0x7d, 0x90, 0xd5, 0xa6, 0xf3, 0xdc, 0x38, 0x89, 0x4e, 0x1f}} ,
{{0xcc, 0x19, 0xda, 0x9b, 0x3b, 0x43, 0x48, 0x21, 0x2e, 0x23, 0x4d, 0x3d, 0xae, 0xf8, 0x8c, 0xfc, 0xdd, 0xa6, 0x74, 0x37, 0x65, 0xca, 0xee, 0x1a, 0x19, 0x8e, 0x9f, 0x64, 0x6f, 0x0c, 0x8b, 0x5a}}},
{{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
{{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
{{{0x25, 0xb9, 0xc2, 0xf0, 0x72, 0xb8, 0x15, 0x16, 0xcc, 0x8d, 0x3c, 0x6f, 0x25, 0xed, 0xf4, 0x46, 0x2e, 0x0c, 0x60, 0x0f, 0xe2, 0x84, 0x34, 0x55, 0x89, 0x59, 0x34, 0x1b, 0xf5, 0x8d, 0xfe, 0x08}} ,
{{0xf8, 0xab, 0x93, 0xbc, 0x44, 0xba, 0x1b, 0x75, 0x4b, 0x49, 0x6f, 0xd0, 0x54, 0x2e, 0x63, 0xba, 0xb5, 0xea, 0xed, 0x32, 0x14, 0xc9, 0x94, 0xd8, 0xc5, 0xce, 0xf4, 0x10, 0x68, 0xe0, 0x38, 0x27}}},
{{{0x74, 0x1c, 0x14, 0x9b, 0xd4, 0x64, 0x61, 0x71, 0x5a, 0xb6, 0x21, 0x33, 0x4f, 0xf7, 0x8e, 0xba, 0xa5, 0x48, 0x9a, 0xc7, 0xfa, 0x9a, 0xf0, 0xb4, 0x62, 0xad, 0xf2, 0x5e, 0xcc, 0x03, 0x24, 0x1a}} ,
{{0xf5, 0x76, 0xfd, 0xe4, 0xaf, 0xb9, 0x03, 0x59, 0xce, 0x63, 0xd2, 0x3b, 0x1f, 0xcd, 0x21, 0x0c, 0xad, 0x44, 0xa5, 0x97, 0xac, 0x80, 0x11, 0x02, 0x9b, 0x0c, 0xe5, 0x8b, 0xcd, 0xfb, 0x79, 0x77}}},
{{{0x15, 0xbe, 0x9a, 0x0d, 0xba, 0x38, 0x72, 0x20, 0x8a, 0xf5, 0xbe, 0x59, 0x93, 0x79, 0xb7, 0xf6, 0x6a, 0x0c, 0x38, 0x27, 0x1a, 0x60, 0xf4, 0x86, 0x3b, 0xab, 0x5a, 0x00, 0xa0, 0xce, 0x21, 0x7d}} ,
{{0x6c, 0xba, 0x14, 0xc5, 0xea, 0x12, 0x9e, 0x2e, 0x82, 0x63, 0xce, 0x9b, 0x4a, 0xe7, 0x1d, 0xec, 0xf1, 0x2e, 0x51, 0x1c, 0xf4, 0xd0, 0x69, 0x15, 0x42, 0x9d, 0xa3, 0x3f, 0x0e, 0xbf, 0xe9, 0x5c}}},
{{{0xe4, 0x0d, 0xf4, 0xbd, 0xee, 0x31, 0x10, 0xed, 0xcb, 0x12, 0x86, 0xad, 0xd4, 0x2f, 0x90, 0x37, 0x32, 0xc3, 0x0b, 0x73, 0xec, 0x97, 0x85, 0xa4, 0x01, 0x1c, 0x76, 0x35, 0xfe, 0x75, 0xdd, 0x71}} ,
{{0x11, 0xa4, 0x88, 0x9f, 0x3e, 0x53, 0x69, 0x3b, 0x1b, 0xe0, 0xf7, 0xba, 0x9b, 0xad, 0x4e, 0x81, 0x5f, 0xb5, 0x5c, 0xae, 0xbe, 0x67, 0x86, 0x37, 0x34, 0x8e, 0x07, 0x32, 0x45, 0x4a, 0x67, 0x39}}},
{{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
{{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
{{{0x90, 0x70, 0x58, 0x20, 0x03, 0x1e, 0x67, 0xb2, 0xc8, 0x9b, 0x58, 0xc5, 0xb1, 0xeb, 0x2d, 0x4a, 0xde, 0x82, 0x8c, 0xf2, 0xd2, 0x14, 0xb8, 0x70, 0x61, 0x4e, 0x73, 0xd6, 0x0b, 0x6b, 0x0d, 0x30}} ,
{{0x81, 0xfc, 0x55, 0x5c, 0xbf, 0xa7, 0xc4, 0xbd, 0xe2, 0xf0, 0x4b, 0x8f, 0xe9, 0x7d, 0x99, 0xfa, 0xd3, 0xab, 0xbc, 0xc7, 0x83, 0x2b, 0x04, 0x7f, 0x0c, 0x19, 0x43, 0x03, 0x3d, 0x07, 0xca, 0x40}}},
{{{0xf9, 0xc8, 0xbe, 0x8c, 0x16, 0x81, 0x39, 0x96, 0xf6, 0x17, 0x58, 0xc8, 0x30, 0x58, 0xfb, 0xc2, 0x03, 0x45, 0xd2, 0x52, 0x76, 0xe0, 0x6a, 0x26, 0x28, 0x5c, 0x88, 0x59, 0x6a, 0x5a, 0x54, 0x42}} ,
{{0x07, 0xb5, 0x2e, 0x2c, 0x67, 0x15, 0x9b, 0xfb, 0x83, 0x69, 0x1e, 0x0f, 0xda, 0xd6, 0x29, 0xb1, 0x60, 0xe0, 0xb2, 0xba, 0x69, 0xa2, 0x9e, 0xbd, 0xbd, 0xe0, 0x1c, 0xbd, 0xcd, 0x06, 0x64, 0x70}}},
{{{0x41, 0xfa, 0x8c, 0xe1, 0x89, 0x8f, 0x27, 0xc8, 0x25, 0x8f, 0x6f, 0x5f, 0x55, 0xf8, 0xde, 0x95, 0x6d, 0x2f, 0x75, 0x16, 0x2b, 0x4e, 0x44, 0xfd, 0x86, 0x6e, 0xe9, 0x70, 0x39, 0x76, 0x97, 0x7e}} ,
{{0x17, 0x62, 0x6b, 0x14, 0xa1, 0x7c, 0xd0, 0x79, 0x6e, 0xd8, 0x8a, 0xa5, 0x6d, 0x8c, 0x93, 0xd2, 0x3f, 0xec, 0x44, 0x8d, 0x6e, 0x91, 0x01, 0x8c, 0x8f, 0xee, 0x01, 0x8f, 0xc0, 0xb4, 0x85, 0x0e}}},
{{{0x02, 0x3a, 0x70, 0x41, 0xe4, 0x11, 0x57, 0x23, 0xac, 0xe6, 0xfc, 0x54, 0x7e, 0xcd, 0xd7, 0x22, 0xcb, 0x76, 0x9f, 0x20, 0xce, 0xa0, 0x73, 0x76, 0x51, 0x3b, 0xa4, 0xf8, 0xe3, 0x62, 0x12, 0x6c}} ,
{{0x7f, 0x00, 0x9c, 0x26, 0x0d, 0x6f, 0x48, 0x7f, 0x3a, 0x01, 0xed, 0xc5, 0x96, 0xb0, 0x1f, 0x4f, 0xa8, 0x02, 0x62, 0x27, 0x8a, 0x50, 0x8d, 0x9a, 0x8b, 0x52, 0x0f, 0x1e, 0xcf, 0x41, 0x38, 0x19}}},
{{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
{{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
{{{0xf5, 0x6c, 0xd4, 0x2f, 0x0f, 0x69, 0x0f, 0x87, 0x3f, 0x61, 0x65, 0x1e, 0x35, 0x34, 0x85, 0xba, 0x02, 0x30, 0xac, 0x25, 0x3d, 0xe2, 0x62, 0xf1, 0xcc, 0xe9, 0x1b, 0xc2, 0xef, 0x6a, 0x42, 0x57}} ,
{{0x34, 0x1f, 0x2e, 0xac, 0xd1, 0xc7, 0x04, 0x52, 0x32, 0x66, 0xb2, 0x33, 0x73, 0x21, 0x34, 0x54, 0xf7, 0x71, 0xed, 0x06, 0xb0, 0xff, 0xa6, 0x59, 0x6f, 0x8a, 0x4e, 0xfb, 0x02, 0xb0, 0x45, 0x6b}}},
{{{0xf5, 0x48, 0x0b, 0x03, 0xc5, 0x22, 0x7d, 0x80, 0x08, 0x53, 0xfe, 0x32, 0xb1, 0xa1, 0x8a, 0x74, 0x6f, 0xbd, 0x3f, 0x85, 0xf4, 0xcf, 0xf5, 0x60, 0xaf, 0x41, 0x7e, 0x3e, 0x46, 0xa3, 0x5a, 0x20}} ,
{{0xaa, 0x35, 0x87, 0x44, 0x63, 0x66, 0x97, 0xf8, 0x6e, 0x55, 0x0c, 0x04, 0x3e, 0x35, 0x50, 0xbf, 0x93, 0x69, 0xd2, 0x8b, 0x05, 0x55, 0x99, 0xbe, 0xe2, 0x53, 0x61, 0xec, 0xe8, 0x08, 0x0b, 0x32}}},
{{{0xb3, 0x10, 0x45, 0x02, 0x69, 0x59, 0x2e, 0x97, 0xd9, 0x64, 0xf8, 0xdb, 0x25, 0x80, 0xdc, 0xc4, 0xd5, 0x62, 0x3c, 0xed, 0x65, 0x91, 0xad, 0xd1, 0x57, 0x81, 0x94, 0xaa, 0xa1, 0x29, 0xfc, 0x68}} ,
{{0xdd, 0xb5, 0x7d, 0xab, 0x5a, 0x21, 0x41, 0x53, 0xbb, 0x17, 0x79, 0x0d, 0xd1, 0xa8, 0x0c, 0x0c, 0x20, 0x88, 0x09, 0xe9, 0x84, 0xe8, 0x25, 0x11, 0x67, 0x7a, 0x8b, 0x1a, 0xe4, 0x5d, 0xe1, 0x5d}}},
{{{0x37, 0xea, 0xfe, 0x65, 0x3b, 0x25, 0xe8, 0xe1, 0xc2, 0xc5, 0x02, 0xa4, 0xbe, 0x98, 0x0a, 0x2b, 0x61, 0xc1, 0x9b, 0xe2, 0xd5, 0x92, 0xe6, 0x9e, 0x7d, 0x1f, 0xca, 0x43, 0x88, 0x8b, 0x2c, 0x59}} ,
{{0xe0, 0xb5, 0x00, 0x1d, 0x2a, 0x6f, 0xaf, 0x79, 0x86, 0x2f, 0xa6, 0x5a, 0x93, 0xd1, 0xfe, 0xae, 0x3a, 0xee, 0xdb, 0x7c, 0x61, 0xbe, 0x7c, 0x01, 0xf9, 0xfe, 0x52, 0xdc, 0xd8, 0x52, 0xa3, 0x42}}},
{{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
{{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
{{{0x22, 0xaf, 0x13, 0x37, 0xbd, 0x37, 0x71, 0xac, 0x04, 0x46, 0x63, 0xac, 0xa4, 0x77, 0xed, 0x25, 0x38, 0xe0, 0x15, 0xa8, 0x64, 0x00, 0x0d, 0xce, 0x51, 0x01, 0xa9, 0xbc, 0x0f, 0x03, 0x1c, 0x04}} ,
{{0x89, 0xf9, 0x80, 0x07, 0xcf, 0x3f, 0xb3, 0xe9, 0xe7, 0x45, 0x44, 0x3d, 0x2a, 0x7c, 0xe9, 0xe4, 0x16, 0x5c, 0x5e, 0x65, 0x1c, 0xc7, 0x7d, 0xc6, 0x7a, 0xfb, 0x43, 0xee, 0x25, 0x76, 0x46, 0x72}}},
{{{0x02, 0xa2, 0xed, 0xf4, 0x8f, 0x6b, 0x0b, 0x3e, 0xeb, 0x35, 0x1a, 0xd5, 0x7e, 0xdb, 0x78, 0x00, 0x96, 0x8a, 0xa0, 0xb4, 0xcf, 0x60, 0x4b, 0xd4, 0xd5, 0xf9, 0x2d, 0xbf, 0x88, 0xbd, 0x22, 0x62}} ,
{{0x13, 0x53, 0xe4, 0x82, 0x57, 0xfa, 0x1e, 0x8f, 0x06, 0x2b, 0x90, 0xba, 0x08, 0xb6, 0x10, 0x54, 0x4f, 0x7c, 0x1b, 0x26, 0xed, 0xda, 0x6b, 0xdd, 0x25, 0xd0, 0x4e, 0xea, 0x42, 0xbb, 0x25, 0x03}}},
{{{0x51, 0x16, 0x50, 0x7c, 0xd5, 0x5d, 0xf6, 0x99, 0xe8, 0x77, 0x72, 0x4e, 0xfa, 0x62, 0xcb, 0x76, 0x75, 0x0c, 0xe2, 0x71, 0x98, 0x92, 0xd5, 0xfa, 0x45, 0xdf, 0x5c, 0x6f, 0x1e, 0x9e, 0x28, 0x69}} ,
{{0x0d, 0xac, 0x66, 0x6d, 0xc3, 0x8b, 0xba, 0x16, 0xb5, 0xe2, 0xa0, 0x0d, 0x0c, 0xbd, 0xa4, 0x8e, 0x18, 0x6c, 0xf2, 0xdc, 0xf9, 0xdc, 0x4a, 0x86, 0x25, 0x95, 0x14, 0xcb, 0xd8, 0x1a, 0x04, 0x0f}}},
{{{0x97, 0xa5, 0xdb, 0x8b, 0x2d, 0xaa, 0x42, 0x11, 0x09, 0xf2, 0x93, 0xbb, 0xd9, 0x06, 0x84, 0x4e, 0x11, 0xa8, 0xa0, 0x25, 0x2b, 0xa6, 0x5f, 0xae, 0xc4, 0xb4, 0x4c, 0xc8, 0xab, 0xc7, 0x3b, 0x02}} ,
{{0xee, 0xc9, 0x29, 0x0f, 0xdf, 0x11, 0x85, 0xed, 0xce, 0x0d, 0x62, 0x2c, 0x8f, 0x4b, 0xf9, 0x04, 0xe9, 0x06, 0x72, 0x1d, 0x37, 0x20, 0x50, 0xc9, 0x14, 0xeb, 0xec, 0x39, 0xa7, 0x97, 0x2b, 0x4d}}},
{{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
{{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
{{{0x69, 0xd1, 0x39, 0xbd, 0xfb, 0x33, 0xbe, 0xc4, 0xf0, 0x5c, 0xef, 0xf0, 0x56, 0x68, 0xfc, 0x97, 0x47, 0xc8, 0x72, 0xb6, 0x53, 0xa4, 0x0a, 0x98, 0xa5, 0xb4, 0x37, 0x71, 0xcf, 0x66, 0x50, 0x6d}} ,
{{0x17, 0xa4, 0x19, 0x52, 0x11, 0x47, 0xb3, 0x5c, 0x5b, 0xa9, 0x2e, 0x22, 0xb4, 0x00, 0x52, 0xf9, 0x57, 0x18, 0xb8, 0xbe, 0x5a, 0xe3, 0xab, 0x83, 0xc8, 0x87, 0x0a, 0x2a, 0xd8, 0x8c, 0xbb, 0x54}}},
{{{0xa9, 0x62, 0x93, 0x85, 0xbe, 0xe8, 0x73, 0x4a, 0x0e, 0xb0, 0xb5, 0x2d, 0x94, 0x50, 0xaa, 0xd3, 0xb2, 0xea, 0x9d, 0x62, 0x76, 0x3b, 0x07, 0x34, 0x4e, 0x2d, 0x70, 0xc8, 0x9a, 0x15, 0x66, 0x6b}} ,
{{0xc5, 0x96, 0xca, 0xc8, 0x22, 0x1a, 0xee, 0x5f, 0xe7, 0x31, 0x60, 0x22, 0x83, 0x08, 0x63, 0xce, 0xb9, 0x32, 0x44, 0x58, 0x5d, 0x3a, 0x9b, 0xe4, 0x04, 0xd5, 0xef, 0x38, 0xef, 0x4b, 0xdd, 0x19}}},
{{{0x4d, 0xc2, 0x17, 0x75, 0xa1, 0x68, 0xcd, 0xc3, 0xc6, 0x03, 0x44, 0xe3, 0x78, 0x09, 0x91, 0x47, 0x3f, 0x0f, 0xe4, 0x92, 0x58, 0xfa, 0x7d, 0x1f, 0x20, 0x94, 0x58, 0x5e, 0xbc, 0x19, 0x02, 0x6f}} ,
{{0x20, 0xd6, 0xd8, 0x91, 0x54, 0xa7, 0xf3, 0x20, 0x4b, 0x34, 0x06, 0xfa, 0x30, 0xc8, 0x6f, 0x14, 0x10, 0x65, 0x74, 0x13, 0x4e, 0xf0, 0x69, 0x26, 0xce, 0xcf, 0x90, 0xf4, 0xd0, 0xc5, 0xc8, 0x64}}},
{{{0x26, 0xa2, 0x50, 0x02, 0x24, 0x72, 0xf1, 0xf0, 0x4e, 0x2d, 0x93, 0xd5, 0x08, 0xe7, 0xae, 0x38, 0xf7, 0x18, 0xa5, 0x32, 0x34, 0xc2, 0xf0, 0xa6, 0xec, 0xb9, 0x61, 0x7b, 0x64, 0x99, 0xac, 0x71}} ,
{{0x25, 0xcf, 0x74, 0x55, 0x1b, 0xaa, 0xa9, 0x38, 0x41, 0x40, 0xd5, 0x95, 0x95, 0xab, 0x1c, 0x5e, 0xbc, 0x41, 0x7e, 0x14, 0x30, 0xbe, 0x13, 0x89, 0xf4, 0xe5, 0xeb, 0x28, 0xc0, 0xc2, 0x96, 0x3a}}},
{{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
{{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
{{{0x2b, 0x77, 0x45, 0xec, 0x67, 0x76, 0x32, 0x4c, 0xb9, 0xdf, 0x25, 0x32, 0x6b, 0xcb, 0xe7, 0x14, 0x61, 0x43, 0xee, 0xba, 0x9b, 0x71, 0xef, 0xd2, 0x48, 0x65, 0xbb, 0x1b, 0x8a, 0x13, 0x1b, 0x22}} ,
{{0x84, 0xad, 0x0c, 0x18, 0x38, 0x5a, 0xba, 0xd0, 0x98, 0x59, 0xbf, 0x37, 0xb0, 0x4f, 0x97, 0x60, 0x20, 0xb3, 0x9b, 0x97, 0xf6, 0x08, 0x6c, 0xa4, 0xff, 0xfb, 0xb7, 0xfa, 0x95, 0xb2, 0x51, 0x79}}},
{{{0x28, 0x5c, 0x3f, 0xdb, 0x6b, 0x18, 0x3b, 0x5c, 0xd1, 0x04, 0x28, 0xde, 0x85, 0x52, 0x31, 0xb5, 0xbb, 0xf6, 0xa9, 0xed, 0xbe, 0x28, 0x4f, 0xb3, 0x7e, 0x05, 0x6a, 0xdb, 0x95, 0x0d, 0x1b, 0x1c}} ,
{{0xd5, 0xc5, 0xc3, 0x9a, 0x0a, 0xd0, 0x31, 0x3e, 0x07, 0x36, 0x8e, 0xc0, 0x8a, 0x62, 0xb1, 0xca, 0xd6, 0x0e, 0x1e, 0x9d, 0xef, 0xab, 0x98, 0x4d, 0xbb, 0x6c, 0x05, 0xe0, 0xe4, 0x5d, 0xbd, 0x57}}},
{{{0xcc, 0x21, 0x27, 0xce, 0xfd, 0xa9, 0x94, 0x8e, 0xe1, 0xab, 0x49, 0xe0, 0x46, 0x26, 0xa1, 0xa8, 0x8c, 0xa1, 0x99, 0x1d, 0xb4, 0x27, 0x6d, 0x2d, 0xc8, 0x39, 0x30, 0x5e, 0x37, 0x52, 0xc4, 0x6e}} ,
{{0xa9, 0x85, 0xf4, 0xe7, 0xb0, 0x15, 0x33, 0x84, 0x1b, 0x14, 0x1a, 0x02, 0xd9, 0x3b, 0xad, 0x0f, 0x43, 0x6c, 0xea, 0x3e, 0x0f, 0x7e, 0xda, 0xdd, 0x6b, 0x4c, 0x7f, 0x6e, 0xd4, 0x6b, 0xbf, 0x0f}}},
{{{0x47, 0x9f, 0x7c, 0x56, 0x7c, 0x43, 0x91, 0x1c, 0xbb, 0x4e, 0x72, 0x3e, 0x64, 0xab, 0xa0, 0xa0, 0xdf, 0xb4, 0xd8, 0x87, 0x3a, 0xbd, 0xa8, 0x48, 0xc9, 0xb8, 0xef, 0x2e, 0xad, 0x6f, 0x84, 0x4f}} ,
{{0x2d, 0x2d, 0xf0, 0x1b, 0x7e, 0x2a, 0x6c, 0xf8, 0xa9, 0x6a, 0xe1, 0xf0, 0x99, 0xa1, 0x67, 0x9a, 0xd4, 0x13, 0xca, 0xca, 0xba, 0x27, 0x92, 0xaa, 0xa1, 0x5d, 0x50, 0xde, 0xcc, 0x40, 0x26, 0x0a}}},
{{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
{{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
{{{0x9f, 0x3e, 0xf2, 0xb2, 0x90, 0xce, 0xdb, 0x64, 0x3e, 0x03, 0xdd, 0x37, 0x36, 0x54, 0x70, 0x76, 0x24, 0xb5, 0x69, 0x03, 0xfc, 0xa0, 0x2b, 0x74, 0xb2, 0x05, 0x0e, 0xcc, 0xd8, 0x1f, 0x6a, 0x1f}} ,
{{0x19, 0x5e, 0x60, 0x69, 0x58, 0x86, 0xa0, 0x31, 0xbd, 0x32, 0xe9, 0x2c, 0x5c, 0xd2, 0x85, 0xba, 0x40, 0x64, 0xa8, 0x74, 0xf8, 0x0e, 0x1c, 0xb3, 0xa9, 0x69, 0xe8, 0x1e, 0x40, 0x64, 0x99, 0x77}}},
{{{0x6c, 0x32, 0x4f, 0xfd, 0xbb, 0x5c, 0xbb, 0x8d, 0x64, 0x66, 0x4a, 0x71, 0x1f, 0x79, 0xa3, 0xad, 0x8d, 0xf9, 0xd4, 0xec, 0xcf, 0x67, 0x70, 0xfa, 0x05, 0x4a, 0x0f, 0x6e, 0xaf, 0x87, 0x0a, 0x6f}} ,
{{0xc6, 0x36, 0x6e, 0x6c, 0x8c, 0x24, 0x09, 0x60, 0xbe, 0x26, 0xd2, 0x4c, 0x5e, 0x17, 0xca, 0x5f, 0x1d, 0xcc, 0x87, 0xe8, 0x42, 0x6a, 0xcb, 0xcb, 0x7d, 0x92, 0x05, 0x35, 0x81, 0x13, 0x60, 0x6b}}},
{{{0xf4, 0x15, 0xcd, 0x0f, 0x0a, 0xaf, 0x4e, 0x6b, 0x51, 0xfd, 0x14, 0xc4, 0x2e, 0x13, 0x86, 0x74, 0x44, 0xcb, 0x66, 0x6b, 0xb6, 0x9d, 0x74, 0x56, 0x32, 0xac, 0x8d, 0x8e, 0x8c, 0x8c, 0x8c, 0x39}} ,
{{0xca, 0x59, 0x74, 0x1a, 0x11, 0xef, 0x6d, 0xf7, 0x39, 0x5c, 0x3b, 0x1f, 0xfa, 0xe3, 0x40, 0x41, 0x23, 0x9e, 0xf6, 0xd1, 0x21, 0xa2, 0xbf, 0xad, 0x65, 0x42, 0x6b, 0x59, 0x8a, 0xe8, 0xc5, 0x7f}}},
{{{0x64, 0x05, 0x7a, 0x84, 0x4a, 0x13, 0xc3, 0xf6, 0xb0, 0x6e, 0x9a, 0x6b, 0x53, 0x6b, 0x32, 0xda, 0xd9, 0x74, 0x75, 0xc4, 0xba, 0x64, 0x3d, 0x3b, 0x08, 0xdd, 0x10, 0x46, 0xef, 0xc7, 0x90, 0x1f}} ,
{{0x7b, 0x2f, 0x3a, 0xce, 0xc8, 0xa1, 0x79, 0x3c, 0x30, 0x12, 0x44, 0x28, 0xf6, 0xbc, 0xff, 0xfd, 0xf4, 0xc0, 0x97, 0xb0, 0xcc, 0xc3, 0x13, 0x7a, 0xb9, 0x9a, 0x16, 0xe4, 0xcb, 0x4c, 0x34, 0x63}}},
{{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
{{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
{{{0x07, 0x4e, 0xd3, 0x2d, 0x09, 0x33, 0x0e, 0xd2, 0x0d, 0xbe, 0x3e, 0xe7, 0xe4, 0xaa, 0xb7, 0x00, 0x8b, 0xe8, 0xad, 0xaa, 0x7a, 0x8d, 0x34, 0x28, 0xa9, 0x81, 0x94, 0xc5, 0xe7, 0x42, 0xac, 0x47}} ,
{{0x24, 0x89, 0x7a, 0x8f, 0xb5, 0x9b, 0xf0, 0xc2, 0x03, 0x64, 0xd0, 0x1e, 0xf5, 0xa4, 0xb2, 0xf3, 0x74, 0xe9, 0x1a, 0x16, 0xfd, 0xcb, 0x15, 0xea, 0xeb, 0x10, 0x6c, 0x35, 0xd1, 0xc1, 0xa6, 0x28}}},
{{{0xcc, 0xd5, 0x39, 0xfc, 0xa5, 0xa4, 0xad, 0x32, 0x15, 0xce, 0x19, 0xe8, 0x34, 0x2b, 0x1c, 0x60, 0x91, 0xfc, 0x05, 0xa9, 0xb3, 0xdc, 0x80, 0x29, 0xc4, 0x20, 0x79, 0x06, 0x39, 0xc0, 0xe2, 0x22}} ,
{{0xbb, 0xa8, 0xe1, 0x89, 0x70, 0x57, 0x18, 0x54, 0x3c, 0xf6, 0x0d, 0x82, 0x12, 0x05, 0x87, 0x96, 0x06, 0x39, 0xe3, 0xf8, 0xb3, 0x95, 0xe5, 0xd7, 0x26, 0xbf, 0x09, 0x5a, 0x94, 0xf9, 0x1c, 0x63}}},
{{{0x2b, 0x8c, 0x2d, 0x9a, 0x8b, 0x84, 0xf2, 0x56, 0xfb, 0xad, 0x2e, 0x7f, 0xb7, 0xfc, 0x30, 0xe1, 0x35, 0x89, 0xba, 0x4d, 0xa8, 0x6d, 0xce, 0x8c, 0x8b, 0x30, 0xe0, 0xda, 0x29, 0x18, 0x11, 0x17}} ,
{{0x19, 0xa6, 0x5a, 0x65, 0x93, 0xc3, 0xb5, 0x31, 0x22, 0x4f, 0xf3, 0xf6, 0x0f, 0xeb, 0x28, 0xc3, 0x7c, 0xeb, 0xce, 0x86, 0xec, 0x67, 0x76, 0x6e, 0x35, 0x45, 0x7b, 0xd8, 0x6b, 0x92, 0x01, 0x65}}},
{{{0x3d, 0xd5, 0x9a, 0x64, 0x73, 0x36, 0xb1, 0xd6, 0x86, 0x98, 0x42, 0x3f, 0x8a, 0xf1, 0xc7, 0xf5, 0x42, 0xa8, 0x9c, 0x52, 0xa8, 0xdc, 0xf9, 0x24, 0x3f, 0x4a, 0xa1, 0xa4, 0x5b, 0xe8, 0x62, 0x1a}} ,
{{0xc5, 0xbd, 0xc8, 0x14, 0xd5, 0x0d, 0xeb, 0xe1, 0xa5, 0xe6, 0x83, 0x11, 0x09, 0x00, 0x1d, 0x55, 0x83, 0x51, 0x7e, 0x75, 0x00, 0x81, 0xb9, 0xcb, 0xd8, 0xc5, 0xe5, 0xa1, 0xd9, 0x17, 0x6d, 0x1f}}},
{{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
{{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
{{{0xea, 0xf9, 0xe4, 0xe9, 0xe1, 0x52, 0x3f, 0x51, 0x19, 0x0d, 0xdd, 0xd9, 0x9d, 0x93, 0x31, 0x87, 0x23, 0x09, 0xd5, 0x83, 0xeb, 0x92, 0x09, 0x76, 0x6e, 0xe3, 0xf8, 0xc0, 0xa2, 0x66, 0xb5, 0x36}} ,
{{0x3a, 0xbb, 0x39, 0xed, 0x32, 0x02, 0xe7, 0x43, 0x7a, 0x38, 0x14, 0x84, 0xe3, 0x44, 0xd2, 0x5e, 0x94, 0xdd, 0x78, 0x89, 0x55, 0x4c, 0x73, 0x9e, 0xe1, 0xe4, 0x3e, 0x43, 0xd0, 0x4a, 0xde, 0x1b}}},
{{{0xb2, 0xe7, 0x8f, 0xe3, 0xa3, 0xc5, 0xcb, 0x72, 0xee, 0x79, 0x41, 0xf8, 0xdf, 0xee, 0x65, 0xc5, 0x45, 0x77, 0x27, 0x3c, 0xbd, 0x58, 0xd3, 0x75, 0xe2, 0x04, 0x4b, 0xbb, 0x65, 0xf3, 0xc8, 0x0f}} ,
{{0x24, 0x7b, 0x93, 0x34, 0xb5, 0xe2, 0x74, 0x48, 0xcd, 0xa0, 0x0b, 0x92, 0x97, 0x66, 0x39, 0xf4, 0xb0, 0xe2, 0x5d, 0x39, 0x6a, 0x5b, 0x45, 0x17, 0x78, 0x1e, 0xdb, 0x91, 0x81, 0x1c, 0xf9, 0x16}}},
{{{0x16, 0xdf, 0xd1, 0x5a, 0xd5, 0xe9, 0x4e, 0x58, 0x95, 0x93, 0x5f, 0x51, 0x09, 0xc3, 0x2a, 0xc9, 0xd4, 0x55, 0x48, 0x79, 0xa4, 0xa3, 0xb2, 0xc3, 0x62, 0xaa, 0x8c, 0xe8, 0xad, 0x47, 0x39, 0x1b}} ,
{{0x46, 0xda, 0x9e, 0x51, 0x3a, 0xe6, 0xd1, 0xa6, 0xbb, 0x4d, 0x7b, 0x08, 0xbe, 0x8c, 0xd5, 0xf3, 0x3f, 0xfd, 0xf7, 0x44, 0x80, 0x2d, 0x53, 0x4b, 0xd0, 0x87, 0x68, 0xc1, 0xb5, 0xd8, 0xf7, 0x07}}},
{{{0xf4, 0x10, 0x46, 0xbe, 0xb7, 0xd2, 0xd1, 0xce, 0x5e, 0x76, 0xa2, 0xd7, 0x03, 0xdc, 0xe4, 0x81, 0x5a, 0xf6, 0x3c, 0xde, 0xae, 0x7a, 0x9d, 0x21, 0x34, 0xa5, 0xf6, 0xa9, 0x73, 0xe2, 0x8d, 0x60}} ,
{{0xfa, 0x44, 0x71, 0xf6, 0x41, 0xd8, 0xc6, 0x58, 0x13, 0x37, 0xeb, 0x84, 0x0f, 0x96, 0xc7, 0xdc, 0xc8, 0xa9, 0x7a, 0x83, 0xb2, 0x2f, 0x31, 0xb1, 0x1a, 0xd8, 0x98, 0x3f, 0x11, 0xd0, 0x31, 0x3b}}},
{{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
{{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
{{{0x81, 0xd5, 0x34, 0x16, 0x01, 0xa3, 0x93, 0xea, 0x52, 0x94, 0xec, 0x93, 0xb7, 0x81, 0x11, 0x2d, 0x58, 0xf9, 0xb5, 0x0a, 0xaa, 0x4f, 0xf6, 0x2e, 0x3f, 0x36, 0xbf, 0x33, 0x5a, 0xe7, 0xd1, 0x08}} ,
{{0x1a, 0xcf, 0x42, 0xae, 0xcc, 0xb5, 0x77, 0x39, 0xc4, 0x5b, 0x5b, 0xd0, 0x26, 0x59, 0x27, 0xd0, 0x55, 0x71, 0x12, 0x9d, 0x88, 0x3d, 0x9c, 0xea, 0x41, 0x6a, 0xf0, 0x50, 0x93, 0x93, 0xdd, 0x47}}},
{{{0x6f, 0xc9, 0x51, 0x6d, 0x1c, 0xaa, 0xf5, 0xa5, 0x90, 0x3f, 0x14, 0xe2, 0x6e, 0x8e, 0x64, 0xfd, 0xac, 0xe0, 0x4e, 0x22, 0xe5, 0xc1, 0xbc, 0x29, 0x0a, 0x6a, 0x9e, 0xa1, 0x60, 0xcb, 0x2f, 0x0b}} ,
{{0xdc, 0x39, 0x32, 0xf3, 0xa1, 0x44, 0xe9, 0xc5, 0xc3, 0x78, 0xfb, 0x95, 0x47, 0x34, 0x35, 0x34, 0xe8, 0x25, 0xde, 0x93, 0xc6, 0xb4, 0x76, 0x6d, 0x86, 0x13, 0xc6, 0xe9, 0x68, 0xb5, 0x01, 0x63}}},
{{{0x1f, 0x9a, 0x52, 0x64, 0x97, 0xd9, 0x1c, 0x08, 0x51, 0x6f, 0x26, 0x9d, 0xaa, 0x93, 0x33, 0x43, 0xfa, 0x77, 0xe9, 0x62, 0x9b, 0x5d, 0x18, 0x75, 0xeb, 0x78, 0xf7, 0x87, 0x8f, 0x41, 0xb4, 0x4d}} ,
{{0x13, 0xa8, 0x82, 0x3e, 0xe9, 0x13, 0xad, 0xeb, 0x01, 0xca, 0xcf, 0xda, 0xcd, 0xf7, 0x6c, 0xc7, 0x7a, 0xdc, 0x1e, 0x6e, 0xc8, 0x4e, 0x55, 0x62, 0x80, 0xea, 0x78, 0x0c, 0x86, 0xb9, 0x40, 0x51}}},
{{{0x27, 0xae, 0xd3, 0x0d, 0x4c, 0x8f, 0x34, 0xea, 0x7d, 0x3c, 0xe5, 0x8a, 0xcf, 0x5b, 0x92, 0xd8, 0x30, 0x16, 0xb4, 0xa3, 0x75, 0xff, 0xeb, 0x27, 0xc8, 0x5c, 0x6c, 0xc2, 0xee, 0x6c, 0x21, 0x0b}} ,
{{0xc3, 0xba, 0x12, 0x53, 0x2a, 0xaa, 0x77, 0xad, 0x19, 0x78, 0x55, 0x8a, 0x2e, 0x60, 0x87, 0xc2, 0x6e, 0x91, 0x38, 0x91, 0x3f, 0x7a, 0xc5, 0x24, 0x8f, 0x51, 0xc5, 0xde, 0xb0, 0x53, 0x30, 0x56}}},
{{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
{{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
{{{0x02, 0xfe, 0x54, 0x12, 0x18, 0xca, 0x7d, 0xa5, 0x68, 0x43, 0xa3, 0x6d, 0x14, 0x2a, 0x6a, 0xa5, 0x8e, 0x32, 0xe7, 0x63, 0x4f, 0xe3, 0xc6, 0x44, 0x3e, 0xab, 0x63, 0xca, 0x17, 0x86, 0x74, 0x3f}} ,
{{0x1e, 0x64, 0xc1, 0x7d, 0x52, 0xdc, 0x13, 0x5a, 0xa1, 0x9c, 0x4e, 0xee, 0x99, 0x28, 0xbb, 0x4c, 0xee, 0xac, 0xa9, 0x1b, 0x89, 0xa2, 0x38, 0x39, 0x7b, 0xc4, 0x0f, 0x42, 0xe6, 0x89, 0xed, 0x0f}}},
{{{0xf3, 0x3c, 0x8c, 0x80, 0x83, 0x10, 0x8a, 0x37, 0x50, 0x9c, 0xb4, 0xdf, 0x3f, 0x8c, 0xf7, 0x23, 0x07, 0xd6, 0xff, 0xa0, 0x82, 0x6c, 0x75, 0x3b, 0xe4, 0xb5, 0xbb, 0xe4, 0xe6, 0x50, 0xf0, 0x08}} ,
{{0x62, 0xee, 0x75, 0x48, 0x92, 0x33, 0xf2, 0xf4, 0xad, 0x15, 0x7a, 0xa1, 0x01, 0x46, 0xa9, 0x32, 0x06, 0x88, 0xb6, 0x36, 0x47, 0x35, 0xb9, 0xb4, 0x42, 0x85, 0x76, 0xf0, 0x48, 0x00, 0x90, 0x38}}},
{{{0x51, 0x15, 0x9d, 0xc3, 0x95, 0xd1, 0x39, 0xbb, 0x64, 0x9d, 0x15, 0x81, 0xc1, 0x68, 0xd0, 0xb6, 0xa4, 0x2c, 0x7d, 0x5e, 0x02, 0x39, 0x00, 0xe0, 0x3b, 0xa4, 0xcc, 0xca, 0x1d, 0x81, 0x24, 0x10}} ,
{{0xe7, 0x29, 0xf9, 0x37, 0xd9, 0x46, 0x5a, 0xcd, 0x70, 0xfe, 0x4d, 0x5b, 0xbf, 0xa5, 0xcf, 0x91, 0xf4, 0xef, 0xee, 0x8a, 0x29, 0xd0, 0xe7, 0xc4, 0x25, 0x92, 0x8a, 0xff, 0x36, 0xfc, 0xe4, 0x49}}},
{{{0xbd, 0x00, 0xb9, 0x04, 0x7d, 0x35, 0xfc, 0xeb, 0xd0, 0x0b, 0x05, 0x32, 0x52, 0x7a, 0x89, 0x24, 0x75, 0x50, 0xe1, 0x63, 0x02, 0x82, 0x8e, 0xe7, 0x85, 0x0c, 0xf2, 0x56, 0x44, 0x37, 0x83, 0x25}} ,
{{0x8f, 0xa1, 0xce, 0xcb, 0x60, 0xda, 0x12, 0x02, 0x1e, 0x29, 0x39, 0x2a, 0x03, 0xb7, 0xeb, 0x77, 0x40, 0xea, 0xc9, 0x2b, 0x2c, 0xd5, 0x7d, 0x7e, 0x2c, 0xc7, 0x5a, 0xfd, 0xff, 0xc4, 0xd1, 0x62}}},
{{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
{{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
{{{0x1d, 0x88, 0x98, 0x5b, 0x4e, 0xfc, 0x41, 0x24, 0x05, 0xe6, 0x50, 0x2b, 0xae, 0x96, 0x51, 0xd9, 0x6b, 0x72, 0xb2, 0x33, 0x42, 0x98, 0x68, 0xbb, 0x10, 0x5a, 0x7a, 0x8c, 0x9d, 0x07, 0xb4, 0x05}} ,
{{0x2f, 0x61, 0x9f, 0xd7, 0xa8, 0x3f, 0x83, 0x8c, 0x10, 0x69, 0x90, 0xe6, 0xcf, 0xd2, 0x63, 0xa3, 0xe4, 0x54, 0x7e, 0xe5, 0x69, 0x13, 0x1c, 0x90, 0x57, 0xaa, 0xe9, 0x53, 0x22, 0x43, 0x29, 0x23}}},
{{{0xe5, 0x1c, 0xf8, 0x0a, 0xfd, 0x2d, 0x7e, 0xf5, 0xf5, 0x70, 0x7d, 0x41, 0x6b, 0x11, 0xfe, 0xbe, 0x99, 0xd1, 0x55, 0x29, 0x31, 0xbf, 0xc0, 0x97, 0x6c, 0xd5, 0x35, 0xcc, 0x5e, 0x8b, 0xd9, 0x69}} ,
{{0x8e, 0x4e, 0x9f, 0x25, 0xf8, 0x81, 0x54, 0x2d, 0x0e, 0xd5, 0x54, 0x81, 0x9b, 0xa6, 0x92, 0xce, 0x4b, 0xe9, 0x8f, 0x24, 0x3b, 0xca, 0xe0, 0x44, 0xab, 0x36, 0xfe, 0xfb, 0x87, 0xd4, 0x26, 0x3e}}},
{{{0x0f, 0x93, 0x9c, 0x11, 0xe7, 0xdb, 0xf1, 0xf0, 0x85, 0x43, 0x28, 0x15, 0x37, 0xdd, 0xde, 0x27, 0xdf, 0xad, 0x3e, 0x49, 0x4f, 0xe0, 0x5b, 0xf6, 0x80, 0x59, 0x15, 0x3c, 0x85, 0xb7, 0x3e, 0x12}} ,
{{0xf5, 0xff, 0xcc, 0xf0, 0xb4, 0x12, 0x03, 0x5f, 0xc9, 0x84, 0xcb, 0x1d, 0x17, 0xe0, 0xbc, 0xcc, 0x03, 0x62, 0xa9, 0x8b, 0x94, 0xa6, 0xaa, 0x18, 0xcb, 0x27, 0x8d, 0x49, 0xa6, 0x17, 0x15, 0x07}}},
{{{0xd9, 0xb6, 0xd4, 0x9d, 0xd4, 0x6a, 0xaf, 0x70, 0x07, 0x2c, 0x10, 0x9e, 0xbd, 0x11, 0xad, 0xe4, 0x26, 0x33, 0x70, 0x92, 0x78, 0x1c, 0x74, 0x9f, 0x75, 0x60, 0x56, 0xf4, 0x39, 0xa8, 0xa8, 0x62}} ,
{{0x3b, 0xbf, 0x55, 0x35, 0x61, 0x8b, 0x44, 0x97, 0xe8, 0x3a, 0x55, 0xc1, 0xc8, 0x3b, 0xfd, 0x95, 0x29, 0x11, 0x60, 0x96, 0x1e, 0xcb, 0x11, 0x9d, 0xc2, 0x03, 0x8a, 0x1b, 0xc6, 0xd6, 0x45, 0x3d}}},
{{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
{{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
{{{0x7e, 0x0e, 0x50, 0xb2, 0xcc, 0x0d, 0x6b, 0xa6, 0x71, 0x5b, 0x42, 0xed, 0xbd, 0xaf, 0xac, 0xf0, 0xfc, 0x12, 0xa2, 0x3f, 0x4e, 0xda, 0xe8, 0x11, 0xf3, 0x23, 0xe1, 0x04, 0x62, 0x03, 0x1c, 0x4e}} ,
{{0xc8, 0xb1, 0x1b, 0x6f, 0x73, 0x61, 0x3d, 0x27, 0x0d, 0x7d, 0x7a, 0x25, 0x5f, 0x73, 0x0e, 0x2f, 0x93, 0xf6, 0x24, 0xd8, 0x4f, 0x90, 0xac, 0xa2, 0x62, 0x0a, 0xf0, 0x61, 0xd9, 0x08, 0x59, 0x6a}}},
{{{0x6f, 0x2d, 0x55, 0xf8, 0x2f, 0x8e, 0xf0, 0x18, 0x3b, 0xea, 0xdd, 0x26, 0x72, 0xd1, 0xf5, 0xfe, 0xe5, 0xb8, 0xe6, 0xd3, 0x10, 0x48, 0x46, 0x49, 0x3a, 0x9f, 0x5e, 0x45, 0x6b, 0x90, 0xe8, 0x7f}} ,
{{0xd3, 0x76, 0x69, 0x33, 0x7b, 0xb9, 0x40, 0x70, 0xee, 0xa6, 0x29, 0x6b, 0xdd, 0xd0, 0x5d, 0x8d, 0xc1, 0x3e, 0x4a, 0xea, 0x37, 0xb1, 0x03, 0x02, 0x03, 0x35, 0xf1, 0x28, 0x9d, 0xff, 0x00, 0x13}}},
{{{0x7a, 0xdb, 0x12, 0xd2, 0x8a, 0x82, 0x03, 0x1b, 0x1e, 0xaf, 0xf9, 0x4b, 0x9c, 0xbe, 0xae, 0x7c, 0xe4, 0x94, 0x2a, 0x23, 0xb3, 0x62, 0x86, 0xe7, 0xfd, 0x23, 0xaa, 0x99, 0xbd, 0x2b, 0x11, 0x6c}} ,
{{0x8d, 0xa6, 0xd5, 0xac, 0x9d, 0xcc, 0x68, 0x75, 0x7f, 0xc3, 0x4d, 0x4b, 0xdd, 0x6c, 0xbb, 0x11, 0x5a, 0x60, 0xe5, 0xbd, 0x7d, 0x27, 0x8b, 0xda, 0xb4, 0x95, 0xf6, 0x03, 0x27, 0xa4, 0x92, 0x3f}}},
{{{0x22, 0xd6, 0xb5, 0x17, 0x84, 0xbf, 0x12, 0xcc, 0x23, 0x14, 0x4a, 0xdf, 0x14, 0x31, 0xbc, 0xa1, 0xac, 0x6e, 0xab, 0xfa, 0x57, 0x11, 0x53, 0xb3, 0x27, 0xe6, 0xf9, 0x47, 0x33, 0x44, 0x34, 0x1e}} ,
{{0x79, 0xfc, 0xa6, 0xb4, 0x0b, 0x35, 0x20, 0xc9, 0x4d, 0x22, 0x84, 0xc4, 0xa9, 0x20, 0xec, 0x89, 0x94, 0xba, 0x66, 0x56, 0x48, 0xb9, 0x87, 0x7f, 0xca, 0x1e, 0x06, 0xed, 0xa5, 0x55, 0x59, 0x29}}},
{{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
{{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
{{{0x56, 0xe1, 0xf5, 0xf1, 0xd5, 0xab, 0xa8, 0x2b, 0xae, 0x89, 0xf3, 0xcf, 0x56, 0x9f, 0xf2, 0x4b, 0x31, 0xbc, 0x18, 0xa9, 0x06, 0x5b, 0xbe, 0xb4, 0x61, 0xf8, 0xb2, 0x06, 0x9c, 0x81, 0xab, 0x4c}} ,
{{0x1f, 0x68, 0x76, 0x01, 0x16, 0x38, 0x2b, 0x0f, 0x77, 0x97, 0x92, 0x67, 0x4e, 0x86, 0x6a, 0x8b, 0xe5, 0xe8, 0x0c, 0xf7, 0x36, 0x39, 0xb5, 0x33, 0xe6, 0xcf, 0x5e, 0xbd, 0x18, 0xfb, 0x10, 0x1f}}},
{{{0x83, 0xf0, 0x0d, 0x63, 0xef, 0x53, 0x6b, 0xb5, 0x6b, 0xf9, 0x83, 0xcf, 0xde, 0x04, 0x22, 0x9b, 0x2c, 0x0a, 0xe0, 0xa5, 0xd8, 0xc7, 0x9c, 0xa5, 0xa3, 0xf6, 0x6f, 0xcf, 0x90, 0x6b, 0x68, 0x7c}} ,
{{0x33, 0x15, 0xd7, 0x7f, 0x1a, 0xd5, 0x21, 0x58, 0xc4, 0x18, 0xa5, 0xf0, 0xcc, 0x73, 0xa8, 0xfd, 0xfa, 0x18, 0xd1, 0x03, 0x91, 0x8d, 0x52, 0xd2, 0xa3, 0xa4, 0xd3, 0xb1, 0xea, 0x1d, 0x0f, 0x00}}},
{{{0xcc, 0x48, 0x83, 0x90, 0xe5, 0xfd, 0x3f, 0x84, 0xaa, 0xf9, 0x8b, 0x82, 0x59, 0x24, 0x34, 0x68, 0x4f, 0x1c, 0x23, 0xd9, 0xcc, 0x71, 0xe1, 0x7f, 0x8c, 0xaf, 0xf1, 0xee, 0x00, 0xb6, 0xa0, 0x77}} ,
{{0xf5, 0x1a, 0x61, 0xf7, 0x37, 0x9d, 0x00, 0xf4, 0xf2, 0x69, 0x6f, 0x4b, 0x01, 0x85, 0x19, 0x45, 0x4d, 0x7f, 0x02, 0x7c, 0x6a, 0x05, 0x47, 0x6c, 0x1f, 0x81, 0x20, 0xd4, 0xe8, 0x50, 0x27, 0x72}}},
{{{0x2c, 0x3a, 0xe5, 0xad, 0xf4, 0xdd, 0x2d, 0xf7, 0x5c, 0x44, 0xb5, 0x5b, 0x21, 0xa3, 0x89, 0x5f, 0x96, 0x45, 0xca, 0x4d, 0xa4, 0x21, 0x99, 0x70, 0xda, 0xc4, 0xc4, 0xa0, 0xe5, 0xf4, 0xec, 0x0a}} ,
{{0x07, 0x68, 0x21, 0x65, 0xe9, 0x08, 0xa0, 0x0b, 0x6a, 0x4a, 0xba, 0xb5, 0x80, 0xaf, 0xd0, 0x1b, 0xc5, 0xf5, 0x4b, 0x73, 0x50, 0x60, 0x2d, 0x71, 0x69, 0x61, 0x0e, 0xc0, 0x20, 0x40, 0x30, 0x19}}},
{{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
{{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
{{{0xd0, 0x75, 0x57, 0x3b, 0xeb, 0x5c, 0x14, 0x56, 0x50, 0xc9, 0x4f, 0xb8, 0xb8, 0x1e, 0xa3, 0xf4, 0xab, 0xf5, 0xa9, 0x20, 0x15, 0x94, 0x82, 0xda, 0x96, 0x1c, 0x9b, 0x59, 0x8c, 0xff, 0xf4, 0x51}} ,
{{0xc1, 0x3a, 0x86, 0xd7, 0xb0, 0x06, 0x84, 0x7f, 0x1b, 0xbd, 0xd4, 0x07, 0x78, 0x80, 0x2e, 0xb1, 0xb4, 0xee, 0x52, 0x38, 0xee, 0x9a, 0xf9, 0xf6, 0xf3, 0x41, 0x6e, 0xd4, 0x88, 0x95, 0xac, 0x35}}},
{{{0x41, 0x97, 0xbf, 0x71, 0x6a, 0x9b, 0x72, 0xec, 0xf3, 0xf8, 0x6b, 0xe6, 0x0e, 0x6c, 0x69, 0xa5, 0x2f, 0x68, 0x52, 0xd8, 0x61, 0x81, 0xc0, 0x63, 0x3f, 0xa6, 0x3c, 0x13, 0x90, 0xe6, 0x8d, 0x56}} ,
{{0xe8, 0x39, 0x30, 0x77, 0x23, 0xb1, 0xfd, 0x1b, 0x3d, 0x3e, 0x74, 0x4d, 0x7f, 0xae, 0x5b, 0x3a, 0xb4, 0x65, 0x0e, 0x3a, 0x43, 0xdc, 0xdc, 0x41, 0x47, 0xe6, 0xe8, 0x92, 0x09, 0x22, 0x48, 0x4c}}},
{{{0x85, 0x57, 0x9f, 0xb5, 0xc8, 0x06, 0xb2, 0x9f, 0x47, 0x3f, 0xf0, 0xfa, 0xe6, 0xa9, 0xb1, 0x9b, 0x6f, 0x96, 0x7d, 0xf9, 0xa4, 0x65, 0x09, 0x75, 0x32, 0xa6, 0x6c, 0x7f, 0x47, 0x4b, 0x2f, 0x4f}} ,
{{0x34, 0xe9, 0x59, 0x93, 0x9d, 0x26, 0x80, 0x54, 0xf2, 0xcc, 0x3c, 0xc2, 0x25, 0x85, 0xe3, 0x6a, 0xc1, 0x62, 0x04, 0xa7, 0x08, 0x32, 0x6d, 0xa1, 0x39, 0x84, 0x8a, 0x3b, 0x87, 0x5f, 0x11, 0x13}}},
{{{0xda, 0x03, 0x34, 0x66, 0xc4, 0x0c, 0x73, 0x6e, 0xbc, 0x24, 0xb5, 0xf9, 0x70, 0x81, 0x52, 0xe9, 0xf4, 0x7c, 0x23, 0xdd, 0x9f, 0xb8, 0x46, 0xef, 0x1d, 0x22, 0x55, 0x7d, 0x71, 0xc4, 0x42, 0x33}} ,
{{0xc5, 0x37, 0x69, 0x5b, 0xa8, 0xc6, 0x9d, 0xa4, 0xfc, 0x61, 0x6e, 0x68, 0x46, 0xea, 0xd7, 0x1c, 0x67, 0xd2, 0x7d, 0xfa, 0xf1, 0xcc, 0x54, 0x8d, 0x36, 0x35, 0xc9, 0x00, 0xdf, 0x6c, 0x67, 0x50}}},
{{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
{{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
{{{0x9a, 0x4d, 0x42, 0x29, 0x5d, 0xa4, 0x6b, 0x6f, 0xa8, 0x8a, 0x4d, 0x91, 0x7b, 0xd2, 0xdf, 0x36, 0xef, 0x01, 0x22, 0xc5, 0xcc, 0x8d, 0xeb, 0x58, 0x3d, 0xb3, 0x50, 0xfc, 0x8b, 0x97, 0x96, 0x33}} ,
{{0x93, 0x33, 0x07, 0xc8, 0x4a, 0xca, 0xd0, 0xb1, 0xab, 0xbd, 0xdd, 0xa7, 0x7c, 0xac, 0x3e, 0x45, 0xcb, 0xcc, 0x07, 0x91, 0xbf, 0x35, 0x9d, 0xcb, 0x7d, 0x12, 0x3c, 0x11, 0x59, 0x13, 0xcf, 0x5c}}},
{{{0x45, 0xb8, 0x41, 0xd7, 0xab, 0x07, 0x15, 0x00, 0x8e, 0xce, 0xdf, 0xb2, 0x43, 0x5c, 0x01, 0xdc, 0xf4, 0x01, 0x51, 0x95, 0x10, 0x5a, 0xf6, 0x24, 0x24, 0xa0, 0x19, 0x3a, 0x09, 0x2a, 0xaa, 0x3f}} ,
{{0xdc, 0x8e, 0xeb, 0xc6, 0xbf, 0xdd, 0x11, 0x7b, 0xe7, 0x47, 0xe6, 0xce, 0xe7, 0xb6, 0xc5, 0xe8, 0x8a, 0xdc, 0x4b, 0x57, 0x15, 0x3b, 0x66, 0xca, 0x89, 0xa3, 0xfd, 0xac, 0x0d, 0xe1, 0x1d, 0x7a}}},
{{{0x89, 0xef, 0xbf, 0x03, 0x75, 0xd0, 0x29, 0x50, 0xcb, 0x7d, 0xd6, 0xbe, 0xad, 0x5f, 0x7b, 0x00, 0x32, 0xaa, 0x98, 0xed, 0x3f, 0x8f, 0x92, 0xcb, 0x81, 0x56, 0x01, 0x63, 0x64, 0xa3, 0x38, 0x39}} ,
{{0x8b, 0xa4, 0xd6, 0x50, 0xb4, 0xaa, 0x5d, 0x64, 0x64, 0x76, 0x2e, 0xa1, 0xa6, 0xb3, 0xb8, 0x7c, 0x7a, 0x56, 0xf5, 0x5c, 0x4e, 0x84, 0x5c, 0xfb, 0xdd, 0xca, 0x48, 0x8b, 0x48, 0xb9, 0xba, 0x34}}},
{{{0xc5, 0xe3, 0xe8, 0xae, 0x17, 0x27, 0xe3, 0x64, 0x60, 0x71, 0x47, 0x29, 0x02, 0x0f, 0x92, 0x5d, 0x10, 0x93, 0xc8, 0x0e, 0xa1, 0xed, 0xba, 0xa9, 0x96, 0x1c, 0xc5, 0x76, 0x30, 0xcd, 0xf9, 0x30}} ,
{{0x95, 0xb0, 0xbd, 0x8c, 0xbc, 0xa7, 0x4f, 0x7e, 0xfd, 0x4e, 0x3a, 0xbf, 0x5f, 0x04, 0x79, 0x80, 0x2b, 0x5a, 0x9f, 0x4f, 0x68, 0x21, 0x19, 0x71, 0xc6, 0x20, 0x01, 0x42, 0xaa, 0xdf, 0xae, 0x2c}}},
{{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
{{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
{{{0x90, 0x6e, 0x7e, 0x4b, 0x71, 0x93, 0xc0, 0x72, 0xed, 0xeb, 0x71, 0x24, 0x97, 0x26, 0x9c, 0xfe, 0xcb, 0x3e, 0x59, 0x19, 0xa8, 0x0f, 0x75, 0x7d, 0xbe, 0x18, 0xe6, 0x96, 0x1e, 0x95, 0x70, 0x60}} ,
{{0x89, 0x66, 0x3e, 0x1d, 0x4c, 0x5f, 0xfe, 0xc0, 0x04, 0x43, 0xd6, 0x44, 0x19, 0xb5, 0xad, 0xc7, 0x22, 0xdc, 0x71, 0x28, 0x64, 0xde, 0x41, 0x38, 0x27, 0x8f, 0x2c, 0x6b, 0x08, 0xb8, 0xb8, 0x7b}}},
{{{0x3d, 0x70, 0x27, 0x9d, 0xd9, 0xaf, 0xb1, 0x27, 0xaf, 0xe3, 0x5d, 0x1e, 0x3a, 0x30, 0x54, 0x61, 0x60, 0xe8, 0xc3, 0x26, 0x3a, 0xbc, 0x7e, 0xf5, 0x81, 0xdd, 0x64, 0x01, 0x04, 0xeb, 0xc0, 0x1e}} ,
{{0xda, 0x2c, 0xa4, 0xd1, 0xa1, 0xc3, 0x5c, 0x6e, 0x32, 0x07, 0x1f, 0xb8, 0x0e, 0x19, 0x9e, 0x99, 0x29, 0x33, 0x9a, 0xae, 0x7a, 0xed, 0x68, 0x42, 0x69, 0x7c, 0x07, 0xb3, 0x38, 0x2c, 0xf6, 0x3d}}},
{{{0x64, 0xaa, 0xb5, 0x88, 0x79, 0x65, 0x38, 0x8c, 0x94, 0xd6, 0x62, 0x37, 0x7d, 0x64, 0xcd, 0x3a, 0xeb, 0xff, 0xe8, 0x81, 0x09, 0xc7, 0x6a, 0x50, 0x09, 0x0d, 0x28, 0x03, 0x0d, 0x9a, 0x93, 0x0a}} ,
{{0x42, 0xa3, 0xf1, 0xc5, 0xb4, 0x0f, 0xd8, 0xc8, 0x8d, 0x15, 0x31, 0xbd, 0xf8, 0x07, 0x8b, 0xcd, 0x08, 0x8a, 0xfb, 0x18, 0x07, 0xfe, 0x8e, 0x52, 0x86, 0xef, 0xbe, 0xec, 0x49, 0x52, 0x99, 0x08}}},
{{{0x0f, 0xa9, 0xd5, 0x01, 0xaa, 0x48, 0x4f, 0x28, 0x66, 0x32, 0x1a, 0xba, 0x7c, 0xea, 0x11, 0x80, 0x17, 0x18, 0x9b, 0x56, 0x88, 0x25, 0x06, 0x69, 0x12, 0x2c, 0xea, 0x56, 0x69, 0x41, 0x24, 0x19}} ,
{{0xde, 0x21, 0xf0, 0xda, 0x8a, 0xfb, 0xb1, 0xb8, 0xcd, 0xc8, 0x6a, 0x82, 0x19, 0x73, 0xdb, 0xc7, 0xcf, 0x88, 0xeb, 0x96, 0xee, 0x6f, 0xfb, 0x06, 0xd2, 0xcd, 0x7d, 0x7b, 0x12, 0x28, 0x8e, 0x0c}}},
{{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
{{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
{{{0x93, 0x44, 0x97, 0xce, 0x28, 0xff, 0x3a, 0x40, 0xc4, 0xf5, 0xf6, 0x9b, 0xf4, 0x6b, 0x07, 0x84, 0xfb, 0x98, 0xd8, 0xec, 0x8c, 0x03, 0x57, 0xec, 0x49, 0xed, 0x63, 0xb6, 0xaa, 0xff, 0x98, 0x28}} ,
{{0x3d, 0x16, 0x35, 0xf3, 0x46, 0xbc, 0xb3, 0xf4, 0xc6, 0xb6, 0x4f, 0xfa, 0xf4, 0xa0, 0x13, 0xe6, 0x57, 0x45, 0x93, 0xb9, 0xbc, 0xd6, 0x59, 0xe7, 0x77, 0x94, 0x6c, 0xab, 0x96, 0x3b, 0x4f, 0x09}}},
{{{0x5a, 0xf7, 0x6b, 0x01, 0x12, 0x4f, 0x51, 0xc1, 0x70, 0x84, 0x94, 0x47, 0xb2, 0x01, 0x6c, 0x71, 0xd7, 0xcc, 0x17, 0x66, 0x0f, 0x59, 0x5d, 0x5d, 0x10, 0x01, 0x57, 0x11, 0xf5, 0xdd, 0xe2, 0x34}} ,
{{0x26, 0xd9, 0x1f, 0x5c, 0x58, 0xac, 0x8b, 0x03, 0xd2, 0xc3, 0x85, 0x0f, 0x3a, 0xc3, 0x7f, 0x6d, 0x8e, 0x86, 0xcd, 0x52, 0x74, 0x8f, 0x55, 0x77, 0x17, 0xb7, 0x8e, 0xb7, 0x88, 0xea, 0xda, 0x1b}}},
{{{0xb6, 0xea, 0x0e, 0x40, 0x93, 0x20, 0x79, 0x35, 0x6a, 0x61, 0x84, 0x5a, 0x07, 0x6d, 0xf9, 0x77, 0x6f, 0xed, 0x69, 0x1c, 0x0d, 0x25, 0x76, 0xcc, 0xf0, 0xdb, 0xbb, 0xc5, 0xad, 0xe2, 0x26, 0x57}} ,
{{0xcf, 0xe8, 0x0e, 0x6b, 0x96, 0x7d, 0xed, 0x27, 0xd1, 0x3c, 0xa9, 0xd9, 0x50, 0xa9, 0x98, 0x84, 0x5e, 0x86, 0xef, 0xd6, 0xf0, 0xf8, 0x0e, 0x89, 0x05, 0x2f, 0xd9, 0x5f, 0x15, 0x5f, 0x73, 0x79}}},
{{{0xc8, 0x5c, 0x16, 0xfe, 0xed, 0x9f, 0x26, 0x56, 0xf6, 0x4b, 0x9f, 0xa7, 0x0a, 0x85, 0xfe, 0xa5, 0x8c, 0x87, 0xdd, 0x98, 0xce, 0x4e, 0xc3, 0x58, 0x55, 0xb2, 0x7b, 0x3d, 0xd8, 0x6b, 0xb5, 0x4c}} ,
{{0x65, 0x38, 0xa0, 0x15, 0xfa, 0xa7, 0xb4, 0x8f, 0xeb, 0xc4, 0x86, 0x9b, 0x30, 0xa5, 0x5e, 0x4d, 0xea, 0x8a, 0x9a, 0x9f, 0x1a, 0xd8, 0x5b, 0x53, 0x14, 0x19, 0x25, 0x63, 0xb4, 0x6f, 0x1f, 0x5d}}},
{{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
{{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
{{{0xac, 0x8f, 0xbc, 0x1e, 0x7d, 0x8b, 0x5a, 0x0b, 0x8d, 0xaf, 0x76, 0x2e, 0x71, 0xe3, 0x3b, 0x6f, 0x53, 0x2f, 0x3e, 0x90, 0x95, 0xd4, 0x35, 0x14, 0x4f, 0x8c, 0x3c, 0xce, 0x57, 0x1c, 0x76, 0x49}} ,
{{0xa8, 0x50, 0xe1, 0x61, 0x6b, 0x57, 0x35, 0xeb, 0x44, 0x0b, 0x0c, 0x6e, 0xf9, 0x25, 0x80, 0x74, 0xf2, 0x8f, 0x6f, 0x7a, 0x3e, 0x7f, 0x2d, 0xf3, 0x4e, 0x09, 0x65, 0x10, 0x5e, 0x03, 0x25, 0x32}}},
{{{0xa9, 0x60, 0xdc, 0x0f, 0x64, 0xe5, 0x1d, 0xe2, 0x8d, 0x4f, 0x79, 0x2f, 0x0e, 0x24, 0x02, 0x00, 0x05, 0x77, 0x43, 0x25, 0x3d, 0x6a, 0xc7, 0xb7, 0xbf, 0x04, 0x08, 0x65, 0xf4, 0x39, 0x4b, 0x65}} ,
{{0x96, 0x19, 0x12, 0x6b, 0x6a, 0xb7, 0xe3, 0xdc, 0x45, 0x9b, 0xdb, 0xb4, 0xa8, 0xae, 0xdc, 0xa8, 0x14, 0x44, 0x65, 0x62, 0xce, 0x34, 0x9a, 0x84, 0x18, 0x12, 0x01, 0xf1, 0xe2, 0x7b, 0xce, 0x50}}},
{{{0x41, 0x21, 0x30, 0x53, 0x1b, 0x47, 0x01, 0xb7, 0x18, 0xd8, 0x82, 0x57, 0xbd, 0xa3, 0x60, 0xf0, 0x32, 0xf6, 0x5b, 0xf0, 0x30, 0x88, 0x91, 0x59, 0xfd, 0x90, 0xa2, 0xb9, 0x55, 0x93, 0x21, 0x34}} ,
{{0x97, 0x67, 0x9e, 0xeb, 0x6a, 0xf9, 0x6e, 0xd6, 0x73, 0xe8, 0x6b, 0x29, 0xec, 0x63, 0x82, 0x00, 0xa8, 0x99, 0x1c, 0x1d, 0x30, 0xc8, 0x90, 0x52, 0x90, 0xb6, 0x6a, 0x80, 0x4e, 0xff, 0x4b, 0x51}}},
{{{0x0f, 0x7d, 0x63, 0x8c, 0x6e, 0x5c, 0xde, 0x30, 0xdf, 0x65, 0xfa, 0x2e, 0xb0, 0xa3, 0x25, 0x05, 0x54, 0xbd, 0x25, 0xba, 0x06, 0xae, 0xdf, 0x8b, 0xd9, 0x1b, 0xea, 0x38, 0xb3, 0x05, 0x16, 0x09}} ,
{{0xc7, 0x8c, 0xbf, 0x64, 0x28, 0xad, 0xf8, 0xa5, 0x5a, 0x6f, 0xc9, 0xba, 0xd5, 0x7f, 0xd5, 0xd6, 0xbd, 0x66, 0x2f, 0x3d, 0xaa, 0x54, 0xf6, 0xba, 0x32, 0x22, 0x9a, 0x1e, 0x52, 0x05, 0xf4, 0x1d}}},
{{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
{{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
{{{0xaa, 0x1f, 0xbb, 0xeb, 0xfe, 0xe4, 0x87, 0xfc, 0xb1, 0x2c, 0xb7, 0x88, 0xf4, 0xc6, 0xb9, 0xf5, 0x24, 0x46, 0xf2, 0xa5, 0x9f, 0x8f, 0x8a, 0x93, 0x70, 0x69, 0xd4, 0x56, 0xec, 0xfd, 0x06, 0x46}} ,
{{0x4e, 0x66, 0xcf, 0x4e, 0x34, 0xce, 0x0c, 0xd9, 0xa6, 0x50, 0xd6, 0x5e, 0x95, 0xaf, 0xe9, 0x58, 0xfa, 0xee, 0x9b, 0xb8, 0xa5, 0x0f, 0x35, 0xe0, 0x43, 0x82, 0x6d, 0x65, 0xe6, 0xd9, 0x00, 0x0f}}},
{{{0x7b, 0x75, 0x3a, 0xfc, 0x64, 0xd3, 0x29, 0x7e, 0xdd, 0x49, 0x9a, 0x59, 0x53, 0xbf, 0xb4, 0xa7, 0x52, 0xb3, 0x05, 0xab, 0xc3, 0xaf, 0x16, 0x1a, 0x85, 0x42, 0x32, 0xa2, 0x86, 0xfa, 0x39, 0x43}} ,
{{0x0e, 0x4b, 0xa3, 0x63, 0x8a, 0xfe, 0xa5, 0x58, 0xf1, 0x13, 0xbd, 0x9d, 0xaa, 0x7f, 0x76, 0x40, 0x70, 0x81, 0x10, 0x75, 0x99, 0xbb, 0xbe, 0x0b, 0x16, 0xe9, 0xba, 0x62, 0x34, 0xcc, 0x07, 0x6d}}},
{{{0xc3, 0xf1, 0xc6, 0x93, 0x65, 0xee, 0x0b, 0xbc, 0xea, 0x14, 0xf0, 0xc1, 0xf8, 0x84, 0x89, 0xc2, 0xc9, 0xd7, 0xea, 0x34, 0xca, 0xa7, 0xc4, 0x99, 0xd5, 0x50, 0x69, 0xcb, 0xd6, 0x21, 0x63, 0x7c}} ,
{{0x99, 0xeb, 0x7c, 0x31, 0x73, 0x64, 0x67, 0x7f, 0x0c, 0x66, 0xaa, 0x8c, 0x69, 0x91, 0xe2, 0x26, 0xd3, 0x23, 0xe2, 0x76, 0x5d, 0x32, 0x52, 0xdf, 0x5d, 0xc5, 0x8f, 0xb7, 0x7c, 0x84, 0xb3, 0x70}}},
{{{0xeb, 0x01, 0xc7, 0x36, 0x97, 0x4e, 0xb6, 0xab, 0x5f, 0x0d, 0x2c, 0xba, 0x67, 0x64, 0x55, 0xde, 0xbc, 0xff, 0xa6, 0xec, 0x04, 0xd3, 0x8d, 0x39, 0x56, 0x5e, 0xee, 0xf8, 0xe4, 0x2e, 0x33, 0x62}} ,
{{0x65, 0xef, 0xb8, 0x9f, 0xc8, 0x4b, 0xa7, 0xfd, 0x21, 0x49, 0x9b, 0x92, 0x35, 0x82, 0xd6, 0x0a, 0x9b, 0xf2, 0x79, 0xf1, 0x47, 0x2f, 0x6a, 0x7e, 0x9f, 0xcf, 0x18, 0x02, 0x3c, 0xfb, 0x1b, 0x3e}}},
{{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
{{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
{{{0x2f, 0x8b, 0xc8, 0x40, 0x51, 0xd1, 0xac, 0x1a, 0x0b, 0xe4, 0xa9, 0xa2, 0x42, 0x21, 0x19, 0x2f, 0x7b, 0x97, 0xbf, 0xf7, 0x57, 0x6d, 0x3f, 0x3d, 0x4f, 0x0f, 0xe2, 0xb2, 0x81, 0x00, 0x9e, 0x7b}} ,
{{0x8c, 0x85, 0x2b, 0xc4, 0xfc, 0xf1, 0xab, 0xe8, 0x79, 0x22, 0xc4, 0x84, 0x17, 0x3a, 0xfa, 0x86, 0xa6, 0x7d, 0xf9, 0xf3, 0x6f, 0x03, 0x57, 0x20, 0x4d, 0x79, 0xf9, 0x6e, 0x71, 0x54, 0x38, 0x09}}},
{{{0x40, 0x29, 0x74, 0xa8, 0x2f, 0x5e, 0xf9, 0x79, 0xa4, 0xf3, 0x3e, 0xb9, 0xfd, 0x33, 0x31, 0xac, 0x9a, 0x69, 0x88, 0x1e, 0x77, 0x21, 0x2d, 0xf3, 0x91, 0x52, 0x26, 0x15, 0xb2, 0xa6, 0xcf, 0x7e}} ,
{{0xc6, 0x20, 0x47, 0x6c, 0xa4, 0x7d, 0xcb, 0x63, 0xea, 0x5b, 0x03, 0xdf, 0x3e, 0x88, 0x81, 0x6d, 0xce, 0x07, 0x42, 0x18, 0x60, 0x7e, 0x7b, 0x55, 0xfe, 0x6a, 0xf3, 0xda, 0x5c, 0x8b, 0x95, 0x10}}},
{{{0x62, 0xe4, 0x0d, 0x03, 0xb4, 0xd7, 0xcd, 0xfa, 0xbd, 0x46, 0xdf, 0x93, 0x71, 0x10, 0x2c, 0xa8, 0x3b, 0xb6, 0x09, 0x05, 0x70, 0x84, 0x43, 0x29, 0xa8, 0x59, 0xf5, 0x8e, 0x10, 0xe4, 0xd7, 0x20}} ,
{{0x57, 0x82, 0x1c, 0xab, 0xbf, 0x62, 0x70, 0xe8, 0xc4, 0xcf, 0xf0, 0x28, 0x6e, 0x16, 0x3c, 0x08, 0x78, 0x89, 0x85, 0x46, 0x0f, 0xf6, 0x7f, 0xcf, 0xcb, 0x7e, 0xb8, 0x25, 0xe9, 0x5a, 0xfa, 0x03}}},
{{{0xfb, 0x95, 0x92, 0x63, 0x50, 0xfc, 0x62, 0xf0, 0xa4, 0x5e, 0x8c, 0x18, 0xc2, 0x17, 0x24, 0xb7, 0x78, 0xc2, 0xa9, 0xe7, 0x6a, 0x32, 0xd6, 0x29, 0x85, 0xaf, 0xcb, 0x8d, 0x91, 0x13, 0xda, 0x6b}} ,
{{0x36, 0x0a, 0xc2, 0xb6, 0x4b, 0xa5, 0x5d, 0x07, 0x17, 0x41, 0x31, 0x5f, 0x62, 0x46, 0xf8, 0x92, 0xf9, 0x66, 0x48, 0x73, 0xa6, 0x97, 0x0d, 0x7d, 0x88, 0xee, 0x62, 0xb1, 0x03, 0xa8, 0x3f, 0x2c}}},
{{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
{{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
{{{0x4a, 0xb1, 0x70, 0x8a, 0xa9, 0xe8, 0x63, 0x79, 0x00, 0xe2, 0x25, 0x16, 0xca, 0x4b, 0x0f, 0xa4, 0x66, 0xad, 0x19, 0x9f, 0x88, 0x67, 0x0c, 0x8b, 0xc2, 0x4a, 0x5b, 0x2b, 0x6d, 0x95, 0xaf, 0x19}} ,
{{0x8b, 0x9d, 0xb6, 0xcc, 0x60, 0xb4, 0x72, 0x4f, 0x17, 0x69, 0x5a, 0x4a, 0x68, 0x34, 0xab, 0xa1, 0x45, 0x32, 0x3c, 0x83, 0x87, 0x72, 0x30, 0x54, 0x77, 0x68, 0xae, 0xfb, 0xb5, 0x8b, 0x22, 0x5e}}},
{{{0xf1, 0xb9, 0x87, 0x35, 0xc5, 0xbb, 0xb9, 0xcf, 0xf5, 0xd6, 0xcd, 0xd5, 0x0c, 0x7c, 0x0e, 0xe6, 0x90, 0x34, 0xfb, 0x51, 0x42, 0x1e, 0x6d, 0xac, 0x9a, 0x46, 0xc4, 0x97, 0x29, 0x32, 0xbf, 0x45}} ,
{{0x66, 0x9e, 0xc6, 0x24, 0xc0, 0xed, 0xa5, 0x5d, 0x88, 0xd4, 0xf0, 0x73, 0x97, 0x7b, 0xea, 0x7f, 0x42, 0xff, 0x21, 0xa0, 0x9b, 0x2f, 0x9a, 0xfd, 0x53, 0x57, 0x07, 0x84, 0x48, 0x88, 0x9d, 0x52}}},
{{{0xc6, 0x96, 0x48, 0x34, 0x2a, 0x06, 0xaf, 0x94, 0x3d, 0xf4, 0x1a, 0xcf, 0xf2, 0xc0, 0x21, 0xc2, 0x42, 0x5e, 0xc8, 0x2f, 0x35, 0xa2, 0x3e, 0x29, 0xfa, 0x0c, 0x84, 0xe5, 0x89, 0x72, 0x7c, 0x06}} ,
{{0x32, 0x65, 0x03, 0xe5, 0x89, 0xa6, 0x6e, 0xb3, 0x5b, 0x8e, 0xca, 0xeb, 0xfe, 0x22, 0x56, 0x8b, 0x5d, 0x14, 0x4b, 0x4d, 0xf9, 0xbe, 0xb5, 0xf5, 0xe6, 0x5c, 0x7b, 0x8b, 0xf4, 0x13, 0x11, 0x34}}},
{{{0x07, 0xc6, 0x22, 0x15, 0xe2, 0x9c, 0x60, 0xa2, 0x19, 0xd9, 0x27, 0xae, 0x37, 0x4e, 0xa6, 0xc9, 0x80, 0xa6, 0x91, 0x8f, 0x12, 0x49, 0xe5, 0x00, 0x18, 0x47, 0xd1, 0xd7, 0x28, 0x22, 0x63, 0x39}} ,
{{0xe8, 0xe2, 0x00, 0x7e, 0xf2, 0x9e, 0x1e, 0x99, 0x39, 0x95, 0x04, 0xbd, 0x1e, 0x67, 0x7b, 0xb2, 0x26, 0xac, 0xe6, 0xaa, 0xe2, 0x46, 0xd5, 0xe4, 0xe8, 0x86, 0xbd, 0xab, 0x7c, 0x55, 0x59, 0x6f}}},
{{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
{{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
{{{0x24, 0x64, 0x6e, 0x9b, 0x35, 0x71, 0x78, 0xce, 0x33, 0x03, 0x21, 0x33, 0x36, 0xf1, 0x73, 0x9b, 0xb9, 0x15, 0x8b, 0x2c, 0x69, 0xcf, 0x4d, 0xed, 0x4f, 0x4d, 0x57, 0x14, 0x13, 0x82, 0xa4, 0x4d}} ,
{{0x65, 0x6e, 0x0a, 0xa4, 0x59, 0x07, 0x17, 0xf2, 0x6b, 0x4a, 0x1f, 0x6e, 0xf6, 0xb5, 0xbc, 0x62, 0xe4, 0xb6, 0xda, 0xa2, 0x93, 0xbc, 0x29, 0x05, 0xd2, 0xd2, 0x73, 0x46, 0x03, 0x16, 0x40, 0x31}}},
{{{0x4c, 0x73, 0x6d, 0x15, 0xbd, 0xa1, 0x4d, 0x5c, 0x13, 0x0b, 0x24, 0x06, 0x98, 0x78, 0x1c, 0x5b, 0xeb, 0x1f, 0x18, 0x54, 0x43, 0xd9, 0x55, 0x66, 0xda, 0x29, 0x21, 0xe8, 0xb8, 0x3c, 0x42, 0x22}} ,
{{0xb4, 0xcd, 0x08, 0x6f, 0x15, 0x23, 0x1a, 0x0b, 0x22, 0xed, 0xd1, 0xf1, 0xa7, 0xc7, 0x73, 0x45, 0xf3, 0x9e, 0xce, 0x76, 0xb7, 0xf6, 0x39, 0xb6, 0x8e, 0x79, 0xbe, 0xe9, 0x9b, 0xcf, 0x7d, 0x62}}},
{{{0x92, 0x5b, 0xfc, 0x72, 0xfd, 0xba, 0xf1, 0xfd, 0xa6, 0x7c, 0x95, 0xe3, 0x61, 0x3f, 0xe9, 0x03, 0xd4, 0x2b, 0xd4, 0x20, 0xd9, 0xdb, 0x4d, 0x32, 0x3e, 0xf5, 0x11, 0x64, 0xe3, 0xb4, 0xbe, 0x32}} ,
{{0x86, 0x17, 0x90, 0xe7, 0xc9, 0x1f, 0x10, 0xa5, 0x6a, 0x2d, 0x39, 0xd0, 0x3b, 0xc4, 0xa6, 0xe9, 0x59, 0x13, 0xda, 0x1a, 0xe6, 0xa0, 0xb9, 0x3c, 0x50, 0xb8, 0x40, 0x7c, 0x15, 0x36, 0x5a, 0x42}}},
{{{0xb4, 0x0b, 0x32, 0xab, 0xdc, 0x04, 0x51, 0x55, 0x21, 0x1e, 0x0b, 0x75, 0x99, 0x89, 0x73, 0x35, 0x3a, 0x91, 0x2b, 0xfe, 0xe7, 0x49, 0xea, 0x76, 0xc1, 0xf9, 0x46, 0xb9, 0x53, 0x02, 0x23, 0x04}} ,
{{0xfc, 0x5a, 0x1e, 0x1d, 0x74, 0x58, 0x95, 0xa6, 0x8f, 0x7b, 0x97, 0x3e, 0x17, 0x3b, 0x79, 0x2d, 0xa6, 0x57, 0xef, 0x45, 0x02, 0x0b, 0x4d, 0x6e, 0x9e, 0x93, 0x8d, 0x2f, 0xd9, 0x9d, 0xdb, 0x04}}},
{{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
{{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
{{{0xc0, 0xd7, 0x56, 0x97, 0x58, 0x91, 0xde, 0x09, 0x4f, 0x9f, 0xbe, 0x63, 0xb0, 0x83, 0x86, 0x43, 0x5d, 0xbc, 0xe0, 0xf3, 0xc0, 0x75, 0xbf, 0x8b, 0x8e, 0xaa, 0xf7, 0x8b, 0x64, 0x6e, 0xb0, 0x63}} ,
{{0x16, 0xae, 0x8b, 0xe0, 0x9b, 0x24, 0x68, 0x5c, 0x44, 0xc2, 0xd0, 0x08, 0xb7, 0x7b, 0x62, 0xfd, 0x7f, 0xd8, 0xd4, 0xb7, 0x50, 0xfd, 0x2c, 0x1b, 0xbf, 0x41, 0x95, 0xd9, 0x8e, 0xd8, 0x17, 0x1b}}},
{{{0x86, 0x55, 0x37, 0x8e, 0xc3, 0x38, 0x48, 0x14, 0xb5, 0x97, 0xd2, 0xa7, 0x54, 0x45, 0xf1, 0x35, 0x44, 0x38, 0x9e, 0xf1, 0x1b, 0xb6, 0x34, 0x00, 0x3c, 0x96, 0xee, 0x29, 0x00, 0xea, 0x2c, 0x0b}} ,
{{0xea, 0xda, 0x99, 0x9e, 0x19, 0x83, 0x66, 0x6d, 0xe9, 0x76, 0x87, 0x50, 0xd1, 0xfd, 0x3c, 0x60, 0x87, 0xc6, 0x41, 0xd9, 0x8e, 0xdb, 0x5e, 0xde, 0xaa, 0x9a, 0xd3, 0x28, 0xda, 0x95, 0xea, 0x47}}},
{{{0xd0, 0x80, 0xba, 0x19, 0xae, 0x1d, 0xa9, 0x79, 0xf6, 0x3f, 0xac, 0x5d, 0x6f, 0x96, 0x1f, 0x2a, 0xce, 0x29, 0xb2, 0xff, 0x37, 0xf1, 0x94, 0x8f, 0x0c, 0xb5, 0x28, 0xba, 0x9a, 0x21, 0xf6, 0x66}} ,
{{0x02, 0xfb, 0x54, 0xb8, 0x05, 0xf3, 0x81, 0x52, 0x69, 0x34, 0x46, 0x9d, 0x86, 0x76, 0x8f, 0xd7, 0xf8, 0x6a, 0x66, 0xff, 0xe6, 0xa7, 0x90, 0xf7, 0x5e, 0xcd, 0x6a, 0x9b, 0x55, 0xfc, 0x9d, 0x48}}},
{{{0xbd, 0xaa, 0x13, 0xe6, 0xcd, 0x45, 0x4a, 0xa4, 0x59, 0x0a, 0x64, 0xb1, 0x98, 0xd6, 0x34, 0x13, 0x04, 0xe6, 0x97, 0x94, 0x06, 0xcb, 0xd4, 0x4e, 0xbb, 0x96, 0xcd, 0xd1, 0x57, 0xd1, 0xe3, 0x06}} ,
{{0x7a, 0x6c, 0x45, 0x27, 0xc4, 0x93, 0x7f, 0x7d, 0x7c, 0x62, 0x50, 0x38, 0x3a, 0x6b, 0xb5, 0x88, 0xc6, 0xd9, 0xf1, 0x78, 0x19, 0xb9, 0x39, 0x93, 0x3d, 0xc9, 0xe0, 0x9c, 0x3c, 0xce, 0xf5, 0x72}}},
{{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
{{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
{{{0x24, 0xea, 0x23, 0x7d, 0x56, 0x2c, 0xe2, 0x59, 0x0e, 0x85, 0x60, 0x04, 0x88, 0x5a, 0x74, 0x1e, 0x4b, 0xef, 0x13, 0xda, 0x4c, 0xff, 0x83, 0x45, 0x85, 0x3f, 0x08, 0x95, 0x2c, 0x20, 0x13, 0x1f}} ,
{{0x48, 0x5f, 0x27, 0x90, 0x5c, 0x02, 0x42, 0xad, 0x78, 0x47, 0x5c, 0xb5, 0x7e, 0x08, 0x85, 0x00, 0xfa, 0x7f, 0xfd, 0xfd, 0xe7, 0x09, 0x11, 0xf2, 0x7e, 0x1b, 0x38, 0x6c, 0x35, 0x6d, 0x33, 0x66}}},
{{{0x93, 0x03, 0x36, 0x81, 0xac, 0xe4, 0x20, 0x09, 0x35, 0x4c, 0x45, 0xb2, 0x1e, 0x4c, 0x14, 0x21, 0xe6, 0xe9, 0x8a, 0x7b, 0x8d, 0xfe, 0x1e, 0xc6, 0x3e, 0xc1, 0x35, 0xfa, 0xe7, 0x70, 0x4e, 0x1d}} ,
{{0x61, 0x2e, 0xc2, 0xdd, 0x95, 0x57, 0xd1, 0xab, 0x80, 0xe8, 0x63, 0x17, 0xb5, 0x48, 0xe4, 0x8a, 0x11, 0x9e, 0x72, 0xbe, 0x85, 0x8d, 0x51, 0x0a, 0xf2, 0x9f, 0xe0, 0x1c, 0xa9, 0x07, 0x28, 0x7b}}},
{{{0xbb, 0x71, 0x14, 0x5e, 0x26, 0x8c, 0x3d, 0xc8, 0xe9, 0x7c, 0xd3, 0xd6, 0xd1, 0x2f, 0x07, 0x6d, 0xe6, 0xdf, 0xfb, 0x79, 0xd6, 0x99, 0x59, 0x96, 0x48, 0x40, 0x0f, 0x3a, 0x7b, 0xb2, 0xa0, 0x72}} ,
{{0x4e, 0x3b, 0x69, 0xc8, 0x43, 0x75, 0x51, 0x6c, 0x79, 0x56, 0xe4, 0xcb, 0xf7, 0xa6, 0x51, 0xc2, 0x2c, 0x42, 0x0b, 0xd4, 0x82, 0x20, 0x1c, 0x01, 0x08, 0x66, 0xd7, 0xbf, 0x04, 0x56, 0xfc, 0x02}}},
{{{0x24, 0xe8, 0xb7, 0x60, 0xae, 0x47, 0x80, 0xfc, 0xe5, 0x23, 0xe7, 0xc2, 0xc9, 0x85, 0xe6, 0x98, 0xa0, 0x29, 0x4e, 0xe1, 0x84, 0x39, 0x2d, 0x95, 0x2c, 0xf3, 0x45, 0x3c, 0xff, 0xaf, 0x27, 0x4c}} ,
{{0x6b, 0xa6, 0xf5, 0x4b, 0x11, 0xbd, 0xba, 0x5b, 0x9e, 0xc4, 0xa4, 0x51, 0x1e, 0xbe, 0xd0, 0x90, 0x3a, 0x9c, 0xc2, 0x26, 0xb6, 0x1e, 0xf1, 0x95, 0x7d, 0xc8, 0x6d, 0x52, 0xe6, 0x99, 0x2c, 0x5f}}},
{{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
{{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
{{{0x85, 0xe0, 0x24, 0x32, 0xb4, 0xd1, 0xef, 0xfc, 0x69, 0xa2, 0xbf, 0x8f, 0x72, 0x2c, 0x95, 0xf6, 0xe4, 0x6e, 0x7d, 0x90, 0xf7, 0x57, 0x81, 0xa0, 0xf7, 0xda, 0xef, 0x33, 0x07, 0xe3, 0x6b, 0x78}} ,
{{0x36, 0x27, 0x3e, 0xc6, 0x12, 0x07, 0xab, 0x4e, 0xbe, 0x69, 0x9d, 0xb3, 0xbe, 0x08, 0x7c, 0x2a, 0x47, 0x08, 0xfd, 0xd4, 0xcd, 0x0e, 0x27, 0x34, 0x5b, 0x98, 0x34, 0x2f, 0x77, 0x5f, 0x3a, 0x65}}},
{{{0x13, 0xaa, 0x2e, 0x4c, 0xf0, 0x22, 0xb8, 0x6c, 0xb3, 0x19, 0x4d, 0xeb, 0x6b, 0xd0, 0xa4, 0xc6, 0x9c, 0xdd, 0xc8, 0x5b, 0x81, 0x57, 0x89, 0xdf, 0x33, 0xa9, 0x68, 0x49, 0x80, 0xe4, 0xfe, 0x21}} ,
{{0x00, 0x17, 0x90, 0x30, 0xe9, 0xd3, 0x60, 0x30, 0x31, 0xc2, 0x72, 0x89, 0x7a, 0x36, 0xa5, 0xbd, 0x39, 0x83, 0x85, 0x50, 0xa1, 0x5d, 0x6c, 0x41, 0x1d, 0xb5, 0x2c, 0x07, 0x40, 0x77, 0x0b, 0x50}}},
{{{0x64, 0x34, 0xec, 0xc0, 0x9e, 0x44, 0x41, 0xaf, 0xa0, 0x36, 0x05, 0x6d, 0xea, 0x30, 0x25, 0x46, 0x35, 0x24, 0x9d, 0x86, 0xbd, 0x95, 0xf1, 0x6a, 0x46, 0xd7, 0x94, 0x54, 0xf9, 0x3b, 0xbd, 0x5d}} ,
{{0x77, 0x5b, 0xe2, 0x37, 0xc7, 0xe1, 0x7c, 0x13, 0x8c, 0x9f, 0x7b, 0x7b, 0x2a, 0xce, 0x42, 0xa3, 0xb9, 0x2a, 0x99, 0xa8, 0xc0, 0xd8, 0x3c, 0x86, 0xb0, 0xfb, 0xe9, 0x76, 0x77, 0xf7, 0xf5, 0x56}}},
{{{0xdf, 0xb3, 0x46, 0x11, 0x6e, 0x13, 0xb7, 0x28, 0x4e, 0x56, 0xdd, 0xf1, 0xac, 0xad, 0x58, 0xc3, 0xf8, 0x88, 0x94, 0x5e, 0x06, 0x98, 0xa1, 0xe4, 0x6a, 0xfb, 0x0a, 0x49, 0x5d, 0x8a, 0xfe, 0x77}} ,
{{0x46, 0x02, 0xf5, 0xa5, 0xaf, 0xc5, 0x75, 0x6d, 0xba, 0x45, 0x35, 0x0a, 0xfe, 0xc9, 0xac, 0x22, 0x91, 0x8d, 0x21, 0x95, 0x33, 0x03, 0xc0, 0x8a, 0x16, 0xf3, 0x39, 0xe0, 0x01, 0x0f, 0x53, 0x3c}}},
{{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
{{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
{{{0x34, 0x75, 0x37, 0x1f, 0x34, 0x4e, 0xa9, 0x1d, 0x68, 0x67, 0xf8, 0x49, 0x98, 0x96, 0xfc, 0x4c, 0x65, 0x97, 0xf7, 0x02, 0x4a, 0x52, 0x6c, 0x01, 0xbd, 0x48, 0xbb, 0x1b, 0xed, 0xa4, 0xe2, 0x53}} ,
{{0x59, 0xd5, 0x9b, 0x5a, 0xa2, 0x90, 0xd3, 0xb8, 0x37, 0x4c, 0x55, 0x82, 0x28, 0x08, 0x0f, 0x7f, 0xaa, 0x81, 0x65, 0xe0, 0x0c, 0x52, 0xc9, 0xa3, 0x32, 0x27, 0x64, 0xda, 0xfd, 0x34, 0x23, 0x5a}}},
{{{0xb5, 0xb0, 0x0c, 0x4d, 0xb3, 0x7b, 0x23, 0xc8, 0x1f, 0x8a, 0x39, 0x66, 0xe6, 0xba, 0x4c, 0x10, 0x37, 0xca, 0x9c, 0x7c, 0x05, 0x9e, 0xff, 0xc0, 0xf8, 0x8e, 0xb1, 0x8f, 0x6f, 0x67, 0x18, 0x26}} ,
{{0x4b, 0x41, 0x13, 0x54, 0x23, 0x1a, 0xa4, 0x4e, 0xa9, 0x8b, 0x1e, 0x4b, 0xfc, 0x15, 0x24, 0xbb, 0x7e, 0xcb, 0xb6, 0x1e, 0x1b, 0xf5, 0xf2, 0xc8, 0x56, 0xec, 0x32, 0xa2, 0x60, 0x5b, 0xa0, 0x2a}}},
{{{0xa4, 0x29, 0x47, 0x86, 0x2e, 0x92, 0x4f, 0x11, 0x4f, 0xf3, 0xb2, 0x5c, 0xd5, 0x3e, 0xa6, 0xb9, 0xc8, 0xe2, 0x33, 0x11, 0x1f, 0x01, 0x8f, 0xb0, 0x9b, 0xc7, 0xa5, 0xff, 0x83, 0x0f, 0x1e, 0x28}} ,
{{0x1d, 0x29, 0x7a, 0xa1, 0xec, 0x8e, 0xb5, 0xad, 0xea, 0x02, 0x68, 0x60, 0x74, 0x29, 0x1c, 0xa5, 0xcf, 0xc8, 0x3b, 0x7d, 0x8b, 0x2b, 0x7c, 0xad, 0xa4, 0x40, 0x17, 0x51, 0x59, 0x7c, 0x2e, 0x5d}}},
{{{0x0a, 0x6c, 0x4f, 0xbc, 0x3e, 0x32, 0xe7, 0x4a, 0x1a, 0x13, 0xc1, 0x49, 0x38, 0xbf, 0xf7, 0xc2, 0xd3, 0x8f, 0x6b, 0xad, 0x52, 0xf7, 0xcf, 0xbc, 0x27, 0xcb, 0x40, 0x67, 0x76, 0xcd, 0x6d, 0x56}} ,
{{0xe5, 0xb0, 0x27, 0xad, 0xbe, 0x9b, 0xf2, 0xb5, 0x63, 0xde, 0x3a, 0x23, 0x95, 0xb7, 0x0a, 0x7e, 0xf3, 0x9e, 0x45, 0x6f, 0x19, 0x39, 0x75, 0x8f, 0x39, 0x3d, 0x0f, 0xc0, 0x9f, 0xf1, 0xe9, 0x51}}},
{{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
{{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
{{{0x88, 0xaa, 0x14, 0x24, 0x86, 0x94, 0x11, 0x12, 0x3e, 0x1a, 0xb5, 0xcc, 0xbb, 0xe0, 0x9c, 0xd5, 0x9c, 0x6d, 0xba, 0x58, 0x72, 0x8d, 0xfb, 0x22, 0x7b, 0x9f, 0x7c, 0x94, 0x30, 0xb3, 0x51, 0x21}} ,
{{0xf6, 0x74, 0x3d, 0xf2, 0xaf, 0xd0, 0x1e, 0x03, 0x7c, 0x23, 0x6b, 0xc9, 0xfc, 0x25, 0x70, 0x90, 0xdc, 0x9a, 0xa4, 0xfb, 0x49, 0xfc, 0x3d, 0x0a, 0x35, 0x38, 0x6f, 0xe4, 0x7e, 0x50, 0x01, 0x2a}}},
{{{0xd6, 0xe3, 0x96, 0x61, 0x3a, 0xfd, 0xef, 0x9b, 0x1f, 0x90, 0xa4, 0x24, 0x14, 0x5b, 0xc8, 0xde, 0x50, 0xb1, 0x1d, 0xaf, 0xe8, 0x55, 0x8a, 0x87, 0x0d, 0xfe, 0xaa, 0x3b, 0x82, 0x2c, 0x8d, 0x7b}} ,
{{0x85, 0x0c, 0xaf, 0xf8, 0x83, 0x44, 0x49, 0xd9, 0x45, 0xcf, 0xf7, 0x48, 0xd9, 0x53, 0xb4, 0xf1, 0x65, 0xa0, 0xe1, 0xc3, 0xb3, 0x15, 0xed, 0x89, 0x9b, 0x4f, 0x62, 0xb3, 0x57, 0xa5, 0x45, 0x1c}}},
{{{0x8f, 0x12, 0xea, 0xaf, 0xd1, 0x1f, 0x79, 0x10, 0x0b, 0xf6, 0xa3, 0x7b, 0xea, 0xac, 0x8b, 0x57, 0x32, 0x62, 0xe7, 0x06, 0x12, 0x51, 0xa0, 0x3b, 0x43, 0x5e, 0xa4, 0x20, 0x78, 0x31, 0xce, 0x0d}} ,
{{0x84, 0x7c, 0xc2, 0xa6, 0x91, 0x23, 0xce, 0xbd, 0xdc, 0xf9, 0xce, 0xd5, 0x75, 0x30, 0x22, 0xe6, 0xf9, 0x43, 0x62, 0x0d, 0xf7, 0x75, 0x9d, 0x7f, 0x8c, 0xff, 0x7d, 0xe4, 0x72, 0xac, 0x9f, 0x1c}}},
{{{0x88, 0xc1, 0x99, 0xd0, 0x3c, 0x1c, 0x5d, 0xb4, 0xef, 0x13, 0x0f, 0x90, 0xb9, 0x36, 0x2f, 0x95, 0x95, 0xc6, 0xdc, 0xde, 0x0a, 0x51, 0xe2, 0x8d, 0xf3, 0xbc, 0x51, 0xec, 0xdf, 0xb1, 0xa2, 0x5f}} ,
{{0x2e, 0x68, 0xa1, 0x23, 0x7d, 0x9b, 0x40, 0x69, 0x85, 0x7b, 0x42, 0xbf, 0x90, 0x4b, 0xd6, 0x40, 0x2f, 0xd7, 0x52, 0x52, 0xb2, 0x21, 0xde, 0x64, 0xbd, 0x88, 0xc3, 0x6d, 0xa5, 0xfa, 0x81, 0x3f}}},
{{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
{{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
{{{0xfb, 0xfd, 0x47, 0x7b, 0x8a, 0x66, 0x9e, 0x79, 0x2e, 0x64, 0x82, 0xef, 0xf7, 0x21, 0xec, 0xf6, 0xd8, 0x86, 0x09, 0x31, 0x7c, 0xdd, 0x03, 0x6a, 0x58, 0xa0, 0x77, 0xb7, 0x9b, 0x8c, 0x87, 0x1f}} ,
{{0x55, 0x47, 0xe4, 0xa8, 0x3d, 0x55, 0x21, 0x34, 0xab, 0x1d, 0xae, 0xe0, 0xf4, 0xea, 0xdb, 0xc5, 0xb9, 0x58, 0xbf, 0xc4, 0x2a, 0x89, 0x31, 0x1a, 0xf4, 0x2d, 0xe1, 0xca, 0x37, 0x99, 0x47, 0x59}}},
{{{0xc7, 0xca, 0x63, 0xc1, 0x49, 0xa9, 0x35, 0x45, 0x55, 0x7e, 0xda, 0x64, 0x32, 0x07, 0x50, 0xf7, 0x32, 0xac, 0xde, 0x75, 0x58, 0x9b, 0x11, 0xb2, 0x3a, 0x1f, 0xf5, 0xf7, 0x79, 0x04, 0xe6, 0x08}} ,
{{0x46, 0xfa, 0x22, 0x4b, 0xfa, 0xe1, 0xfe, 0x96, 0xfc, 0x67, 0xba, 0x67, 0x97, 0xc4, 0xe7, 0x1b, 0x86, 0x90, 0x5f, 0xee, 0xf4, 0x5b, 0x11, 0xb2, 0xcd, 0xad, 0xee, 0xc2, 0x48, 0x6c, 0x2b, 0x1b}}},
{{{0xe3, 0x39, 0x62, 0xb4, 0x4f, 0x31, 0x04, 0xc9, 0xda, 0xd5, 0x73, 0x51, 0x57, 0xc5, 0xb8, 0xf3, 0xa3, 0x43, 0x70, 0xe4, 0x61, 0x81, 0x84, 0xe2, 0xbb, 0xbf, 0x4f, 0x9e, 0xa4, 0x5e, 0x74, 0x06}} ,
{{0x29, 0xac, 0xff, 0x27, 0xe0, 0x59, 0xbe, 0x39, 0x9c, 0x0d, 0x83, 0xd7, 0x10, 0x0b, 0x15, 0xb7, 0xe1, 0xc2, 0x2c, 0x30, 0x73, 0x80, 0x3a, 0x7d, 0x5d, 0xab, 0x58, 0x6b, 0xc1, 0xf0, 0xf4, 0x22}}},
{{{0xfe, 0x7f, 0xfb, 0x35, 0x7d, 0xc6, 0x01, 0x23, 0x28, 0xc4, 0x02, 0xac, 0x1f, 0x42, 0xb4, 0x9d, 0xfc, 0x00, 0x94, 0xa5, 0xee, 0xca, 0xda, 0x97, 0x09, 0x41, 0x77, 0x87, 0x5d, 0x7b, 0x87, 0x78}} ,
{{0xf5, 0xfb, 0x90, 0x2d, 0x81, 0x19, 0x9e, 0x2f, 0x6d, 0x85, 0x88, 0x8c, 0x40, 0x5c, 0x77, 0x41, 0x4d, 0x01, 0x19, 0x76, 0x60, 0xe8, 0x4c, 0x48, 0xe4, 0x33, 0x83, 0x32, 0x6c, 0xb4, 0x41, 0x03}}},
{{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
{{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
{{{0xff, 0x10, 0xc2, 0x09, 0x4f, 0x6e, 0xf4, 0xd2, 0xdf, 0x7e, 0xca, 0x7b, 0x1c, 0x1d, 0xba, 0xa3, 0xb6, 0xda, 0x67, 0x33, 0xd4, 0x87, 0x36, 0x4b, 0x11, 0x20, 0x05, 0xa6, 0x29, 0xc1, 0x87, 0x17}} ,
{{0xf6, 0x96, 0xca, 0x2f, 0xda, 0x38, 0xa7, 0x1b, 0xfc, 0xca, 0x7d, 0xfe, 0x08, 0x89, 0xe2, 0x47, 0x2b, 0x6a, 0x5d, 0x4b, 0xfa, 0xa1, 0xb4, 0xde, 0xb6, 0xc2, 0x31, 0x51, 0xf5, 0xe0, 0xa4, 0x0b}}},
{{{0x5c, 0xe5, 0xc6, 0x04, 0x8e, 0x2b, 0x57, 0xbe, 0x38, 0x85, 0x23, 0xcb, 0xb7, 0xbe, 0x4f, 0xa9, 0xd3, 0x6e, 0x12, 0xaa, 0xd5, 0xb2, 0x2e, 0x93, 0x29, 0x9a, 0x4a, 0x88, 0x18, 0x43, 0xf5, 0x01}} ,
{{0x50, 0xfc, 0xdb, 0xa2, 0x59, 0x21, 0x8d, 0xbd, 0x7e, 0x33, 0xae, 0x2f, 0x87, 0x1a, 0xd0, 0x97, 0xc7, 0x0d, 0x4d, 0x63, 0x01, 0xef, 0x05, 0x84, 0xec, 0x40, 0xdd, 0xa8, 0x0a, 0x4f, 0x70, 0x0b}}},
{{{0x41, 0x69, 0x01, 0x67, 0x5c, 0xd3, 0x8a, 0xc5, 0xcf, 0x3f, 0xd1, 0x57, 0xd1, 0x67, 0x3e, 0x01, 0x39, 0xb5, 0xcb, 0x81, 0x56, 0x96, 0x26, 0xb6, 0xc2, 0xe7, 0x5c, 0xfb, 0x63, 0x97, 0x58, 0x06}} ,
{{0x0c, 0x0e, 0xf3, 0xba, 0xf0, 0xe5, 0xba, 0xb2, 0x57, 0x77, 0xc6, 0x20, 0x9b, 0x89, 0x24, 0xbe, 0xf2, 0x9c, 0x8a, 0xba, 0x69, 0xc1, 0xf1, 0xb0, 0x4f, 0x2a, 0x05, 0x9a, 0xee, 0x10, 0x7e, 0x36}}},
{{{0x3f, 0x26, 0xe9, 0x40, 0xe9, 0x03, 0xad, 0x06, 0x69, 0x91, 0xe0, 0xd1, 0x89, 0x60, 0x84, 0x79, 0xde, 0x27, 0x6d, 0xe6, 0x76, 0xbd, 0xea, 0xe6, 0xae, 0x48, 0xc3, 0x67, 0xc0, 0x57, 0xcd, 0x2f}} ,
{{0x7f, 0xc1, 0xdc, 0xb9, 0xc7, 0xbc, 0x86, 0x3d, 0x55, 0x4b, 0x28, 0x7a, 0xfb, 0x4d, 0xc7, 0xf8, 0xbc, 0x67, 0x2a, 0x60, 0x4d, 0x8f, 0x07, 0x0b, 0x1a, 0x17, 0xbf, 0xfa, 0xac, 0xa7, 0x3d, 0x1a}}},
{{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
{{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
{{{0x91, 0x3f, 0xed, 0x5e, 0x18, 0x78, 0x3f, 0x23, 0x2c, 0x0d, 0x8c, 0x44, 0x00, 0xe8, 0xfb, 0xe9, 0x8e, 0xd6, 0xd1, 0x36, 0x58, 0x57, 0x9e, 0xae, 0x4b, 0x5c, 0x0b, 0x07, 0xbc, 0x6b, 0x55, 0x2b}} ,
{{0x6f, 0x4d, 0x17, 0xd7, 0xe1, 0x84, 0xd9, 0x78, 0xb1, 0x90, 0xfd, 0x2e, 0xb3, 0xb5, 0x19, 0x3f, 0x1b, 0xfa, 0xc0, 0x68, 0xb3, 0xdd, 0x00, 0x2e, 0x89, 0xbd, 0x7e, 0x80, 0x32, 0x13, 0xa0, 0x7b}}},
{{{0x1a, 0x6f, 0x40, 0xaf, 0x44, 0x44, 0xb0, 0x43, 0x8f, 0x0d, 0xd0, 0x1e, 0xc4, 0x0b, 0x19, 0x5d, 0x8e, 0xfe, 0xc1, 0xf3, 0xc5, 0x5c, 0x91, 0xf8, 0x04, 0x4e, 0xbe, 0x90, 0xb4, 0x47, 0x5c, 0x3f}} ,
{{0xb0, 0x3b, 0x2c, 0xf3, 0xfe, 0x32, 0x71, 0x07, 0x3f, 0xaa, 0xba, 0x45, 0x60, 0xa8, 0x8d, 0xea, 0x54, 0xcb, 0x39, 0x10, 0xb4, 0xf2, 0x8b, 0xd2, 0x14, 0x82, 0x42, 0x07, 0x8e, 0xe9, 0x7c, 0x53}}},
{{{0xb0, 0xae, 0xc1, 0x8d, 0xc9, 0x8f, 0xb9, 0x7a, 0x77, 0xef, 0xba, 0x79, 0xa0, 0x3c, 0xa8, 0xf5, 0x6a, 0xe2, 0x3f, 0x5d, 0x00, 0xe3, 0x4b, 0x45, 0x24, 0x7b, 0x43, 0x78, 0x55, 0x1d, 0x2b, 0x1e}} ,
{{0x01, 0xb8, 0xd6, 0x16, 0x67, 0xa0, 0x15, 0xb9, 0xe1, 0x58, 0xa4, 0xa7, 0x31, 0x37, 0x77, 0x2f, 0x8b, 0x12, 0x9f, 0xf4, 0x3f, 0xc7, 0x36, 0x66, 0xd2, 0xa8, 0x56, 0xf7, 0x7f, 0x74, 0xc6, 0x41}}},
{{{0x5d, 0xf8, 0xb4, 0xa8, 0x30, 0xdd, 0xcc, 0x38, 0xa5, 0xd3, 0xca, 0xd8, 0xd1, 0xf8, 0xb2, 0x31, 0x91, 0xd4, 0x72, 0x05, 0x57, 0x4a, 0x3b, 0x82, 0x4a, 0xc6, 0x68, 0x20, 0xe2, 0x18, 0x41, 0x61}} ,
{{0x19, 0xd4, 0x8d, 0x47, 0x29, 0x12, 0x65, 0xb0, 0x11, 0x78, 0x47, 0xb5, 0xcb, 0xa3, 0xa5, 0xfa, 0x05, 0x85, 0x54, 0xa9, 0x33, 0x97, 0x8d, 0x2b, 0xc2, 0xfe, 0x99, 0x35, 0x28, 0xe5, 0xeb, 0x63}}},
{{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
{{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
{{{0xb1, 0x3f, 0x3f, 0xef, 0xd8, 0xf4, 0xfc, 0xb3, 0xa0, 0x60, 0x50, 0x06, 0x2b, 0x29, 0x52, 0x70, 0x15, 0x0b, 0x24, 0x24, 0xf8, 0x5f, 0x79, 0x18, 0xcc, 0xff, 0x89, 0x99, 0x84, 0xa1, 0xae, 0x13}} ,
{{0x44, 0x1f, 0xb8, 0xc2, 0x01, 0xc1, 0x30, 0x19, 0x55, 0x05, 0x60, 0x10, 0xa4, 0x6c, 0x2d, 0x67, 0x70, 0xe5, 0x25, 0x1b, 0xf2, 0xbf, 0xdd, 0xfb, 0x70, 0x2b, 0xa1, 0x8c, 0x9c, 0x94, 0x84, 0x08}}},
{{{0xe7, 0xc4, 0x43, 0x4d, 0xc9, 0x2b, 0x69, 0x5d, 0x1d, 0x3c, 0xaf, 0xbb, 0x43, 0x38, 0x4e, 0x98, 0x3d, 0xed, 0x0d, 0x21, 0x03, 0xfd, 0xf0, 0x99, 0x47, 0x04, 0xb0, 0x98, 0x69, 0x55, 0x72, 0x0f}} ,
{{0x5e, 0xdf, 0x15, 0x53, 0x3b, 0x86, 0x80, 0xb0, 0xf1, 0x70, 0x68, 0x8f, 0x66, 0x7c, 0x0e, 0x49, 0x1a, 0xd8, 0x6b, 0xfe, 0x4e, 0xef, 0xca, 0x47, 0xd4, 0x03, 0xc1, 0x37, 0x50, 0x9c, 0xc1, 0x16}}},
{{{0xcd, 0x24, 0xc6, 0x3e, 0x0c, 0x82, 0x9b, 0x91, 0x2b, 0x61, 0x4a, 0xb2, 0x0f, 0x88, 0x55, 0x5f, 0x5a, 0x57, 0xff, 0xe5, 0x74, 0x0b, 0x13, 0x43, 0x00, 0xd8, 0x6b, 0xcf, 0xd2, 0x15, 0x03, 0x2c}} ,
{{0xdc, 0xff, 0x15, 0x61, 0x2f, 0x4a, 0x2f, 0x62, 0xf2, 0x04, 0x2f, 0xb5, 0x0c, 0xb7, 0x1e, 0x3f, 0x74, 0x1a, 0x0f, 0xd7, 0xea, 0xcd, 0xd9, 0x7d, 0xf6, 0x12, 0x0e, 0x2f, 0xdb, 0x5a, 0x3b, 0x16}}},
{{{0x1b, 0x37, 0x47, 0xe3, 0xf5, 0x9e, 0xea, 0x2c, 0x2a, 0xe7, 0x82, 0x36, 0xf4, 0x1f, 0x81, 0x47, 0x92, 0x4b, 0x69, 0x0e, 0x11, 0x8c, 0x5d, 0x53, 0x5b, 0x81, 0x27, 0x08, 0xbc, 0xa0, 0xae, 0x25}} ,
{{0x69, 0x32, 0xa1, 0x05, 0x11, 0x42, 0x00, 0xd2, 0x59, 0xac, 0x4d, 0x62, 0x8b, 0x13, 0xe2, 0x50, 0x5d, 0xa0, 0x9d, 0x9b, 0xfd, 0xbb, 0x12, 0x41, 0x75, 0x41, 0x9e, 0xcc, 0xdc, 0xc7, 0xdc, 0x5d}}},
{{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
{{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
{{{0xd9, 0xe3, 0x38, 0x06, 0x46, 0x70, 0x82, 0x5e, 0x28, 0x49, 0x79, 0xff, 0x25, 0xd2, 0x4e, 0x29, 0x8d, 0x06, 0xb0, 0x23, 0xae, 0x9b, 0x66, 0xe4, 0x7d, 0xc0, 0x70, 0x91, 0xa3, 0xfc, 0xec, 0x4e}} ,
{{0x62, 0x12, 0x37, 0x6a, 0x30, 0xf6, 0x1e, 0xfb, 0x14, 0x5c, 0x0d, 0x0e, 0xb7, 0x81, 0x6a, 0xe7, 0x08, 0x05, 0xac, 0xaa, 0x38, 0x46, 0xe2, 0x73, 0xea, 0x4b, 0x07, 0x81, 0x43, 0x7c, 0x9e, 0x5e}}},
{{{0xfc, 0xf9, 0x21, 0x4f, 0x2e, 0x76, 0x9b, 0x1f, 0x28, 0x60, 0x77, 0x43, 0x32, 0x9d, 0xbe, 0x17, 0x30, 0x2a, 0xc6, 0x18, 0x92, 0x66, 0x62, 0x30, 0x98, 0x40, 0x11, 0xa6, 0x7f, 0x18, 0x84, 0x28}} ,
{{0x3f, 0xab, 0xd3, 0xf4, 0x8a, 0x76, 0xa1, 0x3c, 0xca, 0x2d, 0x49, 0xc3, 0xea, 0x08, 0x0b, 0x85, 0x17, 0x2a, 0xc3, 0x6c, 0x08, 0xfd, 0x57, 0x9f, 0x3d, 0x5f, 0xdf, 0x67, 0x68, 0x42, 0x00, 0x32}}},
{{{0x51, 0x60, 0x1b, 0x06, 0x4f, 0x8a, 0x21, 0xba, 0x38, 0xa8, 0xba, 0xd6, 0x40, 0xf6, 0xe9, 0x9b, 0x76, 0x4d, 0x56, 0x21, 0x5b, 0x0a, 0x9b, 0x2e, 0x4f, 0x3d, 0x81, 0x32, 0x08, 0x9f, 0x97, 0x5b}} ,
{{0xe5, 0x44, 0xec, 0x06, 0x9d, 0x90, 0x79, 0x9f, 0xd3, 0xe0, 0x79, 0xaf, 0x8f, 0x10, 0xfd, 0xdd, 0x04, 0xae, 0x27, 0x97, 0x46, 0x33, 0x79, 0xea, 0xb8, 0x4e, 0xca, 0x5a, 0x59, 0x57, 0xe1, 0x0e}}},
{{{0x1a, 0xda, 0xf3, 0xa5, 0x41, 0x43, 0x28, 0xfc, 0x7e, 0xe7, 0x71, 0xea, 0xc6, 0x3b, 0x59, 0xcc, 0x2e, 0xd3, 0x40, 0xec, 0xb3, 0x13, 0x6f, 0x44, 0xcd, 0x13, 0xb2, 0x37, 0xf2, 0x6e, 0xd9, 0x1c}} ,
{{0xe3, 0xdb, 0x60, 0xcd, 0x5c, 0x4a, 0x18, 0x0f, 0xef, 0x73, 0x36, 0x71, 0x8c, 0xf6, 0x11, 0xb4, 0xd8, 0xce, 0x17, 0x5e, 0x4f, 0x26, 0x77, 0x97, 0x5f, 0xcb, 0xef, 0x91, 0xeb, 0x6a, 0x62, 0x7a}}},
{{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
{{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
{{{0x18, 0x4a, 0xa2, 0x97, 0x08, 0x81, 0x2d, 0x83, 0xc4, 0xcc, 0xf0, 0x83, 0x7e, 0xec, 0x0d, 0x95, 0x4c, 0x5b, 0xfb, 0xfa, 0x98, 0x80, 0x4a, 0x66, 0x56, 0x0c, 0x51, 0xb3, 0xf2, 0x04, 0x5d, 0x27}} ,
{{0x3b, 0xb9, 0xb8, 0x06, 0x5a, 0x2e, 0xfe, 0xc3, 0x82, 0x37, 0x9c, 0xa3, 0x11, 0x1f, 0x9c, 0xa6, 0xda, 0x63, 0x48, 0x9b, 0xad, 0xde, 0x2d, 0xa6, 0xbc, 0x6e, 0x32, 0xda, 0x27, 0x65, 0xdd, 0x57}}},
{{{0x84, 0x4f, 0x37, 0x31, 0x7d, 0x2e, 0xbc, 0xad, 0x87, 0x07, 0x2a, 0x6b, 0x37, 0xfc, 0x5f, 0xeb, 0x4e, 0x75, 0x35, 0xa6, 0xde, 0xab, 0x0a, 0x19, 0x3a, 0xb7, 0xb1, 0xef, 0x92, 0x6a, 0x3b, 0x3c}} ,
{{0x3b, 0xb2, 0x94, 0x6d, 0x39, 0x60, 0xac, 0xee, 0xe7, 0x81, 0x1a, 0x3b, 0x76, 0x87, 0x5c, 0x05, 0x94, 0x2a, 0x45, 0xb9, 0x80, 0xe9, 0x22, 0xb1, 0x07, 0xcb, 0x40, 0x9e, 0x70, 0x49, 0x6d, 0x12}}},
{{{0xfd, 0x18, 0x78, 0x84, 0xa8, 0x4c, 0x7d, 0x6e, 0x59, 0xa6, 0xe5, 0x74, 0xf1, 0x19, 0xa6, 0x84, 0x2e, 0x51, 0xc1, 0x29, 0x13, 0xf2, 0x14, 0x6b, 0x5d, 0x53, 0x51, 0xf7, 0xef, 0xbf, 0x01, 0x22}} ,
{{0xa4, 0x4b, 0x62, 0x4c, 0xe6, 0xfd, 0x72, 0x07, 0xf2, 0x81, 0xfc, 0xf2, 0xbd, 0x12, 0x7c, 0x68, 0x76, 0x2a, 0xba, 0xf5, 0x65, 0xb1, 0x1f, 0x17, 0x0a, 0x38, 0xb0, 0xbf, 0xc0, 0xf8, 0xf4, 0x2a}}},
{{{0x55, 0x60, 0x55, 0x5b, 0xe4, 0x1d, 0x71, 0x4c, 0x9d, 0x5b, 0x9f, 0x70, 0xa6, 0x85, 0x9a, 0x2c, 0xa0, 0xe2, 0x32, 0x48, 0xce, 0x9e, 0x2a, 0xa5, 0x07, 0x3b, 0xc7, 0x6c, 0x86, 0x77, 0xde, 0x3c}} ,
{{0xf7, 0x18, 0x7a, 0x96, 0x7e, 0x43, 0x57, 0xa9, 0x55, 0xfc, 0x4e, 0xb6, 0x72, 0x00, 0xf2, 0xe4, 0xd7, 0x52, 0xd3, 0xd3, 0xb6, 0x85, 0xf6, 0x71, 0xc7, 0x44, 0x3f, 0x7f, 0xd7, 0xb3, 0xf2, 0x79}}},
{{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
{{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
{{{0x46, 0xca, 0xa7, 0x55, 0x7b, 0x79, 0xf3, 0xca, 0x5a, 0x65, 0xf6, 0xed, 0x50, 0x14, 0x7b, 0xe4, 0xc4, 0x2a, 0x65, 0x9e, 0xe2, 0xf9, 0xca, 0xa7, 0x22, 0x26, 0x53, 0xcb, 0x21, 0x5b, 0xa7, 0x31}} ,
{{0x90, 0xd7, 0xc5, 0x26, 0x08, 0xbd, 0xb0, 0x53, 0x63, 0x58, 0xc3, 0x31, 0x5e, 0x75, 0x46, 0x15, 0x91, 0xa6, 0xf8, 0x2f, 0x1a, 0x08, 0x65, 0x88, 0x2f, 0x98, 0x04, 0xf1, 0x7c, 0x6e, 0x00, 0x77}}},
{{{0x81, 0x21, 0x61, 0x09, 0xf6, 0x4e, 0xf1, 0x92, 0xee, 0x63, 0x61, 0x73, 0x87, 0xc7, 0x54, 0x0e, 0x42, 0x4b, 0xc9, 0x47, 0xd1, 0xb8, 0x7e, 0x91, 0x75, 0x37, 0x99, 0x28, 0xb8, 0xdd, 0x7f, 0x50}} ,
{{0x89, 0x8f, 0xc0, 0xbe, 0x5d, 0xd6, 0x9f, 0xa0, 0xf0, 0x9d, 0x81, 0xce, 0x3a, 0x7b, 0x98, 0x58, 0xbb, 0xd7, 0x78, 0xc8, 0x3f, 0x13, 0xf1, 0x74, 0x19, 0xdf, 0xf8, 0x98, 0x89, 0x5d, 0xfa, 0x5f}}},
{{{0x9e, 0x35, 0x85, 0x94, 0x47, 0x1f, 0x90, 0x15, 0x26, 0xd0, 0x84, 0xed, 0x8a, 0x80, 0xf7, 0x63, 0x42, 0x86, 0x27, 0xd7, 0xf4, 0x75, 0x58, 0xdc, 0x9c, 0xc0, 0x22, 0x7e, 0x20, 0x35, 0xfd, 0x1f}} ,
{{0x68, 0x0e, 0x6f, 0x97, 0xba, 0x70, 0xbb, 0xa3, 0x0e, 0xe5, 0x0b, 0x12, 0xf4, 0xa2, 0xdc, 0x47, 0xf8, 0xe6, 0xd0, 0x23, 0x6c, 0x33, 0xa8, 0x99, 0x46, 0x6e, 0x0f, 0x44, 0xba, 0x76, 0x48, 0x0f}}},
{{{0xa3, 0x2a, 0x61, 0x37, 0xe2, 0x59, 0x12, 0x0e, 0x27, 0xba, 0x64, 0x43, 0xae, 0xc0, 0x42, 0x69, 0x79, 0xa4, 0x1e, 0x29, 0x8b, 0x15, 0xeb, 0xf8, 0xaf, 0xd4, 0xa2, 0x68, 0x33, 0xb5, 0x7a, 0x24}} ,
{{0x2c, 0x19, 0x33, 0xdd, 0x1b, 0xab, 0xec, 0x01, 0xb0, 0x23, 0xf8, 0x42, 0x2b, 0x06, 0x88, 0xea, 0x3d, 0x2d, 0x00, 0x2a, 0x78, 0x45, 0x4d, 0x38, 0xed, 0x2e, 0x2e, 0x44, 0x49, 0xed, 0xcb, 0x33}}},
{{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
{{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
{{{0xa0, 0x68, 0xe8, 0x41, 0x8f, 0x91, 0xf8, 0x11, 0x13, 0x90, 0x2e, 0xa7, 0xab, 0x30, 0xef, 0xad, 0xa0, 0x61, 0x00, 0x88, 0xef, 0xdb, 0xce, 0x5b, 0x5c, 0xbb, 0x62, 0xc8, 0x56, 0xf9, 0x00, 0x73}} ,
{{0x3f, 0x60, 0xc1, 0x82, 0x2d, 0xa3, 0x28, 0x58, 0x24, 0x9e, 0x9f, 0xe3, 0x70, 0xcc, 0x09, 0x4e, 0x1a, 0x3f, 0x11, 0x11, 0x15, 0x07, 0x3c, 0xa4, 0x41, 0xe0, 0x65, 0xa3, 0x0a, 0x41, 0x6d, 0x11}}},
{{{0x31, 0x40, 0x01, 0x52, 0x56, 0x94, 0x5b, 0x28, 0x8a, 0xaa, 0x52, 0xee, 0xd8, 0x0a, 0x05, 0x8d, 0xcd, 0xb5, 0xaa, 0x2e, 0x38, 0xaa, 0xb7, 0x87, 0xf7, 0x2b, 0xfb, 0x04, 0xcb, 0x84, 0x3d, 0x54}} ,
{{0x20, 0xef, 0x59, 0xde, 0xa4, 0x2b, 0x93, 0x6e, 0x2e, 0xec, 0x42, 0x9a, 0xd4, 0x2d, 0xf4, 0x46, 0x58, 0x27, 0x2b, 0x18, 0x8f, 0x83, 0x3d, 0x69, 0x9e, 0xd4, 0x3e, 0xb6, 0xc5, 0xfd, 0x58, 0x03}}},
{{{0x33, 0x89, 0xc9, 0x63, 0x62, 0x1c, 0x17, 0xb4, 0x60, 0xc4, 0x26, 0x68, 0x09, 0xc3, 0x2e, 0x37, 0x0f, 0x7b, 0xb4, 0x9c, 0xb6, 0xf9, 0xfb, 0xd4, 0x51, 0x78, 0xc8, 0x63, 0xea, 0x77, 0x47, 0x07}} ,
{{0x32, 0xb4, 0x18, 0x47, 0x79, 0xcb, 0xd4, 0x5a, 0x07, 0x14, 0x0f, 0xa0, 0xd5, 0xac, 0xd0, 0x41, 0x40, 0xab, 0x61, 0x23, 0xe5, 0x2a, 0x2a, 0x6f, 0xf7, 0xa8, 0xd4, 0x76, 0xef, 0xe7, 0x45, 0x6c}}},
{{{0xa1, 0x5e, 0x60, 0x4f, 0xfb, 0xe1, 0x70, 0x6a, 0x1f, 0x55, 0x4f, 0x09, 0xb4, 0x95, 0x33, 0x36, 0xc6, 0x81, 0x01, 0x18, 0x06, 0x25, 0x27, 0xa4, 0xb4, 0x24, 0xa4, 0x86, 0x03, 0x4c, 0xac, 0x02}} ,
{{0x77, 0x38, 0xde, 0xd7, 0x60, 0x48, 0x07, 0xf0, 0x74, 0xa8, 0xff, 0x54, 0xe5, 0x30, 0x43, 0xff, 0x77, 0xfb, 0x21, 0x07, 0xff, 0xb2, 0x07, 0x6b, 0xe4, 0xe5, 0x30, 0xfc, 0x19, 0x6c, 0xa3, 0x01}}},
{{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
{{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
{{{0x13, 0xc5, 0x2c, 0xac, 0xd3, 0x83, 0x82, 0x7c, 0x29, 0xf7, 0x05, 0xa5, 0x00, 0xb6, 0x1f, 0x86, 0x55, 0xf4, 0xd6, 0x2f, 0x0c, 0x99, 0xd0, 0x65, 0x9b, 0x6b, 0x46, 0x0d, 0x43, 0xf8, 0x16, 0x28}} ,
{{0x1e, 0x7f, 0xb4, 0x74, 0x7e, 0xb1, 0x89, 0x4f, 0x18, 0x5a, 0xab, 0x64, 0x06, 0xdf, 0x45, 0x87, 0xe0, 0x6a, 0xc6, 0xf0, 0x0e, 0xc9, 0x24, 0x35, 0x38, 0xea, 0x30, 0x54, 0xb4, 0xc4, 0x52, 0x54}}},
{{{0xe9, 0x9f, 0xdc, 0x3f, 0xc1, 0x89, 0x44, 0x74, 0x27, 0xe4, 0xc1, 0x90, 0xff, 0x4a, 0xa7, 0x3c, 0xee, 0xcd, 0xf4, 0x1d, 0x25, 0x94, 0x7f, 0x63, 0x16, 0x48, 0xbc, 0x64, 0xfe, 0x95, 0xc4, 0x0c}} ,
{{0x8b, 0x19, 0x75, 0x6e, 0x03, 0x06, 0x5e, 0x6a, 0x6f, 0x1a, 0x8c, 0xe3, 0xd3, 0x28, 0xf2, 0xe0, 0xb9, 0x7a, 0x43, 0x69, 0xe6, 0xd3, 0xc0, 0xfe, 0x7e, 0x97, 0xab, 0x6c, 0x7b, 0x8e, 0x13, 0x42}}},
{{{0xd4, 0xca, 0x70, 0x3d, 0xab, 0xfb, 0x5f, 0x5e, 0x00, 0x0c, 0xcc, 0x77, 0x22, 0xf8, 0x78, 0x55, 0xae, 0x62, 0x35, 0xfb, 0x9a, 0xc6, 0x03, 0xe4, 0x0c, 0xee, 0xab, 0xc7, 0xc0, 0x89, 0x87, 0x54}} ,
{{0x32, 0xad, 0xae, 0x85, 0x58, 0x43, 0xb8, 0xb1, 0xe6, 0x3e, 0x00, 0x9c, 0x78, 0x88, 0x56, 0xdb, 0x9c, 0xfc, 0x79, 0xf6, 0xf9, 0x41, 0x5f, 0xb7, 0xbc, 0x11, 0xf9, 0x20, 0x36, 0x1c, 0x53, 0x2b}}},
{{{0x5a, 0x20, 0x5b, 0xa1, 0xa5, 0x44, 0x91, 0x24, 0x02, 0x63, 0x12, 0x64, 0xb8, 0x55, 0xf6, 0xde, 0x2c, 0xdb, 0x47, 0xb8, 0xc6, 0x0a, 0xc3, 0x00, 0x78, 0x93, 0xd8, 0xf5, 0xf5, 0x18, 0x28, 0x0a}} ,
{{0xd6, 0x1b, 0x9a, 0x6c, 0xe5, 0x46, 0xea, 0x70, 0x96, 0x8d, 0x4e, 0x2a, 0x52, 0x21, 0x26, 0x4b, 0xb1, 0xbb, 0x0f, 0x7c, 0xa9, 0x9b, 0x04, 0xbb, 0x51, 0x08, 0xf1, 0x9a, 0xa4, 0x76, 0x7c, 0x18}}},
{{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
{{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
{{{0xfa, 0x94, 0xf7, 0x40, 0xd0, 0xd7, 0xeb, 0xa9, 0x82, 0x36, 0xd5, 0x15, 0xb9, 0x33, 0x7a, 0xbf, 0x8a, 0xf2, 0x63, 0xaa, 0x37, 0xf5, 0x59, 0xac, 0xbd, 0xbb, 0x32, 0x36, 0xbe, 0x73, 0x99, 0x38}} ,
{{0x2c, 0xb3, 0xda, 0x7a, 0xd8, 0x3d, 0x99, 0xca, 0xd2, 0xf4, 0xda, 0x99, 0x8e, 0x4f, 0x98, 0xb7, 0xf4, 0xae, 0x3e, 0x9f, 0x8e, 0x35, 0x60, 0xa4, 0x33, 0x75, 0xa4, 0x04, 0x93, 0xb1, 0x6b, 0x4d}}},
{{{0x97, 0x9d, 0xa8, 0xcd, 0x97, 0x7b, 0x9d, 0xb9, 0xe7, 0xa5, 0xef, 0xfd, 0xa8, 0x42, 0x6b, 0xc3, 0x62, 0x64, 0x7d, 0xa5, 0x1b, 0xc9, 0x9e, 0xd2, 0x45, 0xb9, 0xee, 0x03, 0xb0, 0xbf, 0xc0, 0x68}} ,
{{0xed, 0xb7, 0x84, 0x2c, 0xf6, 0xd3, 0xa1, 0x6b, 0x24, 0x6d, 0x87, 0x56, 0x97, 0x59, 0x79, 0x62, 0x9f, 0xac, 0xed, 0xf3, 0xc9, 0x89, 0x21, 0x2e, 0x04, 0xb3, 0xcc, 0x2f, 0xbe, 0xd6, 0x0a, 0x4b}}},
{{{0x39, 0x61, 0x05, 0xed, 0x25, 0x89, 0x8b, 0x5d, 0x1b, 0xcb, 0x0c, 0x55, 0xf4, 0x6a, 0x00, 0x8a, 0x46, 0xe8, 0x1e, 0xc6, 0x83, 0xc8, 0x5a, 0x76, 0xdb, 0xcc, 0x19, 0x7a, 0xcc, 0x67, 0x46, 0x0b}} ,
{{0x53, 0xcf, 0xc2, 0xa1, 0xad, 0x6a, 0xf3, 0xcd, 0x8f, 0xc9, 0xde, 0x1c, 0xf8, 0x6c, 0x8f, 0xf8, 0x76, 0x42, 0xe7, 0xfe, 0xb2, 0x72, 0x21, 0x0a, 0x66, 0x74, 0x8f, 0xb7, 0xeb, 0xe4, 0x6f, 0x01}}},
{{{0x22, 0x8c, 0x6b, 0xbe, 0xfc, 0x4d, 0x70, 0x62, 0x6e, 0x52, 0x77, 0x99, 0x88, 0x7e, 0x7b, 0x57, 0x7a, 0x0d, 0xfe, 0xdc, 0x72, 0x92, 0xf1, 0x68, 0x1d, 0x97, 0xd7, 0x7c, 0x8d, 0x53, 0x10, 0x37}} ,
{{0x53, 0x88, 0x77, 0x02, 0xca, 0x27, 0xa8, 0xe5, 0x45, 0xe2, 0xa8, 0x48, 0x2a, 0xab, 0x18, 0xca, 0xea, 0x2d, 0x2a, 0x54, 0x17, 0x37, 0x32, 0x09, 0xdc, 0xe0, 0x4a, 0xb7, 0x7d, 0x82, 0x10, 0x7d}}},
{{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
{{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
{{{0x8a, 0x64, 0x1e, 0x14, 0x0a, 0x57, 0xd4, 0xda, 0x5c, 0x96, 0x9b, 0x01, 0x4c, 0x67, 0xbf, 0x8b, 0x30, 0xfe, 0x08, 0xdb, 0x0d, 0xd5, 0xa8, 0xd7, 0x09, 0x11, 0x85, 0xa2, 0xd3, 0x45, 0xfb, 0x7e}} ,
{{0xda, 0x8c, 0xc2, 0xd0, 0xac, 0x18, 0xe8, 0x52, 0x36, 0xd4, 0x21, 0xa3, 0xdd, 0x57, 0x22, 0x79, 0xb7, 0xf8, 0x71, 0x9d, 0xc6, 0x91, 0x70, 0x86, 0x56, 0xbf, 0xa1, 0x11, 0x8b, 0x19, 0xe1, 0x0f}}},
{{{0x18, 0x32, 0x98, 0x2c, 0x8f, 0x91, 0xae, 0x12, 0xf0, 0x8c, 0xea, 0xf3, 0x3c, 0xb9, 0x5d, 0xe4, 0x69, 0xed, 0xb2, 0x47, 0x18, 0xbd, 0xce, 0x16, 0x52, 0x5c, 0x23, 0xe2, 0xa5, 0x25, 0x52, 0x5d}} ,
{{0xb9, 0xb1, 0xe7, 0x5d, 0x4e, 0xbc, 0xee, 0xbb, 0x40, 0x81, 0x77, 0x82, 0x19, 0xab, 0xb5, 0xc6, 0xee, 0xab, 0x5b, 0x6b, 0x63, 0x92, 0x8a, 0x34, 0x8d, 0xcd, 0xee, 0x4f, 0x49, 0xe5, 0xc9, 0x7e}}},
{{{0x21, 0xac, 0x8b, 0x22, 0xcd, 0xc3, 0x9a, 0xe9, 0x5e, 0x78, 0xbd, 0xde, 0xba, 0xad, 0xab, 0xbf, 0x75, 0x41, 0x09, 0xc5, 0x58, 0xa4, 0x7d, 0x92, 0xb0, 0x7f, 0xf2, 0xa1, 0xd1, 0xc0, 0xb3, 0x6d}} ,
{{0x62, 0x4f, 0xd0, 0x75, 0x77, 0xba, 0x76, 0x77, 0xd7, 0xb8, 0xd8, 0x92, 0x6f, 0x98, 0x34, 0x3d, 0xd6, 0x4e, 0x1c, 0x0f, 0xf0, 0x8f, 0x2e, 0xf1, 0xb3, 0xbd, 0xb1, 0xb9, 0xec, 0x99, 0xb4, 0x07}}},
{{{0x60, 0x57, 0x2e, 0x9a, 0x72, 0x1d, 0x6b, 0x6e, 0x58, 0x33, 0x24, 0x8c, 0x48, 0x39, 0x46, 0x8e, 0x89, 0x6a, 0x88, 0x51, 0x23, 0x62, 0xb5, 0x32, 0x09, 0x36, 0xe3, 0x57, 0xf5, 0x98, 0xde, 0x6f}} ,
{{0x8b, 0x2c, 0x00, 0x48, 0x4a, 0xf9, 0x5b, 0x87, 0x69, 0x52, 0xe5, 0x5b, 0xd1, 0xb1, 0xe5, 0x25, 0x25, 0xe0, 0x9c, 0xc2, 0x13, 0x44, 0xe8, 0xb9, 0x0a, 0x70, 0xad, 0xbd, 0x0f, 0x51, 0x94, 0x69}}},
{{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
{{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
{{{0xa2, 0xdc, 0xab, 0xa9, 0x25, 0x2d, 0xac, 0x5f, 0x03, 0x33, 0x08, 0xe7, 0x7e, 0xfe, 0x95, 0x36, 0x3c, 0x5b, 0x3a, 0xd3, 0x05, 0x82, 0x1c, 0x95, 0x2d, 0xd8, 0x77, 0x7e, 0x02, 0xd9, 0x5b, 0x70}} ,
{{0xc2, 0xfe, 0x1b, 0x0c, 0x67, 0xcd, 0xd6, 0xe0, 0x51, 0x8e, 0x2c, 0xe0, 0x79, 0x88, 0xf0, 0xcf, 0x41, 0x4a, 0xad, 0x23, 0xd4, 0x46, 0xca, 0x94, 0xa1, 0xc3, 0xeb, 0x28, 0x06, 0xfa, 0x17, 0x14}}},
{{{0x7b, 0xaa, 0x70, 0x0a, 0x4b, 0xfb, 0xf5, 0xbf, 0x80, 0xc5, 0xcf, 0x08, 0x7a, 0xdd, 0xa1, 0xf4, 0x9d, 0x54, 0x50, 0x53, 0x23, 0x77, 0x23, 0xf5, 0x34, 0xa5, 0x22, 0xd1, 0x0d, 0x96, 0x2e, 0x47}} ,
{{0xcc, 0xb7, 0x32, 0x89, 0x57, 0xd0, 0x98, 0x75, 0xe4, 0x37, 0x99, 0xa9, 0xe8, 0xba, 0xed, 0xba, 0xeb, 0xc7, 0x4f, 0x15, 0x76, 0x07, 0x0c, 0x4c, 0xef, 0x9f, 0x52, 0xfc, 0x04, 0x5d, 0x58, 0x10}}},
{{{0xce, 0x82, 0xf0, 0x8f, 0x79, 0x02, 0xa8, 0xd1, 0xda, 0x14, 0x09, 0x48, 0xee, 0x8a, 0x40, 0x98, 0x76, 0x60, 0x54, 0x5a, 0xde, 0x03, 0x24, 0xf5, 0xe6, 0x2f, 0xe1, 0x03, 0xbf, 0x68, 0x82, 0x7f}} ,
{{0x64, 0xe9, 0x28, 0xc7, 0xa4, 0xcf, 0x2a, 0xf9, 0x90, 0x64, 0x72, 0x2c, 0x8b, 0xeb, 0xec, 0xa0, 0xf2, 0x7d, 0x35, 0xb5, 0x90, 0x4d, 0x7f, 0x5b, 0x4a, 0x49, 0xe4, 0xb8, 0x3b, 0xc8, 0xa1, 0x2f}}},
{{{0x8b, 0xc5, 0xcc, 0x3d, 0x69, 0xa6, 0xa1, 0x18, 0x44, 0xbc, 0x4d, 0x77, 0x37, 0xc7, 0x86, 0xec, 0x0c, 0xc9, 0xd6, 0x44, 0xa9, 0x23, 0x27, 0xb9, 0x03, 0x34, 0xa7, 0x0a, 0xd5, 0xc7, 0x34, 0x37}} ,
{{0xf9, 0x7e, 0x3e, 0x66, 0xee, 0xf9, 0x99, 0x28, 0xff, 0xad, 0x11, 0xd8, 0xe2, 0x66, 0xc5, 0xcd, 0x0f, 0x0d, 0x0b, 0x6a, 0xfc, 0x7c, 0x24, 0xa8, 0x4f, 0xa8, 0x5e, 0x80, 0x45, 0x8b, 0x6c, 0x41}}},
{{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
{{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
{{{0xef, 0x1e, 0xec, 0xf7, 0x8d, 0x77, 0xf2, 0xea, 0xdb, 0x60, 0x03, 0x21, 0xc0, 0xff, 0x5e, 0x67, 0xc3, 0x71, 0x0b, 0x21, 0xb4, 0x41, 0xa0, 0x68, 0x38, 0xc6, 0x01, 0xa3, 0xd3, 0x51, 0x3c, 0x3c}} ,
{{0x92, 0xf8, 0xd6, 0x4b, 0xef, 0x42, 0x13, 0xb2, 0x4a, 0xc4, 0x2e, 0x72, 0x3f, 0xc9, 0x11, 0xbd, 0x74, 0x02, 0x0e, 0xf5, 0x13, 0x9d, 0x83, 0x1a, 0x1b, 0xd5, 0x54, 0xde, 0xc4, 0x1e, 0x16, 0x6c}}},
{{{0x27, 0x52, 0xe4, 0x63, 0xaa, 0x94, 0xe6, 0xc3, 0x28, 0x9c, 0xc6, 0x56, 0xac, 0xfa, 0xb6, 0xbd, 0xe2, 0xcc, 0x76, 0xc6, 0x27, 0x27, 0xa2, 0x8e, 0x78, 0x2b, 0x84, 0x72, 0x10, 0xbd, 0x4e, 0x2a}} ,
{{0xea, 0xa7, 0x23, 0xef, 0x04, 0x61, 0x80, 0x50, 0xc9, 0x6e, 0xa5, 0x96, 0xd1, 0xd1, 0xc8, 0xc3, 0x18, 0xd7, 0x2d, 0xfd, 0x26, 0xbd, 0xcb, 0x7b, 0x92, 0x51, 0x0e, 0x4a, 0x65, 0x57, 0xb8, 0x49}}},
{{{0xab, 0x55, 0x36, 0xc3, 0xec, 0x63, 0x55, 0x11, 0x55, 0xf6, 0xa5, 0xc7, 0x01, 0x5f, 0xfe, 0x79, 0xd8, 0x0a, 0xf7, 0x03, 0xd8, 0x98, 0x99, 0xf5, 0xd0, 0x00, 0x54, 0x6b, 0x66, 0x28, 0xf5, 0x25}} ,
{{0x7a, 0x8d, 0xa1, 0x5d, 0x70, 0x5d, 0x51, 0x27, 0xee, 0x30, 0x65, 0x56, 0x95, 0x46, 0xde, 0xbd, 0x03, 0x75, 0xb4, 0x57, 0x59, 0x89, 0xeb, 0x02, 0x9e, 0xcc, 0x89, 0x19, 0xa7, 0xcb, 0x17, 0x67}}},
{{{0x6a, 0xeb, 0xfc, 0x9a, 0x9a, 0x10, 0xce, 0xdb, 0x3a, 0x1c, 0x3c, 0x6a, 0x9d, 0xea, 0x46, 0xbc, 0x45, 0x49, 0xac, 0xe3, 0x41, 0x12, 0x7c, 0xf0, 0xf7, 0x4f, 0xf9, 0xf7, 0xff, 0x2c, 0x89, 0x04}} ,
{{0x30, 0x31, 0x54, 0x1a, 0x46, 0xca, 0xe6, 0xc6, 0xcb, 0xe2, 0xc3, 0xc1, 0x8b, 0x75, 0x81, 0xbe, 0xee, 0xf8, 0xa3, 0x11, 0x1c, 0x25, 0xa3, 0xa7, 0x35, 0x51, 0x55, 0xe2, 0x25, 0xaa, 0xe2, 0x3a}}},
{{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
{{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
{{{0xb4, 0x48, 0x10, 0x9f, 0x8a, 0x09, 0x76, 0xfa, 0xf0, 0x7a, 0xb0, 0x70, 0xf7, 0x83, 0x80, 0x52, 0x84, 0x2b, 0x26, 0xa2, 0xc4, 0x5d, 0x4f, 0xba, 0xb1, 0xc8, 0x40, 0x0d, 0x78, 0x97, 0xc4, 0x60}} ,
{{0xd4, 0xb1, 0x6c, 0x08, 0xc7, 0x40, 0x38, 0x73, 0x5f, 0x0b, 0xf3, 0x76, 0x5d, 0xb2, 0xa5, 0x2f, 0x57, 0x57, 0x07, 0xed, 0x08, 0xa2, 0x6c, 0x4f, 0x08, 0x02, 0xb5, 0x0e, 0xee, 0x44, 0xfa, 0x22}}},
{{{0x0f, 0x00, 0x3f, 0xa6, 0x04, 0x19, 0x56, 0x65, 0x31, 0x7f, 0x8b, 0xeb, 0x0d, 0xe1, 0x47, 0x89, 0x97, 0x16, 0x53, 0xfa, 0x81, 0xa7, 0xaa, 0xb2, 0xbf, 0x67, 0xeb, 0x72, 0x60, 0x81, 0x0d, 0x48}} ,
{{0x7e, 0x13, 0x33, 0xcd, 0xa8, 0x84, 0x56, 0x1e, 0x67, 0xaf, 0x6b, 0x43, 0xac, 0x17, 0xaf, 0x16, 0xc0, 0x52, 0x99, 0x49, 0x5b, 0x87, 0x73, 0x7e, 0xb5, 0x43, 0xda, 0x6b, 0x1d, 0x0f, 0x2d, 0x55}}},
{{{0xe9, 0x58, 0x1f, 0xff, 0x84, 0x3f, 0x93, 0x1c, 0xcb, 0xe1, 0x30, 0x69, 0xa5, 0x75, 0x19, 0x7e, 0x14, 0x5f, 0xf8, 0xfc, 0x09, 0xdd, 0xa8, 0x78, 0x9d, 0xca, 0x59, 0x8b, 0xd1, 0x30, 0x01, 0x13}} ,
{{0xff, 0x76, 0x03, 0xc5, 0x4b, 0x89, 0x99, 0x70, 0x00, 0x59, 0x70, 0x9c, 0xd5, 0xd9, 0x11, 0x89, 0x5a, 0x46, 0xfe, 0xef, 0xdc, 0xd9, 0x55, 0x2b, 0x45, 0xa7, 0xb0, 0x2d, 0xfb, 0x24, 0xc2, 0x29}}},
{{{0x38, 0x06, 0xf8, 0x0b, 0xac, 0x82, 0xc4, 0x97, 0x2b, 0x90, 0xe0, 0xf7, 0xa8, 0xab, 0x6c, 0x08, 0x80, 0x66, 0x90, 0x46, 0xf7, 0x26, 0x2d, 0xf8, 0xf1, 0xc4, 0x6b, 0x4a, 0x82, 0x98, 0x8e, 0x37}} ,
{{0x8e, 0xb4, 0xee, 0xb8, 0xd4, 0x3f, 0xb2, 0x1b, 0xe0, 0x0a, 0x3d, 0x75, 0x34, 0x28, 0xa2, 0x8e, 0xc4, 0x92, 0x7b, 0xfe, 0x60, 0x6e, 0x6d, 0xb8, 0x31, 0x1d, 0x62, 0x0d, 0x78, 0x14, 0x42, 0x11}}},
{{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
{{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
{{{0x5e, 0xa8, 0xd8, 0x04, 0x9b, 0x73, 0xc9, 0xc9, 0xdc, 0x0d, 0x73, 0xbf, 0x0a, 0x0a, 0x73, 0xff, 0x18, 0x1f, 0x9c, 0x51, 0xaa, 0xc6, 0xf1, 0x83, 0x25, 0xfd, 0xab, 0xa3, 0x11, 0xd3, 0x01, 0x24}} ,
{{0x4d, 0xe3, 0x7e, 0x38, 0x62, 0x5e, 0x64, 0xbb, 0x2b, 0x53, 0xb5, 0x03, 0x68, 0xc4, 0xf2, 0x2b, 0x5a, 0x03, 0x32, 0x99, 0x4a, 0x41, 0x9a, 0xe1, 0x1a, 0xae, 0x8c, 0x48, 0xf3, 0x24, 0x32, 0x65}}},
{{{0xe8, 0xdd, 0xad, 0x3a, 0x8c, 0xea, 0xf4, 0xb3, 0xb2, 0xe5, 0x73, 0xf2, 0xed, 0x8b, 0xbf, 0xed, 0xb1, 0x0c, 0x0c, 0xfb, 0x2b, 0xf1, 0x01, 0x48, 0xe8, 0x26, 0x03, 0x8e, 0x27, 0x4d, 0x96, 0x72}} ,
{{0xc8, 0x09, 0x3b, 0x60, 0xc9, 0x26, 0x4d, 0x7c, 0xf2, 0x9c, 0xd4, 0xa1, 0x3b, 0x26, 0xc2, 0x04, 0x33, 0x44, 0x76, 0x3c, 0x02, 0xbb, 0x11, 0x42, 0x0c, 0x22, 0xb7, 0xc6, 0xe1, 0xac, 0xb4, 0x0e}}},
{{{0x6f, 0x85, 0xe7, 0xef, 0xde, 0x67, 0x30, 0xfc, 0xbf, 0x5a, 0xe0, 0x7b, 0x7a, 0x2a, 0x54, 0x6b, 0x5d, 0x62, 0x85, 0xa1, 0xf8, 0x16, 0x88, 0xec, 0x61, 0xb9, 0x96, 0xb5, 0xef, 0x2d, 0x43, 0x4d}} ,
{{0x7c, 0x31, 0x33, 0xcc, 0xe4, 0xcf, 0x6c, 0xff, 0x80, 0x47, 0x77, 0xd1, 0xd8, 0xe9, 0x69, 0x97, 0x98, 0x7f, 0x20, 0x57, 0x1d, 0x1d, 0x4f, 0x08, 0x27, 0xc8, 0x35, 0x57, 0x40, 0xc6, 0x21, 0x0c}}},
{{{0xd2, 0x8e, 0x9b, 0xfa, 0x42, 0x8e, 0xdf, 0x8f, 0xc7, 0x86, 0xf9, 0xa4, 0xca, 0x70, 0x00, 0x9d, 0x21, 0xbf, 0xec, 0x57, 0x62, 0x30, 0x58, 0x8c, 0x0d, 0x35, 0xdb, 0x5d, 0x8b, 0x6a, 0xa0, 0x5a}} ,
{{0xc1, 0x58, 0x7c, 0x0d, 0x20, 0xdd, 0x11, 0x26, 0x5f, 0x89, 0x3b, 0x97, 0x58, 0xf8, 0x8b, 0xe3, 0xdf, 0x32, 0xe2, 0xfc, 0xd8, 0x67, 0xf2, 0xa5, 0x37, 0x1e, 0x6d, 0xec, 0x7c, 0x27, 0x20, 0x79}}},
{{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
{{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
{{{0xd0, 0xe9, 0xc0, 0xfa, 0x95, 0x45, 0x23, 0x96, 0xf1, 0x2c, 0x79, 0x25, 0x14, 0xce, 0x40, 0x14, 0x44, 0x2c, 0x36, 0x50, 0xd9, 0x63, 0x56, 0xb7, 0x56, 0x3b, 0x9e, 0xa7, 0xef, 0x89, 0xbb, 0x0e}} ,
{{0xce, 0x7f, 0xdc, 0x0a, 0xcc, 0x82, 0x1c, 0x0a, 0x78, 0x71, 0xe8, 0x74, 0x8d, 0x01, 0x30, 0x0f, 0xa7, 0x11, 0x4c, 0xdf, 0x38, 0xd7, 0xa7, 0x0d, 0xf8, 0x48, 0x52, 0x00, 0x80, 0x7b, 0x5f, 0x0e}}},
{{{0x25, 0x83, 0xe6, 0x94, 0x7b, 0x81, 0xb2, 0x91, 0xae, 0x0e, 0x05, 0xc9, 0xa3, 0x68, 0x2d, 0xd9, 0x88, 0x25, 0x19, 0x2a, 0x61, 0x61, 0x21, 0x97, 0x15, 0xa1, 0x35, 0xa5, 0x46, 0xc8, 0xa2, 0x0e}} ,
{{0x1b, 0x03, 0x0d, 0x8b, 0x5a, 0x1b, 0x97, 0x4b, 0xf2, 0x16, 0x31, 0x3d, 0x1f, 0x33, 0xa0, 0x50, 0x3a, 0x18, 0xbe, 0x13, 0xa1, 0x76, 0xc1, 0xba, 0x1b, 0xf1, 0x05, 0x7b, 0x33, 0xa8, 0x82, 0x3b}}},
{{{0xba, 0x36, 0x7b, 0x6d, 0xa9, 0xea, 0x14, 0x12, 0xc5, 0xfa, 0x91, 0x00, 0xba, 0x9b, 0x99, 0xcc, 0x56, 0x02, 0xe9, 0xa0, 0x26, 0x40, 0x66, 0x8c, 0xc4, 0xf8, 0x85, 0x33, 0x68, 0xe7, 0x03, 0x20}} ,
{{0x50, 0x5b, 0xff, 0xa9, 0xb2, 0xf1, 0xf1, 0x78, 0xcf, 0x14, 0xa4, 0xa9, 0xfc, 0x09, 0x46, 0x94, 0x54, 0x65, 0x0d, 0x9c, 0x5f, 0x72, 0x21, 0xe2, 0x97, 0xa5, 0x2d, 0x81, 0xce, 0x4a, 0x5f, 0x79}}},
{{{0x3d, 0x5f, 0x5c, 0xd2, 0xbc, 0x7d, 0x77, 0x0e, 0x2a, 0x6d, 0x22, 0x45, 0x84, 0x06, 0xc4, 0xdd, 0xc6, 0xa6, 0xc6, 0xd7, 0x49, 0xad, 0x6d, 0x87, 0x91, 0x0e, 0x3a, 0x67, 0x1d, 0x2c, 0x1d, 0x56}} ,
{{0xfe, 0x7a, 0x74, 0xcf, 0xd4, 0xd2, 0xe5, 0x19, 0xde, 0xd0, 0xdb, 0x70, 0x23, 0x69, 0xe6, 0x6d, 0xec, 0xec, 0xcc, 0x09, 0x33, 0x6a, 0x77, 0xdc, 0x6b, 0x22, 0x76, 0x5d, 0x92, 0x09, 0xac, 0x2d}}},
{{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
{{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
{{{0x23, 0x15, 0x17, 0xeb, 0xd3, 0xdb, 0x12, 0x5e, 0x01, 0xf0, 0x91, 0xab, 0x2c, 0x41, 0xce, 0xac, 0xed, 0x1b, 0x4b, 0x2d, 0xbc, 0xdb, 0x17, 0x66, 0x89, 0x46, 0xad, 0x4b, 0x1e, 0x6f, 0x0b, 0x14}} ,
{{0x11, 0xce, 0xbf, 0xb6, 0x77, 0x2d, 0x48, 0x22, 0x18, 0x4f, 0xa3, 0x5d, 0x4a, 0xb0, 0x70, 0x12, 0x3e, 0x54, 0xd7, 0xd8, 0x0e, 0x2b, 0x27, 0xdc, 0x53, 0xff, 0xca, 0x8c, 0x59, 0xb3, 0x4e, 0x44}}},
{{{0x07, 0x76, 0x61, 0x0f, 0x66, 0xb2, 0x21, 0x39, 0x7e, 0xc0, 0xec, 0x45, 0x28, 0x82, 0xa1, 0x29, 0x32, 0x44, 0x35, 0x13, 0x5e, 0x61, 0x5e, 0x54, 0xcb, 0x7c, 0xef, 0xf6, 0x41, 0xcf, 0x9f, 0x0a}} ,
{{0xdd, 0xf9, 0xda, 0x84, 0xc3, 0xe6, 0x8a, 0x9f, 0x24, 0xd2, 0x96, 0x5d, 0x39, 0x6f, 0x58, 0x8c, 0xc1, 0x56, 0x93, 0xab, 0xb5, 0x79, 0x3b, 0xd2, 0xa8, 0x73, 0x16, 0xed, 0xfa, 0xb4, 0x2f, 0x73}}},
{{{0x8b, 0xb1, 0x95, 0xe5, 0x92, 0x50, 0x35, 0x11, 0x76, 0xac, 0xf4, 0x4d, 0x24, 0xc3, 0x32, 0xe6, 0xeb, 0xfe, 0x2c, 0x87, 0xc4, 0xf1, 0x56, 0xc4, 0x75, 0x24, 0x7a, 0x56, 0x85, 0x5a, 0x3a, 0x13}} ,
{{0x0d, 0x16, 0xac, 0x3c, 0x4a, 0x58, 0x86, 0x3a, 0x46, 0x7f, 0x6c, 0xa3, 0x52, 0x6e, 0x37, 0xe4, 0x96, 0x9c, 0xe9, 0x5c, 0x66, 0x41, 0x67, 0xe4, 0xfb, 0x79, 0x0c, 0x05, 0xf6, 0x64, 0xd5, 0x7c}}},
{{{0x28, 0xc1, 0xe1, 0x54, 0x73, 0xf2, 0xbf, 0x76, 0x74, 0x19, 0x19, 0x1b, 0xe4, 0xb9, 0xa8, 0x46, 0x65, 0x73, 0xf3, 0x77, 0x9b, 0x29, 0x74, 0x5b, 0xc6, 0x89, 0x6c, 0x2c, 0x7c, 0xf8, 0xb3, 0x0f}} ,
{{0xf7, 0xd5, 0xe9, 0x74, 0x5d, 0xb8, 0x25, 0x16, 0xb5, 0x30, 0xbc, 0x84, 0xc5, 0xf0, 0xad, 0xca, 0x12, 0x28, 0xbc, 0x9d, 0xd4, 0xfa, 0x82, 0xe6, 0xe3, 0xbf, 0xa2, 0x15, 0x2c, 0xd4, 0x34, 0x10}}},
{{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
{{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
{{{0x61, 0xb1, 0x46, 0xba, 0x0e, 0x31, 0xa5, 0x67, 0x6c, 0x7f, 0xd6, 0xd9, 0x27, 0x85, 0x0f, 0x79, 0x14, 0xc8, 0x6c, 0x2f, 0x5f, 0x5b, 0x9c, 0x35, 0x3d, 0x38, 0x86, 0x77, 0x65, 0x55, 0x6a, 0x7b}} ,
{{0xd3, 0xb0, 0x3a, 0x66, 0x60, 0x1b, 0x43, 0xf1, 0x26, 0x58, 0x99, 0x09, 0x8f, 0x2d, 0xa3, 0x14, 0x71, 0x85, 0xdb, 0xed, 0xf6, 0x26, 0xd5, 0x61, 0x9a, 0x73, 0xac, 0x0e, 0xea, 0xac, 0xb7, 0x0c}}},
{{{0x5e, 0xf4, 0xe5, 0x17, 0x0e, 0x10, 0x9f, 0xe7, 0x43, 0x5f, 0x67, 0x5c, 0xac, 0x4b, 0xe5, 0x14, 0x41, 0xd2, 0xbf, 0x48, 0xf5, 0x14, 0xb0, 0x71, 0xc6, 0x61, 0xc1, 0xb2, 0x70, 0x58, 0xd2, 0x5a}} ,
{{0x2d, 0xba, 0x16, 0x07, 0x92, 0x94, 0xdc, 0xbd, 0x50, 0x2b, 0xc9, 0x7f, 0x42, 0x00, 0xba, 0x61, 0xed, 0xf8, 0x43, 0xed, 0xf5, 0xf9, 0x40, 0x60, 0xb2, 0xb0, 0x82, 0xcb, 0xed, 0x75, 0xc7, 0x65}}},
{{{0x80, 0xba, 0x0d, 0x09, 0x40, 0xa7, 0x39, 0xa6, 0x67, 0x34, 0x7e, 0x66, 0xbe, 0x56, 0xfb, 0x53, 0x78, 0xc4, 0x46, 0xe8, 0xed, 0x68, 0x6c, 0x7f, 0xce, 0xe8, 0x9f, 0xce, 0xa2, 0x64, 0x58, 0x53}} ,
{{0xe8, 0xc1, 0xa9, 0xc2, 0x7b, 0x59, 0x21, 0x33, 0xe2, 0x43, 0x73, 0x2b, 0xac, 0x2d, 0xc1, 0x89, 0x3b, 0x15, 0xe2, 0xd5, 0xc0, 0x97, 0x8a, 0xfd, 0x6f, 0x36, 0x33, 0xb7, 0xb9, 0xc3, 0x88, 0x09}}},
{{{0xd0, 0xb6, 0x56, 0x30, 0x5c, 0xae, 0xb3, 0x75, 0x44, 0xa4, 0x83, 0x51, 0x6e, 0x01, 0x65, 0xef, 0x45, 0x76, 0xe6, 0xf5, 0xa2, 0x0d, 0xd4, 0x16, 0x3b, 0x58, 0x2f, 0xf2, 0x2f, 0x36, 0x18, 0x3f}} ,
{{0xfd, 0x2f, 0xe0, 0x9b, 0x1e, 0x8c, 0xc5, 0x18, 0xa9, 0xca, 0xd4, 0x2b, 0x35, 0xb6, 0x95, 0x0a, 0x9f, 0x7e, 0xfb, 0xc4, 0xef, 0x88, 0x7b, 0x23, 0x43, 0xec, 0x2f, 0x0d, 0x0f, 0x7a, 0xfc, 0x5c}}},
{{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
{{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
{{{0x8d, 0xd2, 0xda, 0xc7, 0x44, 0xd6, 0x7a, 0xdb, 0x26, 0x7d, 0x1d, 0xb8, 0xe1, 0xde, 0x9d, 0x7a, 0x7d, 0x17, 0x7e, 0x1c, 0x37, 0x04, 0x8d, 0x2d, 0x7c, 0x5e, 0x18, 0x38, 0x1e, 0xaf, 0xc7, 0x1b}} ,
{{0x33, 0x48, 0x31, 0x00, 0x59, 0xf6, 0xf2, 0xca, 0x0f, 0x27, 0x1b, 0x63, 0x12, 0x7e, 0x02, 0x1d, 0x49, 0xc0, 0x5d, 0x79, 0x87, 0xef, 0x5e, 0x7a, 0x2f, 0x1f, 0x66, 0x55, 0xd8, 0x09, 0xd9, 0x61}}},
{{{0x54, 0x83, 0x02, 0x18, 0x82, 0x93, 0x99, 0x07, 0xd0, 0xa7, 0xda, 0xd8, 0x75, 0x89, 0xfa, 0xf2, 0xd9, 0xa3, 0xb8, 0x6b, 0x5a, 0x35, 0x28, 0xd2, 0x6b, 0x59, 0xc2, 0xf8, 0x45, 0xe2, 0xbc, 0x06}} ,
{{0x65, 0xc0, 0xa3, 0x88, 0x51, 0x95, 0xfc, 0x96, 0x94, 0x78, 0xe8, 0x0d, 0x8b, 0x41, 0xc9, 0xc2, 0x58, 0x48, 0x75, 0x10, 0x2f, 0xcd, 0x2a, 0xc9, 0xa0, 0x6d, 0x0f, 0xdd, 0x9c, 0x98, 0x26, 0x3d}}},
{{{0x2f, 0x66, 0x29, 0x1b, 0x04, 0x89, 0xbd, 0x7e, 0xee, 0x6e, 0xdd, 0xb7, 0x0e, 0xef, 0xb0, 0x0c, 0xb4, 0xfc, 0x7f, 0xc2, 0xc9, 0x3a, 0x3c, 0x64, 0xef, 0x45, 0x44, 0xaf, 0x8a, 0x90, 0x65, 0x76}} ,
{{0xa1, 0x4c, 0x70, 0x4b, 0x0e, 0xa0, 0x83, 0x70, 0x13, 0xa4, 0xaf, 0xb8, 0x38, 0x19, 0x22, 0x65, 0x09, 0xb4, 0x02, 0x4f, 0x06, 0xf8, 0x17, 0xce, 0x46, 0x45, 0xda, 0x50, 0x7c, 0x8a, 0xd1, 0x4e}}},
{{{0xf7, 0xd4, 0x16, 0x6c, 0x4e, 0x95, 0x9d, 0x5d, 0x0f, 0x91, 0x2b, 0x52, 0xfe, 0x5c, 0x34, 0xe5, 0x30, 0xe6, 0xa4, 0x3b, 0xf3, 0xf3, 0x34, 0x08, 0xa9, 0x4a, 0xa0, 0xb5, 0x6e, 0xb3, 0x09, 0x0a}} ,
{{0x26, 0xd9, 0x5e, 0xa3, 0x0f, 0xeb, 0xa2, 0xf3, 0x20, 0x3b, 0x37, 0xd4, 0xe4, 0x9e, 0xce, 0x06, 0x3d, 0x53, 0xed, 0xae, 0x2b, 0xeb, 0xb6, 0x24, 0x0a, 0x11, 0xa3, 0x0f, 0xd6, 0x7f, 0xa4, 0x3a}}},
{{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
{{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
{{{0xdb, 0x9f, 0x2c, 0xfc, 0xd6, 0xb2, 0x1e, 0x2e, 0x52, 0x7a, 0x06, 0x87, 0x2d, 0x86, 0x72, 0x2b, 0x6d, 0x90, 0x77, 0x46, 0x43, 0xb5, 0x7a, 0xf8, 0x60, 0x7d, 0x91, 0x60, 0x5b, 0x9d, 0x9e, 0x07}} ,
{{0x97, 0x87, 0xc7, 0x04, 0x1c, 0x38, 0x01, 0x39, 0x58, 0xc7, 0x85, 0xa3, 0xfc, 0x64, 0x00, 0x64, 0x25, 0xa2, 0xbf, 0x50, 0x94, 0xca, 0x26, 0x31, 0x45, 0x0a, 0x24, 0xd2, 0x51, 0x29, 0x51, 0x16}}},
{{{0x4d, 0x4a, 0xd7, 0x98, 0x71, 0x57, 0xac, 0x7d, 0x8b, 0x37, 0xbd, 0x63, 0xff, 0x87, 0xb1, 0x49, 0x95, 0x20, 0x7c, 0xcf, 0x7c, 0x59, 0xc4, 0x91, 0x9c, 0xef, 0xd0, 0xdb, 0x60, 0x09, 0x9d, 0x46}} ,
{{0xcb, 0x78, 0x94, 0x90, 0xe4, 0x45, 0xb3, 0xf6, 0xd9, 0xf6, 0x57, 0x74, 0xd5, 0xf8, 0x83, 0x4f, 0x39, 0xc9, 0xbd, 0x88, 0xc2, 0x57, 0x21, 0x1f, 0x24, 0x32, 0x68, 0xf8, 0xc7, 0x21, 0x5f, 0x0b}}},
{{{0x2a, 0x36, 0x68, 0xfc, 0x5f, 0xb6, 0x4f, 0xa5, 0xe3, 0x9d, 0x24, 0x2f, 0xc0, 0x93, 0x61, 0xcf, 0xf8, 0x0a, 0xed, 0xe1, 0xdb, 0x27, 0xec, 0x0e, 0x14, 0x32, 0x5f, 0x8e, 0xa1, 0x62, 0x41, 0x16}} ,
{{0x95, 0x21, 0x01, 0xce, 0x95, 0x5b, 0x0e, 0x57, 0xc7, 0xb9, 0x62, 0xb5, 0x28, 0xca, 0x11, 0xec, 0xb4, 0x46, 0x06, 0x73, 0x26, 0xff, 0xfb, 0x66, 0x7d, 0xee, 0x5f, 0xb2, 0x56, 0xfd, 0x2a, 0x08}}},
{{{0x92, 0x67, 0x77, 0x56, 0xa1, 0xff, 0xc4, 0xc5, 0x95, 0xf0, 0xe3, 0x3a, 0x0a, 0xca, 0x94, 0x4d, 0x9e, 0x7e, 0x3d, 0xb9, 0x6e, 0xb6, 0xb0, 0xce, 0xa4, 0x30, 0x89, 0x99, 0xe9, 0xad, 0x11, 0x59}} ,
{{0xf6, 0x48, 0x95, 0xa1, 0x6f, 0x5f, 0xb7, 0xa5, 0xbb, 0x30, 0x00, 0x1c, 0xd2, 0x8a, 0xd6, 0x25, 0x26, 0x1b, 0xb2, 0x0d, 0x37, 0x6a, 0x05, 0xf4, 0x9d, 0x3e, 0x17, 0x2a, 0x43, 0xd2, 0x3a, 0x06}}},
{{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
{{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
{{{0x32, 0x99, 0x93, 0xd1, 0x9a, 0x72, 0xf3, 0xa9, 0x16, 0xbd, 0xb4, 0x4c, 0xdd, 0xf9, 0xd4, 0xb2, 0x64, 0x9a, 0xd3, 0x05, 0xe4, 0xa3, 0x73, 0x1c, 0xcb, 0x7e, 0x57, 0x67, 0xff, 0x04, 0xb3, 0x10}} ,
{{0xb9, 0x4b, 0xa4, 0xad, 0xd0, 0x6d, 0x61, 0x23, 0xb4, 0xaf, 0x34, 0xa9, 0xaa, 0x65, 0xec, 0xd9, 0x69, 0xe3, 0x85, 0xcd, 0xcc, 0xe7, 0xb0, 0x9b, 0x41, 0xc1, 0x1c, 0xf9, 0xa0, 0xfa, 0xb7, 0x13}}},
{{{0x04, 0xfd, 0x88, 0x3c, 0x0c, 0xd0, 0x09, 0x52, 0x51, 0x4f, 0x06, 0x19, 0xcc, 0xc3, 0xbb, 0xde, 0x80, 0xc5, 0x33, 0xbc, 0xf9, 0xf3, 0x17, 0x36, 0xdd, 0xc6, 0xde, 0xe8, 0x9b, 0x5d, 0x79, 0x1b}} ,
{{0x65, 0x0a, 0xbe, 0x51, 0x57, 0xad, 0x50, 0x79, 0x08, 0x71, 0x9b, 0x07, 0x95, 0x8f, 0xfb, 0xae, 0x4b, 0x38, 0xba, 0xcf, 0x53, 0x2a, 0x86, 0x1e, 0xc0, 0x50, 0x5c, 0x67, 0x1b, 0xf6, 0x87, 0x6c}}},
{{{0x4f, 0x00, 0xb2, 0x66, 0x55, 0xed, 0x4a, 0xed, 0x8d, 0xe1, 0x66, 0x18, 0xb2, 0x14, 0x74, 0x8d, 0xfd, 0x1a, 0x36, 0x0f, 0x26, 0x5c, 0x8b, 0x89, 0xf3, 0xab, 0xf2, 0xf3, 0x24, 0x67, 0xfd, 0x70}} ,
{{0xfd, 0x4e, 0x2a, 0xc1, 0x3a, 0xca, 0x8f, 0x00, 0xd8, 0xec, 0x74, 0x67, 0xef, 0x61, 0xe0, 0x28, 0xd0, 0x96, 0xf4, 0x48, 0xde, 0x81, 0xe3, 0xef, 0xdc, 0xaa, 0x7d, 0xf3, 0xb6, 0x55, 0xa6, 0x65}}},
{{{0xeb, 0xcb, 0xc5, 0x70, 0x91, 0x31, 0x10, 0x93, 0x0d, 0xc8, 0xd0, 0xef, 0x62, 0xe8, 0x6f, 0x82, 0xe3, 0x69, 0x3d, 0x91, 0x7f, 0x31, 0xe1, 0x26, 0x35, 0x3c, 0x4a, 0x2f, 0xab, 0xc4, 0x9a, 0x5e}} ,
{{0xab, 0x1b, 0xb5, 0xe5, 0x2b, 0xc3, 0x0e, 0x29, 0xb0, 0xd0, 0x73, 0xe6, 0x4f, 0x64, 0xf2, 0xbc, 0xe4, 0xe4, 0xe1, 0x9a, 0x52, 0x33, 0x2f, 0xbd, 0xcc, 0x03, 0xee, 0x8a, 0xfa, 0x00, 0x5f, 0x50}}},
{{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
{{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
{{{0xf6, 0xdb, 0x0d, 0x22, 0x3d, 0xb5, 0x14, 0x75, 0x31, 0xf0, 0x81, 0xe2, 0xb9, 0x37, 0xa2, 0xa9, 0x84, 0x11, 0x9a, 0x07, 0xb5, 0x53, 0x89, 0x78, 0xa9, 0x30, 0x27, 0xa1, 0xf1, 0x4e, 0x5c, 0x2e}} ,
{{0x8b, 0x00, 0x54, 0xfb, 0x4d, 0xdc, 0xcb, 0x17, 0x35, 0x40, 0xff, 0xb7, 0x8c, 0xfe, 0x4a, 0xe4, 0x4e, 0x99, 0x4e, 0xa8, 0x74, 0x54, 0x5d, 0x5c, 0x96, 0xa3, 0x12, 0x55, 0x36, 0x31, 0x17, 0x5c}}},
{{{0xce, 0x24, 0xef, 0x7b, 0x86, 0xf2, 0x0f, 0x77, 0xe8, 0x5c, 0x7d, 0x87, 0x38, 0x2d, 0xef, 0xaf, 0xf2, 0x8c, 0x72, 0x2e, 0xeb, 0xb6, 0x55, 0x4b, 0x6e, 0xf1, 0x4e, 0x8a, 0x0e, 0x9a, 0x6c, 0x4c}} ,
{{0x25, 0xea, 0x86, 0xc2, 0xd1, 0x4f, 0xb7, 0x3e, 0xa8, 0x5c, 0x8d, 0x66, 0x81, 0x25, 0xed, 0xc5, 0x4c, 0x05, 0xb9, 0xd8, 0xd6, 0x70, 0xbe, 0x73, 0x82, 0xe8, 0xa1, 0xe5, 0x1e, 0x71, 0xd5, 0x26}}},
{{{0x4e, 0x6d, 0xc3, 0xa7, 0x4f, 0x22, 0x45, 0x26, 0xa2, 0x7e, 0x16, 0xf7, 0xf7, 0x63, 0xdc, 0x86, 0x01, 0x2a, 0x71, 0x38, 0x5c, 0x33, 0xc3, 0xce, 0x30, 0xff, 0xf9, 0x2c, 0x91, 0x71, 0x8a, 0x72}} ,
{{0x8c, 0x44, 0x09, 0x28, 0xd5, 0x23, 0xc9, 0x8f, 0xf3, 0x84, 0x45, 0xc6, 0x9a, 0x5e, 0xff, 0xd2, 0xc7, 0x57, 0x93, 0xa3, 0xc1, 0x69, 0xdd, 0x62, 0x0f, 0xda, 0x5c, 0x30, 0x59, 0x5d, 0xe9, 0x4c}}},
{{{0x92, 0x7e, 0x50, 0x27, 0x72, 0xd7, 0x0c, 0xd6, 0x69, 0x96, 0x81, 0x35, 0x84, 0x94, 0x35, 0x8b, 0x6c, 0xaa, 0x62, 0x86, 0x6e, 0x1c, 0x15, 0xf3, 0x6c, 0xb3, 0xff, 0x65, 0x1b, 0xa2, 0x9b, 0x59}} ,
{{0xe2, 0xa9, 0x65, 0x88, 0xc4, 0x50, 0xfa, 0xbb, 0x3b, 0x6e, 0x5f, 0x44, 0x01, 0xca, 0x97, 0xd4, 0xdd, 0xf6, 0xcd, 0x3f, 0x3f, 0xe5, 0x97, 0x67, 0x2b, 0x8c, 0x66, 0x0f, 0x35, 0x9b, 0xf5, 0x07}}},
{{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
{{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
{{{0xf1, 0x59, 0x27, 0xd8, 0xdb, 0x5a, 0x11, 0x5e, 0x82, 0xf3, 0x38, 0xff, 0x1c, 0xed, 0xfe, 0x3f, 0x64, 0x54, 0x3f, 0x7f, 0xd1, 0x81, 0xed, 0xef, 0x65, 0xc5, 0xcb, 0xfd, 0xe1, 0x80, 0xcd, 0x11}} ,
{{0xe0, 0xdb, 0x22, 0x28, 0xe6, 0xff, 0x61, 0x9d, 0x41, 0x14, 0x2d, 0x3b, 0x26, 0x22, 0xdf, 0xf1, 0x34, 0x81, 0xe9, 0x45, 0xee, 0x0f, 0x98, 0x8b, 0xa6, 0x3f, 0xef, 0xf7, 0x43, 0x19, 0xf1, 0x43}}},
{{{0xee, 0xf3, 0x00, 0xa1, 0x50, 0xde, 0xc0, 0xb6, 0x01, 0xe3, 0x8c, 0x3c, 0x4d, 0x31, 0xd2, 0xb0, 0x58, 0xcd, 0xed, 0x10, 0x4a, 0x7a, 0xef, 0x80, 0xa9, 0x19, 0x32, 0xf3, 0xd8, 0x33, 0x8c, 0x06}} ,
{{0xcb, 0x7d, 0x4f, 0xff, 0x30, 0xd8, 0x12, 0x3b, 0x39, 0x1c, 0x06, 0xf9, 0x4c, 0x34, 0x35, 0x71, 0xb5, 0x16, 0x94, 0x67, 0xdf, 0xee, 0x11, 0xde, 0xa4, 0x1d, 0x88, 0x93, 0x35, 0xa9, 0x32, 0x10}}},
{{{0xe9, 0xc3, 0xbc, 0x7b, 0x5c, 0xfc, 0xb2, 0xf9, 0xc9, 0x2f, 0xe5, 0xba, 0x3a, 0x0b, 0xab, 0x64, 0x38, 0x6f, 0x5b, 0x4b, 0x93, 0xda, 0x64, 0xec, 0x4d, 0x3d, 0xa0, 0xf5, 0xbb, 0xba, 0x47, 0x48}} ,
{{0x60, 0xbc, 0x45, 0x1f, 0x23, 0xa2, 0x3b, 0x70, 0x76, 0xe6, 0x97, 0x99, 0x4f, 0x77, 0x54, 0x67, 0x30, 0x9a, 0xe7, 0x66, 0xd6, 0xcd, 0x2e, 0x51, 0x24, 0x2c, 0x42, 0x4a, 0x11, 0xfe, 0x6f, 0x7e}}},
{{{0x87, 0xc0, 0xb1, 0xf0, 0xa3, 0x6f, 0x0c, 0x93, 0xa9, 0x0a, 0x72, 0xef, 0x5c, 0xbe, 0x65, 0x35, 0xa7, 0x6a, 0x4e, 0x2c, 0xbf, 0x21, 0x23, 0xe8, 0x2f, 0x97, 0xc7, 0x3e, 0xc8, 0x17, 0xac, 0x1e}} ,
{{0x7b, 0xef, 0x21, 0xe5, 0x40, 0xcc, 0x1e, 0xdc, 0xd6, 0xbd, 0x97, 0x7a, 0x7c, 0x75, 0x86, 0x7a, 0x25, 0x5a, 0x6e, 0x7c, 0xe5, 0x51, 0x3c, 0x1b, 0x5b, 0x82, 0x9a, 0x07, 0x60, 0xa1, 0x19, 0x04}}},
{{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
{{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
{{{0x96, 0x88, 0xa6, 0xab, 0x8f, 0xe3, 0x3a, 0x49, 0xf8, 0xfe, 0x34, 0xe7, 0x6a, 0xb2, 0xfe, 0x40, 0x26, 0x74, 0x57, 0x4c, 0xf6, 0xd4, 0x99, 0xce, 0x5d, 0x7b, 0x2f, 0x67, 0xd6, 0x5a, 0xe4, 0x4e}} ,
{{0x5c, 0x82, 0xb3, 0xbd, 0x55, 0x25, 0xf6, 0x6a, 0x93, 0xa4, 0x02, 0xc6, 0x7d, 0x5c, 0xb1, 0x2b, 0x5b, 0xff, 0xfb, 0x56, 0xf8, 0x01, 0x41, 0x90, 0xc6, 0xb6, 0xac, 0x4f, 0xfe, 0xa7, 0x41, 0x70}}},
{{{0xdb, 0xfa, 0x9b, 0x2c, 0xd4, 0x23, 0x67, 0x2c, 0x8a, 0x63, 0x6c, 0x07, 0x26, 0x48, 0x4f, 0xc2, 0x03, 0xd2, 0x53, 0x20, 0x28, 0xed, 0x65, 0x71, 0x47, 0xa9, 0x16, 0x16, 0x12, 0xbc, 0x28, 0x33}} ,
{{0x39, 0xc0, 0xfa, 0xfa, 0xcd, 0x33, 0x43, 0xc7, 0x97, 0x76, 0x9b, 0x93, 0x91, 0x72, 0xeb, 0xc5, 0x18, 0x67, 0x4c, 0x11, 0xf0, 0xf4, 0xe5, 0x73, 0xb2, 0x5c, 0x1b, 0xc2, 0x26, 0x3f, 0xbf, 0x2b}}},
{{{0x86, 0xe6, 0x8c, 0x1d, 0xdf, 0xca, 0xfc, 0xd5, 0xf8, 0x3a, 0xc3, 0x44, 0x72, 0xe6, 0x78, 0x9d, 0x2b, 0x97, 0xf8, 0x28, 0x45, 0xb4, 0x20, 0xc9, 0x2a, 0x8c, 0x67, 0xaa, 0x11, 0xc5, 0x5b, 0x2f}} ,
{{0x17, 0x0f, 0x86, 0x52, 0xd7, 0x9d, 0xc3, 0x44, 0x51, 0x76, 0x32, 0x65, 0xb4, 0x37, 0x81, 0x99, 0x46, 0x37, 0x62, 0xed, 0xcf, 0x64, 0x9d, 0x72, 0x40, 0x7a, 0x4c, 0x0b, 0x76, 0x2a, 0xfb, 0x56}}},
{{{0x33, 0xa7, 0x90, 0x7c, 0xc3, 0x6f, 0x17, 0xa5, 0xa0, 0x67, 0x72, 0x17, 0xea, 0x7e, 0x63, 0x14, 0x83, 0xde, 0xc1, 0x71, 0x2d, 0x41, 0x32, 0x7a, 0xf3, 0xd1, 0x2b, 0xd8, 0x2a, 0xa6, 0x46, 0x36}} ,
{{0xac, 0xcc, 0x6b, 0x7c, 0xf9, 0xb8, 0x8b, 0x08, 0x5c, 0xd0, 0x7d, 0x8f, 0x73, 0xea, 0x20, 0xda, 0x86, 0xca, 0x00, 0xc7, 0xad, 0x73, 0x4d, 0xe9, 0xe8, 0xa9, 0xda, 0x1f, 0x03, 0x06, 0xdd, 0x24}}},
{{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
{{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
{{{0x9c, 0xb2, 0x61, 0x0a, 0x98, 0x2a, 0xa5, 0xd7, 0xee, 0xa9, 0xac, 0x65, 0xcb, 0x0a, 0x1e, 0xe2, 0xbe, 0xdc, 0x85, 0x59, 0x0f, 0x9c, 0xa6, 0x57, 0x34, 0xa5, 0x87, 0xeb, 0x7b, 0x1e, 0x0c, 0x3c}} ,
{{0x2f, 0xbd, 0x84, 0x63, 0x0d, 0xb5, 0xa0, 0xf0, 0x4b, 0x9e, 0x93, 0xc6, 0x34, 0x9a, 0x34, 0xff, 0x73, 0x19, 0x2f, 0x6e, 0x54, 0x45, 0x2c, 0x92, 0x31, 0x76, 0x34, 0xf1, 0xb2, 0x26, 0xe8, 0x74}}},
{{{0x0a, 0x67, 0x90, 0x6d, 0x0c, 0x4c, 0xcc, 0xc0, 0xe6, 0xbd, 0xa7, 0x5e, 0x55, 0x8c, 0xcd, 0x58, 0x9b, 0x11, 0xa2, 0xbb, 0x4b, 0xb1, 0x43, 0x04, 0x3c, 0x55, 0xed, 0x23, 0xfe, 0xcd, 0xb1, 0x53}} ,
{{0x05, 0xfb, 0x75, 0xf5, 0x01, 0xaf, 0x38, 0x72, 0x58, 0xfc, 0x04, 0x29, 0x34, 0x7a, 0x67, 0xa2, 0x08, 0x50, 0x6e, 0xd0, 0x2b, 0x73, 0xd5, 0xb8, 0xe4, 0x30, 0x96, 0xad, 0x45, 0xdf, 0xa6, 0x5c}}},
{{{0x0d, 0x88, 0x1a, 0x90, 0x7e, 0xdc, 0xd8, 0xfe, 0xc1, 0x2f, 0x5d, 0x67, 0xee, 0x67, 0x2f, 0xed, 0x6f, 0x55, 0x43, 0x5f, 0x87, 0x14, 0x35, 0x42, 0xd3, 0x75, 0xae, 0xd5, 0xd3, 0x85, 0x1a, 0x76}} ,
{{0x87, 0xc8, 0xa0, 0x6e, 0xe1, 0xb0, 0xad, 0x6a, 0x4a, 0x34, 0x71, 0xed, 0x7c, 0xd6, 0x44, 0x03, 0x65, 0x4a, 0x5c, 0x5c, 0x04, 0xf5, 0x24, 0x3f, 0xb0, 0x16, 0x5e, 0x8c, 0xb2, 0xd2, 0xc5, 0x20}}},
{{{0x98, 0x83, 0xc2, 0x37, 0xa0, 0x41, 0xa8, 0x48, 0x5c, 0x5f, 0xbf, 0xc8, 0xfa, 0x24, 0xe0, 0x59, 0x2c, 0xbd, 0xf6, 0x81, 0x7e, 0x88, 0xe6, 0xca, 0x04, 0xd8, 0x5d, 0x60, 0xbb, 0x74, 0xa7, 0x0b}} ,
{{0x21, 0x13, 0x91, 0xbf, 0x77, 0x7a, 0x33, 0xbc, 0xe9, 0x07, 0x39, 0x0a, 0xdd, 0x7d, 0x06, 0x10, 0x9a, 0xee, 0x47, 0x73, 0x1b, 0x15, 0x5a, 0xfb, 0xcd, 0x4d, 0xd0, 0xd2, 0x3a, 0x01, 0xba, 0x54}}},
{{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
{{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
{{{0x48, 0xd5, 0x39, 0x4a, 0x0b, 0x20, 0x6a, 0x43, 0xa0, 0x07, 0x82, 0x5e, 0x49, 0x7c, 0xc9, 0x47, 0xf1, 0x7c, 0x37, 0xb9, 0x23, 0xef, 0x6b, 0x46, 0x45, 0x8c, 0x45, 0x76, 0xdf, 0x14, 0x6b, 0x6e}} ,
{{0x42, 0xc9, 0xca, 0x29, 0x4c, 0x76, 0x37, 0xda, 0x8a, 0x2d, 0x7c, 0x3a, 0x58, 0xf2, 0x03, 0xb4, 0xb5, 0xb9, 0x1a, 0x13, 0x2d, 0xde, 0x5f, 0x6b, 0x9d, 0xba, 0x52, 0xc9, 0x5d, 0xb3, 0xf3, 0x30}}},
{{{0x4c, 0x6f, 0xfe, 0x6b, 0x0c, 0x62, 0xd7, 0x48, 0x71, 0xef, 0xb1, 0x85, 0x79, 0xc0, 0xed, 0x24, 0xb1, 0x08, 0x93, 0x76, 0x8e, 0xf7, 0x38, 0x8e, 0xeb, 0xfe, 0x80, 0x40, 0xaf, 0x90, 0x64, 0x49}} ,
{{0x4a, 0x88, 0xda, 0xc1, 0x98, 0x44, 0x3c, 0x53, 0x4e, 0xdb, 0x4b, 0xb9, 0x12, 0x5f, 0xcd, 0x08, 0x04, 0xef, 0x75, 0xe7, 0xb1, 0x3a, 0xe5, 0x07, 0xfa, 0xca, 0x65, 0x7b, 0x72, 0x10, 0x64, 0x7f}}},
{{{0x3d, 0x81, 0xf0, 0xeb, 0x16, 0xfd, 0x58, 0x33, 0x8d, 0x7c, 0x1a, 0xfb, 0x20, 0x2c, 0x8a, 0xee, 0x90, 0xbb, 0x33, 0x6d, 0x45, 0xe9, 0x8e, 0x99, 0x85, 0xe1, 0x08, 0x1f, 0xc5, 0xf1, 0xb5, 0x46}} ,
{{0xe4, 0xe7, 0x43, 0x4b, 0xa0, 0x3f, 0x2b, 0x06, 0xba, 0x17, 0xae, 0x3d, 0xe6, 0xce, 0xbd, 0xb8, 0xed, 0x74, 0x11, 0x35, 0xec, 0x96, 0xfe, 0x31, 0xe3, 0x0e, 0x7a, 0x4e, 0xc9, 0x1d, 0xcb, 0x20}}},
{{{0xe0, 0x67, 0xe9, 0x7b, 0xdb, 0x96, 0x5c, 0xb0, 0x32, 0xd0, 0x59, 0x31, 0x90, 0xdc, 0x92, 0x97, 0xac, 0x09, 0x38, 0x31, 0x0f, 0x7e, 0xd6, 0x5d, 0xd0, 0x06, 0xb6, 0x1f, 0xea, 0xf0, 0x5b, 0x07}} ,
{{0x81, 0x9f, 0xc7, 0xde, 0x6b, 0x41, 0x22, 0x35, 0x14, 0x67, 0x77, 0x3e, 0x90, 0x81, 0xb0, 0xd9, 0x85, 0x4c, 0xca, 0x9b, 0x3f, 0x04, 0x59, 0xd6, 0xaa, 0x17, 0xc3, 0x88, 0x34, 0x37, 0xba, 0x43}}},
{{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
{{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
{{{0x4c, 0xb6, 0x69, 0xc8, 0x81, 0x95, 0x94, 0x33, 0x92, 0x34, 0xe9, 0x3c, 0x84, 0x0d, 0x3d, 0x5a, 0x37, 0x9c, 0x22, 0xa0, 0xaa, 0x65, 0xce, 0xb4, 0xc2, 0x2d, 0x66, 0x67, 0x02, 0xff, 0x74, 0x10}} ,
{{0x22, 0xb0, 0xd5, 0xe6, 0xc7, 0xef, 0xb1, 0xa7, 0x13, 0xda, 0x60, 0xb4, 0x80, 0xc1, 0x42, 0x7d, 0x10, 0x70, 0x97, 0x04, 0x4d, 0xda, 0x23, 0x89, 0xc2, 0x0e, 0x68, 0xcb, 0xde, 0xe0, 0x9b, 0x29}}},
{{{0x33, 0xfe, 0x42, 0x2a, 0x36, 0x2b, 0x2e, 0x36, 0x64, 0x5c, 0x8b, 0xcc, 0x81, 0x6a, 0x15, 0x08, 0xa1, 0x27, 0xe8, 0x57, 0xe5, 0x78, 0x8e, 0xf2, 0x58, 0x19, 0x12, 0x42, 0xae, 0xc4, 0x63, 0x3e}} ,
{{0x78, 0x96, 0x9c, 0xa7, 0xca, 0x80, 0xae, 0x02, 0x85, 0xb1, 0x7c, 0x04, 0x5c, 0xc1, 0x5b, 0x26, 0xc1, 0xba, 0xed, 0xa5, 0x59, 0x70, 0x85, 0x8c, 0x8c, 0xe8, 0x87, 0xac, 0x6a, 0x28, 0x99, 0x35}}},
{{{0x9f, 0x04, 0x08, 0x28, 0xbe, 0x87, 0xda, 0x80, 0x28, 0x38, 0xde, 0x9f, 0xcd, 0xe4, 0xe3, 0x62, 0xfb, 0x2e, 0x46, 0x8d, 0x01, 0xb3, 0x06, 0x51, 0xd4, 0x19, 0x3b, 0x11, 0xfa, 0xe2, 0xad, 0x1e}} ,
{{0xa0, 0x20, 0x99, 0x69, 0x0a, 0xae, 0xa3, 0x70, 0x4e, 0x64, 0x80, 0xb7, 0x85, 0x9c, 0x87, 0x54, 0x43, 0x43, 0x55, 0x80, 0x6d, 0x8d, 0x7c, 0xa9, 0x64, 0xca, 0x6c, 0x2e, 0x21, 0xd8, 0xc8, 0x6c}}},
{{{0x91, 0x4a, 0x07, 0xad, 0x08, 0x75, 0xc1, 0x4f, 0xa4, 0xb2, 0xc3, 0x6f, 0x46, 0x3e, 0xb1, 0xce, 0x52, 0xab, 0x67, 0x09, 0x54, 0x48, 0x6b, 0x6c, 0xd7, 0x1d, 0x71, 0x76, 0xcb, 0xff, 0xdd, 0x31}} ,
{{0x36, 0x88, 0xfa, 0xfd, 0xf0, 0x36, 0x6f, 0x07, 0x74, 0x88, 0x50, 0xd0, 0x95, 0x38, 0x4a, 0x48, 0x2e, 0x07, 0x64, 0x97, 0x11, 0x76, 0x01, 0x1a, 0x27, 0x4d, 0x8e, 0x25, 0x9a, 0x9b, 0x1c, 0x22}}},
{{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
{{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
{{{0xbe, 0x57, 0xbd, 0x0e, 0x0f, 0xac, 0x5e, 0x76, 0xa3, 0x71, 0xad, 0x2b, 0x10, 0x45, 0x02, 0xec, 0x59, 0xd5, 0x5d, 0xa9, 0x44, 0xcc, 0x25, 0x4c, 0xb3, 0x3c, 0x5b, 0x69, 0x07, 0x55, 0x26, 0x6b}} ,
{{0x30, 0x6b, 0xd4, 0xa7, 0x51, 0x29, 0xe3, 0xf9, 0x7a, 0x75, 0x2a, 0x82, 0x2f, 0xd6, 0x1d, 0x99, 0x2b, 0x80, 0xd5, 0x67, 0x1e, 0x15, 0x9d, 0xca, 0xfd, 0xeb, 0xac, 0x97, 0x35, 0x09, 0x7f, 0x3f}}},
{{{0x35, 0x0d, 0x34, 0x0a, 0xb8, 0x67, 0x56, 0x29, 0x20, 0xf3, 0x19, 0x5f, 0xe2, 0x83, 0x42, 0x73, 0x53, 0xa8, 0xc5, 0x02, 0x19, 0x33, 0xb4, 0x64, 0xbd, 0xc3, 0x87, 0x8c, 0xd7, 0x76, 0xed, 0x25}} ,
{{0x47, 0x39, 0x37, 0x76, 0x0d, 0x1d, 0x0c, 0xf5, 0x5a, 0x6d, 0x43, 0x88, 0x99, 0x15, 0xb4, 0x52, 0x0f, 0x2a, 0xb3, 0xb0, 0x3f, 0xa6, 0xb3, 0x26, 0xb3, 0xc7, 0x45, 0xf5, 0x92, 0x5f, 0x9b, 0x17}}},
{{{0x9d, 0x23, 0xbd, 0x15, 0xfe, 0x52, 0x52, 0x15, 0x26, 0x79, 0x86, 0xba, 0x06, 0x56, 0x66, 0xbb, 0x8c, 0x2e, 0x10, 0x11, 0xd5, 0x4a, 0x18, 0x52, 0xda, 0x84, 0x44, 0xf0, 0x3e, 0xe9, 0x8c, 0x35}} ,
{{0xad, 0xa0, 0x41, 0xec, 0xc8, 0x4d, 0xb9, 0xd2, 0x6e, 0x96, 0x4e, 0x5b, 0xc5, 0xc2, 0xa0, 0x1b, 0xcf, 0x0c, 0xbf, 0x17, 0x66, 0x57, 0xc1, 0x17, 0x90, 0x45, 0x71, 0xc2, 0xe1, 0x24, 0xeb, 0x27}}},
{{{0x2c, 0xb9, 0x42, 0xa4, 0xaf, 0x3b, 0x42, 0x0e, 0xc2, 0x0f, 0xf2, 0xea, 0x83, 0xaf, 0x9a, 0x13, 0x17, 0xb0, 0xbd, 0x89, 0x17, 0xe3, 0x72, 0xcb, 0x0e, 0x76, 0x7e, 0x41, 0x63, 0x04, 0x88, 0x71}} ,
{{0x75, 0x78, 0x38, 0x86, 0x57, 0xdd, 0x9f, 0xee, 0x54, 0x70, 0x65, 0xbf, 0xf1, 0x2c, 0xe0, 0x39, 0x0d, 0xe3, 0x89, 0xfd, 0x8e, 0x93, 0x4f, 0x43, 0xdc, 0xd5, 0x5b, 0xde, 0xf9, 0x98, 0xe5, 0x7b}}},
{{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
{{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
{{{0xe7, 0x3b, 0x65, 0x11, 0xdf, 0xb2, 0xf2, 0x63, 0x94, 0x12, 0x6f, 0x5c, 0x9e, 0x77, 0xc1, 0xb6, 0xd8, 0xab, 0x58, 0x7a, 0x1d, 0x95, 0x73, 0xdd, 0xe7, 0xe3, 0x6f, 0xf2, 0x03, 0x1d, 0xdb, 0x76}} ,
{{0xae, 0x06, 0x4e, 0x2c, 0x52, 0x1b, 0xbc, 0x5a, 0x5a, 0xa5, 0xbe, 0x27, 0xbd, 0xeb, 0xe1, 0x14, 0x17, 0x68, 0x26, 0x07, 0x03, 0xd1, 0x18, 0x0b, 0xdf, 0xf1, 0x06, 0x5c, 0xa6, 0x1b, 0xb9, 0x24}}},
{{{0xc5, 0x66, 0x80, 0x13, 0x0e, 0x48, 0x8c, 0x87, 0x31, 0x84, 0xb4, 0x60, 0xed, 0xc5, 0xec, 0xb6, 0xc5, 0x05, 0x33, 0x5f, 0x2f, 0x7d, 0x40, 0xb6, 0x32, 0x1d, 0x38, 0x74, 0x1b, 0xf1, 0x09, 0x3d}} ,
{{0xd4, 0x69, 0x82, 0xbc, 0x8d, 0xf8, 0x34, 0x36, 0x75, 0x55, 0x18, 0x55, 0x58, 0x3c, 0x79, 0xaf, 0x26, 0x80, 0xab, 0x9b, 0x95, 0x00, 0xf1, 0xcb, 0xda, 0xc1, 0x9f, 0xf6, 0x2f, 0xa2, 0xf4, 0x45}}},
{{{0x17, 0xbe, 0xeb, 0x85, 0xed, 0x9e, 0xcd, 0x56, 0xf5, 0x17, 0x45, 0x42, 0xb4, 0x1f, 0x44, 0x4c, 0x05, 0x74, 0x15, 0x47, 0x00, 0xc6, 0x6a, 0x3d, 0x24, 0x09, 0x0d, 0x58, 0xb1, 0x42, 0xd7, 0x04}} ,
{{0x8d, 0xbd, 0xa3, 0xc4, 0x06, 0x9b, 0x1f, 0x90, 0x58, 0x60, 0x74, 0xb2, 0x00, 0x3b, 0x3c, 0xd2, 0xda, 0x82, 0xbb, 0x10, 0x90, 0x69, 0x92, 0xa9, 0xb4, 0x30, 0x81, 0xe3, 0x7c, 0xa8, 0x89, 0x45}}},
{{{0x3f, 0xdc, 0x05, 0xcb, 0x41, 0x3c, 0xc8, 0x23, 0x04, 0x2c, 0x38, 0x99, 0xe3, 0x68, 0x55, 0xf9, 0xd3, 0x32, 0xc7, 0xbf, 0xfa, 0xd4, 0x1b, 0x5d, 0xde, 0xdc, 0x10, 0x42, 0xc0, 0x42, 0xd9, 0x75}} ,
{{0x2d, 0xab, 0x35, 0x4e, 0x87, 0xc4, 0x65, 0x97, 0x67, 0x24, 0xa4, 0x47, 0xad, 0x3f, 0x8e, 0xf3, 0xcb, 0x31, 0x17, 0x77, 0xc5, 0xe2, 0xd7, 0x8f, 0x3c, 0xc1, 0xcd, 0x56, 0x48, 0xc1, 0x6c, 0x69}}},
{{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
{{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
{{{0x14, 0xae, 0x5f, 0x88, 0x7b, 0xa5, 0x90, 0xdf, 0x10, 0xb2, 0x8b, 0x5e, 0x24, 0x17, 0xc3, 0xa3, 0xd4, 0x0f, 0x92, 0x61, 0x1a, 0x19, 0x5a, 0xad, 0x76, 0xbd, 0xd8, 0x1c, 0xdd, 0xe0, 0x12, 0x6d}} ,
{{0x8e, 0xbd, 0x70, 0x8f, 0x02, 0xa3, 0x24, 0x4d, 0x5a, 0x67, 0xc4, 0xda, 0xf7, 0x20, 0x0f, 0x81, 0x5b, 0x7a, 0x05, 0x24, 0x67, 0x83, 0x0b, 0x2a, 0x80, 0xe7, 0xfd, 0x74, 0x4b, 0x9e, 0x5c, 0x0d}}},
{{{0x94, 0xd5, 0x5f, 0x1f, 0xa2, 0xfb, 0xeb, 0xe1, 0x07, 0x34, 0xf8, 0x20, 0xad, 0x81, 0x30, 0x06, 0x2d, 0xa1, 0x81, 0x95, 0x36, 0xcf, 0x11, 0x0b, 0xaf, 0xc1, 0x2b, 0x9a, 0x6c, 0x55, 0xc1, 0x16}} ,
{{0x36, 0x4f, 0xf1, 0x5e, 0x74, 0x35, 0x13, 0x28, 0xd7, 0x11, 0xcf, 0xb8, 0xde, 0x93, 0xb3, 0x05, 0xb8, 0xb5, 0x73, 0xe9, 0xeb, 0xad, 0x19, 0x1e, 0x89, 0x0f, 0x8b, 0x15, 0xd5, 0x8c, 0xe3, 0x23}}},
{{{0x33, 0x79, 0xe7, 0x18, 0xe6, 0x0f, 0x57, 0x93, 0x15, 0xa0, 0xa7, 0xaa, 0xc4, 0xbf, 0x4f, 0x30, 0x74, 0x95, 0x5e, 0x69, 0x4a, 0x5b, 0x45, 0xe4, 0x00, 0xeb, 0x23, 0x74, 0x4c, 0xdf, 0x6b, 0x45}} ,
{{0x97, 0x29, 0x6c, 0xc4, 0x42, 0x0b, 0xdd, 0xc0, 0x29, 0x5c, 0x9b, 0x34, 0x97, 0xd0, 0xc7, 0x79, 0x80, 0x63, 0x74, 0xe4, 0x8e, 0x37, 0xb0, 0x2b, 0x7c, 0xe8, 0x68, 0x6c, 0xc3, 0x82, 0x97, 0x57}}},
{{{0x22, 0xbe, 0x83, 0xb6, 0x4b, 0x80, 0x6b, 0x43, 0x24, 0x5e, 0xef, 0x99, 0x9b, 0xa8, 0xfc, 0x25, 0x8d, 0x3b, 0x03, 0x94, 0x2b, 0x3e, 0xe7, 0x95, 0x76, 0x9b, 0xcc, 0x15, 0xdb, 0x32, 0xe6, 0x66}} ,
{{0x84, 0xf0, 0x4a, 0x13, 0xa6, 0xd6, 0xfa, 0x93, 0x46, 0x07, 0xf6, 0x7e, 0x5c, 0x6d, 0x5e, 0xf6, 0xa6, 0xe7, 0x48, 0xf0, 0x06, 0xea, 0xff, 0x90, 0xc1, 0xcc, 0x4c, 0x19, 0x9c, 0x3c, 0x4e, 0x53}}},
{{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
{{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
{{{0x2a, 0x50, 0xe3, 0x07, 0x15, 0x59, 0xf2, 0x8b, 0x81, 0xf2, 0xf3, 0xd3, 0x6c, 0x99, 0x8c, 0x70, 0x67, 0xec, 0xcc, 0xee, 0x9e, 0x59, 0x45, 0x59, 0x7d, 0x47, 0x75, 0x69, 0xf5, 0x24, 0x93, 0x5d}} ,
{{0x6a, 0x4f, 0x1b, 0xbe, 0x6b, 0x30, 0xcf, 0x75, 0x46, 0xe3, 0x7b, 0x9d, 0xfc, 0xcd, 0xd8, 0x5c, 0x1f, 0xb4, 0xc8, 0xe2, 0x24, 0xec, 0x1a, 0x28, 0x05, 0x32, 0x57, 0xfd, 0x3c, 0x5a, 0x98, 0x10}}},
{{{0xa3, 0xdb, 0xf7, 0x30, 0xd8, 0xc2, 0x9a, 0xe1, 0xd3, 0xce, 0x22, 0xe5, 0x80, 0x1e, 0xd9, 0xe4, 0x1f, 0xab, 0xc0, 0x71, 0x1a, 0x86, 0x0e, 0x27, 0x99, 0x5b, 0xfa, 0x76, 0x99, 0xb0, 0x08, 0x3c}} ,
{{0x2a, 0x93, 0xd2, 0x85, 0x1b, 0x6a, 0x5d, 0xa6, 0xee, 0xd1, 0xd1, 0x33, 0xbd, 0x6a, 0x36, 0x73, 0x37, 0x3a, 0x44, 0xb4, 0xec, 0xa9, 0x7a, 0xde, 0x83, 0x40, 0xd7, 0xdf, 0x28, 0xba, 0xa2, 0x30}}},
{{{0xd3, 0xb5, 0x6d, 0x05, 0x3f, 0x9f, 0xf3, 0x15, 0x8d, 0x7c, 0xca, 0xc9, 0xfc, 0x8a, 0x7c, 0x94, 0xb0, 0x63, 0x36, 0x9b, 0x78, 0xd1, 0x91, 0x1f, 0x93, 0xd8, 0x57, 0x43, 0xde, 0x76, 0xa3, 0x43}} ,
{{0x9b, 0x35, 0xe2, 0xa9, 0x3d, 0x32, 0x1e, 0xbb, 0x16, 0x28, 0x70, 0xe9, 0x45, 0x2f, 0x8f, 0x70, 0x7f, 0x08, 0x7e, 0x53, 0xc4, 0x7a, 0xbf, 0xf7, 0xe1, 0xa4, 0x6a, 0xd8, 0xac, 0x64, 0x1b, 0x11}}},
{{{0xb2, 0xeb, 0x47, 0x46, 0x18, 0x3e, 0x1f, 0x99, 0x0c, 0xcc, 0xf1, 0x2c, 0xe0, 0xe7, 0x8f, 0xe0, 0x01, 0x7e, 0x65, 0xb8, 0x0c, 0xd0, 0xfb, 0xc8, 0xb9, 0x90, 0x98, 0x33, 0x61, 0x3b, 0xd8, 0x27}} ,
{{0xa0, 0xbe, 0x72, 0x3a, 0x50, 0x4b, 0x74, 0xab, 0x01, 0xc8, 0x93, 0xc5, 0xe4, 0xc7, 0x08, 0x6c, 0xb4, 0xca, 0xee, 0xeb, 0x8e, 0xd7, 0x4e, 0x26, 0xc6, 0x1d, 0xe2, 0x71, 0xaf, 0x89, 0xa0, 0x2a}}},
{{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
{{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
{{{0x98, 0x0b, 0xe4, 0xde, 0xdb, 0xa8, 0xfa, 0x82, 0x74, 0x06, 0x52, 0x6d, 0x08, 0x52, 0x8a, 0xff, 0x62, 0xc5, 0x6a, 0x44, 0x0f, 0x51, 0x8c, 0x1f, 0x6e, 0xb6, 0xc6, 0x2c, 0x81, 0xd3, 0x76, 0x46}} ,
{{0xf4, 0x29, 0x74, 0x2e, 0x80, 0xa7, 0x1a, 0x8f, 0xf6, 0xbd, 0xd6, 0x8e, 0xbf, 0xc1, 0x95, 0x2a, 0xeb, 0xa0, 0x7f, 0x45, 0xa0, 0x50, 0x14, 0x05, 0xb1, 0x57, 0x4c, 0x74, 0xb7, 0xe2, 0x89, 0x7d}}},
{{{0x07, 0xee, 0xa7, 0xad, 0xb7, 0x09, 0x0b, 0x49, 0x4e, 0xbf, 0xca, 0xe5, 0x21, 0xe6, 0xe6, 0xaf, 0xd5, 0x67, 0xf3, 0xce, 0x7e, 0x7c, 0x93, 0x7b, 0x5a, 0x10, 0x12, 0x0e, 0x6c, 0x06, 0x11, 0x75}} ,
{{0xd5, 0xfc, 0x86, 0xa3, 0x3b, 0xa3, 0x3e, 0x0a, 0xfb, 0x0b, 0xf7, 0x36, 0xb1, 0x5b, 0xda, 0x70, 0xb7, 0x00, 0xa7, 0xda, 0x88, 0x8f, 0x84, 0xa8, 0xbc, 0x1c, 0x39, 0xb8, 0x65, 0xf3, 0x4d, 0x60}}},
{{{0x96, 0x9d, 0x31, 0xf4, 0xa2, 0xbe, 0x81, 0xb9, 0xa5, 0x59, 0x9e, 0xba, 0x07, 0xbe, 0x74, 0x58, 0xd8, 0xeb, 0xc5, 0x9f, 0x3d, 0xd1, 0xf4, 0xae, 0xce, 0x53, 0xdf, 0x4f, 0xc7, 0x2a, 0x89, 0x4d}} ,
{{0x29, 0xd8, 0xf2, 0xaa, 0xe9, 0x0e, 0xf7, 0x2e, 0x5f, 0x9d, 0x8a, 0x5b, 0x09, 0xed, 0xc9, 0x24, 0x22, 0xf4, 0x0f, 0x25, 0x8f, 0x1c, 0x84, 0x6e, 0x34, 0x14, 0x6c, 0xea, 0xb3, 0x86, 0x5d, 0x04}}},
{{{0x07, 0x98, 0x61, 0xe8, 0x6a, 0xd2, 0x81, 0x49, 0x25, 0xd5, 0x5b, 0x18, 0xc7, 0x35, 0x52, 0x51, 0xa4, 0x46, 0xad, 0x18, 0x0d, 0xc9, 0x5f, 0x18, 0x91, 0x3b, 0xb4, 0xc0, 0x60, 0x59, 0x8d, 0x66}} ,
{{0x03, 0x1b, 0x79, 0x53, 0x6e, 0x24, 0xae, 0x57, 0xd9, 0x58, 0x09, 0x85, 0x48, 0xa2, 0xd3, 0xb5, 0xe2, 0x4d, 0x11, 0x82, 0xe6, 0x86, 0x3c, 0xe9, 0xb1, 0x00, 0x19, 0xc2, 0x57, 0xf7, 0x66, 0x7a}}},
{{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
{{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
{{{0x0f, 0xe3, 0x89, 0x03, 0xd7, 0x22, 0x95, 0x9f, 0xca, 0xb4, 0x8d, 0x9e, 0x6d, 0x97, 0xff, 0x8d, 0x21, 0x59, 0x07, 0xef, 0x03, 0x2d, 0x5e, 0xf8, 0x44, 0x46, 0xe7, 0x85, 0x80, 0xc5, 0x89, 0x50}} ,
{{0x8b, 0xd8, 0x53, 0x86, 0x24, 0x86, 0x29, 0x52, 0x01, 0xfa, 0x20, 0xc3, 0x4e, 0x95, 0xcb, 0xad, 0x7b, 0x34, 0x94, 0x30, 0xb7, 0x7a, 0xfa, 0x96, 0x41, 0x60, 0x2b, 0xcb, 0x59, 0xb9, 0xca, 0x50}}},
{{{0xc2, 0x5b, 0x9b, 0x78, 0x23, 0x1b, 0x3a, 0x88, 0x94, 0x5f, 0x0a, 0x9b, 0x98, 0x2b, 0x6e, 0x53, 0x11, 0xf6, 0xff, 0xc6, 0x7d, 0x42, 0xcc, 0x02, 0x80, 0x40, 0x0d, 0x1e, 0xfb, 0xaf, 0x61, 0x07}} ,
{{0xb0, 0xe6, 0x2f, 0x81, 0x70, 0xa1, 0x2e, 0x39, 0x04, 0x7c, 0xc4, 0x2c, 0x87, 0x45, 0x4a, 0x5b, 0x69, 0x97, 0xac, 0x6d, 0x2c, 0x10, 0x42, 0x7c, 0x3b, 0x15, 0x70, 0x60, 0x0e, 0x11, 0x6d, 0x3a}}},
{{{0x9b, 0x18, 0x80, 0x5e, 0xdb, 0x05, 0xbd, 0xc6, 0xb7, 0x3c, 0xc2, 0x40, 0x4d, 0x5d, 0xce, 0x97, 0x8a, 0x34, 0x15, 0xab, 0x28, 0x5d, 0x10, 0xf0, 0x37, 0x0c, 0xcc, 0x16, 0xfa, 0x1f, 0x33, 0x0d}} ,
{{0x19, 0xf9, 0x35, 0xaa, 0x59, 0x1a, 0x0c, 0x5c, 0x06, 0xfc, 0x6a, 0x0b, 0x97, 0x53, 0x36, 0xfc, 0x2a, 0xa5, 0x5a, 0x9b, 0x30, 0xef, 0x23, 0xaf, 0x39, 0x5d, 0x9a, 0x6b, 0x75, 0x57, 0x48, 0x0b}}},
{{{0x26, 0xdc, 0x76, 0x3b, 0xfc, 0xf9, 0x9c, 0x3f, 0x89, 0x0b, 0x62, 0x53, 0xaf, 0x83, 0x01, 0x2e, 0xbc, 0x6a, 0xc6, 0x03, 0x0d, 0x75, 0x2a, 0x0d, 0xe6, 0x94, 0x54, 0xcf, 0xb3, 0xe5, 0x96, 0x25}} ,
{{0xfe, 0x82, 0xb1, 0x74, 0x31, 0x8a, 0xa7, 0x6f, 0x56, 0xbd, 0x8d, 0xf4, 0xe0, 0x94, 0x51, 0x59, 0xde, 0x2c, 0x5a, 0xf4, 0x84, 0x6b, 0x4a, 0x88, 0x93, 0xc0, 0x0c, 0x9a, 0xac, 0xa7, 0xa0, 0x68}}},
{{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
{{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
{{{0x25, 0x0d, 0xd6, 0xc7, 0x23, 0x47, 0x10, 0xad, 0xc7, 0x08, 0x5c, 0x87, 0x87, 0x93, 0x98, 0x18, 0xb8, 0xd3, 0x9c, 0xac, 0x5a, 0x3d, 0xc5, 0x75, 0xf8, 0x49, 0x32, 0x14, 0xcc, 0x51, 0x96, 0x24}} ,
{{0x65, 0x9c, 0x5d, 0xf0, 0x37, 0x04, 0xf0, 0x34, 0x69, 0x2a, 0xf0, 0xa5, 0x64, 0xca, 0xde, 0x2b, 0x5b, 0x15, 0x10, 0xd2, 0xab, 0x06, 0xdd, 0xc4, 0xb0, 0xb6, 0x5b, 0xc1, 0x17, 0xdf, 0x8f, 0x02}}},
{{{0xbd, 0x59, 0x3d, 0xbf, 0x5c, 0x31, 0x44, 0x2c, 0x32, 0x94, 0x04, 0x60, 0x84, 0x0f, 0xad, 0x00, 0xb6, 0x8f, 0xc9, 0x1d, 0xcc, 0x5c, 0xa2, 0x49, 0x0e, 0x50, 0x91, 0x08, 0x9a, 0x43, 0x55, 0x05}} ,
{{0x5d, 0x93, 0x55, 0xdf, 0x9b, 0x12, 0x19, 0xec, 0x93, 0x85, 0x42, 0x9e, 0x66, 0x0f, 0x9d, 0xaf, 0x99, 0xaf, 0x26, 0x89, 0xbc, 0x61, 0xfd, 0xff, 0xce, 0x4b, 0xf4, 0x33, 0x95, 0xc9, 0x35, 0x58}}},
{{{0x12, 0x55, 0xf9, 0xda, 0xcb, 0x44, 0xa7, 0xdc, 0x57, 0xe2, 0xf9, 0x9a, 0xe6, 0x07, 0x23, 0x60, 0x54, 0xa7, 0x39, 0xa5, 0x9b, 0x84, 0x56, 0x6e, 0xaa, 0x8b, 0x8f, 0xb0, 0x2c, 0x87, 0xaf, 0x67}} ,
{{0x00, 0xa9, 0x4c, 0xb2, 0x12, 0xf8, 0x32, 0xa8, 0x7a, 0x00, 0x4b, 0x49, 0x32, 0xba, 0x1f, 0x5d, 0x44, 0x8e, 0x44, 0x7a, 0xdc, 0x11, 0xfb, 0x39, 0x08, 0x57, 0x87, 0xa5, 0x12, 0x42, 0x93, 0x0e}}},
{{{0x17, 0xb4, 0xae, 0x72, 0x59, 0xd0, 0xaa, 0xa8, 0x16, 0x8b, 0x63, 0x11, 0xb3, 0x43, 0x04, 0xda, 0x0c, 0xa8, 0xb7, 0x68, 0xdd, 0x4e, 0x54, 0xe7, 0xaf, 0x5d, 0x5d, 0x05, 0x76, 0x36, 0xec, 0x0d}} ,
{{0x6d, 0x7c, 0x82, 0x32, 0x38, 0x55, 0x57, 0x74, 0x5b, 0x7d, 0xc3, 0xc4, 0xfb, 0x06, 0x29, 0xf0, 0x13, 0x55, 0x54, 0xc6, 0xa7, 0xdc, 0x4c, 0x9f, 0x98, 0x49, 0x20, 0xa8, 0xc3, 0x8d, 0xfa, 0x48}}},
{{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
{{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
{{{0x87, 0x47, 0x9d, 0xe9, 0x25, 0xd5, 0xe3, 0x47, 0x78, 0xdf, 0x85, 0xa7, 0x85, 0x5e, 0x7a, 0x4c, 0x5f, 0x79, 0x1a, 0xf3, 0xa2, 0xb2, 0x28, 0xa0, 0x9c, 0xdd, 0x30, 0x40, 0xd4, 0x38, 0xbd, 0x28}} ,
{{0xfc, 0xbb, 0xd5, 0x78, 0x6d, 0x1d, 0xd4, 0x99, 0xb4, 0xaa, 0x44, 0x44, 0x7a, 0x1b, 0xd8, 0xfe, 0xb4, 0x99, 0xb9, 0xcc, 0xe7, 0xc4, 0xd3, 0x3a, 0x73, 0x83, 0x41, 0x5c, 0x40, 0xd7, 0x2d, 0x55}}},
{{{0x26, 0xe1, 0x7b, 0x5f, 0xe5, 0xdc, 0x3f, 0x7d, 0xa1, 0xa7, 0x26, 0x44, 0x22, 0x23, 0xc0, 0x8f, 0x7d, 0xf1, 0xb5, 0x11, 0x47, 0x7b, 0x19, 0xd4, 0x75, 0x6f, 0x1e, 0xa5, 0x27, 0xfe, 0xc8, 0x0e}} ,
{{0xd3, 0x11, 0x3d, 0xab, 0xef, 0x2c, 0xed, 0xb1, 0x3d, 0x7c, 0x32, 0x81, 0x6b, 0xfe, 0xf8, 0x1c, 0x3c, 0x7b, 0xc0, 0x61, 0xdf, 0xb8, 0x75, 0x76, 0x7f, 0xaa, 0xd8, 0x93, 0xaf, 0x3d, 0xe8, 0x3d}}},
{{{0xfd, 0x5b, 0x4e, 0x8d, 0xb6, 0x7e, 0x82, 0x9b, 0xef, 0xce, 0x04, 0x69, 0x51, 0x52, 0xff, 0xef, 0xa0, 0x52, 0xb5, 0x79, 0x17, 0x5e, 0x2f, 0xde, 0xd6, 0x3c, 0x2d, 0xa0, 0x43, 0xb4, 0x0b, 0x19}} ,
{{0xc0, 0x61, 0x48, 0x48, 0x17, 0xf4, 0x9e, 0x18, 0x51, 0x2d, 0xea, 0x2f, 0xf2, 0xf2, 0xe0, 0xa3, 0x14, 0xb7, 0x8b, 0x3a, 0x30, 0xf5, 0x81, 0xc1, 0x5d, 0x71, 0x39, 0x62, 0x55, 0x1f, 0x60, 0x5a}}},
{{{0xe5, 0x89, 0x8a, 0x76, 0x6c, 0xdb, 0x4d, 0x0a, 0x5b, 0x72, 0x9d, 0x59, 0x6e, 0x63, 0x63, 0x18, 0x7c, 0xe3, 0xfa, 0xe2, 0xdb, 0xa1, 0x8d, 0xf4, 0xa5, 0xd7, 0x16, 0xb2, 0xd0, 0xb3, 0x3f, 0x39}} ,
{{0xce, 0x60, 0x09, 0x6c, 0xf5, 0x76, 0x17, 0x24, 0x80, 0x3a, 0x96, 0xc7, 0x94, 0x2e, 0xf7, 0x6b, 0xef, 0xb5, 0x05, 0x96, 0xef, 0xd3, 0x7b, 0x51, 0xda, 0x05, 0x44, 0x67, 0xbc, 0x07, 0x21, 0x4e}}},
{{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
{{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
{{{0xe9, 0x73, 0x6f, 0x21, 0xb9, 0xde, 0x22, 0x7d, 0xeb, 0x97, 0x31, 0x10, 0xa3, 0xea, 0xe1, 0xc6, 0x37, 0xeb, 0x8f, 0x43, 0x58, 0xde, 0x41, 0x64, 0x0e, 0x3e, 0x07, 0x99, 0x3d, 0xf1, 0xdf, 0x1e}} ,
{{0xf8, 0xad, 0x43, 0xc2, 0x17, 0x06, 0xe2, 0xe4, 0xa9, 0x86, 0xcd, 0x18, 0xd7, 0x78, 0xc8, 0x74, 0x66, 0xd2, 0x09, 0x18, 0xa5, 0xf1, 0xca, 0xa6, 0x62, 0x92, 0xc1, 0xcb, 0x00, 0xeb, 0x42, 0x2e}}},
{{{0x7b, 0x34, 0x24, 0x4c, 0xcf, 0x38, 0xe5, 0x6c, 0x0a, 0x01, 0x2c, 0x22, 0x0b, 0x24, 0x38, 0xad, 0x24, 0x7e, 0x19, 0xf0, 0x6c, 0xf9, 0x31, 0xf4, 0x35, 0x11, 0xf6, 0x46, 0x33, 0x3a, 0x23, 0x59}} ,
{{0x20, 0x0b, 0xa1, 0x08, 0x19, 0xad, 0x39, 0x54, 0xea, 0x3e, 0x23, 0x09, 0xb6, 0xe2, 0xd2, 0xbc, 0x4d, 0xfc, 0x9c, 0xf0, 0x13, 0x16, 0x22, 0x3f, 0xb9, 0xd2, 0x11, 0x86, 0x90, 0x55, 0xce, 0x3c}}},
{{{0xc4, 0x0b, 0x4b, 0x62, 0x99, 0x37, 0x84, 0x3f, 0x74, 0xa2, 0xf9, 0xce, 0xe2, 0x0b, 0x0f, 0x2a, 0x3d, 0xa3, 0xe3, 0xdb, 0x5a, 0x9d, 0x93, 0xcc, 0xa5, 0xef, 0x82, 0x91, 0x1d, 0xe6, 0x6c, 0x68}} ,
{{0xa3, 0x64, 0x17, 0x9b, 0x8b, 0xc8, 0x3a, 0x61, 0xe6, 0x9d, 0xc6, 0xed, 0x7b, 0x03, 0x52, 0x26, 0x9d, 0x3a, 0xb3, 0x13, 0xcc, 0x8a, 0xfd, 0x2c, 0x1a, 0x1d, 0xed, 0x13, 0xd0, 0x55, 0x57, 0x0e}}},
{{{0x1a, 0xea, 0xbf, 0xfd, 0x4a, 0x3c, 0x8e, 0xec, 0x29, 0x7e, 0x77, 0x77, 0x12, 0x99, 0xd7, 0x84, 0xf9, 0x55, 0x7f, 0xf1, 0x8b, 0xb4, 0xd2, 0x95, 0xa3, 0x8d, 0xf0, 0x8a, 0xa7, 0xeb, 0x82, 0x4b}} ,
{{0x2c, 0x28, 0xf4, 0x3a, 0xf6, 0xde, 0x0a, 0xe0, 0x41, 0x44, 0x23, 0xf8, 0x3f, 0x03, 0x64, 0x9f, 0xc3, 0x55, 0x4c, 0xc6, 0xc1, 0x94, 0x1c, 0x24, 0x5d, 0x5f, 0x92, 0x45, 0x96, 0x57, 0x37, 0x14}}},
{{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
{{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
{{{0xc1, 0xcd, 0x90, 0x66, 0xb9, 0x76, 0xa0, 0x5b, 0xa5, 0x85, 0x75, 0x23, 0xf9, 0x89, 0xa5, 0x82, 0xb2, 0x6f, 0xb1, 0xeb, 0xc4, 0x69, 0x6f, 0x18, 0x5a, 0xed, 0x94, 0x3d, 0x9d, 0xd9, 0x2c, 0x1a}} ,
{{0x35, 0xb0, 0xe6, 0x73, 0x06, 0xb7, 0x37, 0xe0, 0xf8, 0xb0, 0x22, 0xe8, 0xd2, 0xed, 0x0b, 0xef, 0xe6, 0xc6, 0x5a, 0x99, 0x9e, 0x1a, 0x9f, 0x04, 0x97, 0xe4, 0x4d, 0x0b, 0xbe, 0xba, 0x44, 0x40}}},
{{{0xc1, 0x56, 0x96, 0x91, 0x5f, 0x1f, 0xbb, 0x54, 0x6f, 0x88, 0x89, 0x0a, 0xb2, 0xd6, 0x41, 0x42, 0x6a, 0x82, 0xee, 0x14, 0xaa, 0x76, 0x30, 0x65, 0x0f, 0x67, 0x39, 0xa6, 0x51, 0x7c, 0x49, 0x24}} ,
{{0x35, 0xa3, 0x78, 0xd1, 0x11, 0x0f, 0x75, 0xd3, 0x70, 0x46, 0xdb, 0x20, 0x51, 0xcb, 0x92, 0x80, 0x54, 0x10, 0x74, 0x36, 0x86, 0xa9, 0xd7, 0xa3, 0x08, 0x78, 0xf1, 0x01, 0x29, 0xf8, 0x80, 0x3b}}},
{{{0xdb, 0xa7, 0x9d, 0x9d, 0xbf, 0xa0, 0xcc, 0xed, 0x53, 0xa2, 0xa2, 0x19, 0x39, 0x48, 0x83, 0x19, 0x37, 0x58, 0xd1, 0x04, 0x28, 0x40, 0xf7, 0x8a, 0xc2, 0x08, 0xb7, 0xa5, 0x42, 0xcf, 0x53, 0x4c}} ,
{{0xa7, 0xbb, 0xf6, 0x8e, 0xad, 0xdd, 0xf7, 0x90, 0xdd, 0x5f, 0x93, 0x89, 0xae, 0x04, 0x37, 0xe6, 0x9a, 0xb7, 0xe8, 0xc0, 0xdf, 0x16, 0x2a, 0xbf, 0xc4, 0x3a, 0x3c, 0x41, 0xd5, 0x89, 0x72, 0x5a}}},
{{{0x1f, 0x96, 0xff, 0x34, 0x2c, 0x13, 0x21, 0xcb, 0x0a, 0x89, 0x85, 0xbe, 0xb3, 0x70, 0x9e, 0x1e, 0xde, 0x97, 0xaf, 0x96, 0x30, 0xf7, 0x48, 0x89, 0x40, 0x8d, 0x07, 0xf1, 0x25, 0xf0, 0x30, 0x58}} ,
{{0x1e, 0xd4, 0x93, 0x57, 0xe2, 0x17, 0xe7, 0x9d, 0xab, 0x3c, 0x55, 0x03, 0x82, 0x2f, 0x2b, 0xdb, 0x56, 0x1e, 0x30, 0x2e, 0x24, 0x47, 0x6e, 0xe6, 0xff, 0x33, 0x24, 0x2c, 0x75, 0x51, 0xd4, 0x67}}},
{{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
{{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
{{{0x2b, 0x06, 0xd9, 0xa1, 0x5d, 0xe1, 0xf4, 0xd1, 0x1e, 0x3c, 0x9a, 0xc6, 0x29, 0x2b, 0x13, 0x13, 0x78, 0xc0, 0xd8, 0x16, 0x17, 0x2d, 0x9e, 0xa9, 0xc9, 0x79, 0x57, 0xab, 0x24, 0x91, 0x92, 0x19}} ,
{{0x69, 0xfb, 0xa1, 0x9c, 0xa6, 0x75, 0x49, 0x7d, 0x60, 0x73, 0x40, 0x42, 0xc4, 0x13, 0x0a, 0x95, 0x79, 0x1e, 0x04, 0x83, 0x94, 0x99, 0x9b, 0x1e, 0x0c, 0xe8, 0x1f, 0x54, 0xef, 0xcb, 0xc0, 0x52}}},
{{{0x14, 0x89, 0x73, 0xa1, 0x37, 0x87, 0x6a, 0x7a, 0xcf, 0x1d, 0xd9, 0x2e, 0x1a, 0x67, 0xed, 0x74, 0xc0, 0xf0, 0x9c, 0x33, 0xdd, 0xdf, 0x08, 0xbf, 0x7b, 0xd1, 0x66, 0xda, 0xe6, 0xc9, 0x49, 0x08}} ,
{{0xe9, 0xdd, 0x5e, 0x55, 0xb0, 0x0a, 0xde, 0x21, 0x4c, 0x5a, 0x2e, 0xd4, 0x80, 0x3a, 0x57, 0x92, 0x7a, 0xf1, 0xc4, 0x2c, 0x40, 0xaf, 0x2f, 0xc9, 0x92, 0x03, 0xe5, 0x5a, 0xbc, 0xdc, 0xf4, 0x09}}},
{{{0xf3, 0xe1, 0x2b, 0x7c, 0x05, 0x86, 0x80, 0x93, 0x4a, 0xad, 0xb4, 0x8f, 0x7e, 0x99, 0x0c, 0xfd, 0xcd, 0xef, 0xd1, 0xff, 0x2c, 0x69, 0x34, 0x13, 0x41, 0x64, 0xcf, 0x3b, 0xd0, 0x90, 0x09, 0x1e}} ,
{{0x9d, 0x45, 0xd6, 0x80, 0xe6, 0x45, 0xaa, 0xf4, 0x15, 0xaa, 0x5c, 0x34, 0x87, 0x99, 0xa2, 0x8c, 0x26, 0x84, 0x62, 0x7d, 0xb6, 0x29, 0xc0, 0x52, 0xea, 0xf5, 0x81, 0x18, 0x0f, 0x35, 0xa9, 0x0e}}},
{{{0xe7, 0x20, 0x72, 0x7c, 0x6d, 0x94, 0x5f, 0x52, 0x44, 0x54, 0xe3, 0xf1, 0xb2, 0xb0, 0x36, 0x46, 0x0f, 0xae, 0x92, 0xe8, 0x70, 0x9d, 0x6e, 0x79, 0xb1, 0xad, 0x37, 0xa9, 0x5f, 0xc0, 0xde, 0x03}} ,
{{0x15, 0x55, 0x37, 0xc6, 0x1c, 0x27, 0x1c, 0x6d, 0x14, 0x4f, 0xca, 0xa4, 0xc4, 0x88, 0x25, 0x46, 0x39, 0xfc, 0x5a, 0xe5, 0xfe, 0x29, 0x11, 0x69, 0xf5, 0x72, 0x84, 0x4d, 0x78, 0x9f, 0x94, 0x15}}},
{{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
{{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
{{{0xec, 0xd3, 0xff, 0x57, 0x0b, 0xb0, 0xb2, 0xdc, 0xf8, 0x4f, 0xe2, 0x12, 0xd5, 0x36, 0xbe, 0x6b, 0x09, 0x43, 0x6d, 0xa3, 0x4d, 0x90, 0x2d, 0xb8, 0x74, 0xe8, 0x71, 0x45, 0x19, 0x8b, 0x0c, 0x6a}} ,
{{0xb8, 0x42, 0x1c, 0x03, 0xad, 0x2c, 0x03, 0x8e, 0xac, 0xd7, 0x98, 0x29, 0x13, 0xc6, 0x02, 0x29, 0xb5, 0xd4, 0xe7, 0xcf, 0xcc, 0x8b, 0x83, 0xec, 0x35, 0xc7, 0x9c, 0x74, 0xb7, 0xad, 0x85, 0x5f}}},
{{{0x78, 0x84, 0xe1, 0x56, 0x45, 0x69, 0x68, 0x5a, 0x4f, 0xb8, 0xb1, 0x29, 0xff, 0x33, 0x03, 0x31, 0xb7, 0xcb, 0x96, 0x25, 0xe6, 0xe6, 0x41, 0x98, 0x1a, 0xbb, 0x03, 0x56, 0xf2, 0xb2, 0x91, 0x34}} ,
{{0x2c, 0x6c, 0xf7, 0x66, 0xa4, 0x62, 0x6b, 0x39, 0xb3, 0xba, 0x65, 0xd3, 0x1c, 0xf8, 0x11, 0xaa, 0xbe, 0xdc, 0x80, 0x59, 0x87, 0xf5, 0x7b, 0xe5, 0xe3, 0xb3, 0x3e, 0x39, 0xda, 0xbe, 0x88, 0x09}}},
{{{0x8b, 0xf1, 0xa0, 0xf5, 0xdc, 0x29, 0xb4, 0xe2, 0x07, 0xc6, 0x7a, 0x00, 0xd0, 0x89, 0x17, 0x51, 0xd4, 0xbb, 0xd4, 0x22, 0xea, 0x7e, 0x7d, 0x7c, 0x24, 0xea, 0xf2, 0xe8, 0x22, 0x12, 0x95, 0x06}} ,
{{0xda, 0x7c, 0xa4, 0x0c, 0xf4, 0xba, 0x6e, 0xe1, 0x89, 0xb5, 0x59, 0xca, 0xf1, 0xc0, 0x29, 0x36, 0x09, 0x44, 0xe2, 0x7f, 0xd1, 0x63, 0x15, 0x99, 0xea, 0x25, 0xcf, 0x0c, 0x9d, 0xc0, 0x44, 0x6f}}},
{{{0x1d, 0x86, 0x4e, 0xcf, 0xf7, 0x37, 0x10, 0x25, 0x8f, 0x12, 0xfb, 0x19, 0xfb, 0xe0, 0xed, 0x10, 0xc8, 0xe2, 0xf5, 0x75, 0xb1, 0x33, 0xc0, 0x96, 0x0d, 0xfb, 0x15, 0x6c, 0x0d, 0x07, 0x5f, 0x05}} ,
{{0x69, 0x3e, 0x47, 0x97, 0x2c, 0xaf, 0x52, 0x7c, 0x78, 0x83, 0xad, 0x1b, 0x39, 0x82, 0x2f, 0x02, 0x6f, 0x47, 0xdb, 0x2a, 0xb0, 0xe1, 0x91, 0x99, 0x55, 0xb8, 0x99, 0x3a, 0xa0, 0x44, 0x11, 0x51}}}
};
__device__ static inline void p1p1_to_p2(ge25519_p2 *r, const ge25519_p1p1 *p)
{
fe25519_mul(&r->x, &p->x, &p->t);
fe25519_mul(&r->y, &p->y, &p->z);
fe25519_mul(&r->z, &p->z, &p->t);
}
__device__ static inline void p1p1_to_p2_2(ge25519_p3 *r, const ge25519_p1p1 *p)
{
fe25519_mul(&r->x, &p->x, &p->t);
fe25519_mul(&r->y, &p->y, &p->z);
fe25519_mul(&r->z, &p->z, &p->t);
}
__device__ static inline void p1p1_to_p3(ge25519_p3 *r, const ge25519_p1p1 *p)
{
p1p1_to_p2_2(r, p);
fe25519_mul(&r->t, &p->x, &p->y);
}
__device__ static inline void ge25519_mixadd2(ge25519_p3 *r, const ge25519_aff *q)
{
fe25519 a,b,t1,t2,c,d,e,f,g,h,qt;
fe25519_mul(&qt, &q->x, &q->y);
fe25519_sub(&a, &r->y, &r->x); /* A = (Y1-X1)*(Y2-X2) */
fe25519_add(&b, &r->y, &r->x); /* B = (Y1+X1)*(Y2+X2) */
fe25519_sub(&t1, &q->y, &q->x);
fe25519_add(&t2, &q->y, &q->x);
fe25519_mul(&a, &a, &t1);
fe25519_mul(&b, &b, &t2);
fe25519_sub(&e, &b, &a); /* E = B-A */
fe25519_add(&h, &b, &a); /* H = B+A */
fe25519_mul(&c, &r->t, &qt); /* C = T1*k*T2 */
fe25519_mul(&c, &c, &ge25519_ec2d);
fe25519_add(&d, &r->z, &r->z); /* D = Z1*2 */
fe25519_sub(&f, &d, &c); /* F = D-C */
fe25519_add(&g, &d, &c); /* G = D+C */
fe25519_mul(&r->x, &e, &f);
fe25519_mul(&r->y, &h, &g);
fe25519_mul(&r->z, &g, &f);
fe25519_mul(&r->t, &e, &h);
}
__device__ static inline void add_p1p1(ge25519_p1p1 *r, const ge25519_p3 *p, const ge25519_p3 *q)
{
fe25519 a, b, c, d, t;
fe25519_sub(&a, &p->y, &p->x); /* A = (Y1-X1)*(Y2-X2) */
fe25519_sub(&t, &q->y, &q->x);
fe25519_mul(&a, &a, &t);
fe25519_add(&b, &p->x, &p->y); /* B = (Y1+X1)*(Y2+X2) */
fe25519_add(&t, &q->x, &q->y);
fe25519_mul(&b, &b, &t);
fe25519_mul(&c, &p->t, &q->t); /* C = T1*k*T2 */
fe25519_mul(&c, &c, &ge25519_ec2d);
fe25519_mul(&d, &p->z, &q->z); /* D = Z1*2*Z2 */
fe25519_add(&d, &d, &d);
fe25519_sub(&r->x, &b, &a); /* E = B-A */
fe25519_sub(&r->t, &d, &c); /* F = D-C */
fe25519_add(&r->z, &d, &c); /* G = D+C */
fe25519_add(&r->y, &b, &a); /* H = B+A */
}
/* See http://www.hyperelliptic.org/EFD/g1p/auto-twisted-extended-1.html#doubling-dbl-2008-hwcd */
__device__ static inline void dbl_p1p1(ge25519_p1p1 *r, const ge25519_p2 *p)
{
fe25519 a,b,c,d;
fe25519_square(&a, &p->x);
fe25519_square(&b, &p->y);
fe25519_square(&c, &p->z);
fe25519_add(&c, &c, &c);
fe25519_neg(&d, &a);
fe25519_add(&r->x, &p->x, &p->y);
fe25519_square(&r->x, &r->x);
fe25519_sub(&r->x, &r->x, &a);
fe25519_sub(&r->x, &r->x, &b);
fe25519_add(&r->z, &d, &b);
fe25519_sub(&r->t, &r->z, &c);
fe25519_sub(&r->y, &d, &b);
}
/* Constant-time version of: if(b) r = p */
__device__ static inline void cmov_aff(ge25519_aff *r, const ge25519_aff *p, unsigned char b)
{
fe25519_cmov(&r->x, &p->x, b);
fe25519_cmov(&r->y, &p->y, b);
}
__device__ static inline unsigned char equal(signed char b,signed char c)
{
unsigned char ub = b;
unsigned char uc = c;
unsigned char x = ub ^ uc; /* 0: yes; 1..255: no */
crypto_uint32 y = x; /* 0: yes; 1..255: no */
y -= 1; /* 4294967295: yes; 0..254: no */
y >>= 31; /* 1: yes; 0: no */
return (unsigned char)y;
}
__device__ static inline unsigned char negative(signed char b)
{
unsigned long long x = b; /* 18446744073709551361..18446744073709551615: yes; 0..255: no */
x >>= 63; /* 1: yes; 0: no */
return (unsigned char)x;
}
__device__ static inline void choose_t(ge25519_aff *t, unsigned long long pos, signed char b)
{
/* constant time */
fe25519 v;
*t = ge25519_base_multiples_affine[5*pos+0];
cmov_aff(t, &ge25519_base_multiples_affine[5*pos+1],equal(b,1) | equal(b,-1));
cmov_aff(t, &ge25519_base_multiples_affine[5*pos+2],equal(b,2) | equal(b,-2));
cmov_aff(t, &ge25519_base_multiples_affine[5*pos+3],equal(b,3) | equal(b,-3));
cmov_aff(t, &ge25519_base_multiples_affine[5*pos+4],equal(b,-4));
fe25519_neg(&v, &t->x);
fe25519_cmov(&t->x, &v, negative(b));
}
__device__ static inline void setneutral(ge25519 *r)
{
fe25519_setzero(&r->x);
fe25519_setone(&r->y);
fe25519_setone(&r->z);
fe25519_setzero(&r->t);
}
/* return 0 on success, -1 otherwise */
__device__ static inline int ge25519_unpackneg_vartime(ge25519_p3 *r, const unsigned char p[32])
{
unsigned char par;
fe25519 t, chk, num, den, den2, den4, den6;
fe25519_setone(&r->z);
par = p[31] >> 7;
fe25519_unpack(&r->y, p);
fe25519_square(&num, &r->y); /* x = y^2 */
fe25519_mul(&den, &num, &ge25519_ecd); /* den = dy^2 */
fe25519_sub(&num, &num, &r->z); /* x = y^2-1 */
fe25519_add(&den, &r->z, &den); /* den = dy^2+1 */
/* Computation of sqrt(num/den) */
/* 1.: computation of num^((p-5)/8)*den^((7p-35)/8) = (num*den^7)^((p-5)/8) */
fe25519_square(&den2, &den);
fe25519_square(&den4, &den2);
fe25519_mul(&den6, &den4, &den2);
fe25519_mul(&t, &den6, &num);
fe25519_mul(&t, &t, &den);
fe25519_pow2523(&t, &t);
/* 2. computation of r->x = t * num * den^3 */
fe25519_mul(&t, &t, &num);
fe25519_mul(&t, &t, &den);
fe25519_mul(&t, &t, &den);
fe25519_mul(&r->x, &t, &den);
/* 3. Check whether sqrt computation gave correct result, multiply by sqrt(-1) if not: */
fe25519_square(&chk, &r->x);
fe25519_mul(&chk, &chk, &den);
if (!fe25519_iseq_vartime(&chk, &num))
fe25519_mul(&r->x, &r->x, &ge25519_sqrtm1);
/* 4. Now we have one of the two square roots, except if input was not a square */
fe25519_square(&chk, &r->x);
fe25519_mul(&chk, &chk, &den);
if (!fe25519_iseq_vartime(&chk, &num))
return -1;
/* 5. Choose the desired square root according to parity: */
if(fe25519_getparity(&r->x) != (1-par))
fe25519_neg(&r->x, &r->x);
fe25519_mul(&r->t, &r->x, &r->y);
return 0;
}
__device__ static inline void ge25519_pack(unsigned char r[32], const ge25519_p3 *p)
{
fe25519 tx, ty, zi;
fe25519_invert(&zi, &p->z);
fe25519_mul(&tx, &p->x, &zi);
fe25519_mul(&ty, &p->y, &zi);
fe25519_pack(r, &ty);
r[31] ^= fe25519_getparity(&tx) << 7;
}
/* computes [s1]p1 + [s2]p2 */
__device__ static inline void ge25519_double_scalarmult_vartime(ge25519_p3 *r, const ge25519_p3 *p1, const sc25519 *s1, const ge25519_p3 *p2, const sc25519 *s2)
{
ge25519_p1p1 tp1p1;
ge25519_p3 pre[16];
char *pre5 = (char *)(&(pre[5])); // eliminate type punning warning
unsigned char b[127];
int i;
/* precomputation s2 s1 */
setneutral(pre); /* 00 00 */
pre[1] = *p1; /* 00 01 */
dbl_p1p1(&tp1p1,(ge25519_p2 *)p1); p1p1_to_p3( &pre[2], &tp1p1); /* 00 10 */
add_p1p1(&tp1p1,&pre[1], &pre[2]); p1p1_to_p3( &pre[3], &tp1p1); /* 00 11 */
pre[4] = *p2; /* 01 00 */
add_p1p1(&tp1p1,&pre[1], &pre[4]); p1p1_to_p3( &pre[5], &tp1p1); /* 01 01 */
add_p1p1(&tp1p1,&pre[2], &pre[4]); p1p1_to_p3( &pre[6], &tp1p1); /* 01 10 */
add_p1p1(&tp1p1,&pre[3], &pre[4]); p1p1_to_p3( &pre[7], &tp1p1); /* 01 11 */
dbl_p1p1(&tp1p1,(ge25519_p2 *)p2); p1p1_to_p3( &pre[8], &tp1p1); /* 10 00 */
add_p1p1(&tp1p1,&pre[1], &pre[8]); p1p1_to_p3( &pre[9], &tp1p1); /* 10 01 */
dbl_p1p1(&tp1p1,(ge25519_p2 *)pre5); p1p1_to_p3(&pre[10], &tp1p1); /* 10 10 */
add_p1p1(&tp1p1,&pre[3], &pre[8]); p1p1_to_p3(&pre[11], &tp1p1); /* 10 11 */
add_p1p1(&tp1p1,&pre[4], &pre[8]); p1p1_to_p3(&pre[12], &tp1p1); /* 11 00 */
add_p1p1(&tp1p1,&pre[1],&pre[12]); p1p1_to_p3(&pre[13], &tp1p1); /* 11 01 */
add_p1p1(&tp1p1,&pre[2],&pre[12]); p1p1_to_p3(&pre[14], &tp1p1); /* 11 10 */
add_p1p1(&tp1p1,&pre[3],&pre[12]); p1p1_to_p3(&pre[15], &tp1p1); /* 11 11 */
sc25519_2interleave2(b,s1,s2);
/* scalar multiplication */
*r = pre[b[126]];
for(i=125;i>=0;i--)
{
dbl_p1p1(&tp1p1, (ge25519_p2 *)r);
p1p1_to_p2((ge25519_p2 *) r, &tp1p1);
dbl_p1p1(&tp1p1, (ge25519_p2 *)r);
if(b[i]!=0)
{
p1p1_to_p3(r, &tp1p1);
add_p1p1(&tp1p1, r, &pre[b[i]]);
}
if(i != 0) p1p1_to_p2((ge25519_p2 *)r, &tp1p1);
else p1p1_to_p3(r, &tp1p1);
}
}
__device__ static inline void ge25519_scalarmult_base(ge25519_p3 *r, const sc25519 *s)
{
signed char b[85];
int i;
ge25519_aff t;
sc25519_window3(b,s);
choose_t((ge25519_aff *)r, 0, b[0]);
fe25519_setone(&r->z);
fe25519_mul(&r->t, &r->x, &r->y);
for(i=1;i<85;i++)
{
choose_t(&t, (unsigned long long) i, b[i]);
ge25519_mixadd2(r, &t);
}
}
__device__ static inline void get_hram(unsigned char *hram, const unsigned char *sm, const unsigned char *pk, unsigned char *playground, unsigned long long smlen)
{
unsigned long long i;
for (i = 0;i < 32;++i) playground[i] = sm[i];
for (i = 32;i < 64;++i) playground[i] = pk[i-32];
for (i = 64;i < smlen;++i) playground[i] = sm[i];
SHA512(hram,playground,(unsigned int)smlen);
}
//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
__device__ void C25519::_calcPubDH(C25519::Pair &kp)
{
// First 32 bytes of pub and priv are the keys for ECDH key
// agreement. This generates the public portion from the private.
crypto_scalarmult_base(kp.pub.data,kp.priv.data);
}
__device__ void C25519::_calcPubED(C25519::Pair &kp)
{
unsigned char extsk[64];
sc25519 scsk;
ge25519 gepk;
// Second 32 bytes of pub and priv are the keys for ed25519
// signing and verification.
SHA512(extsk,kp.priv.data + 32,32);
extsk[0] &= 248;
extsk[31] &= 127;
extsk[31] |= 64;
sc25519_from32bytes(&scsk,extsk);
ge25519_scalarmult_base(&gepk,&scsk);
ge25519_pack(kp.pub.data + 32,&gepk);
// In NaCl, the public key is crammed into the next 32 bytes
// of the private key for signing since both keys are required
// to sign. In this version we just get it from kp.pub, so we
// leave that out of private.
} |
21,164 | __global__ void kGauss( double * Y, const double * x, const double * w, const int K )
{
int idx = threadIdx.x + blockIdx.x * blockDim.x;
double y = Y[idx];
Y[idx]=0;
for(int i=0; i<K; ++i)
Y[idx] += w[i]*exp(-(y-x[i])*(y-x[i]));
}
|
21,165 | #include "includes.h"
/*
sergeim19
April 27, 2015
Burgers equation - GPU CUDA version
*/
#define NADVANCE (4000)
#define nu (5.0e-2)
__global__ void kernel_rescale_u(double *u_dev, int N)
{
int j;
j = blockIdx.x * blockDim.x + threadIdx.x;
u_dev[j] = u_dev[j] / (double)N;
} |
21,166 | void __global__ loadee(int *output)
{
int tid = threadIdx.x + blockIdx.x * blockDim.x;
output[tid]=tid;
}
|
21,167 | #include<cuda.h>
#include<cuda_runtime.h>
#include <stdio.h>
#define CONFIG_MASK_SIZE 32
#define CONFIG_IMAGE_WIDTH 640
#define CONFIG_IMAGE_HEIGHT 480
#define CONFIG_IMAGE_CHANNEL 3
#define CONFIG_COMPUTE_COUNT 10000
template <int BLOCK_SIZE, int MASK_SIZE, int CHANNELS>
__global__ void WatermarkKernel(
const unsigned char *srcImage, //HxWxC
const unsigned char *mask, // CONFIG_MASK_SIZE x CONFIG_MASK_SIZE
unsigned char *dstImage){
__shared__ float localMem[MASK_SIZE][MASK_SIZE][CHANNELS];
unsigned long index, maskIndex;
// Block index
int bx = blockIdx.x;
int by = blockIdx.y;
// Thread index
int tx = threadIdx.x;
int ty = threadIdx.y;
//Global index
int gx = bx*BLOCK_SIZE+tx;
int gy = by*BLOCK_SIZE+ty;
index = gy*CONFIG_IMAGE_WIDTH*CONFIG_IMAGE_CHANNEL + gx*CONFIG_IMAGE_CHANNEL;
for(int iter=0; iter<CONFIG_COMPUTE_COUNT; iter++) {
for (int c = 0; c < 3; c++) {
maskIndex = ty * MASK_SIZE + tx;
localMem[ty][tx][c] = (unsigned char) (srcImage[index + c] * (float) mask[maskIndex] / 256.0f);
}
}
__syncthreads();
for(int c=0; c<3; c++){
localMem[ty][tx][c] = localMem[tx][ty][c];
}
__syncthreads();
for(int c=0; c<3; c++){
dstImage[index+c] = (unsigned char) (localMem[ty][tx][c]);
}
}
void LaunchKernel_WatermarkKernel(
const unsigned char *srcImage,
const unsigned char *mask,
unsigned char *dstImage){
dim3 block(CONFIG_MASK_SIZE,CONFIG_MASK_SIZE,1);
dim3 grid(
CONFIG_IMAGE_WIDTH/CONFIG_MASK_SIZE,
CONFIG_IMAGE_HEIGHT/CONFIG_MASK_SIZE,
1);
//printf("BLOCK = (%d,%d,%d)\n", block.x, block.y, block.z);
//printf("GRID = (%d,%d,%d)\n", grid.x, grid.y, grid.z);
WatermarkKernel<CONFIG_MASK_SIZE, CONFIG_MASK_SIZE, CONFIG_IMAGE_CHANNEL> <<<grid, block>>>(
srcImage,
mask,
dstImage);
} |
21,168 | #include "includes.h"
__global__ void addTwoArrays(int *v1, int *v2, int *r, int n)
{
int tid = blockIdx.x * blockDim.x + threadIdx.x;
if (tid >= n) {
return;
}
r[tid] = v1[tid] + v2[tid];
} |
21,169 | #include <iostream>
// Virtual grid dimensions :
//
// 20 000 * 20 000
// 20 blocks, 20 threads
// 2 000 cells/thread
//
// Matrix dimensions :
//
// 20*20 Matrix
// Virtualized as a 400 cells array (20 * 20)
// Each cell of the matrix has 2 000 virtual cells
//
// Algorithm used to get a position into the thread grid :
//
// Pos = blockIdx.x * blockDim.x + threadIdx.x
// SUMARRY :
//
// Variable names : - h_(varname) = HOST (CPU) variable
// - d_(varname) = DEVICE (GPU) variable
// - no prefix = Local variables (They are not transferred between the CPU and the GPU inside the block)
//
// Variables/Matrix usage : - Mat[] = The sum of the values of each cell of this virtual matrix gives the area of the quarter disk
// - vCellsPerThread = Number of virtual cells for each thread (One thread checks for several cells)
// - MatX/MatY = Matrix' dimensions (Blocks * Threads)
// - Area = Sum of the values of each cell of Mat[] after computing
// - Pi = Approx value of Pi
// - SQGridSize = Stands for Square Grid Size, it is the area of the virtual grid (MatX * MatY * vCellsPerThread * vCellsPerThread)
// - MatSize = Size of the 400 cells matrix
//
// CUDA variables/functions : - blockIdx = vec3 struct giving you the position of the block the kernel runs in
// - threadIdx = vec3 struct giving you the position of the thread inside the block the kernel runs in
// - cudaMalloc() = Simillar to malloc(), but allocs memory on the graphics card
// - cudaMemCpy() = Used to copy content from GPU to CPU and vice versa
//
// CODE :
// This is the kernel running on the GPU. It is pretty basic, it checks for each case if it is inside or outside the quarter disk
__global__ void MatComputing(double Mat[], int *vCellsPerThread, int *MatX, int *MatY) {
// Getting the position of the kernel inside the thread and the virtual grid size
int Pos = blockIdx.x * blockDim.x + threadIdx.x,
SQGridSize = *MatX * *MatY * *vCellsPerThread * *vCellsPerThread;
Mat[Pos] = 0;
// This tests each cell to know if it is inside the quarter disk or not
for(double i = blockIdx.x * *vCellsPerThread; i < (blockIdx.x * *vCellsPerThread) + *vCellsPerThread; i++)
for(double j = threadIdx.x * *vCellsPerThread; j < (threadIdx.x * *vCellsPerThread) + *vCellsPerThread; j++)
if((i * i) + (j * j) <= SQGridSize)
Mat[Pos]++;
}
int main() {
// DECLARATIONS AND ALLOCATIONS ON THE GPU
const int h_MatX = 20,
h_MatY = 20,
h_vCellsPerThread = 2000;
const size_t MatSize = h_MatX * h_MatY * sizeof( double);
double *h_Mat = ( double*)malloc(MatSize),
*d_Mat;
int *d_MatX = ( int*)malloc(sizeof( int)),
*d_MatY = ( int*)malloc(sizeof( int)),
*d_vCellsPerThread;
double Pi = 0,
Area = 0;
cudaMalloc((void**)&d_Mat, MatSize);
cudaMalloc((void**)&d_vCellsPerThread, sizeof( double));
cudaMalloc((void**)&d_MatX, sizeof( int));
cudaMalloc((void**)&d_MatY, sizeof( int));
cudaMemcpy(d_Mat, h_Mat, MatSize, cudaMemcpyHostToDevice);
cudaMemcpy(d_vCellsPerThread, &h_vCellsPerThread, sizeof( double), cudaMemcpyHostToDevice);
cudaMemcpy(d_MatX, &h_MatX, sizeof( int), cudaMemcpyHostToDevice);
cudaMemcpy(d_MatY, &h_MatY, sizeof( int), cudaMemcpyHostToDevice);
// MAIN PROGRAM
MatComputing <<<h_MatX, h_MatY>>> (d_Mat, d_vCellsPerThread, d_MatX, d_MatY);
cudaMemcpy(h_Mat, d_Mat, MatSize, cudaMemcpyDeviceToHost);
for(int i = 0; i < h_MatX * h_MatY; i++)
Area+= h_Mat[i];
Pi = (Area * 4) / ((h_MatX * h_vCellsPerThread) * (h_MatY * h_vCellsPerThread));
std::cout << Pi << std::endl;
std::cin.get();
// MEMORY DISALLOCATION
cudaFree(d_Mat);
cudaFree(d_vCellsPerThread);
cudaFree(d_MatX);
cudaFree(d_MatY);
free(h_Mat);
return 0;
} |
21,170 | #include <stdio.h>
#include <stdlib.h>
#include <cuda.h>
#define B 64
#define threadNum 32
const int INF = 1000000000;
void input(char *inFileName);
void output(char *outFileName);
void block_FW();
int ceil(int a, int b);
__global__ void phase1(int* dist, int Round, int n, size_t pitch);
__global__ void phase2(int* dist, int Round, int n, size_t pitch);
__global__ void phase3(int* dist, int Round, int n, size_t pitch);
int n, m;
int *Dist = NULL;
int *device_Dist = NULL;
size_t pitch;
int main(int argc, char* argv[]) {
input(argv[1]);
block_FW();
output(argv[2]);
cudaFreeHost(Dist);
return 0;
}
void input(char* infile) {
FILE* file = fopen(infile, "rb");
fread(&n, sizeof(int), 1, file);
fread(&m, sizeof(int), 1, file);
cudaMallocHost(&Dist, (size_t)n*n*sizeof(int));
for (int i = 0; i < n; ++ i) {
for (int j = 0; j < n; ++ j) {
Dist[i*n+j] = (i==j) ? 0 : INF;
}
}
int pair[3];
for (int i = 0; i < m; ++ i) {
fread(pair, sizeof(int), 3, file);
Dist[pair[0]*n+pair[1]] = pair[2];
}
fclose(file);
}
void output(char *outFileName) {
FILE *outfile = fopen(outFileName, "wb");
fwrite(Dist, sizeof(int), n*n, outfile);
fclose(outfile);
}
int ceil(int a, int b) {
return (a + b - 1) / b;
}
void block_FW() {
unsigned int round = ceil(n, B);
dim3 block_p1 = {1, 1};
dim3 block_p2 = {2, round};
dim3 block_p3 = {round, round};
dim3 threads = {threadNum, threadNum};
cudaMallocPitch(&device_Dist, &pitch, (size_t)n*sizeof(int), (size_t)n);
cudaMemcpy2D(device_Dist, pitch, Dist, (size_t)n*sizeof(int), (size_t)n*sizeof(int), (size_t)n, cudaMemcpyHostToDevice);
for (unsigned int r = 0; r < round; ++r) {
phase1<<<block_p1, threads>>>(device_Dist, r, n, pitch);
phase2<<<block_p2, threads>>>(device_Dist, r, n, pitch);
phase3<<<block_p3, threads>>>(device_Dist, r, n, pitch);
}
cudaMemcpy2D(Dist, (size_t)n*sizeof(int), device_Dist, pitch, (size_t)n*sizeof(int), (size_t)n, cudaMemcpyDeviceToHost);
cudaFree(device_Dist);
}
__global__ void phase1(int* dist, int Round, int n, size_t pitch){
int base = Round*B;
int shift = B/threadNum;
int i_st = base + threadIdx.x*shift, i_ed = i_st + shift;
int j_st = base + threadIdx.y*shift, j_ed = j_st + shift;
if(i_ed > n){
i_ed = n;
}
if(j_ed > n){
j_ed = n;
}
__shared__ int sm[B][B];
#pragma unroll
for(int i=i_st ; i<i_ed ; ++i){
#pragma unroll
for(int j=j_st ; j<j_ed ; ++j){
int *dij = (int*)((char*)dist+pitch*i)+j;
sm[i-base][j-base] = *dij;
}
}
__syncthreads();
int len = ((Round+1)*B < n) ? B : n - (Round)*B;
#pragma unroll
for (int k = 0; k < len; ++k) {
#pragma unroll
for(int i = i_st; i<i_ed ; ++i){
#pragma unroll
for(int j = j_st ; j<j_ed ; ++j){
int relax = sm[i-base][k] + sm[k][j-base];
if(relax < sm[i-base][j-base]){
sm[i-base][j-base] = relax;
}
}
}
__syncthreads();
}
#pragma unroll
for(int i=i_st ; i<i_ed ; ++i){
#pragma unroll
for(int j=j_st ; j<j_ed ; ++j){
int *dij = (int*)((char*)dist+pitch*i)+j;
*dij = sm[i-base][j-base];
}
}
}
__global__ void phase2(int* dist, int Round, int n, size_t pitch){
if(blockIdx.y==Round)
return;
__shared__ int sm[2][B][B];
int base_i = (1-blockIdx.x)*Round*B + blockIdx.x*blockIdx.y*B;
int base_j = blockIdx.x*Round*B + (1-blockIdx.x)*blockIdx.y*B;
int shift = B/threadNum;
int i_st = base_i + threadIdx.x*shift, i_ed = i_st + shift;
int j_st = base_j + threadIdx.y*shift, j_ed = j_st + shift;
#pragma unroll
for(int i=i_st ; i<i_ed ; ++i){
#pragma unroll
for(int j=j_st ; j<j_ed ; ++j){
if(i<n && j<n){
int *dij = (int*)((char*)dist+pitch*i)+j;
sm[0][i-base_i][j-base_j] = *dij;
}
if(Round*B+(i-base_i)<n && Round*B+(j-base_j)<n){
int *dkk = (int*)((char*)dist+pitch*(Round*B+(i-base_i))) + Round*B+(j-base_j);
sm[1][i-base_i][j-base_j] = *dkk;
}
}
}
__syncthreads();
if(i_ed > n){
i_ed = n;
}
if(j_ed > n){
j_ed = n;
}
int len = ((Round+1)*B < n) ? B : n - (Round)*B;
int i_offset = i_st-base_i, i_len = i_ed - i_st;
int j_offset = j_st-base_j, j_len = j_ed - j_st;
#pragma unroll
for(int i=i_offset ; i<i_offset+i_len ; ++i){
#pragma unroll
for(int j=j_offset ; j<j_offset+j_len ; ++j){
#pragma unroll
for (int k = 0; k < len; ++k) {
int relax = sm[1-blockIdx.x][i][k] + sm[blockIdx.x][k][j];
if(relax < sm[0][i][j]){
sm[0][i][j] = relax;
}
}
int *dij = (int*)((char*)dist+pitch*(base_i+i))+base_j+j;
*dij = sm[0][i][j];
}
}
}
__global__ void phase3(int* dist, int Round, int n, size_t pitch){
if(blockIdx.x==Round || blockIdx.y==Round)
return;
__shared__ int sm[2][B][B];
int base_i = blockIdx.x*B;
int base_j = blockIdx.y*B;
int shift = B/threadNum;
int i_st = base_i + threadIdx.x*shift, i_ed = i_st + shift;
int j_st = base_j + threadIdx.y*shift, j_ed = j_st + shift;
#pragma unroll
for(int i=i_st ; i<i_ed ; ++i){
#pragma unroll
for(int j=j_st ; j<j_ed ; ++j){
if(i<n && Round*B+(j-base_j)<n){
int *dik = (int*)((char*)dist+pitch*i)+Round*B+(j-base_j);
sm[0][j-base_j][i-base_i] = *dik;
}
if(Round*B+(i-base_i)<n && j<n){
int *dkj = (int*)((char*)dist+pitch*(Round*B+(i-base_i)))+j;
sm[1][i-base_i][j-base_j] = *dkj;
}
}
}
__syncthreads();
if(i_ed > n){
i_ed = n;
}
if(j_ed > n){
j_ed = n;
}
int len = ((Round+1)*B < n) ? B : n - (Round)*B;
int i_offset = i_st-base_i, i_len = i_ed - i_st;
int j_offset = j_st-base_j, j_len = j_ed - j_st;
#pragma unroll
for(int i = 0 ; i < i_len ; ++i){
#pragma unroll
for(int j= 0 ; j < j_len ; ++j){
int *dij = (int*)((char*)dist+pitch*(i_st+i))+j_st+j;
int ans = *dij;
#pragma unroll
for (int k = 0; k < len; ++k) {
int relax = sm[0][k][i_offset+i] + sm[1][k][j_offset+j];
if(relax < ans){
ans = relax;
}
}
*dij = ans;
}
}
} |
21,171 | #define X_BLOCK 1024
#define PITCH 1024
extern "C"
__global__ void MRDWT(float *constant,float *input4,float *result0){
result0[(((blockIdx.y*PITCH)+(blockIdx.x*X_BLOCK))+threadIdx.x)] = ((((((((((((((((((((((((input4[(threadIdx.x+(blockIdx.x*X_BLOCK))]*9.0)+(input4[(((threadIdx.x+(blockIdx.x*X_BLOCK))+1)%1024)]*8.0))+(input4[(((threadIdx.x+(blockIdx.x*X_BLOCK))+2)%1024)]*7.0))+(input4[(((threadIdx.x+(blockIdx.x*X_BLOCK))+3)%1024)]*6.0))+(input4[(((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)]*5.0))+(input4[(((threadIdx.x+(blockIdx.x*X_BLOCK))+5)%1024)]*4.0))+(input4[(((threadIdx.x+(blockIdx.x*X_BLOCK))+6)%1024)]*3.0))+(input4[(((threadIdx.x+(blockIdx.x*X_BLOCK))+7)%1024)]*2.0))*9.0)+(((((((((input4[(((threadIdx.x+(blockIdx.x*X_BLOCK))+2)%1024)]*9.0)+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+2)%1024)+1)%1024)]*8.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+2)%1024)+2)%1024)]*7.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+2)%1024)+3)%1024)]*6.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+2)%1024)+4)%1024)]*5.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+2)%1024)+5)%1024)]*4.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+2)%1024)+6)%1024)]*3.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+2)%1024)+7)%1024)]*2.0))*8.0))+(((((((((input4[(((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)]*9.0)+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+1)%1024)]*8.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+2)%1024)]*7.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+3)%1024)]*6.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+4)%1024)]*5.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+5)%1024)]*4.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+6)%1024)]*3.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+7)%1024)]*2.0))*7.0))+(((((((((input4[(((threadIdx.x+(blockIdx.x*X_BLOCK))+6)%1024)]*9.0)+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+6)%1024)+1)%1024)]*8.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+6)%1024)+2)%1024)]*7.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+6)%1024)+3)%1024)]*6.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+6)%1024)+4)%1024)]*5.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+6)%1024)+5)%1024)]*4.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+6)%1024)+6)%1024)]*3.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+6)%1024)+7)%1024)]*2.0))*6.0))+(((((((((input4[(((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)]*9.0)+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+1)%1024)]*8.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+2)%1024)]*7.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+3)%1024)]*6.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+4)%1024)]*5.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+5)%1024)]*4.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+6)%1024)]*3.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+7)%1024)]*2.0))*5.0))+(((((((((input4[(((threadIdx.x+(blockIdx.x*X_BLOCK))+10)%1024)]*9.0)+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+10)%1024)+1)%1024)]*8.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+10)%1024)+2)%1024)]*7.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+10)%1024)+3)%1024)]*6.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+10)%1024)+4)%1024)]*5.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+10)%1024)+5)%1024)]*4.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+10)%1024)+6)%1024)]*3.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+10)%1024)+7)%1024)]*2.0))*4.0))+(((((((((input4[(((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)]*9.0)+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+1)%1024)]*8.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+2)%1024)]*7.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+3)%1024)]*6.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+4)%1024)]*5.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+5)%1024)]*4.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+6)%1024)]*3.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+7)%1024)]*2.0))*3.0))+(((((((((input4[(((threadIdx.x+(blockIdx.x*X_BLOCK))+14)%1024)]*9.0)+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+14)%1024)+1)%1024)]*8.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+14)%1024)+2)%1024)]*7.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+14)%1024)+3)%1024)]*6.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+14)%1024)+4)%1024)]*5.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+14)%1024)+5)%1024)]*4.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+14)%1024)+6)%1024)]*3.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+14)%1024)+7)%1024)]*2.0))*2.0))*9.0)+(((((((((((((((((input4[(((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)]*9.0)+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+1)%1024)]*8.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+2)%1024)]*7.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+3)%1024)]*6.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+4)%1024)]*5.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+5)%1024)]*4.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+6)%1024)]*3.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+7)%1024)]*2.0))*9.0)+(((((((((input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+2)%1024)]*9.0)+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+2)%1024)+1)%1024)]*8.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+2)%1024)+2)%1024)]*7.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+2)%1024)+3)%1024)]*6.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+2)%1024)+4)%1024)]*5.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+2)%1024)+5)%1024)]*4.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+2)%1024)+6)%1024)]*3.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+2)%1024)+7)%1024)]*2.0))*8.0))+(((((((((input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+4)%1024)]*9.0)+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+4)%1024)+1)%1024)]*8.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+4)%1024)+2)%1024)]*7.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+4)%1024)+3)%1024)]*6.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+4)%1024)+4)%1024)]*5.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+4)%1024)+5)%1024)]*4.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+4)%1024)+6)%1024)]*3.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+4)%1024)+7)%1024)]*2.0))*7.0))+(((((((((input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+6)%1024)]*9.0)+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+6)%1024)+1)%1024)]*8.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+6)%1024)+2)%1024)]*7.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+6)%1024)+3)%1024)]*6.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+6)%1024)+4)%1024)]*5.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+6)%1024)+5)%1024)]*4.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+6)%1024)+6)%1024)]*3.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+6)%1024)+7)%1024)]*2.0))*6.0))+(((((((((input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+8)%1024)]*9.0)+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+8)%1024)+1)%1024)]*8.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+8)%1024)+2)%1024)]*7.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+8)%1024)+3)%1024)]*6.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+8)%1024)+4)%1024)]*5.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+8)%1024)+5)%1024)]*4.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+8)%1024)+6)%1024)]*3.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+8)%1024)+7)%1024)]*2.0))*5.0))+(((((((((input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+10)%1024)]*9.0)+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+10)%1024)+1)%1024)]*8.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+10)%1024)+2)%1024)]*7.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+10)%1024)+3)%1024)]*6.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+10)%1024)+4)%1024)]*5.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+10)%1024)+5)%1024)]*4.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+10)%1024)+6)%1024)]*3.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+10)%1024)+7)%1024)]*2.0))*4.0))+(((((((((input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+12)%1024)]*9.0)+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+12)%1024)+1)%1024)]*8.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+12)%1024)+2)%1024)]*7.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+12)%1024)+3)%1024)]*6.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+12)%1024)+4)%1024)]*5.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+12)%1024)+5)%1024)]*4.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+12)%1024)+6)%1024)]*3.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+12)%1024)+7)%1024)]*2.0))*3.0))+(((((((((input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+14)%1024)]*9.0)+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+14)%1024)+1)%1024)]*8.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+14)%1024)+2)%1024)]*7.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+14)%1024)+3)%1024)]*6.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+14)%1024)+4)%1024)]*5.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+14)%1024)+5)%1024)]*4.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+14)%1024)+6)%1024)]*3.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+14)%1024)+7)%1024)]*2.0))*2.0))*8.0))+(((((((((((((((((input4[(((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)]*9.0)+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+1)%1024)]*8.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+2)%1024)]*7.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+3)%1024)]*6.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+4)%1024)]*5.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+5)%1024)]*4.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+6)%1024)]*3.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+7)%1024)]*2.0))*9.0)+(((((((((input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+2)%1024)]*9.0)+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+2)%1024)+1)%1024)]*8.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+2)%1024)+2)%1024)]*7.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+2)%1024)+3)%1024)]*6.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+2)%1024)+4)%1024)]*5.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+2)%1024)+5)%1024)]*4.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+2)%1024)+6)%1024)]*3.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+2)%1024)+7)%1024)]*2.0))*8.0))+(((((((((input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+4)%1024)]*9.0)+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+4)%1024)+1)%1024)]*8.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+4)%1024)+2)%1024)]*7.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+4)%1024)+3)%1024)]*6.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+4)%1024)+4)%1024)]*5.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+4)%1024)+5)%1024)]*4.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+4)%1024)+6)%1024)]*3.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+4)%1024)+7)%1024)]*2.0))*7.0))+(((((((((input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+6)%1024)]*9.0)+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+6)%1024)+1)%1024)]*8.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+6)%1024)+2)%1024)]*7.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+6)%1024)+3)%1024)]*6.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+6)%1024)+4)%1024)]*5.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+6)%1024)+5)%1024)]*4.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+6)%1024)+6)%1024)]*3.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+6)%1024)+7)%1024)]*2.0))*6.0))+(((((((((input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+8)%1024)]*9.0)+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+8)%1024)+1)%1024)]*8.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+8)%1024)+2)%1024)]*7.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+8)%1024)+3)%1024)]*6.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+8)%1024)+4)%1024)]*5.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+8)%1024)+5)%1024)]*4.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+8)%1024)+6)%1024)]*3.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+8)%1024)+7)%1024)]*2.0))*5.0))+(((((((((input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+10)%1024)]*9.0)+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+10)%1024)+1)%1024)]*8.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+10)%1024)+2)%1024)]*7.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+10)%1024)+3)%1024)]*6.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+10)%1024)+4)%1024)]*5.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+10)%1024)+5)%1024)]*4.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+10)%1024)+6)%1024)]*3.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+10)%1024)+7)%1024)]*2.0))*4.0))+(((((((((input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+12)%1024)]*9.0)+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+12)%1024)+1)%1024)]*8.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+12)%1024)+2)%1024)]*7.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+12)%1024)+3)%1024)]*6.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+12)%1024)+4)%1024)]*5.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+12)%1024)+5)%1024)]*4.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+12)%1024)+6)%1024)]*3.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+12)%1024)+7)%1024)]*2.0))*3.0))+(((((((((input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+14)%1024)]*9.0)+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+14)%1024)+1)%1024)]*8.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+14)%1024)+2)%1024)]*7.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+14)%1024)+3)%1024)]*6.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+14)%1024)+4)%1024)]*5.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+14)%1024)+5)%1024)]*4.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+14)%1024)+6)%1024)]*3.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+14)%1024)+7)%1024)]*2.0))*2.0))*7.0))+(((((((((((((((((input4[(((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)]*9.0)+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+1)%1024)]*8.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+2)%1024)]*7.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+3)%1024)]*6.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+4)%1024)]*5.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+5)%1024)]*4.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+6)%1024)]*3.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+7)%1024)]*2.0))*9.0)+(((((((((input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+2)%1024)]*9.0)+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+2)%1024)+1)%1024)]*8.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+2)%1024)+2)%1024)]*7.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+2)%1024)+3)%1024)]*6.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+2)%1024)+4)%1024)]*5.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+2)%1024)+5)%1024)]*4.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+2)%1024)+6)%1024)]*3.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+2)%1024)+7)%1024)]*2.0))*8.0))+(((((((((input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+4)%1024)]*9.0)+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+4)%1024)+1)%1024)]*8.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+4)%1024)+2)%1024)]*7.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+4)%1024)+3)%1024)]*6.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+4)%1024)+4)%1024)]*5.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+4)%1024)+5)%1024)]*4.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+4)%1024)+6)%1024)]*3.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+4)%1024)+7)%1024)]*2.0))*7.0))+(((((((((input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+6)%1024)]*9.0)+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+6)%1024)+1)%1024)]*8.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+6)%1024)+2)%1024)]*7.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+6)%1024)+3)%1024)]*6.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+6)%1024)+4)%1024)]*5.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+6)%1024)+5)%1024)]*4.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+6)%1024)+6)%1024)]*3.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+6)%1024)+7)%1024)]*2.0))*6.0))+(((((((((input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+8)%1024)]*9.0)+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+8)%1024)+1)%1024)]*8.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+8)%1024)+2)%1024)]*7.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+8)%1024)+3)%1024)]*6.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+8)%1024)+4)%1024)]*5.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+8)%1024)+5)%1024)]*4.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+8)%1024)+6)%1024)]*3.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+8)%1024)+7)%1024)]*2.0))*5.0))+(((((((((input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+10)%1024)]*9.0)+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+10)%1024)+1)%1024)]*8.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+10)%1024)+2)%1024)]*7.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+10)%1024)+3)%1024)]*6.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+10)%1024)+4)%1024)]*5.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+10)%1024)+5)%1024)]*4.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+10)%1024)+6)%1024)]*3.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+10)%1024)+7)%1024)]*2.0))*4.0))+(((((((((input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+12)%1024)]*9.0)+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+12)%1024)+1)%1024)]*8.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+12)%1024)+2)%1024)]*7.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+12)%1024)+3)%1024)]*6.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+12)%1024)+4)%1024)]*5.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+12)%1024)+5)%1024)]*4.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+12)%1024)+6)%1024)]*3.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+12)%1024)+7)%1024)]*2.0))*3.0))+(((((((((input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+14)%1024)]*9.0)+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+14)%1024)+1)%1024)]*8.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+14)%1024)+2)%1024)]*7.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+14)%1024)+3)%1024)]*6.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+14)%1024)+4)%1024)]*5.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+14)%1024)+5)%1024)]*4.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+14)%1024)+6)%1024)]*3.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+14)%1024)+7)%1024)]*2.0))*2.0))*6.0))+(((((((((((((((((input4[(((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)]*9.0)+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+1)%1024)]*8.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+2)%1024)]*7.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+3)%1024)]*6.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+4)%1024)]*5.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+5)%1024)]*4.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+6)%1024)]*3.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+7)%1024)]*2.0))*9.0)+(((((((((input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+2)%1024)]*9.0)+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+2)%1024)+1)%1024)]*8.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+2)%1024)+2)%1024)]*7.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+2)%1024)+3)%1024)]*6.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+2)%1024)+4)%1024)]*5.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+2)%1024)+5)%1024)]*4.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+2)%1024)+6)%1024)]*3.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+2)%1024)+7)%1024)]*2.0))*8.0))+(((((((((input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+4)%1024)]*9.0)+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+4)%1024)+1)%1024)]*8.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+4)%1024)+2)%1024)]*7.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+4)%1024)+3)%1024)]*6.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+4)%1024)+4)%1024)]*5.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+4)%1024)+5)%1024)]*4.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+4)%1024)+6)%1024)]*3.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+4)%1024)+7)%1024)]*2.0))*7.0))+(((((((((input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+6)%1024)]*9.0)+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+6)%1024)+1)%1024)]*8.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+6)%1024)+2)%1024)]*7.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+6)%1024)+3)%1024)]*6.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+6)%1024)+4)%1024)]*5.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+6)%1024)+5)%1024)]*4.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+6)%1024)+6)%1024)]*3.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+6)%1024)+7)%1024)]*2.0))*6.0))+(((((((((input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+8)%1024)]*9.0)+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+8)%1024)+1)%1024)]*8.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+8)%1024)+2)%1024)]*7.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+8)%1024)+3)%1024)]*6.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+8)%1024)+4)%1024)]*5.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+8)%1024)+5)%1024)]*4.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+8)%1024)+6)%1024)]*3.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+8)%1024)+7)%1024)]*2.0))*5.0))+(((((((((input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+10)%1024)]*9.0)+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+10)%1024)+1)%1024)]*8.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+10)%1024)+2)%1024)]*7.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+10)%1024)+3)%1024)]*6.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+10)%1024)+4)%1024)]*5.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+10)%1024)+5)%1024)]*4.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+10)%1024)+6)%1024)]*3.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+10)%1024)+7)%1024)]*2.0))*4.0))+(((((((((input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+12)%1024)]*9.0)+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+12)%1024)+1)%1024)]*8.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+12)%1024)+2)%1024)]*7.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+12)%1024)+3)%1024)]*6.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+12)%1024)+4)%1024)]*5.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+12)%1024)+5)%1024)]*4.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+12)%1024)+6)%1024)]*3.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+12)%1024)+7)%1024)]*2.0))*3.0))+(((((((((input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+14)%1024)]*9.0)+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+14)%1024)+1)%1024)]*8.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+14)%1024)+2)%1024)]*7.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+14)%1024)+3)%1024)]*6.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+14)%1024)+4)%1024)]*5.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+14)%1024)+5)%1024)]*4.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+14)%1024)+6)%1024)]*3.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+14)%1024)+7)%1024)]*2.0))*2.0))*5.0))+(((((((((((((((((input4[(((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)]*9.0)+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+1)%1024)]*8.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+2)%1024)]*7.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+3)%1024)]*6.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+4)%1024)]*5.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+5)%1024)]*4.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+6)%1024)]*3.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+7)%1024)]*2.0))*9.0)+(((((((((input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+2)%1024)]*9.0)+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+2)%1024)+1)%1024)]*8.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+2)%1024)+2)%1024)]*7.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+2)%1024)+3)%1024)]*6.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+2)%1024)+4)%1024)]*5.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+2)%1024)+5)%1024)]*4.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+2)%1024)+6)%1024)]*3.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+2)%1024)+7)%1024)]*2.0))*8.0))+(((((((((input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+4)%1024)]*9.0)+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+4)%1024)+1)%1024)]*8.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+4)%1024)+2)%1024)]*7.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+4)%1024)+3)%1024)]*6.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+4)%1024)+4)%1024)]*5.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+4)%1024)+5)%1024)]*4.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+4)%1024)+6)%1024)]*3.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+4)%1024)+7)%1024)]*2.0))*7.0))+(((((((((input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+6)%1024)]*9.0)+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+6)%1024)+1)%1024)]*8.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+6)%1024)+2)%1024)]*7.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+6)%1024)+3)%1024)]*6.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+6)%1024)+4)%1024)]*5.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+6)%1024)+5)%1024)]*4.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+6)%1024)+6)%1024)]*3.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+6)%1024)+7)%1024)]*2.0))*6.0))+(((((((((input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+8)%1024)]*9.0)+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+8)%1024)+1)%1024)]*8.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+8)%1024)+2)%1024)]*7.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+8)%1024)+3)%1024)]*6.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+8)%1024)+4)%1024)]*5.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+8)%1024)+5)%1024)]*4.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+8)%1024)+6)%1024)]*3.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+8)%1024)+7)%1024)]*2.0))*5.0))+(((((((((input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+10)%1024)]*9.0)+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+10)%1024)+1)%1024)]*8.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+10)%1024)+2)%1024)]*7.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+10)%1024)+3)%1024)]*6.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+10)%1024)+4)%1024)]*5.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+10)%1024)+5)%1024)]*4.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+10)%1024)+6)%1024)]*3.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+10)%1024)+7)%1024)]*2.0))*4.0))+(((((((((input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+12)%1024)]*9.0)+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+12)%1024)+1)%1024)]*8.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+12)%1024)+2)%1024)]*7.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+12)%1024)+3)%1024)]*6.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+12)%1024)+4)%1024)]*5.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+12)%1024)+5)%1024)]*4.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+12)%1024)+6)%1024)]*3.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+12)%1024)+7)%1024)]*2.0))*3.0))+(((((((((input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+14)%1024)]*9.0)+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+14)%1024)+1)%1024)]*8.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+14)%1024)+2)%1024)]*7.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+14)%1024)+3)%1024)]*6.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+14)%1024)+4)%1024)]*5.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+14)%1024)+5)%1024)]*4.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+14)%1024)+6)%1024)]*3.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+14)%1024)+7)%1024)]*2.0))*2.0))*4.0))+(((((((((((((((((input4[(((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)]*9.0)+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+1)%1024)]*8.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+2)%1024)]*7.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+3)%1024)]*6.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+4)%1024)]*5.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+5)%1024)]*4.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+6)%1024)]*3.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+7)%1024)]*2.0))*9.0)+(((((((((input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+2)%1024)]*9.0)+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+2)%1024)+1)%1024)]*8.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+2)%1024)+2)%1024)]*7.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+2)%1024)+3)%1024)]*6.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+2)%1024)+4)%1024)]*5.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+2)%1024)+5)%1024)]*4.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+2)%1024)+6)%1024)]*3.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+2)%1024)+7)%1024)]*2.0))*8.0))+(((((((((input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+4)%1024)]*9.0)+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+4)%1024)+1)%1024)]*8.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+4)%1024)+2)%1024)]*7.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+4)%1024)+3)%1024)]*6.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+4)%1024)+4)%1024)]*5.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+4)%1024)+5)%1024)]*4.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+4)%1024)+6)%1024)]*3.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+4)%1024)+7)%1024)]*2.0))*7.0))+(((((((((input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+6)%1024)]*9.0)+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+6)%1024)+1)%1024)]*8.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+6)%1024)+2)%1024)]*7.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+6)%1024)+3)%1024)]*6.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+6)%1024)+4)%1024)]*5.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+6)%1024)+5)%1024)]*4.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+6)%1024)+6)%1024)]*3.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+6)%1024)+7)%1024)]*2.0))*6.0))+(((((((((input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+8)%1024)]*9.0)+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+8)%1024)+1)%1024)]*8.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+8)%1024)+2)%1024)]*7.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+8)%1024)+3)%1024)]*6.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+8)%1024)+4)%1024)]*5.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+8)%1024)+5)%1024)]*4.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+8)%1024)+6)%1024)]*3.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+8)%1024)+7)%1024)]*2.0))*5.0))+(((((((((input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+10)%1024)]*9.0)+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+10)%1024)+1)%1024)]*8.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+10)%1024)+2)%1024)]*7.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+10)%1024)+3)%1024)]*6.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+10)%1024)+4)%1024)]*5.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+10)%1024)+5)%1024)]*4.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+10)%1024)+6)%1024)]*3.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+10)%1024)+7)%1024)]*2.0))*4.0))+(((((((((input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+12)%1024)]*9.0)+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+12)%1024)+1)%1024)]*8.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+12)%1024)+2)%1024)]*7.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+12)%1024)+3)%1024)]*6.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+12)%1024)+4)%1024)]*5.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+12)%1024)+5)%1024)]*4.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+12)%1024)+6)%1024)]*3.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+12)%1024)+7)%1024)]*2.0))*3.0))+(((((((((input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+14)%1024)]*9.0)+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+14)%1024)+1)%1024)]*8.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+14)%1024)+2)%1024)]*7.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+14)%1024)+3)%1024)]*6.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+14)%1024)+4)%1024)]*5.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+14)%1024)+5)%1024)]*4.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+14)%1024)+6)%1024)]*3.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+14)%1024)+7)%1024)]*2.0))*2.0))*3.0))+(((((((((((((((((input4[(((threadIdx.x+(blockIdx.x*X_BLOCK))+28)%1024)]*9.0)+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+28)%1024)+1)%1024)]*8.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+28)%1024)+2)%1024)]*7.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+28)%1024)+3)%1024)]*6.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+28)%1024)+4)%1024)]*5.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+28)%1024)+5)%1024)]*4.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+28)%1024)+6)%1024)]*3.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+28)%1024)+7)%1024)]*2.0))*9.0)+(((((((((input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+28)%1024)+2)%1024)]*9.0)+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+28)%1024)+2)%1024)+1)%1024)]*8.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+28)%1024)+2)%1024)+2)%1024)]*7.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+28)%1024)+2)%1024)+3)%1024)]*6.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+28)%1024)+2)%1024)+4)%1024)]*5.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+28)%1024)+2)%1024)+5)%1024)]*4.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+28)%1024)+2)%1024)+6)%1024)]*3.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+28)%1024)+2)%1024)+7)%1024)]*2.0))*8.0))+(((((((((input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+28)%1024)+4)%1024)]*9.0)+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+28)%1024)+4)%1024)+1)%1024)]*8.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+28)%1024)+4)%1024)+2)%1024)]*7.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+28)%1024)+4)%1024)+3)%1024)]*6.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+28)%1024)+4)%1024)+4)%1024)]*5.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+28)%1024)+4)%1024)+5)%1024)]*4.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+28)%1024)+4)%1024)+6)%1024)]*3.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+28)%1024)+4)%1024)+7)%1024)]*2.0))*7.0))+(((((((((input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+28)%1024)+6)%1024)]*9.0)+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+28)%1024)+6)%1024)+1)%1024)]*8.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+28)%1024)+6)%1024)+2)%1024)]*7.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+28)%1024)+6)%1024)+3)%1024)]*6.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+28)%1024)+6)%1024)+4)%1024)]*5.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+28)%1024)+6)%1024)+5)%1024)]*4.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+28)%1024)+6)%1024)+6)%1024)]*3.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+28)%1024)+6)%1024)+7)%1024)]*2.0))*6.0))+(((((((((input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+28)%1024)+8)%1024)]*9.0)+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+28)%1024)+8)%1024)+1)%1024)]*8.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+28)%1024)+8)%1024)+2)%1024)]*7.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+28)%1024)+8)%1024)+3)%1024)]*6.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+28)%1024)+8)%1024)+4)%1024)]*5.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+28)%1024)+8)%1024)+5)%1024)]*4.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+28)%1024)+8)%1024)+6)%1024)]*3.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+28)%1024)+8)%1024)+7)%1024)]*2.0))*5.0))+(((((((((input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+28)%1024)+10)%1024)]*9.0)+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+28)%1024)+10)%1024)+1)%1024)]*8.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+28)%1024)+10)%1024)+2)%1024)]*7.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+28)%1024)+10)%1024)+3)%1024)]*6.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+28)%1024)+10)%1024)+4)%1024)]*5.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+28)%1024)+10)%1024)+5)%1024)]*4.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+28)%1024)+10)%1024)+6)%1024)]*3.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+28)%1024)+10)%1024)+7)%1024)]*2.0))*4.0))+(((((((((input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+28)%1024)+12)%1024)]*9.0)+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+28)%1024)+12)%1024)+1)%1024)]*8.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+28)%1024)+12)%1024)+2)%1024)]*7.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+28)%1024)+12)%1024)+3)%1024)]*6.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+28)%1024)+12)%1024)+4)%1024)]*5.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+28)%1024)+12)%1024)+5)%1024)]*4.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+28)%1024)+12)%1024)+6)%1024)]*3.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+28)%1024)+12)%1024)+7)%1024)]*2.0))*3.0))+(((((((((input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+28)%1024)+14)%1024)]*9.0)+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+28)%1024)+14)%1024)+1)%1024)]*8.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+28)%1024)+14)%1024)+2)%1024)]*7.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+28)%1024)+14)%1024)+3)%1024)]*6.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+28)%1024)+14)%1024)+4)%1024)]*5.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+28)%1024)+14)%1024)+5)%1024)]*4.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+28)%1024)+14)%1024)+6)%1024)]*3.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+28)%1024)+14)%1024)+7)%1024)]*2.0))*2.0))*2.0));
}
#undef X_BLOCK
#undef PITCH
#define X_BLOCK 1024
#define PITCH 1024
extern "C"
__global__ void MRDWT0(float *constant,float *input4,float *result0){
result0[(((blockIdx.y*PITCH)+(blockIdx.x*X_BLOCK))+threadIdx.x)] = (((((((input4[(threadIdx.x+(blockIdx.x*X_BLOCK))]*7.0)+(input4[(((threadIdx.x+(blockIdx.x*X_BLOCK))+1)%1024)]*6.0))+(input4[(((threadIdx.x+(blockIdx.x*X_BLOCK))+2)%1024)]*5.0))+(input4[(((threadIdx.x+(blockIdx.x*X_BLOCK))+3)%1024)]*4.0))+(input4[(((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)]*3.0))+(input4[(((threadIdx.x+(blockIdx.x*X_BLOCK))+5)%1024)]*2.0))+input4[(((threadIdx.x+(blockIdx.x*X_BLOCK))+6)%1024)]);
}
#undef X_BLOCK
#undef PITCH
#define X_BLOCK 1024
#define PITCH 1024
extern "C"
__global__ void MRDWT1(float *constant,float *input4,float *result0){
result0[(((blockIdx.y*PITCH)+(blockIdx.x*X_BLOCK))+threadIdx.x)] = (((((((((((((((input4[(threadIdx.x+(blockIdx.x*X_BLOCK))]*9.0)+(input4[(((threadIdx.x+(blockIdx.x*X_BLOCK))+1)%1024)]*8.0))+(input4[(((threadIdx.x+(blockIdx.x*X_BLOCK))+2)%1024)]*7.0))+(input4[(((threadIdx.x+(blockIdx.x*X_BLOCK))+3)%1024)]*6.0))+(input4[(((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)]*5.0))+(input4[(((threadIdx.x+(blockIdx.x*X_BLOCK))+5)%1024)]*4.0))+(input4[(((threadIdx.x+(blockIdx.x*X_BLOCK))+6)%1024)]*3.0))+(input4[(((threadIdx.x+(blockIdx.x*X_BLOCK))+7)%1024)]*2.0))*7.0)+(((((((((input4[(((threadIdx.x+(blockIdx.x*X_BLOCK))+2)%1024)]*9.0)+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+2)%1024)+1)%1024)]*8.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+2)%1024)+2)%1024)]*7.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+2)%1024)+3)%1024)]*6.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+2)%1024)+4)%1024)]*5.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+2)%1024)+5)%1024)]*4.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+2)%1024)+6)%1024)]*3.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+2)%1024)+7)%1024)]*2.0))*6.0))+(((((((((input4[(((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)]*9.0)+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+1)%1024)]*8.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+2)%1024)]*7.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+3)%1024)]*6.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+4)%1024)]*5.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+5)%1024)]*4.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+6)%1024)]*3.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+7)%1024)]*2.0))*5.0))+(((((((((input4[(((threadIdx.x+(blockIdx.x*X_BLOCK))+6)%1024)]*9.0)+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+6)%1024)+1)%1024)]*8.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+6)%1024)+2)%1024)]*7.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+6)%1024)+3)%1024)]*6.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+6)%1024)+4)%1024)]*5.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+6)%1024)+5)%1024)]*4.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+6)%1024)+6)%1024)]*3.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+6)%1024)+7)%1024)]*2.0))*4.0))+(((((((((input4[(((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)]*9.0)+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+1)%1024)]*8.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+2)%1024)]*7.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+3)%1024)]*6.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+4)%1024)]*5.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+5)%1024)]*4.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+6)%1024)]*3.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+7)%1024)]*2.0))*3.0))+(((((((((input4[(((threadIdx.x+(blockIdx.x*X_BLOCK))+10)%1024)]*9.0)+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+10)%1024)+1)%1024)]*8.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+10)%1024)+2)%1024)]*7.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+10)%1024)+3)%1024)]*6.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+10)%1024)+4)%1024)]*5.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+10)%1024)+5)%1024)]*4.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+10)%1024)+6)%1024)]*3.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+10)%1024)+7)%1024)]*2.0))*2.0))+((((((((input4[(((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)]*9.0)+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+1)%1024)]*8.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+2)%1024)]*7.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+3)%1024)]*6.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+4)%1024)]*5.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+5)%1024)]*4.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+6)%1024)]*3.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+7)%1024)]*2.0)));
}
#undef X_BLOCK
#undef PITCH
#define X_BLOCK 1024
#define PITCH 1024
extern "C"
__global__ void MRDWT2(float *constant,float *input4,float *result0){
result0[(((blockIdx.y*PITCH)+(blockIdx.x*X_BLOCK))+threadIdx.x)] = (((((((((((((((((((((((input4[(threadIdx.x+(blockIdx.x*X_BLOCK))]*9.0)+(input4[(((threadIdx.x+(blockIdx.x*X_BLOCK))+1)%1024)]*8.0))+(input4[(((threadIdx.x+(blockIdx.x*X_BLOCK))+2)%1024)]*7.0))+(input4[(((threadIdx.x+(blockIdx.x*X_BLOCK))+3)%1024)]*6.0))+(input4[(((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)]*5.0))+(input4[(((threadIdx.x+(blockIdx.x*X_BLOCK))+5)%1024)]*4.0))+(input4[(((threadIdx.x+(blockIdx.x*X_BLOCK))+6)%1024)]*3.0))+(input4[(((threadIdx.x+(blockIdx.x*X_BLOCK))+7)%1024)]*2.0))*9.0)+(((((((((input4[(((threadIdx.x+(blockIdx.x*X_BLOCK))+2)%1024)]*9.0)+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+2)%1024)+1)%1024)]*8.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+2)%1024)+2)%1024)]*7.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+2)%1024)+3)%1024)]*6.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+2)%1024)+4)%1024)]*5.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+2)%1024)+5)%1024)]*4.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+2)%1024)+6)%1024)]*3.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+2)%1024)+7)%1024)]*2.0))*8.0))+(((((((((input4[(((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)]*9.0)+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+1)%1024)]*8.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+2)%1024)]*7.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+3)%1024)]*6.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+4)%1024)]*5.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+5)%1024)]*4.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+6)%1024)]*3.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+7)%1024)]*2.0))*7.0))+(((((((((input4[(((threadIdx.x+(blockIdx.x*X_BLOCK))+6)%1024)]*9.0)+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+6)%1024)+1)%1024)]*8.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+6)%1024)+2)%1024)]*7.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+6)%1024)+3)%1024)]*6.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+6)%1024)+4)%1024)]*5.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+6)%1024)+5)%1024)]*4.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+6)%1024)+6)%1024)]*3.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+6)%1024)+7)%1024)]*2.0))*6.0))+(((((((((input4[(((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)]*9.0)+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+1)%1024)]*8.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+2)%1024)]*7.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+3)%1024)]*6.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+4)%1024)]*5.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+5)%1024)]*4.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+6)%1024)]*3.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+7)%1024)]*2.0))*5.0))+(((((((((input4[(((threadIdx.x+(blockIdx.x*X_BLOCK))+10)%1024)]*9.0)+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+10)%1024)+1)%1024)]*8.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+10)%1024)+2)%1024)]*7.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+10)%1024)+3)%1024)]*6.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+10)%1024)+4)%1024)]*5.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+10)%1024)+5)%1024)]*4.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+10)%1024)+6)%1024)]*3.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+10)%1024)+7)%1024)]*2.0))*4.0))+(((((((((input4[(((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)]*9.0)+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+1)%1024)]*8.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+2)%1024)]*7.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+3)%1024)]*6.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+4)%1024)]*5.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+5)%1024)]*4.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+6)%1024)]*3.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+7)%1024)]*2.0))*3.0))+(((((((((input4[(((threadIdx.x+(blockIdx.x*X_BLOCK))+14)%1024)]*9.0)+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+14)%1024)+1)%1024)]*8.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+14)%1024)+2)%1024)]*7.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+14)%1024)+3)%1024)]*6.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+14)%1024)+4)%1024)]*5.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+14)%1024)+5)%1024)]*4.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+14)%1024)+6)%1024)]*3.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+14)%1024)+7)%1024)]*2.0))*2.0))*7.0)+(((((((((((((((((input4[(((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)]*9.0)+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+1)%1024)]*8.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+2)%1024)]*7.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+3)%1024)]*6.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+4)%1024)]*5.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+5)%1024)]*4.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+6)%1024)]*3.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+7)%1024)]*2.0))*9.0)+(((((((((input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+2)%1024)]*9.0)+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+2)%1024)+1)%1024)]*8.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+2)%1024)+2)%1024)]*7.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+2)%1024)+3)%1024)]*6.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+2)%1024)+4)%1024)]*5.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+2)%1024)+5)%1024)]*4.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+2)%1024)+6)%1024)]*3.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+2)%1024)+7)%1024)]*2.0))*8.0))+(((((((((input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+4)%1024)]*9.0)+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+4)%1024)+1)%1024)]*8.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+4)%1024)+2)%1024)]*7.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+4)%1024)+3)%1024)]*6.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+4)%1024)+4)%1024)]*5.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+4)%1024)+5)%1024)]*4.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+4)%1024)+6)%1024)]*3.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+4)%1024)+7)%1024)]*2.0))*7.0))+(((((((((input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+6)%1024)]*9.0)+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+6)%1024)+1)%1024)]*8.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+6)%1024)+2)%1024)]*7.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+6)%1024)+3)%1024)]*6.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+6)%1024)+4)%1024)]*5.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+6)%1024)+5)%1024)]*4.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+6)%1024)+6)%1024)]*3.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+6)%1024)+7)%1024)]*2.0))*6.0))+(((((((((input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+8)%1024)]*9.0)+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+8)%1024)+1)%1024)]*8.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+8)%1024)+2)%1024)]*7.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+8)%1024)+3)%1024)]*6.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+8)%1024)+4)%1024)]*5.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+8)%1024)+5)%1024)]*4.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+8)%1024)+6)%1024)]*3.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+8)%1024)+7)%1024)]*2.0))*5.0))+(((((((((input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+10)%1024)]*9.0)+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+10)%1024)+1)%1024)]*8.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+10)%1024)+2)%1024)]*7.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+10)%1024)+3)%1024)]*6.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+10)%1024)+4)%1024)]*5.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+10)%1024)+5)%1024)]*4.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+10)%1024)+6)%1024)]*3.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+10)%1024)+7)%1024)]*2.0))*4.0))+(((((((((input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+12)%1024)]*9.0)+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+12)%1024)+1)%1024)]*8.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+12)%1024)+2)%1024)]*7.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+12)%1024)+3)%1024)]*6.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+12)%1024)+4)%1024)]*5.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+12)%1024)+5)%1024)]*4.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+12)%1024)+6)%1024)]*3.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+12)%1024)+7)%1024)]*2.0))*3.0))+(((((((((input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+14)%1024)]*9.0)+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+14)%1024)+1)%1024)]*8.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+14)%1024)+2)%1024)]*7.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+14)%1024)+3)%1024)]*6.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+14)%1024)+4)%1024)]*5.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+14)%1024)+5)%1024)]*4.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+14)%1024)+6)%1024)]*3.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4)%1024)+14)%1024)+7)%1024)]*2.0))*2.0))*6.0))+(((((((((((((((((input4[(((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)]*9.0)+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+1)%1024)]*8.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+2)%1024)]*7.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+3)%1024)]*6.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+4)%1024)]*5.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+5)%1024)]*4.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+6)%1024)]*3.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+7)%1024)]*2.0))*9.0)+(((((((((input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+2)%1024)]*9.0)+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+2)%1024)+1)%1024)]*8.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+2)%1024)+2)%1024)]*7.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+2)%1024)+3)%1024)]*6.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+2)%1024)+4)%1024)]*5.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+2)%1024)+5)%1024)]*4.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+2)%1024)+6)%1024)]*3.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+2)%1024)+7)%1024)]*2.0))*8.0))+(((((((((input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+4)%1024)]*9.0)+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+4)%1024)+1)%1024)]*8.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+4)%1024)+2)%1024)]*7.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+4)%1024)+3)%1024)]*6.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+4)%1024)+4)%1024)]*5.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+4)%1024)+5)%1024)]*4.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+4)%1024)+6)%1024)]*3.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+4)%1024)+7)%1024)]*2.0))*7.0))+(((((((((input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+6)%1024)]*9.0)+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+6)%1024)+1)%1024)]*8.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+6)%1024)+2)%1024)]*7.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+6)%1024)+3)%1024)]*6.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+6)%1024)+4)%1024)]*5.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+6)%1024)+5)%1024)]*4.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+6)%1024)+6)%1024)]*3.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+6)%1024)+7)%1024)]*2.0))*6.0))+(((((((((input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+8)%1024)]*9.0)+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+8)%1024)+1)%1024)]*8.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+8)%1024)+2)%1024)]*7.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+8)%1024)+3)%1024)]*6.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+8)%1024)+4)%1024)]*5.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+8)%1024)+5)%1024)]*4.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+8)%1024)+6)%1024)]*3.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+8)%1024)+7)%1024)]*2.0))*5.0))+(((((((((input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+10)%1024)]*9.0)+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+10)%1024)+1)%1024)]*8.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+10)%1024)+2)%1024)]*7.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+10)%1024)+3)%1024)]*6.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+10)%1024)+4)%1024)]*5.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+10)%1024)+5)%1024)]*4.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+10)%1024)+6)%1024)]*3.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+10)%1024)+7)%1024)]*2.0))*4.0))+(((((((((input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+12)%1024)]*9.0)+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+12)%1024)+1)%1024)]*8.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+12)%1024)+2)%1024)]*7.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+12)%1024)+3)%1024)]*6.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+12)%1024)+4)%1024)]*5.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+12)%1024)+5)%1024)]*4.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+12)%1024)+6)%1024)]*3.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+12)%1024)+7)%1024)]*2.0))*3.0))+(((((((((input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+14)%1024)]*9.0)+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+14)%1024)+1)%1024)]*8.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+14)%1024)+2)%1024)]*7.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+14)%1024)+3)%1024)]*6.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+14)%1024)+4)%1024)]*5.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+14)%1024)+5)%1024)]*4.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+14)%1024)+6)%1024)]*3.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+8)%1024)+14)%1024)+7)%1024)]*2.0))*2.0))*5.0))+(((((((((((((((((input4[(((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)]*9.0)+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+1)%1024)]*8.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+2)%1024)]*7.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+3)%1024)]*6.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+4)%1024)]*5.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+5)%1024)]*4.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+6)%1024)]*3.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+7)%1024)]*2.0))*9.0)+(((((((((input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+2)%1024)]*9.0)+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+2)%1024)+1)%1024)]*8.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+2)%1024)+2)%1024)]*7.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+2)%1024)+3)%1024)]*6.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+2)%1024)+4)%1024)]*5.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+2)%1024)+5)%1024)]*4.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+2)%1024)+6)%1024)]*3.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+2)%1024)+7)%1024)]*2.0))*8.0))+(((((((((input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+4)%1024)]*9.0)+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+4)%1024)+1)%1024)]*8.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+4)%1024)+2)%1024)]*7.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+4)%1024)+3)%1024)]*6.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+4)%1024)+4)%1024)]*5.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+4)%1024)+5)%1024)]*4.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+4)%1024)+6)%1024)]*3.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+4)%1024)+7)%1024)]*2.0))*7.0))+(((((((((input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+6)%1024)]*9.0)+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+6)%1024)+1)%1024)]*8.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+6)%1024)+2)%1024)]*7.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+6)%1024)+3)%1024)]*6.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+6)%1024)+4)%1024)]*5.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+6)%1024)+5)%1024)]*4.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+6)%1024)+6)%1024)]*3.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+6)%1024)+7)%1024)]*2.0))*6.0))+(((((((((input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+8)%1024)]*9.0)+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+8)%1024)+1)%1024)]*8.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+8)%1024)+2)%1024)]*7.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+8)%1024)+3)%1024)]*6.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+8)%1024)+4)%1024)]*5.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+8)%1024)+5)%1024)]*4.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+8)%1024)+6)%1024)]*3.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+8)%1024)+7)%1024)]*2.0))*5.0))+(((((((((input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+10)%1024)]*9.0)+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+10)%1024)+1)%1024)]*8.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+10)%1024)+2)%1024)]*7.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+10)%1024)+3)%1024)]*6.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+10)%1024)+4)%1024)]*5.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+10)%1024)+5)%1024)]*4.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+10)%1024)+6)%1024)]*3.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+10)%1024)+7)%1024)]*2.0))*4.0))+(((((((((input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+12)%1024)]*9.0)+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+12)%1024)+1)%1024)]*8.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+12)%1024)+2)%1024)]*7.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+12)%1024)+3)%1024)]*6.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+12)%1024)+4)%1024)]*5.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+12)%1024)+5)%1024)]*4.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+12)%1024)+6)%1024)]*3.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+12)%1024)+7)%1024)]*2.0))*3.0))+(((((((((input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+14)%1024)]*9.0)+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+14)%1024)+1)%1024)]*8.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+14)%1024)+2)%1024)]*7.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+14)%1024)+3)%1024)]*6.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+14)%1024)+4)%1024)]*5.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+14)%1024)+5)%1024)]*4.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+14)%1024)+6)%1024)]*3.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+12)%1024)+14)%1024)+7)%1024)]*2.0))*2.0))*4.0))+(((((((((((((((((input4[(((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)]*9.0)+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+1)%1024)]*8.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+2)%1024)]*7.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+3)%1024)]*6.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+4)%1024)]*5.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+5)%1024)]*4.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+6)%1024)]*3.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+7)%1024)]*2.0))*9.0)+(((((((((input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+2)%1024)]*9.0)+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+2)%1024)+1)%1024)]*8.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+2)%1024)+2)%1024)]*7.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+2)%1024)+3)%1024)]*6.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+2)%1024)+4)%1024)]*5.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+2)%1024)+5)%1024)]*4.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+2)%1024)+6)%1024)]*3.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+2)%1024)+7)%1024)]*2.0))*8.0))+(((((((((input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+4)%1024)]*9.0)+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+4)%1024)+1)%1024)]*8.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+4)%1024)+2)%1024)]*7.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+4)%1024)+3)%1024)]*6.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+4)%1024)+4)%1024)]*5.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+4)%1024)+5)%1024)]*4.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+4)%1024)+6)%1024)]*3.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+4)%1024)+7)%1024)]*2.0))*7.0))+(((((((((input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+6)%1024)]*9.0)+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+6)%1024)+1)%1024)]*8.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+6)%1024)+2)%1024)]*7.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+6)%1024)+3)%1024)]*6.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+6)%1024)+4)%1024)]*5.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+6)%1024)+5)%1024)]*4.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+6)%1024)+6)%1024)]*3.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+6)%1024)+7)%1024)]*2.0))*6.0))+(((((((((input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+8)%1024)]*9.0)+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+8)%1024)+1)%1024)]*8.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+8)%1024)+2)%1024)]*7.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+8)%1024)+3)%1024)]*6.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+8)%1024)+4)%1024)]*5.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+8)%1024)+5)%1024)]*4.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+8)%1024)+6)%1024)]*3.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+8)%1024)+7)%1024)]*2.0))*5.0))+(((((((((input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+10)%1024)]*9.0)+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+10)%1024)+1)%1024)]*8.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+10)%1024)+2)%1024)]*7.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+10)%1024)+3)%1024)]*6.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+10)%1024)+4)%1024)]*5.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+10)%1024)+5)%1024)]*4.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+10)%1024)+6)%1024)]*3.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+10)%1024)+7)%1024)]*2.0))*4.0))+(((((((((input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+12)%1024)]*9.0)+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+12)%1024)+1)%1024)]*8.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+12)%1024)+2)%1024)]*7.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+12)%1024)+3)%1024)]*6.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+12)%1024)+4)%1024)]*5.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+12)%1024)+5)%1024)]*4.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+12)%1024)+6)%1024)]*3.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+12)%1024)+7)%1024)]*2.0))*3.0))+(((((((((input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+14)%1024)]*9.0)+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+14)%1024)+1)%1024)]*8.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+14)%1024)+2)%1024)]*7.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+14)%1024)+3)%1024)]*6.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+14)%1024)+4)%1024)]*5.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+14)%1024)+5)%1024)]*4.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+14)%1024)+6)%1024)]*3.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+16)%1024)+14)%1024)+7)%1024)]*2.0))*2.0))*3.0))+(((((((((((((((((input4[(((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)]*9.0)+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+1)%1024)]*8.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+2)%1024)]*7.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+3)%1024)]*6.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+4)%1024)]*5.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+5)%1024)]*4.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+6)%1024)]*3.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+7)%1024)]*2.0))*9.0)+(((((((((input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+2)%1024)]*9.0)+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+2)%1024)+1)%1024)]*8.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+2)%1024)+2)%1024)]*7.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+2)%1024)+3)%1024)]*6.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+2)%1024)+4)%1024)]*5.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+2)%1024)+5)%1024)]*4.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+2)%1024)+6)%1024)]*3.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+2)%1024)+7)%1024)]*2.0))*8.0))+(((((((((input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+4)%1024)]*9.0)+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+4)%1024)+1)%1024)]*8.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+4)%1024)+2)%1024)]*7.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+4)%1024)+3)%1024)]*6.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+4)%1024)+4)%1024)]*5.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+4)%1024)+5)%1024)]*4.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+4)%1024)+6)%1024)]*3.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+4)%1024)+7)%1024)]*2.0))*7.0))+(((((((((input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+6)%1024)]*9.0)+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+6)%1024)+1)%1024)]*8.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+6)%1024)+2)%1024)]*7.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+6)%1024)+3)%1024)]*6.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+6)%1024)+4)%1024)]*5.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+6)%1024)+5)%1024)]*4.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+6)%1024)+6)%1024)]*3.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+6)%1024)+7)%1024)]*2.0))*6.0))+(((((((((input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+8)%1024)]*9.0)+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+8)%1024)+1)%1024)]*8.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+8)%1024)+2)%1024)]*7.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+8)%1024)+3)%1024)]*6.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+8)%1024)+4)%1024)]*5.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+8)%1024)+5)%1024)]*4.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+8)%1024)+6)%1024)]*3.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+8)%1024)+7)%1024)]*2.0))*5.0))+(((((((((input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+10)%1024)]*9.0)+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+10)%1024)+1)%1024)]*8.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+10)%1024)+2)%1024)]*7.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+10)%1024)+3)%1024)]*6.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+10)%1024)+4)%1024)]*5.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+10)%1024)+5)%1024)]*4.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+10)%1024)+6)%1024)]*3.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+10)%1024)+7)%1024)]*2.0))*4.0))+(((((((((input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+12)%1024)]*9.0)+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+12)%1024)+1)%1024)]*8.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+12)%1024)+2)%1024)]*7.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+12)%1024)+3)%1024)]*6.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+12)%1024)+4)%1024)]*5.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+12)%1024)+5)%1024)]*4.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+12)%1024)+6)%1024)]*3.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+12)%1024)+7)%1024)]*2.0))*3.0))+(((((((((input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+14)%1024)]*9.0)+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+14)%1024)+1)%1024)]*8.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+14)%1024)+2)%1024)]*7.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+14)%1024)+3)%1024)]*6.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+14)%1024)+4)%1024)]*5.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+14)%1024)+5)%1024)]*4.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+14)%1024)+6)%1024)]*3.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+20)%1024)+14)%1024)+7)%1024)]*2.0))*2.0))*2.0))+((((((((((((((((input4[(((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)]*9.0)+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+1)%1024)]*8.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+2)%1024)]*7.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+3)%1024)]*6.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+4)%1024)]*5.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+5)%1024)]*4.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+6)%1024)]*3.0))+(input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+7)%1024)]*2.0))*9.0)+(((((((((input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+2)%1024)]*9.0)+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+2)%1024)+1)%1024)]*8.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+2)%1024)+2)%1024)]*7.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+2)%1024)+3)%1024)]*6.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+2)%1024)+4)%1024)]*5.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+2)%1024)+5)%1024)]*4.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+2)%1024)+6)%1024)]*3.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+2)%1024)+7)%1024)]*2.0))*8.0))+(((((((((input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+4)%1024)]*9.0)+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+4)%1024)+1)%1024)]*8.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+4)%1024)+2)%1024)]*7.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+4)%1024)+3)%1024)]*6.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+4)%1024)+4)%1024)]*5.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+4)%1024)+5)%1024)]*4.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+4)%1024)+6)%1024)]*3.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+4)%1024)+7)%1024)]*2.0))*7.0))+(((((((((input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+6)%1024)]*9.0)+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+6)%1024)+1)%1024)]*8.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+6)%1024)+2)%1024)]*7.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+6)%1024)+3)%1024)]*6.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+6)%1024)+4)%1024)]*5.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+6)%1024)+5)%1024)]*4.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+6)%1024)+6)%1024)]*3.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+6)%1024)+7)%1024)]*2.0))*6.0))+(((((((((input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+8)%1024)]*9.0)+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+8)%1024)+1)%1024)]*8.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+8)%1024)+2)%1024)]*7.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+8)%1024)+3)%1024)]*6.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+8)%1024)+4)%1024)]*5.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+8)%1024)+5)%1024)]*4.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+8)%1024)+6)%1024)]*3.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+8)%1024)+7)%1024)]*2.0))*5.0))+(((((((((input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+10)%1024)]*9.0)+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+10)%1024)+1)%1024)]*8.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+10)%1024)+2)%1024)]*7.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+10)%1024)+3)%1024)]*6.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+10)%1024)+4)%1024)]*5.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+10)%1024)+5)%1024)]*4.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+10)%1024)+6)%1024)]*3.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+10)%1024)+7)%1024)]*2.0))*4.0))+(((((((((input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+12)%1024)]*9.0)+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+12)%1024)+1)%1024)]*8.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+12)%1024)+2)%1024)]*7.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+12)%1024)+3)%1024)]*6.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+12)%1024)+4)%1024)]*5.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+12)%1024)+5)%1024)]*4.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+12)%1024)+6)%1024)]*3.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+12)%1024)+7)%1024)]*2.0))*3.0))+(((((((((input4[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+14)%1024)]*9.0)+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+14)%1024)+1)%1024)]*8.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+14)%1024)+2)%1024)]*7.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+14)%1024)+3)%1024)]*6.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+14)%1024)+4)%1024)]*5.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+14)%1024)+5)%1024)]*4.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+14)%1024)+6)%1024)]*3.0))+(input4[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+24)%1024)+14)%1024)+7)%1024)]*2.0))*2.0)));
}
#undef X_BLOCK
#undef PITCH
#define X_BLOCK 1024
#define PITCH 1024
extern "C"
__global__ void MIRDWT(float *constant,float *input5,float *input6,float *input7,float *input8,float *result0){
result0[(((blockIdx.y*PITCH)+(blockIdx.x*X_BLOCK))+threadIdx.x)] = (((((((((((((((((((((((((((input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967280)%1024)+4294967264)%1024)]*10.0)+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967280)%1024)+4294967268)%1024)]*9.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967280)%1024)+4294967272)%1024)]*8.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967280)%1024)+4294967276)%1024)]*7.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967280)%1024)+4294967280)%1024)]*6.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967280)%1024)+4294967284)%1024)]*5.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967280)%1024)+4294967288)%1024)]*4.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967280)%1024)+4294967292)%1024)]*3.0))+((((((((input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967280)%1024)+4294967264)%1024)]*8.0)+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967280)%1024)+4294967268)%1024)]*7.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967280)%1024)+4294967272)%1024)]*6.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967280)%1024)+4294967276)%1024)]*5.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967280)%1024)+4294967280)%1024)]*4.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967280)%1024)+4294967284)%1024)]*3.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967280)%1024)+4294967288)%1024)]*2.0))+input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967280)%1024)+4294967292)%1024)]))*10.0)+((((((((((input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967282)%1024)+4294967264)%1024)]*10.0)+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967282)%1024)+4294967268)%1024)]*9.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967282)%1024)+4294967272)%1024)]*8.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967282)%1024)+4294967276)%1024)]*7.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967282)%1024)+4294967280)%1024)]*6.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967282)%1024)+4294967284)%1024)]*5.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967282)%1024)+4294967288)%1024)]*4.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967282)%1024)+4294967292)%1024)]*3.0))+((((((((input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967282)%1024)+4294967264)%1024)]*8.0)+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967282)%1024)+4294967268)%1024)]*7.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967282)%1024)+4294967272)%1024)]*6.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967282)%1024)+4294967276)%1024)]*5.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967282)%1024)+4294967280)%1024)]*4.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967282)%1024)+4294967284)%1024)]*3.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967282)%1024)+4294967288)%1024)]*2.0))+input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967282)%1024)+4294967292)%1024)]))*9.0))+((((((((((input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967284)%1024)+4294967264)%1024)]*10.0)+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967284)%1024)+4294967268)%1024)]*9.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967284)%1024)+4294967272)%1024)]*8.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967284)%1024)+4294967276)%1024)]*7.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967284)%1024)+4294967280)%1024)]*6.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967284)%1024)+4294967284)%1024)]*5.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967284)%1024)+4294967288)%1024)]*4.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967284)%1024)+4294967292)%1024)]*3.0))+((((((((input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967284)%1024)+4294967264)%1024)]*8.0)+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967284)%1024)+4294967268)%1024)]*7.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967284)%1024)+4294967272)%1024)]*6.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967284)%1024)+4294967276)%1024)]*5.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967284)%1024)+4294967280)%1024)]*4.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967284)%1024)+4294967284)%1024)]*3.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967284)%1024)+4294967288)%1024)]*2.0))+input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967284)%1024)+4294967292)%1024)]))*8.0))+((((((((((input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967286)%1024)+4294967264)%1024)]*10.0)+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967286)%1024)+4294967268)%1024)]*9.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967286)%1024)+4294967272)%1024)]*8.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967286)%1024)+4294967276)%1024)]*7.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967286)%1024)+4294967280)%1024)]*6.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967286)%1024)+4294967284)%1024)]*5.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967286)%1024)+4294967288)%1024)]*4.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967286)%1024)+4294967292)%1024)]*3.0))+((((((((input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967286)%1024)+4294967264)%1024)]*8.0)+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967286)%1024)+4294967268)%1024)]*7.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967286)%1024)+4294967272)%1024)]*6.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967286)%1024)+4294967276)%1024)]*5.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967286)%1024)+4294967280)%1024)]*4.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967286)%1024)+4294967284)%1024)]*3.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967286)%1024)+4294967288)%1024)]*2.0))+input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967286)%1024)+4294967292)%1024)]))*7.0))+((((((((((input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967288)%1024)+4294967264)%1024)]*10.0)+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967288)%1024)+4294967268)%1024)]*9.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967288)%1024)+4294967272)%1024)]*8.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967288)%1024)+4294967276)%1024)]*7.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967288)%1024)+4294967280)%1024)]*6.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967288)%1024)+4294967284)%1024)]*5.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967288)%1024)+4294967288)%1024)]*4.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967288)%1024)+4294967292)%1024)]*3.0))+((((((((input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967288)%1024)+4294967264)%1024)]*8.0)+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967288)%1024)+4294967268)%1024)]*7.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967288)%1024)+4294967272)%1024)]*6.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967288)%1024)+4294967276)%1024)]*5.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967288)%1024)+4294967280)%1024)]*4.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967288)%1024)+4294967284)%1024)]*3.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967288)%1024)+4294967288)%1024)]*2.0))+input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967288)%1024)+4294967292)%1024)]))*6.0))+((((((((((input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967290)%1024)+4294967264)%1024)]*10.0)+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967290)%1024)+4294967268)%1024)]*9.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967290)%1024)+4294967272)%1024)]*8.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967290)%1024)+4294967276)%1024)]*7.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967290)%1024)+4294967280)%1024)]*6.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967290)%1024)+4294967284)%1024)]*5.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967290)%1024)+4294967288)%1024)]*4.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967290)%1024)+4294967292)%1024)]*3.0))+((((((((input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967290)%1024)+4294967264)%1024)]*8.0)+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967290)%1024)+4294967268)%1024)]*7.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967290)%1024)+4294967272)%1024)]*6.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967290)%1024)+4294967276)%1024)]*5.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967290)%1024)+4294967280)%1024)]*4.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967290)%1024)+4294967284)%1024)]*3.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967290)%1024)+4294967288)%1024)]*2.0))+input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967290)%1024)+4294967292)%1024)]))*5.0))+((((((((((input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967292)%1024)+4294967264)%1024)]*10.0)+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967292)%1024)+4294967268)%1024)]*9.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967292)%1024)+4294967272)%1024)]*8.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967292)%1024)+4294967276)%1024)]*7.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967292)%1024)+4294967280)%1024)]*6.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967292)%1024)+4294967284)%1024)]*5.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967292)%1024)+4294967288)%1024)]*4.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967292)%1024)+4294967292)%1024)]*3.0))+((((((((input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967292)%1024)+4294967264)%1024)]*8.0)+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967292)%1024)+4294967268)%1024)]*7.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967292)%1024)+4294967272)%1024)]*6.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967292)%1024)+4294967276)%1024)]*5.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967292)%1024)+4294967280)%1024)]*4.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967292)%1024)+4294967284)%1024)]*3.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967292)%1024)+4294967288)%1024)]*2.0))+input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967292)%1024)+4294967292)%1024)]))*4.0))+((((((((((input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967294)%1024)+4294967264)%1024)]*10.0)+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967294)%1024)+4294967268)%1024)]*9.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967294)%1024)+4294967272)%1024)]*8.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967294)%1024)+4294967276)%1024)]*7.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967294)%1024)+4294967280)%1024)]*6.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967294)%1024)+4294967284)%1024)]*5.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967294)%1024)+4294967288)%1024)]*4.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967294)%1024)+4294967292)%1024)]*3.0))+((((((((input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967294)%1024)+4294967264)%1024)]*8.0)+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967294)%1024)+4294967268)%1024)]*7.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967294)%1024)+4294967272)%1024)]*6.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967294)%1024)+4294967276)%1024)]*5.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967294)%1024)+4294967280)%1024)]*4.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967294)%1024)+4294967284)%1024)]*3.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967294)%1024)+4294967288)%1024)]*2.0))+input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967294)%1024)+4294967292)%1024)]))*3.0))+((((((((input7[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967280)%1024)]*8.0)+(input7[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967282)%1024)]*7.0))+(input7[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967284)%1024)]*6.0))+(input7[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967286)%1024)]*5.0))+(input7[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967288)%1024)]*4.0))+(input7[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967290)%1024)]*3.0))+(input7[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967292)%1024)]*2.0))+input7[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)+4294967294)%1024)]))*10.0)+(((((((((((((((((((input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967280)%1024)+4294967264)%1024)]*10.0)+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967280)%1024)+4294967268)%1024)]*9.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967280)%1024)+4294967272)%1024)]*8.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967280)%1024)+4294967276)%1024)]*7.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967280)%1024)+4294967280)%1024)]*6.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967280)%1024)+4294967284)%1024)]*5.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967280)%1024)+4294967288)%1024)]*4.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967280)%1024)+4294967292)%1024)]*3.0))+((((((((input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967280)%1024)+4294967264)%1024)]*8.0)+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967280)%1024)+4294967268)%1024)]*7.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967280)%1024)+4294967272)%1024)]*6.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967280)%1024)+4294967276)%1024)]*5.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967280)%1024)+4294967280)%1024)]*4.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967280)%1024)+4294967284)%1024)]*3.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967280)%1024)+4294967288)%1024)]*2.0))+input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967280)%1024)+4294967292)%1024)]))*10.0)+((((((((((input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967282)%1024)+4294967264)%1024)]*10.0)+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967282)%1024)+4294967268)%1024)]*9.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967282)%1024)+4294967272)%1024)]*8.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967282)%1024)+4294967276)%1024)]*7.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967282)%1024)+4294967280)%1024)]*6.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967282)%1024)+4294967284)%1024)]*5.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967282)%1024)+4294967288)%1024)]*4.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967282)%1024)+4294967292)%1024)]*3.0))+((((((((input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967282)%1024)+4294967264)%1024)]*8.0)+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967282)%1024)+4294967268)%1024)]*7.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967282)%1024)+4294967272)%1024)]*6.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967282)%1024)+4294967276)%1024)]*5.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967282)%1024)+4294967280)%1024)]*4.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967282)%1024)+4294967284)%1024)]*3.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967282)%1024)+4294967288)%1024)]*2.0))+input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967282)%1024)+4294967292)%1024)]))*9.0))+((((((((((input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967284)%1024)+4294967264)%1024)]*10.0)+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967284)%1024)+4294967268)%1024)]*9.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967284)%1024)+4294967272)%1024)]*8.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967284)%1024)+4294967276)%1024)]*7.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967284)%1024)+4294967280)%1024)]*6.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967284)%1024)+4294967284)%1024)]*5.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967284)%1024)+4294967288)%1024)]*4.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967284)%1024)+4294967292)%1024)]*3.0))+((((((((input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967284)%1024)+4294967264)%1024)]*8.0)+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967284)%1024)+4294967268)%1024)]*7.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967284)%1024)+4294967272)%1024)]*6.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967284)%1024)+4294967276)%1024)]*5.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967284)%1024)+4294967280)%1024)]*4.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967284)%1024)+4294967284)%1024)]*3.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967284)%1024)+4294967288)%1024)]*2.0))+input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967284)%1024)+4294967292)%1024)]))*8.0))+((((((((((input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967286)%1024)+4294967264)%1024)]*10.0)+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967286)%1024)+4294967268)%1024)]*9.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967286)%1024)+4294967272)%1024)]*8.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967286)%1024)+4294967276)%1024)]*7.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967286)%1024)+4294967280)%1024)]*6.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967286)%1024)+4294967284)%1024)]*5.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967286)%1024)+4294967288)%1024)]*4.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967286)%1024)+4294967292)%1024)]*3.0))+((((((((input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967286)%1024)+4294967264)%1024)]*8.0)+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967286)%1024)+4294967268)%1024)]*7.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967286)%1024)+4294967272)%1024)]*6.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967286)%1024)+4294967276)%1024)]*5.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967286)%1024)+4294967280)%1024)]*4.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967286)%1024)+4294967284)%1024)]*3.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967286)%1024)+4294967288)%1024)]*2.0))+input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967286)%1024)+4294967292)%1024)]))*7.0))+((((((((((input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967288)%1024)+4294967264)%1024)]*10.0)+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967288)%1024)+4294967268)%1024)]*9.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967288)%1024)+4294967272)%1024)]*8.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967288)%1024)+4294967276)%1024)]*7.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967288)%1024)+4294967280)%1024)]*6.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967288)%1024)+4294967284)%1024)]*5.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967288)%1024)+4294967288)%1024)]*4.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967288)%1024)+4294967292)%1024)]*3.0))+((((((((input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967288)%1024)+4294967264)%1024)]*8.0)+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967288)%1024)+4294967268)%1024)]*7.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967288)%1024)+4294967272)%1024)]*6.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967288)%1024)+4294967276)%1024)]*5.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967288)%1024)+4294967280)%1024)]*4.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967288)%1024)+4294967284)%1024)]*3.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967288)%1024)+4294967288)%1024)]*2.0))+input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967288)%1024)+4294967292)%1024)]))*6.0))+((((((((((input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967290)%1024)+4294967264)%1024)]*10.0)+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967290)%1024)+4294967268)%1024)]*9.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967290)%1024)+4294967272)%1024)]*8.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967290)%1024)+4294967276)%1024)]*7.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967290)%1024)+4294967280)%1024)]*6.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967290)%1024)+4294967284)%1024)]*5.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967290)%1024)+4294967288)%1024)]*4.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967290)%1024)+4294967292)%1024)]*3.0))+((((((((input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967290)%1024)+4294967264)%1024)]*8.0)+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967290)%1024)+4294967268)%1024)]*7.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967290)%1024)+4294967272)%1024)]*6.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967290)%1024)+4294967276)%1024)]*5.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967290)%1024)+4294967280)%1024)]*4.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967290)%1024)+4294967284)%1024)]*3.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967290)%1024)+4294967288)%1024)]*2.0))+input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967290)%1024)+4294967292)%1024)]))*5.0))+((((((((((input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967292)%1024)+4294967264)%1024)]*10.0)+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967292)%1024)+4294967268)%1024)]*9.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967292)%1024)+4294967272)%1024)]*8.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967292)%1024)+4294967276)%1024)]*7.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967292)%1024)+4294967280)%1024)]*6.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967292)%1024)+4294967284)%1024)]*5.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967292)%1024)+4294967288)%1024)]*4.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967292)%1024)+4294967292)%1024)]*3.0))+((((((((input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967292)%1024)+4294967264)%1024)]*8.0)+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967292)%1024)+4294967268)%1024)]*7.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967292)%1024)+4294967272)%1024)]*6.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967292)%1024)+4294967276)%1024)]*5.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967292)%1024)+4294967280)%1024)]*4.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967292)%1024)+4294967284)%1024)]*3.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967292)%1024)+4294967288)%1024)]*2.0))+input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967292)%1024)+4294967292)%1024)]))*4.0))+((((((((((input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967294)%1024)+4294967264)%1024)]*10.0)+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967294)%1024)+4294967268)%1024)]*9.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967294)%1024)+4294967272)%1024)]*8.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967294)%1024)+4294967276)%1024)]*7.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967294)%1024)+4294967280)%1024)]*6.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967294)%1024)+4294967284)%1024)]*5.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967294)%1024)+4294967288)%1024)]*4.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967294)%1024)+4294967292)%1024)]*3.0))+((((((((input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967294)%1024)+4294967264)%1024)]*8.0)+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967294)%1024)+4294967268)%1024)]*7.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967294)%1024)+4294967272)%1024)]*6.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967294)%1024)+4294967276)%1024)]*5.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967294)%1024)+4294967280)%1024)]*4.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967294)%1024)+4294967284)%1024)]*3.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967294)%1024)+4294967288)%1024)]*2.0))+input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967294)%1024)+4294967292)%1024)]))*3.0))+((((((((input7[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967280)%1024)]*8.0)+(input7[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967282)%1024)]*7.0))+(input7[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967284)%1024)]*6.0))+(input7[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967286)%1024)]*5.0))+(input7[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967288)%1024)]*4.0))+(input7[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967290)%1024)]*3.0))+(input7[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967292)%1024)]*2.0))+input7[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)+4294967294)%1024)]))*9.0))+(((((((((((((((((((input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967280)%1024)+4294967264)%1024)]*10.0)+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967280)%1024)+4294967268)%1024)]*9.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967280)%1024)+4294967272)%1024)]*8.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967280)%1024)+4294967276)%1024)]*7.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967280)%1024)+4294967280)%1024)]*6.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967280)%1024)+4294967284)%1024)]*5.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967280)%1024)+4294967288)%1024)]*4.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967280)%1024)+4294967292)%1024)]*3.0))+((((((((input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967280)%1024)+4294967264)%1024)]*8.0)+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967280)%1024)+4294967268)%1024)]*7.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967280)%1024)+4294967272)%1024)]*6.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967280)%1024)+4294967276)%1024)]*5.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967280)%1024)+4294967280)%1024)]*4.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967280)%1024)+4294967284)%1024)]*3.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967280)%1024)+4294967288)%1024)]*2.0))+input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967280)%1024)+4294967292)%1024)]))*10.0)+((((((((((input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967282)%1024)+4294967264)%1024)]*10.0)+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967282)%1024)+4294967268)%1024)]*9.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967282)%1024)+4294967272)%1024)]*8.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967282)%1024)+4294967276)%1024)]*7.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967282)%1024)+4294967280)%1024)]*6.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967282)%1024)+4294967284)%1024)]*5.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967282)%1024)+4294967288)%1024)]*4.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967282)%1024)+4294967292)%1024)]*3.0))+((((((((input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967282)%1024)+4294967264)%1024)]*8.0)+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967282)%1024)+4294967268)%1024)]*7.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967282)%1024)+4294967272)%1024)]*6.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967282)%1024)+4294967276)%1024)]*5.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967282)%1024)+4294967280)%1024)]*4.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967282)%1024)+4294967284)%1024)]*3.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967282)%1024)+4294967288)%1024)]*2.0))+input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967282)%1024)+4294967292)%1024)]))*9.0))+((((((((((input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967284)%1024)+4294967264)%1024)]*10.0)+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967284)%1024)+4294967268)%1024)]*9.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967284)%1024)+4294967272)%1024)]*8.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967284)%1024)+4294967276)%1024)]*7.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967284)%1024)+4294967280)%1024)]*6.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967284)%1024)+4294967284)%1024)]*5.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967284)%1024)+4294967288)%1024)]*4.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967284)%1024)+4294967292)%1024)]*3.0))+((((((((input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967284)%1024)+4294967264)%1024)]*8.0)+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967284)%1024)+4294967268)%1024)]*7.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967284)%1024)+4294967272)%1024)]*6.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967284)%1024)+4294967276)%1024)]*5.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967284)%1024)+4294967280)%1024)]*4.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967284)%1024)+4294967284)%1024)]*3.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967284)%1024)+4294967288)%1024)]*2.0))+input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967284)%1024)+4294967292)%1024)]))*8.0))+((((((((((input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967286)%1024)+4294967264)%1024)]*10.0)+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967286)%1024)+4294967268)%1024)]*9.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967286)%1024)+4294967272)%1024)]*8.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967286)%1024)+4294967276)%1024)]*7.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967286)%1024)+4294967280)%1024)]*6.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967286)%1024)+4294967284)%1024)]*5.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967286)%1024)+4294967288)%1024)]*4.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967286)%1024)+4294967292)%1024)]*3.0))+((((((((input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967286)%1024)+4294967264)%1024)]*8.0)+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967286)%1024)+4294967268)%1024)]*7.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967286)%1024)+4294967272)%1024)]*6.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967286)%1024)+4294967276)%1024)]*5.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967286)%1024)+4294967280)%1024)]*4.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967286)%1024)+4294967284)%1024)]*3.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967286)%1024)+4294967288)%1024)]*2.0))+input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967286)%1024)+4294967292)%1024)]))*7.0))+((((((((((input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967288)%1024)+4294967264)%1024)]*10.0)+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967288)%1024)+4294967268)%1024)]*9.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967288)%1024)+4294967272)%1024)]*8.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967288)%1024)+4294967276)%1024)]*7.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967288)%1024)+4294967280)%1024)]*6.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967288)%1024)+4294967284)%1024)]*5.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967288)%1024)+4294967288)%1024)]*4.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967288)%1024)+4294967292)%1024)]*3.0))+((((((((input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967288)%1024)+4294967264)%1024)]*8.0)+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967288)%1024)+4294967268)%1024)]*7.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967288)%1024)+4294967272)%1024)]*6.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967288)%1024)+4294967276)%1024)]*5.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967288)%1024)+4294967280)%1024)]*4.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967288)%1024)+4294967284)%1024)]*3.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967288)%1024)+4294967288)%1024)]*2.0))+input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967288)%1024)+4294967292)%1024)]))*6.0))+((((((((((input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967290)%1024)+4294967264)%1024)]*10.0)+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967290)%1024)+4294967268)%1024)]*9.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967290)%1024)+4294967272)%1024)]*8.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967290)%1024)+4294967276)%1024)]*7.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967290)%1024)+4294967280)%1024)]*6.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967290)%1024)+4294967284)%1024)]*5.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967290)%1024)+4294967288)%1024)]*4.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967290)%1024)+4294967292)%1024)]*3.0))+((((((((input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967290)%1024)+4294967264)%1024)]*8.0)+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967290)%1024)+4294967268)%1024)]*7.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967290)%1024)+4294967272)%1024)]*6.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967290)%1024)+4294967276)%1024)]*5.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967290)%1024)+4294967280)%1024)]*4.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967290)%1024)+4294967284)%1024)]*3.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967290)%1024)+4294967288)%1024)]*2.0))+input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967290)%1024)+4294967292)%1024)]))*5.0))+((((((((((input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967292)%1024)+4294967264)%1024)]*10.0)+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967292)%1024)+4294967268)%1024)]*9.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967292)%1024)+4294967272)%1024)]*8.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967292)%1024)+4294967276)%1024)]*7.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967292)%1024)+4294967280)%1024)]*6.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967292)%1024)+4294967284)%1024)]*5.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967292)%1024)+4294967288)%1024)]*4.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967292)%1024)+4294967292)%1024)]*3.0))+((((((((input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967292)%1024)+4294967264)%1024)]*8.0)+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967292)%1024)+4294967268)%1024)]*7.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967292)%1024)+4294967272)%1024)]*6.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967292)%1024)+4294967276)%1024)]*5.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967292)%1024)+4294967280)%1024)]*4.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967292)%1024)+4294967284)%1024)]*3.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967292)%1024)+4294967288)%1024)]*2.0))+input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967292)%1024)+4294967292)%1024)]))*4.0))+((((((((((input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967294)%1024)+4294967264)%1024)]*10.0)+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967294)%1024)+4294967268)%1024)]*9.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967294)%1024)+4294967272)%1024)]*8.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967294)%1024)+4294967276)%1024)]*7.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967294)%1024)+4294967280)%1024)]*6.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967294)%1024)+4294967284)%1024)]*5.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967294)%1024)+4294967288)%1024)]*4.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967294)%1024)+4294967292)%1024)]*3.0))+((((((((input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967294)%1024)+4294967264)%1024)]*8.0)+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967294)%1024)+4294967268)%1024)]*7.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967294)%1024)+4294967272)%1024)]*6.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967294)%1024)+4294967276)%1024)]*5.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967294)%1024)+4294967280)%1024)]*4.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967294)%1024)+4294967284)%1024)]*3.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967294)%1024)+4294967288)%1024)]*2.0))+input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967294)%1024)+4294967292)%1024)]))*3.0))+((((((((input7[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967280)%1024)]*8.0)+(input7[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967282)%1024)]*7.0))+(input7[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967284)%1024)]*6.0))+(input7[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967286)%1024)]*5.0))+(input7[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967288)%1024)]*4.0))+(input7[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967290)%1024)]*3.0))+(input7[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967292)%1024)]*2.0))+input7[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)+4294967294)%1024)]))*8.0))+(((((((((((((((((((input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967280)%1024)+4294967264)%1024)]*10.0)+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967280)%1024)+4294967268)%1024)]*9.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967280)%1024)+4294967272)%1024)]*8.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967280)%1024)+4294967276)%1024)]*7.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967280)%1024)+4294967280)%1024)]*6.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967280)%1024)+4294967284)%1024)]*5.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967280)%1024)+4294967288)%1024)]*4.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967280)%1024)+4294967292)%1024)]*3.0))+((((((((input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967280)%1024)+4294967264)%1024)]*8.0)+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967280)%1024)+4294967268)%1024)]*7.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967280)%1024)+4294967272)%1024)]*6.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967280)%1024)+4294967276)%1024)]*5.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967280)%1024)+4294967280)%1024)]*4.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967280)%1024)+4294967284)%1024)]*3.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967280)%1024)+4294967288)%1024)]*2.0))+input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967280)%1024)+4294967292)%1024)]))*10.0)+((((((((((input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967282)%1024)+4294967264)%1024)]*10.0)+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967282)%1024)+4294967268)%1024)]*9.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967282)%1024)+4294967272)%1024)]*8.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967282)%1024)+4294967276)%1024)]*7.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967282)%1024)+4294967280)%1024)]*6.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967282)%1024)+4294967284)%1024)]*5.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967282)%1024)+4294967288)%1024)]*4.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967282)%1024)+4294967292)%1024)]*3.0))+((((((((input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967282)%1024)+4294967264)%1024)]*8.0)+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967282)%1024)+4294967268)%1024)]*7.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967282)%1024)+4294967272)%1024)]*6.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967282)%1024)+4294967276)%1024)]*5.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967282)%1024)+4294967280)%1024)]*4.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967282)%1024)+4294967284)%1024)]*3.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967282)%1024)+4294967288)%1024)]*2.0))+input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967282)%1024)+4294967292)%1024)]))*9.0))+((((((((((input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967284)%1024)+4294967264)%1024)]*10.0)+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967284)%1024)+4294967268)%1024)]*9.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967284)%1024)+4294967272)%1024)]*8.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967284)%1024)+4294967276)%1024)]*7.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967284)%1024)+4294967280)%1024)]*6.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967284)%1024)+4294967284)%1024)]*5.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967284)%1024)+4294967288)%1024)]*4.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967284)%1024)+4294967292)%1024)]*3.0))+((((((((input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967284)%1024)+4294967264)%1024)]*8.0)+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967284)%1024)+4294967268)%1024)]*7.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967284)%1024)+4294967272)%1024)]*6.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967284)%1024)+4294967276)%1024)]*5.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967284)%1024)+4294967280)%1024)]*4.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967284)%1024)+4294967284)%1024)]*3.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967284)%1024)+4294967288)%1024)]*2.0))+input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967284)%1024)+4294967292)%1024)]))*8.0))+((((((((((input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967286)%1024)+4294967264)%1024)]*10.0)+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967286)%1024)+4294967268)%1024)]*9.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967286)%1024)+4294967272)%1024)]*8.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967286)%1024)+4294967276)%1024)]*7.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967286)%1024)+4294967280)%1024)]*6.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967286)%1024)+4294967284)%1024)]*5.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967286)%1024)+4294967288)%1024)]*4.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967286)%1024)+4294967292)%1024)]*3.0))+((((((((input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967286)%1024)+4294967264)%1024)]*8.0)+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967286)%1024)+4294967268)%1024)]*7.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967286)%1024)+4294967272)%1024)]*6.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967286)%1024)+4294967276)%1024)]*5.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967286)%1024)+4294967280)%1024)]*4.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967286)%1024)+4294967284)%1024)]*3.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967286)%1024)+4294967288)%1024)]*2.0))+input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967286)%1024)+4294967292)%1024)]))*7.0))+((((((((((input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967288)%1024)+4294967264)%1024)]*10.0)+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967288)%1024)+4294967268)%1024)]*9.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967288)%1024)+4294967272)%1024)]*8.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967288)%1024)+4294967276)%1024)]*7.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967288)%1024)+4294967280)%1024)]*6.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967288)%1024)+4294967284)%1024)]*5.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967288)%1024)+4294967288)%1024)]*4.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967288)%1024)+4294967292)%1024)]*3.0))+((((((((input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967288)%1024)+4294967264)%1024)]*8.0)+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967288)%1024)+4294967268)%1024)]*7.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967288)%1024)+4294967272)%1024)]*6.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967288)%1024)+4294967276)%1024)]*5.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967288)%1024)+4294967280)%1024)]*4.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967288)%1024)+4294967284)%1024)]*3.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967288)%1024)+4294967288)%1024)]*2.0))+input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967288)%1024)+4294967292)%1024)]))*6.0))+((((((((((input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967290)%1024)+4294967264)%1024)]*10.0)+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967290)%1024)+4294967268)%1024)]*9.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967290)%1024)+4294967272)%1024)]*8.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967290)%1024)+4294967276)%1024)]*7.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967290)%1024)+4294967280)%1024)]*6.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967290)%1024)+4294967284)%1024)]*5.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967290)%1024)+4294967288)%1024)]*4.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967290)%1024)+4294967292)%1024)]*3.0))+((((((((input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967290)%1024)+4294967264)%1024)]*8.0)+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967290)%1024)+4294967268)%1024)]*7.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967290)%1024)+4294967272)%1024)]*6.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967290)%1024)+4294967276)%1024)]*5.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967290)%1024)+4294967280)%1024)]*4.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967290)%1024)+4294967284)%1024)]*3.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967290)%1024)+4294967288)%1024)]*2.0))+input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967290)%1024)+4294967292)%1024)]))*5.0))+((((((((((input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967292)%1024)+4294967264)%1024)]*10.0)+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967292)%1024)+4294967268)%1024)]*9.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967292)%1024)+4294967272)%1024)]*8.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967292)%1024)+4294967276)%1024)]*7.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967292)%1024)+4294967280)%1024)]*6.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967292)%1024)+4294967284)%1024)]*5.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967292)%1024)+4294967288)%1024)]*4.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967292)%1024)+4294967292)%1024)]*3.0))+((((((((input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967292)%1024)+4294967264)%1024)]*8.0)+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967292)%1024)+4294967268)%1024)]*7.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967292)%1024)+4294967272)%1024)]*6.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967292)%1024)+4294967276)%1024)]*5.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967292)%1024)+4294967280)%1024)]*4.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967292)%1024)+4294967284)%1024)]*3.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967292)%1024)+4294967288)%1024)]*2.0))+input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967292)%1024)+4294967292)%1024)]))*4.0))+((((((((((input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967294)%1024)+4294967264)%1024)]*10.0)+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967294)%1024)+4294967268)%1024)]*9.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967294)%1024)+4294967272)%1024)]*8.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967294)%1024)+4294967276)%1024)]*7.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967294)%1024)+4294967280)%1024)]*6.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967294)%1024)+4294967284)%1024)]*5.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967294)%1024)+4294967288)%1024)]*4.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967294)%1024)+4294967292)%1024)]*3.0))+((((((((input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967294)%1024)+4294967264)%1024)]*8.0)+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967294)%1024)+4294967268)%1024)]*7.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967294)%1024)+4294967272)%1024)]*6.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967294)%1024)+4294967276)%1024)]*5.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967294)%1024)+4294967280)%1024)]*4.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967294)%1024)+4294967284)%1024)]*3.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967294)%1024)+4294967288)%1024)]*2.0))+input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967294)%1024)+4294967292)%1024)]))*3.0))+((((((((input7[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967280)%1024)]*8.0)+(input7[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967282)%1024)]*7.0))+(input7[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967284)%1024)]*6.0))+(input7[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967286)%1024)]*5.0))+(input7[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967288)%1024)]*4.0))+(input7[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967290)%1024)]*3.0))+(input7[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967292)%1024)]*2.0))+input7[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)+4294967294)%1024)]))*7.0))+(((((((((((((((((((input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967280)%1024)+4294967264)%1024)]*10.0)+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967280)%1024)+4294967268)%1024)]*9.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967280)%1024)+4294967272)%1024)]*8.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967280)%1024)+4294967276)%1024)]*7.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967280)%1024)+4294967280)%1024)]*6.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967280)%1024)+4294967284)%1024)]*5.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967280)%1024)+4294967288)%1024)]*4.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967280)%1024)+4294967292)%1024)]*3.0))+((((((((input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967280)%1024)+4294967264)%1024)]*8.0)+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967280)%1024)+4294967268)%1024)]*7.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967280)%1024)+4294967272)%1024)]*6.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967280)%1024)+4294967276)%1024)]*5.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967280)%1024)+4294967280)%1024)]*4.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967280)%1024)+4294967284)%1024)]*3.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967280)%1024)+4294967288)%1024)]*2.0))+input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967280)%1024)+4294967292)%1024)]))*10.0)+((((((((((input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967282)%1024)+4294967264)%1024)]*10.0)+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967282)%1024)+4294967268)%1024)]*9.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967282)%1024)+4294967272)%1024)]*8.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967282)%1024)+4294967276)%1024)]*7.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967282)%1024)+4294967280)%1024)]*6.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967282)%1024)+4294967284)%1024)]*5.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967282)%1024)+4294967288)%1024)]*4.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967282)%1024)+4294967292)%1024)]*3.0))+((((((((input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967282)%1024)+4294967264)%1024)]*8.0)+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967282)%1024)+4294967268)%1024)]*7.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967282)%1024)+4294967272)%1024)]*6.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967282)%1024)+4294967276)%1024)]*5.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967282)%1024)+4294967280)%1024)]*4.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967282)%1024)+4294967284)%1024)]*3.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967282)%1024)+4294967288)%1024)]*2.0))+input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967282)%1024)+4294967292)%1024)]))*9.0))+((((((((((input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967284)%1024)+4294967264)%1024)]*10.0)+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967284)%1024)+4294967268)%1024)]*9.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967284)%1024)+4294967272)%1024)]*8.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967284)%1024)+4294967276)%1024)]*7.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967284)%1024)+4294967280)%1024)]*6.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967284)%1024)+4294967284)%1024)]*5.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967284)%1024)+4294967288)%1024)]*4.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967284)%1024)+4294967292)%1024)]*3.0))+((((((((input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967284)%1024)+4294967264)%1024)]*8.0)+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967284)%1024)+4294967268)%1024)]*7.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967284)%1024)+4294967272)%1024)]*6.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967284)%1024)+4294967276)%1024)]*5.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967284)%1024)+4294967280)%1024)]*4.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967284)%1024)+4294967284)%1024)]*3.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967284)%1024)+4294967288)%1024)]*2.0))+input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967284)%1024)+4294967292)%1024)]))*8.0))+((((((((((input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967286)%1024)+4294967264)%1024)]*10.0)+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967286)%1024)+4294967268)%1024)]*9.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967286)%1024)+4294967272)%1024)]*8.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967286)%1024)+4294967276)%1024)]*7.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967286)%1024)+4294967280)%1024)]*6.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967286)%1024)+4294967284)%1024)]*5.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967286)%1024)+4294967288)%1024)]*4.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967286)%1024)+4294967292)%1024)]*3.0))+((((((((input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967286)%1024)+4294967264)%1024)]*8.0)+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967286)%1024)+4294967268)%1024)]*7.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967286)%1024)+4294967272)%1024)]*6.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967286)%1024)+4294967276)%1024)]*5.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967286)%1024)+4294967280)%1024)]*4.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967286)%1024)+4294967284)%1024)]*3.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967286)%1024)+4294967288)%1024)]*2.0))+input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967286)%1024)+4294967292)%1024)]))*7.0))+((((((((((input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967288)%1024)+4294967264)%1024)]*10.0)+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967288)%1024)+4294967268)%1024)]*9.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967288)%1024)+4294967272)%1024)]*8.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967288)%1024)+4294967276)%1024)]*7.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967288)%1024)+4294967280)%1024)]*6.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967288)%1024)+4294967284)%1024)]*5.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967288)%1024)+4294967288)%1024)]*4.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967288)%1024)+4294967292)%1024)]*3.0))+((((((((input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967288)%1024)+4294967264)%1024)]*8.0)+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967288)%1024)+4294967268)%1024)]*7.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967288)%1024)+4294967272)%1024)]*6.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967288)%1024)+4294967276)%1024)]*5.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967288)%1024)+4294967280)%1024)]*4.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967288)%1024)+4294967284)%1024)]*3.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967288)%1024)+4294967288)%1024)]*2.0))+input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967288)%1024)+4294967292)%1024)]))*6.0))+((((((((((input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967290)%1024)+4294967264)%1024)]*10.0)+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967290)%1024)+4294967268)%1024)]*9.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967290)%1024)+4294967272)%1024)]*8.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967290)%1024)+4294967276)%1024)]*7.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967290)%1024)+4294967280)%1024)]*6.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967290)%1024)+4294967284)%1024)]*5.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967290)%1024)+4294967288)%1024)]*4.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967290)%1024)+4294967292)%1024)]*3.0))+((((((((input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967290)%1024)+4294967264)%1024)]*8.0)+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967290)%1024)+4294967268)%1024)]*7.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967290)%1024)+4294967272)%1024)]*6.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967290)%1024)+4294967276)%1024)]*5.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967290)%1024)+4294967280)%1024)]*4.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967290)%1024)+4294967284)%1024)]*3.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967290)%1024)+4294967288)%1024)]*2.0))+input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967290)%1024)+4294967292)%1024)]))*5.0))+((((((((((input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967292)%1024)+4294967264)%1024)]*10.0)+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967292)%1024)+4294967268)%1024)]*9.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967292)%1024)+4294967272)%1024)]*8.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967292)%1024)+4294967276)%1024)]*7.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967292)%1024)+4294967280)%1024)]*6.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967292)%1024)+4294967284)%1024)]*5.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967292)%1024)+4294967288)%1024)]*4.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967292)%1024)+4294967292)%1024)]*3.0))+((((((((input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967292)%1024)+4294967264)%1024)]*8.0)+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967292)%1024)+4294967268)%1024)]*7.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967292)%1024)+4294967272)%1024)]*6.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967292)%1024)+4294967276)%1024)]*5.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967292)%1024)+4294967280)%1024)]*4.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967292)%1024)+4294967284)%1024)]*3.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967292)%1024)+4294967288)%1024)]*2.0))+input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967292)%1024)+4294967292)%1024)]))*4.0))+((((((((((input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967294)%1024)+4294967264)%1024)]*10.0)+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967294)%1024)+4294967268)%1024)]*9.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967294)%1024)+4294967272)%1024)]*8.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967294)%1024)+4294967276)%1024)]*7.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967294)%1024)+4294967280)%1024)]*6.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967294)%1024)+4294967284)%1024)]*5.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967294)%1024)+4294967288)%1024)]*4.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967294)%1024)+4294967292)%1024)]*3.0))+((((((((input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967294)%1024)+4294967264)%1024)]*8.0)+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967294)%1024)+4294967268)%1024)]*7.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967294)%1024)+4294967272)%1024)]*6.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967294)%1024)+4294967276)%1024)]*5.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967294)%1024)+4294967280)%1024)]*4.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967294)%1024)+4294967284)%1024)]*3.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967294)%1024)+4294967288)%1024)]*2.0))+input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967294)%1024)+4294967292)%1024)]))*3.0))+((((((((input7[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967280)%1024)]*8.0)+(input7[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967282)%1024)]*7.0))+(input7[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967284)%1024)]*6.0))+(input7[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967286)%1024)]*5.0))+(input7[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967288)%1024)]*4.0))+(input7[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967290)%1024)]*3.0))+(input7[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967292)%1024)]*2.0))+input7[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)+4294967294)%1024)]))*6.0))+(((((((((((((((((((input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967280)%1024)+4294967264)%1024)]*10.0)+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967280)%1024)+4294967268)%1024)]*9.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967280)%1024)+4294967272)%1024)]*8.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967280)%1024)+4294967276)%1024)]*7.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967280)%1024)+4294967280)%1024)]*6.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967280)%1024)+4294967284)%1024)]*5.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967280)%1024)+4294967288)%1024)]*4.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967280)%1024)+4294967292)%1024)]*3.0))+((((((((input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967280)%1024)+4294967264)%1024)]*8.0)+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967280)%1024)+4294967268)%1024)]*7.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967280)%1024)+4294967272)%1024)]*6.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967280)%1024)+4294967276)%1024)]*5.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967280)%1024)+4294967280)%1024)]*4.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967280)%1024)+4294967284)%1024)]*3.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967280)%1024)+4294967288)%1024)]*2.0))+input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967280)%1024)+4294967292)%1024)]))*10.0)+((((((((((input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967282)%1024)+4294967264)%1024)]*10.0)+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967282)%1024)+4294967268)%1024)]*9.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967282)%1024)+4294967272)%1024)]*8.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967282)%1024)+4294967276)%1024)]*7.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967282)%1024)+4294967280)%1024)]*6.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967282)%1024)+4294967284)%1024)]*5.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967282)%1024)+4294967288)%1024)]*4.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967282)%1024)+4294967292)%1024)]*3.0))+((((((((input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967282)%1024)+4294967264)%1024)]*8.0)+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967282)%1024)+4294967268)%1024)]*7.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967282)%1024)+4294967272)%1024)]*6.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967282)%1024)+4294967276)%1024)]*5.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967282)%1024)+4294967280)%1024)]*4.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967282)%1024)+4294967284)%1024)]*3.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967282)%1024)+4294967288)%1024)]*2.0))+input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967282)%1024)+4294967292)%1024)]))*9.0))+((((((((((input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967284)%1024)+4294967264)%1024)]*10.0)+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967284)%1024)+4294967268)%1024)]*9.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967284)%1024)+4294967272)%1024)]*8.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967284)%1024)+4294967276)%1024)]*7.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967284)%1024)+4294967280)%1024)]*6.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967284)%1024)+4294967284)%1024)]*5.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967284)%1024)+4294967288)%1024)]*4.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967284)%1024)+4294967292)%1024)]*3.0))+((((((((input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967284)%1024)+4294967264)%1024)]*8.0)+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967284)%1024)+4294967268)%1024)]*7.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967284)%1024)+4294967272)%1024)]*6.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967284)%1024)+4294967276)%1024)]*5.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967284)%1024)+4294967280)%1024)]*4.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967284)%1024)+4294967284)%1024)]*3.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967284)%1024)+4294967288)%1024)]*2.0))+input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967284)%1024)+4294967292)%1024)]))*8.0))+((((((((((input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967286)%1024)+4294967264)%1024)]*10.0)+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967286)%1024)+4294967268)%1024)]*9.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967286)%1024)+4294967272)%1024)]*8.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967286)%1024)+4294967276)%1024)]*7.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967286)%1024)+4294967280)%1024)]*6.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967286)%1024)+4294967284)%1024)]*5.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967286)%1024)+4294967288)%1024)]*4.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967286)%1024)+4294967292)%1024)]*3.0))+((((((((input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967286)%1024)+4294967264)%1024)]*8.0)+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967286)%1024)+4294967268)%1024)]*7.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967286)%1024)+4294967272)%1024)]*6.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967286)%1024)+4294967276)%1024)]*5.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967286)%1024)+4294967280)%1024)]*4.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967286)%1024)+4294967284)%1024)]*3.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967286)%1024)+4294967288)%1024)]*2.0))+input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967286)%1024)+4294967292)%1024)]))*7.0))+((((((((((input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967288)%1024)+4294967264)%1024)]*10.0)+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967288)%1024)+4294967268)%1024)]*9.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967288)%1024)+4294967272)%1024)]*8.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967288)%1024)+4294967276)%1024)]*7.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967288)%1024)+4294967280)%1024)]*6.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967288)%1024)+4294967284)%1024)]*5.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967288)%1024)+4294967288)%1024)]*4.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967288)%1024)+4294967292)%1024)]*3.0))+((((((((input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967288)%1024)+4294967264)%1024)]*8.0)+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967288)%1024)+4294967268)%1024)]*7.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967288)%1024)+4294967272)%1024)]*6.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967288)%1024)+4294967276)%1024)]*5.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967288)%1024)+4294967280)%1024)]*4.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967288)%1024)+4294967284)%1024)]*3.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967288)%1024)+4294967288)%1024)]*2.0))+input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967288)%1024)+4294967292)%1024)]))*6.0))+((((((((((input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967290)%1024)+4294967264)%1024)]*10.0)+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967290)%1024)+4294967268)%1024)]*9.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967290)%1024)+4294967272)%1024)]*8.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967290)%1024)+4294967276)%1024)]*7.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967290)%1024)+4294967280)%1024)]*6.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967290)%1024)+4294967284)%1024)]*5.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967290)%1024)+4294967288)%1024)]*4.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967290)%1024)+4294967292)%1024)]*3.0))+((((((((input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967290)%1024)+4294967264)%1024)]*8.0)+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967290)%1024)+4294967268)%1024)]*7.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967290)%1024)+4294967272)%1024)]*6.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967290)%1024)+4294967276)%1024)]*5.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967290)%1024)+4294967280)%1024)]*4.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967290)%1024)+4294967284)%1024)]*3.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967290)%1024)+4294967288)%1024)]*2.0))+input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967290)%1024)+4294967292)%1024)]))*5.0))+((((((((((input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967292)%1024)+4294967264)%1024)]*10.0)+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967292)%1024)+4294967268)%1024)]*9.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967292)%1024)+4294967272)%1024)]*8.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967292)%1024)+4294967276)%1024)]*7.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967292)%1024)+4294967280)%1024)]*6.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967292)%1024)+4294967284)%1024)]*5.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967292)%1024)+4294967288)%1024)]*4.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967292)%1024)+4294967292)%1024)]*3.0))+((((((((input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967292)%1024)+4294967264)%1024)]*8.0)+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967292)%1024)+4294967268)%1024)]*7.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967292)%1024)+4294967272)%1024)]*6.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967292)%1024)+4294967276)%1024)]*5.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967292)%1024)+4294967280)%1024)]*4.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967292)%1024)+4294967284)%1024)]*3.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967292)%1024)+4294967288)%1024)]*2.0))+input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967292)%1024)+4294967292)%1024)]))*4.0))+((((((((((input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967294)%1024)+4294967264)%1024)]*10.0)+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967294)%1024)+4294967268)%1024)]*9.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967294)%1024)+4294967272)%1024)]*8.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967294)%1024)+4294967276)%1024)]*7.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967294)%1024)+4294967280)%1024)]*6.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967294)%1024)+4294967284)%1024)]*5.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967294)%1024)+4294967288)%1024)]*4.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967294)%1024)+4294967292)%1024)]*3.0))+((((((((input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967294)%1024)+4294967264)%1024)]*8.0)+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967294)%1024)+4294967268)%1024)]*7.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967294)%1024)+4294967272)%1024)]*6.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967294)%1024)+4294967276)%1024)]*5.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967294)%1024)+4294967280)%1024)]*4.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967294)%1024)+4294967284)%1024)]*3.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967294)%1024)+4294967288)%1024)]*2.0))+input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967294)%1024)+4294967292)%1024)]))*3.0))+((((((((input7[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967280)%1024)]*8.0)+(input7[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967282)%1024)]*7.0))+(input7[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967284)%1024)]*6.0))+(input7[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967286)%1024)]*5.0))+(input7[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967288)%1024)]*4.0))+(input7[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967290)%1024)]*3.0))+(input7[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967292)%1024)]*2.0))+input7[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)+4294967294)%1024)]))*5.0))+(((((((((((((((((((input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967280)%1024)+4294967264)%1024)]*10.0)+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967280)%1024)+4294967268)%1024)]*9.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967280)%1024)+4294967272)%1024)]*8.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967280)%1024)+4294967276)%1024)]*7.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967280)%1024)+4294967280)%1024)]*6.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967280)%1024)+4294967284)%1024)]*5.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967280)%1024)+4294967288)%1024)]*4.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967280)%1024)+4294967292)%1024)]*3.0))+((((((((input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967280)%1024)+4294967264)%1024)]*8.0)+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967280)%1024)+4294967268)%1024)]*7.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967280)%1024)+4294967272)%1024)]*6.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967280)%1024)+4294967276)%1024)]*5.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967280)%1024)+4294967280)%1024)]*4.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967280)%1024)+4294967284)%1024)]*3.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967280)%1024)+4294967288)%1024)]*2.0))+input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967280)%1024)+4294967292)%1024)]))*10.0)+((((((((((input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967282)%1024)+4294967264)%1024)]*10.0)+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967282)%1024)+4294967268)%1024)]*9.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967282)%1024)+4294967272)%1024)]*8.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967282)%1024)+4294967276)%1024)]*7.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967282)%1024)+4294967280)%1024)]*6.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967282)%1024)+4294967284)%1024)]*5.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967282)%1024)+4294967288)%1024)]*4.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967282)%1024)+4294967292)%1024)]*3.0))+((((((((input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967282)%1024)+4294967264)%1024)]*8.0)+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967282)%1024)+4294967268)%1024)]*7.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967282)%1024)+4294967272)%1024)]*6.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967282)%1024)+4294967276)%1024)]*5.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967282)%1024)+4294967280)%1024)]*4.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967282)%1024)+4294967284)%1024)]*3.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967282)%1024)+4294967288)%1024)]*2.0))+input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967282)%1024)+4294967292)%1024)]))*9.0))+((((((((((input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967284)%1024)+4294967264)%1024)]*10.0)+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967284)%1024)+4294967268)%1024)]*9.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967284)%1024)+4294967272)%1024)]*8.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967284)%1024)+4294967276)%1024)]*7.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967284)%1024)+4294967280)%1024)]*6.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967284)%1024)+4294967284)%1024)]*5.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967284)%1024)+4294967288)%1024)]*4.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967284)%1024)+4294967292)%1024)]*3.0))+((((((((input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967284)%1024)+4294967264)%1024)]*8.0)+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967284)%1024)+4294967268)%1024)]*7.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967284)%1024)+4294967272)%1024)]*6.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967284)%1024)+4294967276)%1024)]*5.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967284)%1024)+4294967280)%1024)]*4.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967284)%1024)+4294967284)%1024)]*3.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967284)%1024)+4294967288)%1024)]*2.0))+input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967284)%1024)+4294967292)%1024)]))*8.0))+((((((((((input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967286)%1024)+4294967264)%1024)]*10.0)+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967286)%1024)+4294967268)%1024)]*9.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967286)%1024)+4294967272)%1024)]*8.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967286)%1024)+4294967276)%1024)]*7.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967286)%1024)+4294967280)%1024)]*6.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967286)%1024)+4294967284)%1024)]*5.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967286)%1024)+4294967288)%1024)]*4.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967286)%1024)+4294967292)%1024)]*3.0))+((((((((input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967286)%1024)+4294967264)%1024)]*8.0)+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967286)%1024)+4294967268)%1024)]*7.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967286)%1024)+4294967272)%1024)]*6.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967286)%1024)+4294967276)%1024)]*5.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967286)%1024)+4294967280)%1024)]*4.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967286)%1024)+4294967284)%1024)]*3.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967286)%1024)+4294967288)%1024)]*2.0))+input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967286)%1024)+4294967292)%1024)]))*7.0))+((((((((((input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967288)%1024)+4294967264)%1024)]*10.0)+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967288)%1024)+4294967268)%1024)]*9.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967288)%1024)+4294967272)%1024)]*8.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967288)%1024)+4294967276)%1024)]*7.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967288)%1024)+4294967280)%1024)]*6.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967288)%1024)+4294967284)%1024)]*5.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967288)%1024)+4294967288)%1024)]*4.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967288)%1024)+4294967292)%1024)]*3.0))+((((((((input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967288)%1024)+4294967264)%1024)]*8.0)+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967288)%1024)+4294967268)%1024)]*7.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967288)%1024)+4294967272)%1024)]*6.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967288)%1024)+4294967276)%1024)]*5.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967288)%1024)+4294967280)%1024)]*4.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967288)%1024)+4294967284)%1024)]*3.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967288)%1024)+4294967288)%1024)]*2.0))+input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967288)%1024)+4294967292)%1024)]))*6.0))+((((((((((input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967290)%1024)+4294967264)%1024)]*10.0)+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967290)%1024)+4294967268)%1024)]*9.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967290)%1024)+4294967272)%1024)]*8.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967290)%1024)+4294967276)%1024)]*7.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967290)%1024)+4294967280)%1024)]*6.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967290)%1024)+4294967284)%1024)]*5.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967290)%1024)+4294967288)%1024)]*4.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967290)%1024)+4294967292)%1024)]*3.0))+((((((((input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967290)%1024)+4294967264)%1024)]*8.0)+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967290)%1024)+4294967268)%1024)]*7.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967290)%1024)+4294967272)%1024)]*6.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967290)%1024)+4294967276)%1024)]*5.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967290)%1024)+4294967280)%1024)]*4.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967290)%1024)+4294967284)%1024)]*3.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967290)%1024)+4294967288)%1024)]*2.0))+input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967290)%1024)+4294967292)%1024)]))*5.0))+((((((((((input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967292)%1024)+4294967264)%1024)]*10.0)+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967292)%1024)+4294967268)%1024)]*9.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967292)%1024)+4294967272)%1024)]*8.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967292)%1024)+4294967276)%1024)]*7.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967292)%1024)+4294967280)%1024)]*6.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967292)%1024)+4294967284)%1024)]*5.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967292)%1024)+4294967288)%1024)]*4.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967292)%1024)+4294967292)%1024)]*3.0))+((((((((input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967292)%1024)+4294967264)%1024)]*8.0)+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967292)%1024)+4294967268)%1024)]*7.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967292)%1024)+4294967272)%1024)]*6.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967292)%1024)+4294967276)%1024)]*5.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967292)%1024)+4294967280)%1024)]*4.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967292)%1024)+4294967284)%1024)]*3.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967292)%1024)+4294967288)%1024)]*2.0))+input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967292)%1024)+4294967292)%1024)]))*4.0))+((((((((((input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967294)%1024)+4294967264)%1024)]*10.0)+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967294)%1024)+4294967268)%1024)]*9.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967294)%1024)+4294967272)%1024)]*8.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967294)%1024)+4294967276)%1024)]*7.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967294)%1024)+4294967280)%1024)]*6.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967294)%1024)+4294967284)%1024)]*5.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967294)%1024)+4294967288)%1024)]*4.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967294)%1024)+4294967292)%1024)]*3.0))+((((((((input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967294)%1024)+4294967264)%1024)]*8.0)+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967294)%1024)+4294967268)%1024)]*7.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967294)%1024)+4294967272)%1024)]*6.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967294)%1024)+4294967276)%1024)]*5.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967294)%1024)+4294967280)%1024)]*4.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967294)%1024)+4294967284)%1024)]*3.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967294)%1024)+4294967288)%1024)]*2.0))+input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967294)%1024)+4294967292)%1024)]))*3.0))+((((((((input7[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967280)%1024)]*8.0)+(input7[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967282)%1024)]*7.0))+(input7[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967284)%1024)]*6.0))+(input7[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967286)%1024)]*5.0))+(input7[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967288)%1024)]*4.0))+(input7[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967290)%1024)]*3.0))+(input7[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967292)%1024)]*2.0))+input7[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)+4294967294)%1024)]))*4.0))+(((((((((((((((((((input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967280)%1024)+4294967264)%1024)]*10.0)+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967280)%1024)+4294967268)%1024)]*9.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967280)%1024)+4294967272)%1024)]*8.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967280)%1024)+4294967276)%1024)]*7.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967280)%1024)+4294967280)%1024)]*6.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967280)%1024)+4294967284)%1024)]*5.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967280)%1024)+4294967288)%1024)]*4.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967280)%1024)+4294967292)%1024)]*3.0))+((((((((input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967280)%1024)+4294967264)%1024)]*8.0)+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967280)%1024)+4294967268)%1024)]*7.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967280)%1024)+4294967272)%1024)]*6.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967280)%1024)+4294967276)%1024)]*5.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967280)%1024)+4294967280)%1024)]*4.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967280)%1024)+4294967284)%1024)]*3.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967280)%1024)+4294967288)%1024)]*2.0))+input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967280)%1024)+4294967292)%1024)]))*10.0)+((((((((((input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967282)%1024)+4294967264)%1024)]*10.0)+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967282)%1024)+4294967268)%1024)]*9.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967282)%1024)+4294967272)%1024)]*8.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967282)%1024)+4294967276)%1024)]*7.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967282)%1024)+4294967280)%1024)]*6.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967282)%1024)+4294967284)%1024)]*5.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967282)%1024)+4294967288)%1024)]*4.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967282)%1024)+4294967292)%1024)]*3.0))+((((((((input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967282)%1024)+4294967264)%1024)]*8.0)+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967282)%1024)+4294967268)%1024)]*7.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967282)%1024)+4294967272)%1024)]*6.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967282)%1024)+4294967276)%1024)]*5.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967282)%1024)+4294967280)%1024)]*4.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967282)%1024)+4294967284)%1024)]*3.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967282)%1024)+4294967288)%1024)]*2.0))+input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967282)%1024)+4294967292)%1024)]))*9.0))+((((((((((input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967284)%1024)+4294967264)%1024)]*10.0)+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967284)%1024)+4294967268)%1024)]*9.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967284)%1024)+4294967272)%1024)]*8.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967284)%1024)+4294967276)%1024)]*7.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967284)%1024)+4294967280)%1024)]*6.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967284)%1024)+4294967284)%1024)]*5.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967284)%1024)+4294967288)%1024)]*4.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967284)%1024)+4294967292)%1024)]*3.0))+((((((((input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967284)%1024)+4294967264)%1024)]*8.0)+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967284)%1024)+4294967268)%1024)]*7.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967284)%1024)+4294967272)%1024)]*6.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967284)%1024)+4294967276)%1024)]*5.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967284)%1024)+4294967280)%1024)]*4.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967284)%1024)+4294967284)%1024)]*3.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967284)%1024)+4294967288)%1024)]*2.0))+input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967284)%1024)+4294967292)%1024)]))*8.0))+((((((((((input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967286)%1024)+4294967264)%1024)]*10.0)+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967286)%1024)+4294967268)%1024)]*9.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967286)%1024)+4294967272)%1024)]*8.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967286)%1024)+4294967276)%1024)]*7.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967286)%1024)+4294967280)%1024)]*6.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967286)%1024)+4294967284)%1024)]*5.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967286)%1024)+4294967288)%1024)]*4.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967286)%1024)+4294967292)%1024)]*3.0))+((((((((input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967286)%1024)+4294967264)%1024)]*8.0)+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967286)%1024)+4294967268)%1024)]*7.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967286)%1024)+4294967272)%1024)]*6.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967286)%1024)+4294967276)%1024)]*5.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967286)%1024)+4294967280)%1024)]*4.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967286)%1024)+4294967284)%1024)]*3.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967286)%1024)+4294967288)%1024)]*2.0))+input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967286)%1024)+4294967292)%1024)]))*7.0))+((((((((((input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967288)%1024)+4294967264)%1024)]*10.0)+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967288)%1024)+4294967268)%1024)]*9.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967288)%1024)+4294967272)%1024)]*8.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967288)%1024)+4294967276)%1024)]*7.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967288)%1024)+4294967280)%1024)]*6.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967288)%1024)+4294967284)%1024)]*5.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967288)%1024)+4294967288)%1024)]*4.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967288)%1024)+4294967292)%1024)]*3.0))+((((((((input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967288)%1024)+4294967264)%1024)]*8.0)+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967288)%1024)+4294967268)%1024)]*7.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967288)%1024)+4294967272)%1024)]*6.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967288)%1024)+4294967276)%1024)]*5.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967288)%1024)+4294967280)%1024)]*4.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967288)%1024)+4294967284)%1024)]*3.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967288)%1024)+4294967288)%1024)]*2.0))+input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967288)%1024)+4294967292)%1024)]))*6.0))+((((((((((input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967290)%1024)+4294967264)%1024)]*10.0)+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967290)%1024)+4294967268)%1024)]*9.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967290)%1024)+4294967272)%1024)]*8.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967290)%1024)+4294967276)%1024)]*7.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967290)%1024)+4294967280)%1024)]*6.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967290)%1024)+4294967284)%1024)]*5.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967290)%1024)+4294967288)%1024)]*4.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967290)%1024)+4294967292)%1024)]*3.0))+((((((((input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967290)%1024)+4294967264)%1024)]*8.0)+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967290)%1024)+4294967268)%1024)]*7.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967290)%1024)+4294967272)%1024)]*6.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967290)%1024)+4294967276)%1024)]*5.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967290)%1024)+4294967280)%1024)]*4.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967290)%1024)+4294967284)%1024)]*3.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967290)%1024)+4294967288)%1024)]*2.0))+input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967290)%1024)+4294967292)%1024)]))*5.0))+((((((((((input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967292)%1024)+4294967264)%1024)]*10.0)+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967292)%1024)+4294967268)%1024)]*9.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967292)%1024)+4294967272)%1024)]*8.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967292)%1024)+4294967276)%1024)]*7.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967292)%1024)+4294967280)%1024)]*6.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967292)%1024)+4294967284)%1024)]*5.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967292)%1024)+4294967288)%1024)]*4.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967292)%1024)+4294967292)%1024)]*3.0))+((((((((input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967292)%1024)+4294967264)%1024)]*8.0)+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967292)%1024)+4294967268)%1024)]*7.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967292)%1024)+4294967272)%1024)]*6.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967292)%1024)+4294967276)%1024)]*5.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967292)%1024)+4294967280)%1024)]*4.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967292)%1024)+4294967284)%1024)]*3.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967292)%1024)+4294967288)%1024)]*2.0))+input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967292)%1024)+4294967292)%1024)]))*4.0))+((((((((((input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967294)%1024)+4294967264)%1024)]*10.0)+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967294)%1024)+4294967268)%1024)]*9.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967294)%1024)+4294967272)%1024)]*8.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967294)%1024)+4294967276)%1024)]*7.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967294)%1024)+4294967280)%1024)]*6.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967294)%1024)+4294967284)%1024)]*5.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967294)%1024)+4294967288)%1024)]*4.0))+(input5[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967294)%1024)+4294967292)%1024)]*3.0))+((((((((input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967294)%1024)+4294967264)%1024)]*8.0)+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967294)%1024)+4294967268)%1024)]*7.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967294)%1024)+4294967272)%1024)]*6.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967294)%1024)+4294967276)%1024)]*5.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967294)%1024)+4294967280)%1024)]*4.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967294)%1024)+4294967284)%1024)]*3.0))+(input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967294)%1024)+4294967288)%1024)]*2.0))+input6[(((((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967294)%1024)+4294967292)%1024)]))*3.0))+((((((((input7[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967280)%1024)]*8.0)+(input7[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967282)%1024)]*7.0))+(input7[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967284)%1024)]*6.0))+(input7[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967286)%1024)]*5.0))+(input7[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967288)%1024)]*4.0))+(input7[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967290)%1024)]*3.0))+(input7[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967292)%1024)]*2.0))+input7[(((((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)+4294967294)%1024)]))*3.0))+((((((((input8[(((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967288)%1024)]*8.0)+(input8[(((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967289)%1024)]*7.0))+(input8[(((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967290)%1024)]*6.0))+(input8[(((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967291)%1024)]*5.0))+(input8[(((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967292)%1024)]*4.0))+(input8[(((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967293)%1024)]*3.0))+(input8[(((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967294)%1024)]*2.0))+input8[(((threadIdx.x+(blockIdx.x*X_BLOCK))+4294967295)%1024)]));
}
#undef X_BLOCK
#undef PITCH
|
21,172 | __global__ void init_i32 (int* vector, int vector_ld, int value, int rows, int cols) {
int row = blockIdx.x * blockDim.x + threadIdx.x;
int col = blockIdx.y * blockDim.y + threadIdx.y;
if (row < rows && col < cols) {
vector[row+col*vector_ld] = value;
}
}
extern "C" {
void VectorFragment_init_i32 (int* vector, int vector_ld, int value, int rows, int cols, cudaStream_t stream) {
dim3 blockDim(32, 32);
dim3 gridDim((rows + blockDim.x - 1) / blockDim.x, (cols + blockDim.y - 1) / blockDim.y);
init_i32 <<<gridDim, blockDim, 0, stream>>> (vector, vector_ld, value, rows, cols);
}
}
__global__ void init_f32 (float* vector, int vector_ld, float value, int rows, int cols) {
int row = blockIdx.x * blockDim.x + threadIdx.x;
int col = blockIdx.y * blockDim.y + threadIdx.y;
if (row < rows && col < cols) {
vector[row+col*vector_ld] = value;
}
}
extern "C" {
void VectorFragment_init_f32 (float* vector, int vector_ld, float value, int rows, int cols, cudaStream_t stream) {
dim3 blockDim(32, 32);
dim3 gridDim((rows + blockDim.x - 1) / blockDim.x, (cols + blockDim.y - 1) / blockDim.y);
init_f32 <<<gridDim, blockDim, 0, stream>>> (vector, vector_ld, value, rows, cols);
}
}
__global__ void addValue_i32 (int* vector, int vector_ld, int value, int* output, int output_ld, int rows, int cols) {
int row = blockIdx.x * blockDim.x + threadIdx.x;
int col = blockIdx.y * blockDim.y + threadIdx.y;
if (row < rows && col < cols) {
output[row+col*output_ld] = vector[row+col*vector_ld] + value;
}
}
extern "C" {
void VectorFragment_addValue_i32 (int* vector, int vector_ld, int value, int* output, int output_ld, int rows, int cols, cudaStream_t stream) {
dim3 blockDim(32, 32);
dim3 gridDim((rows + blockDim.x - 1) / blockDim.x, (cols + blockDim.y - 1) / blockDim.y);
addValue_i32 <<<gridDim, blockDim, 0, stream>>> (vector, vector_ld, value, output, output_ld, rows, cols);
}
}
__global__ void addValue_f32 (float* vector, int vector_ld, float value, float* output, int output_ld, int rows, int cols) {
int row = blockIdx.x * blockDim.x + threadIdx.x;
int col = blockIdx.y * blockDim.y + threadIdx.y;
if (row < rows && col < cols) {
output[row+col*output_ld] = vector[row+col*vector_ld] + value;
}
}
extern "C" {
void VectorFragment_addValue_f32 (float* vector, int vector_ld, float value, float* output, int output_ld, int rows, int cols, cudaStream_t stream) {
dim3 blockDim(32, 32);
dim3 gridDim((rows + blockDim.x - 1) / blockDim.x, (cols + blockDim.y - 1) / blockDim.y);
addValue_f32 <<<gridDim, blockDim, 0, stream>>> (vector, vector_ld, value, output, output_ld, rows, cols);
}
}
__global__ void scl_i32 (int* vector, int vector_ld, int value, int* output, int output_ld, int rows, int cols) {
int row = blockIdx.x * blockDim.x + threadIdx.x;
int col = blockIdx.y * blockDim.y + threadIdx.y;
if (row < rows && col < cols) {
output[row+col*output_ld] = vector[row+col*vector_ld] * value;
}
}
extern "C" {
void VectorFragment_scl_i32 (int* vector, int vector_ld, int value, int* output, int output_ld, int rows, int cols, cudaStream_t stream) {
dim3 blockDim(32, 32);
dim3 gridDim((rows + blockDim.x - 1) / blockDim.x, (cols + blockDim.y - 1) / blockDim.y);
scl_i32 <<<gridDim, blockDim, 0, stream>>> (vector, vector_ld, value, output, output_ld, rows, cols);
}
}
__global__ void scl_f32 (float* vector, int vector_ld, float value, float* output, int output_ld, int rows, int cols) {
int row = blockIdx.x * blockDim.x + threadIdx.x;
int col = blockIdx.y * blockDim.y + threadIdx.y;
if (row < rows && col < cols) {
output[row+col*output_ld] = vector[row+col*vector_ld] * value;
}
}
extern "C" {
void VectorFragment_scl_f32 (float* vector, int vector_ld, float value, float* output, int output_ld, int rows, int cols, cudaStream_t stream) {
dim3 blockDim(32, 32);
dim3 gridDim((rows + blockDim.x - 1) / blockDim.x, (cols + blockDim.y - 1) / blockDim.y);
scl_f32 <<<gridDim, blockDim, 0, stream>>> (vector, vector_ld, value, output, output_ld, rows, cols);
}
}
__global__ void add_i32 (int* left_op, int left_op_ld, int* right_op, int right_op_ld, int* output, int output_ld, int rows, int cols) {
int row = blockIdx.x * blockDim.x + threadIdx.x;
int col = blockIdx.y * blockDim.y + threadIdx.y;
if (row < rows && col < cols) {
output[row+col*output_ld] = left_op[row+col*left_op_ld] + right_op[row+col*right_op_ld];
}
}
extern "C" {
void VectorFragment_add_i32 (int* left_op, int left_op_ld, int* right_op, int right_op_ld, int* output, int output_ld, int rows, int cols, cudaStream_t stream) {
dim3 blockDim(32, 32);
dim3 gridDim((rows + blockDim.x - 1) / blockDim.x, (cols + blockDim.y - 1) / blockDim.y);
add_i32 <<<gridDim, blockDim, 0, stream>>> (left_op, left_op_ld, right_op, right_op_ld, output, output_ld, rows, cols);
}
}
__global__ void add_f32 (float* left_op, int left_op_ld, float* right_op, int right_op_ld, float* output, int output_ld, int rows, int cols) {
int row = blockIdx.x * blockDim.x + threadIdx.x;
int col = blockIdx.y * blockDim.y + threadIdx.y;
if (row < rows && col < cols) {
output[row+col*output_ld] = left_op[row+col*left_op_ld] + right_op[row+col*right_op_ld];
}
}
extern "C" {
void VectorFragment_add_f32 (float* left_op, int left_op_ld, float* right_op, int right_op_ld, float* output, int output_ld, int rows, int cols, cudaStream_t stream) {
dim3 blockDim(32, 32);
dim3 gridDim((rows + blockDim.x - 1) / blockDim.x, (cols + blockDim.y - 1) / blockDim.y);
add_f32 <<<gridDim, blockDim, 0, stream>>> (left_op, left_op_ld, right_op, right_op_ld, output, output_ld, rows, cols);
}
}
__global__ void sub_i32 (int* left_op, int left_op_ld, int* right_op, int right_op_ld, int* output, int output_ld, int rows, int cols) {
int row = blockIdx.x * blockDim.x + threadIdx.x;
int col = blockIdx.y * blockDim.y + threadIdx.y;
if (row < rows && col < cols) {
output[row+col*output_ld] = left_op[row+col*left_op_ld] - right_op[row+col*right_op_ld];
}
}
extern "C" {
void VectorFragment_sub_i32 (int* left_op, int left_op_ld, int* right_op, int right_op_ld, int* output, int output_ld, int rows, int cols, cudaStream_t stream) {
dim3 blockDim(32, 32);
dim3 gridDim((rows + blockDim.x - 1) / blockDim.x, (cols + blockDim.y - 1) / blockDim.y);
sub_i32 <<<gridDim, blockDim, 0, stream>>> (left_op, left_op_ld, right_op, right_op_ld, output, output_ld, rows, cols);
}
}
__global__ void sub_f32 (float* left_op, int left_op_ld, float* right_op, int right_op_ld, float* output, int output_ld, int rows, int cols) {
int row = blockIdx.x * blockDim.x + threadIdx.x;
int col = blockIdx.y * blockDim.y + threadIdx.y;
if (row < rows && col < cols) {
output[row+col*output_ld] = left_op[row+col*left_op_ld] - right_op[row+col*right_op_ld];
}
}
extern "C" {
void VectorFragment_sub_f32 (float* left_op, int left_op_ld, float* right_op, int right_op_ld, float* output, int output_ld, int rows, int cols, cudaStream_t stream) {
dim3 blockDim(32, 32);
dim3 gridDim((rows + blockDim.x - 1) / blockDim.x, (cols + blockDim.y - 1) / blockDim.y);
sub_f32 <<<gridDim, blockDim, 0, stream>>> (left_op, left_op_ld, right_op, right_op_ld, output, output_ld, rows, cols);
}
}
__global__ void mult_i32 (int* left_op, int left_op_ld, int* right_op, int right_op_ld, int* output, int output_ld, int rows, int cols) {
int row = blockIdx.x * blockDim.x + threadIdx.x;
int col = blockIdx.y * blockDim.y + threadIdx.y;
if (row < rows && col < cols) {
output[row+col*output_ld] = left_op[row+col*left_op_ld] * right_op[row+col*right_op_ld];
}
}
extern "C" {
void VectorFragment_mult_i32 (int* left_op, int left_op_ld, int* right_op, int right_op_ld, int* output, int output_ld, int rows, int cols, cudaStream_t stream) {
dim3 blockDim(32, 32);
dim3 gridDim((rows + blockDim.x - 1) / blockDim.x, (cols + blockDim.y - 1) / blockDim.y);
mult_i32 <<<gridDim, blockDim, 0, stream>>> (left_op, left_op_ld, right_op, right_op_ld, output, output_ld, rows, cols);
}
}
__global__ void mult_f32 (float* left_op, int left_op_ld, float* right_op, int right_op_ld, float* output, int output_ld, int rows, int cols) {
int row = blockIdx.x * blockDim.x + threadIdx.x;
int col = blockIdx.y * blockDim.y + threadIdx.y;
if (row < rows && col < cols) {
output[row+col*output_ld] = left_op[row+col*left_op_ld] * right_op[row+col*right_op_ld];
}
}
extern "C" {
void VectorFragment_mult_f32 (float* left_op, int left_op_ld, float* right_op, int right_op_ld, float* output, int output_ld, int rows, int cols, cudaStream_t stream) {
dim3 blockDim(32, 32);
dim3 gridDim((rows + blockDim.x - 1) / blockDim.x, (cols + blockDim.y - 1) / blockDim.y);
mult_f32 <<<gridDim, blockDim, 0, stream>>> (left_op, left_op_ld, right_op, right_op_ld, output, output_ld, rows, cols);
}
}
__global__ void square_i32 (int* vector, int vector_ld, int* output, int output_ld, int rows, int cols) {
int row = blockIdx.x * blockDim.x + threadIdx.x;
int col = blockIdx.y * blockDim.y + threadIdx.y;
if (row < rows && col < cols) {
output[row+col*output_ld] = vector[row+col*vector_ld] * vector[row+col*vector_ld];
}
}
extern "C" {
void VectorFragment_square_i32 (int* vector, int vector_ld, int* output, int output_ld, int rows, int cols, cudaStream_t stream) {
dim3 blockDim(32, 32);
dim3 gridDim((rows + blockDim.x - 1) / blockDim.x, (cols + blockDim.y - 1) / blockDim.y);
square_i32 <<<gridDim, blockDim, 0, stream>>> (vector, vector_ld, output, output_ld, rows, cols);
}
}
__global__ void square_f32 (float* vector, int vector_ld, float* output, int output_ld, int rows, int cols) {
int row = blockIdx.x * blockDim.x + threadIdx.x;
int col = blockIdx.y * blockDim.y + threadIdx.y;
if (row < rows && col < cols) {
output[row+col*output_ld] = vector[row+col*vector_ld] * vector[row+col*vector_ld];
}
}
extern "C" {
void VectorFragment_square_f32 (float* vector, int vector_ld, float* output, int output_ld, int rows, int cols, cudaStream_t stream) {
dim3 blockDim(32, 32);
dim3 gridDim((rows + blockDim.x - 1) / blockDim.x, (cols + blockDim.y - 1) / blockDim.y);
square_f32 <<<gridDim, blockDim, 0, stream>>> (vector, vector_ld, output, output_ld, rows, cols);
}
}
__global__ void binarize_i32 (int* vector, int vector_ld, int threshold, int* output, int output_ld, int rows, int cols) {
int row = blockIdx.x * blockDim.x + threadIdx.x;
int col = blockIdx.y * blockDim.y + threadIdx.y;
if (row < rows && col < cols) {
output[row+col*output_ld] = vector[row+col*vector_ld] > threshold ? 1 : 0;
}
}
extern "C" {
void VectorFragment_binarize_i32 (int* vector, int vector_ld, int threshold, int* output, int output_ld, int rows, int cols, cudaStream_t stream) {
dim3 blockDim(32, 32);
dim3 gridDim((rows + blockDim.x - 1) / blockDim.x, (cols + blockDim.y - 1) / blockDim.y);
binarize_i32 <<<gridDim, blockDim, 0, stream>>> (vector, vector_ld, threshold, output, output_ld, rows, cols);
}
}
__global__ void binarize_f32 (float* vector, int vector_ld, float threshold, float* output, int output_ld, int rows, int cols) {
int row = blockIdx.x * blockDim.x + threadIdx.x;
int col = blockIdx.y * blockDim.y + threadIdx.y;
if (row < rows && col < cols) {
output[row+col*output_ld] = vector[row+col*vector_ld] > threshold ? 1 : 0;
}
}
extern "C" {
void VectorFragment_binarize_f32 (float* vector, int vector_ld, float threshold, float* output, int output_ld, int rows, int cols, cudaStream_t stream) {
dim3 blockDim(32, 32);
dim3 gridDim((rows + blockDim.x - 1) / blockDim.x, (cols + blockDim.y - 1) / blockDim.y);
binarize_f32 <<<gridDim, blockDim, 0, stream>>> (vector, vector_ld, threshold, output, output_ld, rows, cols);
}
}
__global__ void aypb_i32 (int a, int* y, int y_ld, int b, int rows, int cols) {
int row = blockIdx.x * blockDim.x + threadIdx.x;
int col = blockIdx.y * blockDim.y + threadIdx.y;
if (row < rows && col < cols) {
y[row+col*y_ld] = a * y[row+col*y_ld] + b;
}
}
extern "C" {
void VectorFragment_aypb_i32 (int a, int* y, int y_ld, int b, int rows, int cols, cudaStream_t stream) {
dim3 blockDim(32, 32);
dim3 gridDim((rows + blockDim.x - 1) / blockDim.x, (cols + blockDim.y - 1) / blockDim.y);
aypb_i32 <<<gridDim, blockDim, 0, stream>>> (a, y, y_ld, b, rows, cols);
}
}
__global__ void aypb_f32 (float a, float* y, int y_ld, float b, int rows, int cols) {
int row = blockIdx.x * blockDim.x + threadIdx.x;
int col = blockIdx.y * blockDim.y + threadIdx.y;
if (row < rows && col < cols) {
y[row+col*y_ld] = a * y[row+col*y_ld] + b;
}
}
extern "C" {
void VectorFragment_aypb_f32 (float a, float* y, int y_ld, float b, int rows, int cols, cudaStream_t stream) {
dim3 blockDim(32, 32);
dim3 gridDim((rows + blockDim.x - 1) / blockDim.x, (cols + blockDim.y - 1) / blockDim.y);
aypb_f32 <<<gridDim, blockDim, 0, stream>>> (a, y, y_ld, b, rows, cols);
}
}
__global__ void axpb_y_i32 (int a, int* x, int x_ld, int b, int* y, int y_ld, int rows, int cols) {
int row = blockIdx.x * blockDim.x + threadIdx.x;
int col = blockIdx.y * blockDim.y + threadIdx.y;
if (row < rows && col < cols) {
y[row+col*y_ld] *= a * x[row+col*x_ld] + b;
}
}
extern "C" {
void VectorFragment_axpb_y_i32 (int a, int* x, int x_ld, int b, int* y, int y_ld, int rows, int cols, cudaStream_t stream) {
dim3 blockDim(32, 32);
dim3 gridDim((rows + blockDim.x - 1) / blockDim.x, (cols + blockDim.y - 1) / blockDim.y);
axpb_y_i32 <<<gridDim, blockDim, 0, stream>>> (a, x, x_ld, b, y, y_ld, rows, cols);
}
}
__global__ void axpb_y_f32 (float a, float* x, int x_ld, float b, float* y, int y_ld, int rows, int cols) {
int row = blockIdx.x * blockDim.x + threadIdx.x;
int col = blockIdx.y * blockDim.y + threadIdx.y;
if (row < rows && col < cols) {
y[row+col*y_ld] *= a * x[row+col*x_ld] + b;
}
}
extern "C" {
void VectorFragment_axpb_y_f32 (float a, float* x, int x_ld, float b, float* y, int y_ld, int rows, int cols, cudaStream_t stream) {
dim3 blockDim(32, 32);
dim3 gridDim((rows + blockDim.x - 1) / blockDim.x, (cols + blockDim.y - 1) / blockDim.y);
axpb_y_f32 <<<gridDim, blockDim, 0, stream>>> (a, x, x_ld, b, y, y_ld, rows, cols);
}
}
__global__ void xvpy_i32 (int* x, int x_ld, int* v, int v_ld, int* y, int y_ld, int rows, int cols) {
int row = blockIdx.x * blockDim.x + threadIdx.x;
int col = blockIdx.y * blockDim.y + threadIdx.y;
if (row < rows && col < cols) {
y[row+col*y_ld] += x[row+col*x_ld] * v[row+col*v_ld];
}
}
extern "C" {
void VectorFragment_xvpy_i32 (int* x, int x_ld, int* v, int v_ld, int* y, int y_ld, int rows, int cols, cudaStream_t stream) {
dim3 blockDim(32, 32);
dim3 gridDim((rows + blockDim.x - 1) / blockDim.x, (cols + blockDim.y - 1) / blockDim.y);
xvpy_i32 <<<gridDim, blockDim, 0, stream>>> (x, x_ld, v, v_ld, y, y_ld, rows, cols);
}
}
__global__ void xvpy_f32 (float* x, int x_ld, float* v, int v_ld, float* y, int y_ld, int rows, int cols) {
int row = blockIdx.x * blockDim.x + threadIdx.x;
int col = blockIdx.y * blockDim.y + threadIdx.y;
if (row < rows && col < cols) {
y[row+col*y_ld] += x[row+col*x_ld] * v[row+col*v_ld];
}
}
extern "C" {
void VectorFragment_xvpy_f32 (float* x, int x_ld, float* v, int v_ld, float* y, int y_ld, int rows, int cols, cudaStream_t stream) {
dim3 blockDim(32, 32);
dim3 gridDim((rows + blockDim.x - 1) / blockDim.x, (cols + blockDim.y - 1) / blockDim.y);
xvpy_f32 <<<gridDim, blockDim, 0, stream>>> (x, x_ld, v, v_ld, y, y_ld, rows, cols);
}
}
__global__ void x_avpb_py_i32 (int* x, int x_ld, int a, int* v, int v_ld, int b, int* y, int y_ld, int rows, int cols) {
int row = blockIdx.x * blockDim.x + threadIdx.x;
int col = blockIdx.y * blockDim.y + threadIdx.y;
if (row < rows && col < cols) {
y[row+col*y_ld] += x[row+col*x_ld] * (a * v[row+col*v_ld] + b);
}
}
extern "C" {
void VectorFragment_x_avpb_py_i32 (int* x, int x_ld, int a, int* v, int v_ld, int b, int* y, int y_ld, int rows, int cols, cudaStream_t stream) {
dim3 blockDim(32, 32);
dim3 gridDim((rows + blockDim.x - 1) / blockDim.x, (cols + blockDim.y - 1) / blockDim.y);
x_avpb_py_i32 <<<gridDim, blockDim, 0, stream>>> (x, x_ld, a, v, v_ld, b, y, y_ld, rows, cols);
}
}
__global__ void x_avpb_py_f32 (float* x, int x_ld, float a, float* v, int v_ld, float b, float* y, int y_ld, int rows, int cols) {
int row = blockIdx.x * blockDim.x + threadIdx.x;
int col = blockIdx.y * blockDim.y + threadIdx.y;
if (row < rows && col < cols) {
y[row+col*y_ld] += x[row+col*x_ld] * (a * v[row+col*v_ld] + b);
}
}
extern "C" {
void VectorFragment_x_avpb_py_f32 (float* x, int x_ld, float a, float* v, int v_ld, float b, float* y, int y_ld, int rows, int cols, cudaStream_t stream) {
dim3 blockDim(32, 32);
dim3 gridDim((rows + blockDim.x - 1) / blockDim.x, (cols + blockDim.y - 1) / blockDim.y);
x_avpb_py_f32 <<<gridDim, blockDim, 0, stream>>> (x, x_ld, a, v, v_ld, b, y, y_ld, rows, cols);
}
}
__global__ void sigmoid_f32 (float* vector, int vector_ld, float* output, int output_ld, int rows, int cols) {
int row = blockIdx.x * blockDim.x + threadIdx.x;
int col = blockIdx.y * blockDim.y + threadIdx.y;
if (row < rows && col < cols) {
float tmp = vector[row+col*vector_ld]; output[row+col*output_ld] = 0.5 - 0.5 * tmp / (1.0 + (tmp < 0.0 ? -tmp : tmp));
}
}
extern "C" {
void VectorFragment_sigmoid_f32 (float* vector, int vector_ld, float* output, int output_ld, int rows, int cols, cudaStream_t stream) {
dim3 blockDim(32, 32);
dim3 gridDim((rows + blockDim.x - 1) / blockDim.x, (cols + blockDim.y - 1) / blockDim.y);
sigmoid_f32 <<<gridDim, blockDim, 0, stream>>> (vector, vector_ld, output, output_ld, rows, cols);
}
}
__global__ void sigmoidDeriv_f32 (float* vector, int vector_ld, float* output, int output_ld, int rows, int cols) {
int row = blockIdx.x * blockDim.x + threadIdx.x;
int col = blockIdx.y * blockDim.y + threadIdx.y;
if (row < rows && col < cols) {
float tmp = 1.0 + (vector[row+col*vector_ld] < 0.0 ? -vector[row+col*vector_ld] : vector[row+col*vector_ld]); output[row+col*output_ld] = - 0.5 / (tmp*tmp);
}
}
extern "C" {
void VectorFragment_sigmoidDeriv_f32 (float* vector, int vector_ld, float* output, int output_ld, int rows, int cols, cudaStream_t stream) {
dim3 blockDim(32, 32);
dim3 gridDim((rows + blockDim.x - 1) / blockDim.x, (cols + blockDim.y - 1) / blockDim.y);
sigmoidDeriv_f32 <<<gridDim, blockDim, 0, stream>>> (vector, vector_ld, output, output_ld, rows, cols);
}
}
__global__ void tanh_f32 (float* vector, int vector_ld, float* output, int output_ld, int rows, int cols) {
int row = blockIdx.x * blockDim.x + threadIdx.x;
int col = blockIdx.y * blockDim.y + threadIdx.y;
if (row < rows && col < cols) {
float tmp = vector[row+col*vector_ld]; output[row+col*output_ld] = tmp / (1.0 + (tmp < 0.0 ? -tmp : tmp));
}
}
extern "C" {
void VectorFragment_tanh_f32 (float* vector, int vector_ld, float* output, int output_ld, int rows, int cols, cudaStream_t stream) {
dim3 blockDim(32, 32);
dim3 gridDim((rows + blockDim.x - 1) / blockDim.x, (cols + blockDim.y - 1) / blockDim.y);
tanh_f32 <<<gridDim, blockDim, 0, stream>>> (vector, vector_ld, output, output_ld, rows, cols);
}
}
__global__ void tanhDeriv_f32 (float* vector, int vector_ld, float* output, int output_ld, int rows, int cols) {
int row = blockIdx.x * blockDim.x + threadIdx.x;
int col = blockIdx.y * blockDim.y + threadIdx.y;
if (row < rows && col < cols) {
float tmp = vector[row+col*vector_ld] < 0.0 ? -vector[row+col*vector_ld] : vector[row+col*vector_ld]; output[row+col*output_ld] = 1.0 / ((1.0+tmp)*(1.0+tmp));
}
}
extern "C" {
void VectorFragment_tanhDeriv_f32 (float* vector, int vector_ld, float* output, int output_ld, int rows, int cols, cudaStream_t stream) {
dim3 blockDim(32, 32);
dim3 gridDim((rows + blockDim.x - 1) / blockDim.x, (cols + blockDim.y - 1) / blockDim.y);
tanhDeriv_f32 <<<gridDim, blockDim, 0, stream>>> (vector, vector_ld, output, output_ld, rows, cols);
}
}
__global__ void relu_f32 (float* vector, int vector_ld, float* output, int output_ld, int rows, int cols) {
int row = blockIdx.x * blockDim.x + threadIdx.x;
int col = blockIdx.y * blockDim.y + threadIdx.y;
if (row < rows && col < cols) {
output[row+col*output_ld] = vector[row+col*vector_ld] > 0.0 ? vector[row+col*vector_ld] : 0.0;
}
}
extern "C" {
void VectorFragment_relu_f32 (float* vector, int vector_ld, float* output, int output_ld, int rows, int cols, cudaStream_t stream) {
dim3 blockDim(32, 32);
dim3 gridDim((rows + blockDim.x - 1) / blockDim.x, (cols + blockDim.y - 1) / blockDim.y);
relu_f32 <<<gridDim, blockDim, 0, stream>>> (vector, vector_ld, output, output_ld, rows, cols);
}
}
__global__ void reluDeriv_f32 (float* vector, int vector_ld, float* output, int output_ld, int rows, int cols) {
int row = blockIdx.x * blockDim.x + threadIdx.x;
int col = blockIdx.y * blockDim.y + threadIdx.y;
if (row < rows && col < cols) {
output[row+col*output_ld] = vector[row+col*vector_ld] > 0.0 ? 1.0 : 0.0;
}
}
extern "C" {
void VectorFragment_reluDeriv_f32 (float* vector, int vector_ld, float* output, int output_ld, int rows, int cols, cudaStream_t stream) {
dim3 blockDim(32, 32);
dim3 gridDim((rows + blockDim.x - 1) / blockDim.x, (cols + blockDim.y - 1) / blockDim.y);
reluDeriv_f32 <<<gridDim, blockDim, 0, stream>>> (vector, vector_ld, output, output_ld, rows, cols);
}
}
__global__ void customErrorCalc_f32 (float* vector, int vector_ld, float* ideal_vector, int ideal_vector_ld, float threshold, float scaleFoff, float scaleFon, float* output, int output_ld, int rows, int cols) {
int row = blockIdx.x * blockDim.x + threadIdx.x;
int col = blockIdx.y * blockDim.y + threadIdx.y;
if (row < rows && col < cols) {
float vectorValue = vector[row+col*vector_ld];
if (ideal_vector[row+col*vector_ld] > threshold) {
output[row+col*output_ld] = 1.0 - vectorValue;
if (vectorValue < threshold) {
output[row+col*output_ld] *= scaleFoff;
}
} else {
output[row+col*output_ld] = vectorValue * vectorValue;
if (vectorValue > threshold) {
output[row+col*output_ld] *= scaleFon;
}
}
}
}
extern "C" {
void VectorFragment_customErrorCalc_f32 (float* vector, int vector_ld, float* ideal_vector, int ideal_vector_ld, float threshold, float scaleFoff, float scaleFon, float* output, int output_ld, int rows, int cols, cudaStream_t stream) {
dim3 blockDim(32, 32);
dim3 gridDim((rows + blockDim.x - 1) / blockDim.x, (cols + blockDim.y - 1) / blockDim.y);
customErrorCalc_f32 <<<gridDim, blockDim, 0, stream>>> (vector, vector_ld, ideal_vector, ideal_vector_ld, threshold, scaleFoff, scaleFon, output, output_ld, rows, cols);
}
}
|
21,173 | #include "includes.h"
#define BLOCK_SIZE 512
#define BLOCK_SIZE_HOUGH 360
#define STEP_SIZE 5
#define NUMBER_OF_STEPS 360/STEP_SIZE
// Circ mask kernel storage
__constant__ int maskKernelX[NUMBER_OF_STEPS];
__constant__ int maskKernelY[NUMBER_OF_STEPS];
// Function to set precalculated relative coordinates for circle boundary coordinates
__global__ void setAllValuesKernel(int* houghSpace, int height, int width, float value)
{
int const index = blockIdx.x * BLOCK_SIZE + threadIdx.x;
if (index < height*width) {
houghSpace[index] = value;
}
__syncthreads();
} |
21,174 | //
// Created by pierfied on 10/5/20.
//
#include "wigner.cuh"
// Compute the log factorial via the gamma function.
__device__ double lnfac(double x) {
return lgamma(x + 1);
}
// Compute the recursion seed for the case d(j, -j, m, beta).
__device__ double emmRecursionSeed(double j, double m, double beta) {
double prefac = (lnfac(2 * j) - lnfac(j + m) - lnfac(j - m)) / 2;
double cosfac = (j - m) * log(cos(beta / 2));
double sinfac = (j + m) * log(sin(beta / 2));
double d = exp(prefac + cosfac + sinfac);
return d;
}
// Compute the recursion seed for the case d(j, m, j, beta).
__device__ double spinRecursionSeed(double j, double m, double beta) {
double prefac = (lnfac(2 * j) - lnfac(j + m) - lnfac(j - m)) / 2;
double cosfac = (j + m) * log(cos(beta / 2));
double sinfac = (j - m) * log(sin(beta / 2));
double d = exp(prefac + cosfac + sinfac);
return d;
}
__global__ void recursionCoeffKernel(int lmax, int spin, double *fac1, double *fac2, double *fac3) {
int index = blockIdx.x * blockDim.x + threadIdx.x;
int stride = blockDim.x * gridDim.x;
int nEll = lmax + 1;
for (int i = index; i < nEll * nEll; i += stride) {
// Get the l & m values from the index.
int im = i / nEll;
int il = i % nEll;
double m = im;
double l = il;
// Only compute the coefficients for l >= m.
if (l < m) continue;
// Compute the recursion coefficients.
int ind = im * nEll - (im - 1) * im / 2 + (il - im);
double denomFac = sqrt(((l + 1) * (l + 1) - m * m) * ((l + 1) * (l + 1) - spin * spin));
fac1[ind] = (l + 1) * (2 * l + 1) / denomFac;
fac2[ind] = m * spin / (l * (l + 1));
fac3[ind] = (l + 1) * sqrt((l * l - m * m) * (l * l - spin * spin)) / (l * denomFac);
}
// Set the second and third l,m = 0 coefficients to 0 because of divide by zero error.
fac2[0] = 0;
fac3[0] = 0;
}
void computeRecursionCoeffs(int lmax, int spin, double **fac1, double **fac2, double **fac3) {
// Create the arrays for the coefficients.
int facSize = (lmax + 1) * (lmax + 2) / 2;
cudaMallocManaged(fac1, sizeof(double) * facSize);
cudaMallocManaged(fac2, sizeof(double) * facSize);
cudaMallocManaged(fac3, sizeof(double) * facSize);
// Launch the kernel to compute the coefficients.
int blockSize, gridSize;
cudaOccupancyMaxPotentialBlockSize(&gridSize, &blockSize, recursionCoeffKernel, 0, 0);
recursionCoeffKernel<<<gridSize, blockSize>>>(lmax, spin, *fac1, *fac2, *fac3);
}
|
21,175 | #include "includes.h"
__global__ void sharedSum(int N, float *input, float *output){
int i = blockIdx.x * blockDim.x + threadIdx.x;
if(i >= N) return;
__shared__ float tmp[BLOCK_SIZE];
memset(tmp, 0, sizeof(tmp));
float a = input[i];
for(int j=0;j<BLOCK_SIZE;++j){
atomicAdd(tmp + j, a);
}
__syncthreads();
output[blockDim.x*blockIdx.x + threadIdx.x] = tmp[threadIdx.x];
return;
} |
21,176 | #include <cuda.h> //required for CUDA
#include <curand_kernel.h>
#include <time.h>
#include <limits.h>
#include <iostream>
#include <fstream>
#include <math.h>
#include <cassert>
#include <stdlib.h>
#include <string>
#include <sstream>
#include <vector>
using namespace std;
#define MAX_N_TERMS 10
__global__ void MC_Integratev1(float* degrees,int dimension,int n_terms,float* I_val,curandState *states, long int seed,int thread_max_iterations)
{
//Get the Global ID
int id = blockIdx.x*blockDim.x+threadIdx.x;
float x;
float I = 0.0;
float f[MAX_N_TERMS];
//float* f =new float[n_terms];
//Initialize the random number generator
curand_init(seed, id, 0, &states[id]);
for (int iter_count=0;iter_count< thread_max_iterations;iter_count++)
{
//Initialize f with the coefficients
for (int term_i=0;term_i<n_terms;term_i++)
{
f[term_i]=degrees[(2+term_i)*dimension];
}
for (int d=1;d<dimension;d++)
{
//Generate a random number in the range of the limits of this dimension
x = curand_uniform (&states[id]); //x between 0 and 1
//Generate dimension sample based on the limits of the dimension
x = x*(degrees[1*dimension+d]-degrees[0*dimension+d])+degrees[0*dimension+d];
for (int term_i=0;term_i<n_terms;term_i++)
{
//Multiply f of this term by x^(power of this dimension in this term)
f[term_i]*=pow(x,degrees[(2+term_i)*dimension+d]);
}
}
//Add the evaluation to the private summation
for (int term_i=0;term_i<n_terms;term_i++)
{
I+=f[term_i];
}
}
//Add the private summation to the global summation
atomicAdd(I_val,I);
}
__global__ void MC_Integratev2(float* degrees_g,int dimension,int n_terms,float* I_val, long int seed,int thread_max_iterations)
{
//Get the global and local ids
int id = blockIdx.x*blockDim.x+threadIdx.x;
int lid=threadIdx.x;
float x;
float I = 0.0;
float f[MAX_N_TERMS];
//float* f =new float[n_terms];
//Dynamically allocate shared memory for 'degrees' and 'I_shared'
extern __shared__ float shared_mem[];
float* I_shared = shared_mem;
I_shared[0]=0;
float* degrees = &shared_mem[1];
//Initialize the local copy of 'degrees' for the shared copy
if(lid<(2+n_terms)*dimension)
{
//copy one element of degrees
degrees[lid]=degrees_g[lid];
}
// Create a state in private memory
curandState state;
//Initialize the random number generator
curand_init(seed,id,0,&state);
//Synchronize all threads to assure that 'degrees' is initialized
__syncthreads();
for (int iter_count=0;iter_count< thread_max_iterations;iter_count++)
{
//Initialize f with the coefficients
for (int term_i=0;term_i<n_terms;term_i++)
{
f[term_i]=degrees[(2+term_i)*dimension];
}
for (int d=1;d<dimension;d++)
{
//Generate a random number in the range of the limits of this dimension
x = curand_uniform (&state); //x between 0 and 1
//Generate dimension sample based on the limits of the dimension
x = x*(degrees[1*dimension+d]-degrees[0*dimension+d])+degrees[0*dimension+d];
for (int term_i=0;term_i<n_terms;term_i++)
{
//Multiply f of this term by x^(power of this dimension in this term)
f[term_i]*=pow(x,degrees[(2+term_i)*dimension+d]);
}
}
//Add the evaluation to the private summation
for (int term_i=0;term_i<n_terms;term_i++)
{
I+=f[term_i];
}
}
//Add the private summation to the shared summation
atomicAdd(I_shared,I);
//Synchronize all the threads to assure they all added their private summations to the shared summation
__syncthreads();
//Thread 0 in the block add the shared summation to the global summation
if(lid==0)
{
atomicAdd(I_val,*I_shared);
}
}
int main(int argc, char** argv)
{
//----------------------------------
// Parse Command Line
//----------------------------------
if (argc < 8)
{
std::cerr << "Required Command-Line Arguments Are:\n";
std::cerr << "Text file name\n";
std::cerr << "Method (1 or 2)\n";
std::cerr << "Dimension \n";
std::cerr << "Number of Blocks \n";
std::cerr << "Number of Threads per Block \n";
std::cerr << "Number of iterations in a thread \n";
std::cerr << "Validation (1 to validate, 2 validate and show polynomial) \n";
return -1;
}
string filename=argv[1];
int Method = atol(argv[2]);
int dimension = atol(argv[3]);
long long int N_blocks = atol(argv[4]);
int N_threads = atol(argv[5]);
int thread_max_iterations=atol(argv[6]);
int Validate=atol(argv[7]);
long int max_evaluations = N_blocks*N_threads*thread_max_iterations;
//----------------------------------
// Read The file into an array (degrees)
//----------------------------------
//Each line in the file represent a term in the polynomial where the first number is the coefficient
//and the following numbers are the powers of the variables of each dimension in order
//Line 0: Lower limits for each dimension
//Line 1: Upper limits for each dimension
//Accordingly the first element (coefficient) in the first two lines are ignored
//Add one to the dimension as the first element in every line is the coefficient (first dimension is 1)
dimension++;
string line,number;
ifstream myfile (filename.c_str());
float temp=0;
std::vector<float> degrees (0);
int line_c=0;
if (myfile.is_open())
{
while ( getline (myfile,line) )
{
std::stringstream linestream(line);
int number_c=0;
degrees.resize((line_c+1)*dimension);
while ( getline (linestream,number,' ' ) )
{
stringstream ss;
ss<<number;
ss>>temp;
degrees[line_c*dimension+number_c]=temp;
number_c++;
}
assert(number_c==dimension);
line_c++;
}
//First two lines are the limits and we need at least one term in the polynomial
assert(line_c>2);
myfile.close();
}
else cout << "Unable to open file";
//n_terms: Number of terms in the polynomial (first two lines are the limits)
int n_terms=line_c-2;
if(n_terms>MAX_N_TERMS)
{
std::cerr<<"The Maximum Number of terms defined in the code is "<<MAX_N_TERMS<<std::endl;
return -1;
}
//----------------------------------
//Display the numbers in the file (same format as the file)
//----------------------------------
if(Validate==2)
{
std::cout<<"-----------------------------"<<std::endl;
std::cout<<"Upper Limit for dimensions = ";
for(int j=1;j<dimension;j++)
{
std::cout<<degrees[j]<<" ";
}
std::cout<<std::endl;
std::cout<<"Lower Limit for dimensions = ";
for(int j=1;j<dimension;j++)
{
std::cout<<degrees[dimension+j]<<" ";
}
std::cout<<std::endl;
for (int i=2;i<line_c;i++)
{
std::cout<<"Term "<<i-2<<" Coefficient = ";
for(int j=0;j<dimension;j++)
{
if(j==0)
{
std::cout<<degrees[i*dimension+j]<<", Powers = ";
}
else
{
std::cout<<degrees[i*dimension+j]<<" ";
}
}
std::cout<<std::endl;
}
std::cout<<"-----------------------------"<<std::endl;
}
//----------------------------------
//Calculate the Analytical solution
//----------------------------------
double Ianalytical=0;
for (int term_i=0;term_i<n_terms;term_i++)
{
double a,b,I;
//Initialize by the coefficient
I=degrees[(2+term_i)*dimension];
for (int d=1;d<dimension;d++)
{
a= degrees[0*dimension+d];
b= degrees[1*dimension+d];
b=pow(b,degrees[(2+term_i)*dimension+d]+1);
a=pow(a,degrees[(2+term_i)*dimension+d]+1);
I*=(b-a)/(double)(degrees[(2+term_i)*dimension+d]+1);
}
Ianalytical+=I;
}
std::cout<<"Analytical Solution = "<< Ianalytical <<std::endl;
std::cout<<"-----------------------------"<<std::endl;
//************************//
// PARALLEL RUN //
//***********************//
std::cout<<"Parallel Case using method "<<Method<<": "<<std::endl;
std::cout<< "Number of blocks = " << N_blocks <<std::endl;
std::cout <<"Number of threads per block = " << N_threads<<std::endl;
std::cout<< "Number of Iterations per thread = " << thread_max_iterations << std::endl;
std::cout<<"Total number of Evaluations = "<<max_evaluations<<std::endl;
std::cout<<"Dimension = "<<dimension-1<<std::endl;
std::cout<<"-----------------------------"<<std::endl;
//---------------------------------------
//Initial Setup (Check the Block and grid sizes)
//---------------------------------------
//Get Device properties
cudaDeviceProp device_properties;
cudaGetDeviceProperties (&device_properties, 0);
if (N_threads>device_properties.maxThreadsDim[0])
{
std::cerr << "Maximum threads for dimension 0 = " << device_properties.maxThreadsDim[0] << std::endl;
return -1;
}
if(N_blocks>device_properties.maxGridSize[0])
{
std::cerr << "Maximum grid dimension 0 = " << device_properties.maxGridSize[0] << std::endl;
return -1;
}
//---------------------------------------
// Setup Profiling
//---------------------------------------
cudaEvent_t start, stop;
cudaEventCreate(&start);
cudaEventCreate(&stop);
cudaEventRecord(start,0);
//I_val: Final Estimated Value of the Integral
float I_val=0;
//Pointers to data on the device
float *devDegrees;
float *dev_I_val;
curandState *devStates;
//seed the host random number generator to get a random seed for the Curand
srand(clock());
//Random seed to be used for Curand
long int seed = rand();
cudaError_t err;
//Allocate memory for A,B,C on device
//Pass the address of a pointer where the malloc function will write the address of the data in it
//it have to be casted to a void pointer
if (Method!=2)
{err = cudaMalloc( (void **)&devStates, N_blocks*N_threads * sizeof(curandState) );assert(err == cudaSuccess);}
err = cudaMalloc((void**)&devDegrees,degrees.size()*sizeof(float));assert(err == cudaSuccess);
err = cudaMalloc((void**)&dev_I_val,sizeof(float));assert(err == cudaSuccess);
//Copy the data to the device
// CudaMemcpy(TO_ADDRESS, FROM_ADDRESS, NUMBER_OF_BYTES, DIRECTION)
//Where the direction is either cudaMemcpyHostToDevice or cudaMemcpyDeviceToHost
err = cudaMemcpy( devDegrees,°rees[0],degrees.size()*sizeof(float),cudaMemcpyHostToDevice);assert(err == cudaSuccess);
err = cudaMemcpy( dev_I_val,&I_val,sizeof(float),cudaMemcpyHostToDevice);assert(err == cudaSuccess);
//RUN THE KERNEL
if(Method==1)
{
MC_Integratev1<<<N_blocks,N_threads>>>(devDegrees,dimension,n_terms,dev_I_val,devStates,seed,thread_max_iterations);
}
else if (Method ==2)
{
MC_Integratev2<<<N_blocks,N_threads,(1+(2+n_terms)*dimension)*sizeof(float)>>>(devDegrees,dimension,n_terms,dev_I_val,seed,thread_max_iterations);
}
else
{
std::cerr<<"Please enter a valid method"<<std::endl;
cudaFree(devDegrees);
cudaFree(dev_I_val);
return -1;
}
//Copy the result to the Host
err =cudaMemcpy(&I_val,dev_I_val,sizeof(float),cudaMemcpyDeviceToHost);assert(err == cudaSuccess);
//FREE MEMORY ON DEVICE
cudaFree(devDegrees);
cudaFree(dev_I_val);
if (Method!=2)
{cudaFree(devStates);}
//Multiply by the Volume
float a,b;
for (int d=1;d<dimension;d++)
{
a= degrees[0*dimension+d];
b= degrees[1*dimension+d];
I_val*=(b-a);
}
//Divide by the total number of evaluations
I_val/=(float)N_blocks;
I_val/=(float)N_threads;
I_val/=(float)thread_max_iterations;
//---------------------------------------
// Stop Profiling
//---------------------------------------
cudaEventRecord(stop,0);
cudaEventSynchronize(stop);
float gpu_time;
cudaEventElapsedTime(&gpu_time, start, stop); //time in milliseconds
gpu_time /= 1000.0;
std::cout<<"GPU Results: "<<std::endl;
std::cout <<"I = " << I_val << ", GPU time = "<<gpu_time<<std::endl;
//******************//
// SERIAL RUN //
//*****************//
if (Validate==1||Validate==2)
{
std::cout<<"-----------------------------"<<std::endl;
std::cout<<"Host Results: "<<std::endl;
double t_start_cpu = (double)clock()/(double)CLOCKS_PER_SEC;
//Set f_0_s to hold the coefficients of the polynomial terms
std::vector<double> f_0_s (n_terms,0);
for (int term_i=0;term_i<n_terms;term_i++)
{
f_0_s[term_i]=degrees[(2+term_i)*dimension];
}
srand(clock()); //seed the random number generator
long int N = 0;
double x;
double I = 0.0;
double a,b;
std::vector<double> f (n_terms,0);
do
{
//Initialize f with the coefficients
f=f_0_s;
for (int d=1;d<dimension;d++)
{
//Generate a random number in the range of the limits of this dimension
x = (double)rand()/(double)RAND_MAX; //x between 0 and 1
//limits
a= degrees[0*dimension+d];
b= degrees[1*dimension+d];
x = x*(b-a) + a; //x between a2 and b2
for (int term_i=0;term_i<n_terms;term_i++)
{
//2: first 2 lines are the limits
f[term_i]*=pow(x,degrees[(2+term_i)*dimension+d]);
}
}
for (int term_i=0;term_i<n_terms;term_i++)
{
I+=f[term_i];
}
N++;
}
while (N <= max_evaluations);
//Multiply by the Volume
for (int d=1;d<dimension;d++)
{
a= degrees[0*dimension+d];
b= degrees[1*dimension+d];
I*=(b-a);
}
I/=(double)N;
double t_stop_cpu = (double)clock()/(double)CLOCKS_PER_SEC;
double cpu_time=t_stop_cpu-t_start_cpu;
std::cout <<"I = " << I << ", Host time = "<<cpu_time<<std::endl;
std::cout<<"Speed up = "<<cpu_time/gpu_time<<std::endl;
}
}
|
21,177 | /* Matrix Multiplication AX+Y in Cuda
*******************************************************************
* Description:
* Populate a float array of size N^2 with each index
* generated M times using mulitplication.
*******************************************************************
* Source:
* https://stackoverflow.com/questions/7663343/simplest-possible-example-to-show-gpu-outperform-cpu-using-cuda
*******************************************************************
*/
#include <ctime>
#include <iostream>
using namespace std;
/* matrix mult function */
__global__
void matrix_mult(int n, int r, float *matrix) {
// give index to each thread
int index = blockIdx.x * blockDim.x + threadIdx.x;
// assign i / N at current index
matrix[index] = 1.0f * index / n;
// generate a new value at current index r times
for (int j = 0; j < r; j++) {
matrix[index] = matrix[index] * matrix[index] - 0.25f;
}
}
/* program's main() */
int main(int argc, char* argv[]) {
// initialize default array size and run count, and threads per block
int N = 1024;
int R = 1000;
int T = 256;
// assign new values to N (and R) if arguments provided
if (argc > 2) {
// iterate over arguments
for (int i = 0; i < argc; i++) {
// get current argument
string arg = argv[i];
// if size specified
if (arg.compare("-n") == 0) {
N = stoi(argv[i + 1]);
}
// if run count specified
else if (arg.compare("-r") == 0) {
R = stoi(argv[i + 1]);
}
// if thread count specified
else if (arg.compare("-t") == 0) {
T = stoi(argv[i + 1]);
}
}
}
// calculate full size of matrix
unsigned int N_squared = N * N;
// print info
cout << "========================================" << endl;
cout << "|\tMatrix Multiplication" << endl;
cout << "========================================" << endl;
cout << "|\tUsing CUDA 9.2" << endl;
cout << "|\tN = " << N << "x" << N << " (=" << N_squared << ")"<< endl;
cout << "|\tRuns = " << R << endl;
cout << "|\tThreads/Block = " << T << endl;
cout << "|" << endl;
cout << "|\trunning..." << endl;
// initialize the float array (using 1D array to simulate 2D array or matrix)
float *matrix;
// allocate unified memory
cudaMallocManaged(&matrix, N_squared * sizeof(float));
// initialize clock
clock_t start = clock();
// perform matrix mult on CPU
matrix_mult<<<(N_squared + T - 1) / T, T>>>(N_squared, R, matrix);
// wait for GPU before continuing on CPU
cudaDeviceSynchronize();
// stop clock
clock_t stop = clock();
// print end status
cout << "|\t done!" << endl;
cout << "|" << endl;
cout << "|\tTime = " << (stop - start) / (double) CLOCKS_PER_SEC << " seconds" << endl;
cout << "========================================" << endl;
// free allocated memory
cudaFree(matrix);
return 0;
}
|
21,178 | #include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <assert.h>
#include <unistd.h>
#include <sys/time.h>
/* Problem size. */
#define NX 4096
#define NY 4096
#ifndef M_PI
#define M_PI 3.14159
#endif
void init_array(double *x, double *A)
{
int i, j;
for (i = 0; i < NX; i++) {
// x[i] = i * M_PI; <-- ΝΧ επαναλήψεις - Λάθος
for (j = 0; j < NY; j++) {
A[i*NY + j] = ((double) i*(j)) / NX;
}
}
for (j = 0; j < NY; j++) {
x[j] = j * M_PI;
}
}
__global__ void trans_norm_vector_kernel1(double* A, double* x, double* tmp)
{
int i = blockIdx.x * blockDim.x + threadIdx.x;
__shared__ double tmp_shared;
if (i < NX)
{
tmp_shared = tmp[i];
for(int j = 0; j < NY; j++)
{
tmp_shared = tmp_shared + A[i*NY+j] * x[j];
}
tmp[i] = tmp_shared;
}
}
__global__ void trans_norm_vector_kernel2(double* A, double* y, double* tmp)
{
int j = blockIdx.x * blockDim.x + threadIdx.x;
__shared__ double y_shared;
if (j < NY)
{
y_shared = y[j];
for(int i = 0; i < NX; i++)
{
y_shared = y_shared + A[i*NY+j] * tmp[i];
}
y[j] = y_shared;
}
}
int main(int argc, char *argv[])
{
double *A_h, *A_d;
double *x_h, *x_d;
double *y_h, *y_d;
double *tmp_h, *tmp_d;
struct timeval cpu_start, cpu_end;
A_h = (double*)malloc(NX*NY*sizeof(double));
x_h = (double*)malloc(NY*sizeof(double));
y_h = (double*)malloc(NY*sizeof(double));
tmp_h = (double*)malloc(NX*sizeof(double));
// Δέσμευση μνήμης στο device για τα διανύσματα
cudaMalloc((void **) &A_d, NX*NY*sizeof(double));
cudaMalloc((void **) &x_d, NY*sizeof(double));
cudaMalloc((void **) &y_d, NY*sizeof(double));
cudaMalloc((void **) &tmp_d, NX*sizeof(double));
cudaMemset(y_d, 0, NY*sizeof(double));
cudaMemset(tmp_d, 0, NX*sizeof(double));
init_array(x_h, A_h);
// Αντιγραφή x στο device
cudaMemcpy(x_d, x_h, NY*sizeof(double), cudaMemcpyHostToDevice);
// Αντιγραφή A στο device
cudaMemcpy(A_d, A_h, NX*NY*sizeof(double), cudaMemcpyHostToDevice);
//----------------------------------------------------------------------
// Κάθε block θα έχει διάσταση 16x16
unsigned int BLOCK_SIZE_PER_DIM = 16;
// Στρογγυλοποίηση προς τα πάνω για το πλήθος των block σε κάθε διάσταση
unsigned int numBlocksX = (NX - 1) / BLOCK_SIZE_PER_DIM + 1;
unsigned int numBlocksY = (NY - 1) / BLOCK_SIZE_PER_DIM + 1;
// Ορισμός διαστάσεων πλέγματος
dim3 dimGrid1(numBlocksX, 1);
dim3 dimGrid2(numBlocksY, 1);
// Ορισμός διαστάσεων block
dim3 dimBlock(BLOCK_SIZE_PER_DIM, BLOCK_SIZE_PER_DIM, 1);
//----------------------------------------------------------------------
gettimeofday(&cpu_start, NULL);
// Κλήση υπολογιστικού πυρήνα
trans_norm_vector_kernel1<<<dimGrid1, dimBlock>>>(A_d, x_d, tmp_d);
cudaThreadSynchronize();
trans_norm_vector_kernel2<<<dimGrid2, dimBlock>>>(A_d, y_d, tmp_d);
cudaThreadSynchronize();
cudaMemcpy(y_h, y_d, NY*sizeof(double), cudaMemcpyDeviceToHost);
gettimeofday(&cpu_end, NULL);
fprintf(stdout, "GPU Runtime :%0.6lfs\n", ((cpu_end.tv_sec - cpu_start.tv_sec) * 1000000.0 + (cpu_end.tv_usec - cpu_start.tv_usec)) / 1000000.0);
printf("================================\n");
FILE *f = fopen("ask2_cuda_output.txt", "w+");
if (f == NULL)
{
printf("Error opening ask2_cuda_output.txt!\n");
exit(1);
}
for (int i = 0; i < NY; i++) {
fprintf(f, "%f\n", y_h[i]);
}
if(f) { printf("Results saved in ask2_cuda_output.txt!\n"); }
fclose(f);
// Αποδέσμευση μνήμης στον host
free(A_h);
free(x_h);
free(y_h);
free(tmp_h);
// Αποδέσμευση μνήμης στον host
cudaFree(A_d);
cudaFree(x_d);
cudaFree(y_d);
cudaFree(tmp_d);
return 0;
}
|
21,179 | #include "includes.h"
__global__ void rotate_weights_kernel(const float *src_weight_gpu, float *weight_deform_gpu, int nweights, int n, int kernel_size, int reverse)
{
const int index = blockIdx.x*blockDim.x + threadIdx.x;
const int kernel_area = kernel_size * kernel_size;
const int i = index * kernel_area;
const int stage_step = (nweights / kernel_area) / 4; // 4 stages
const int stage_id = index / stage_step;
// nweights = (c / groups) * n * size * size;
// kernel_area = size*size
if (i < nweights)
{
// if(reverse)
if (stage_id == 0) {
// simple copy
for (int y = 0; y < kernel_size; ++y) {
for (int x = 0; x < kernel_size; ++x) {
const int src_i = x + y*kernel_size + i;
const int dst_i = x + y*kernel_size + i;
if (reverse) weight_deform_gpu[src_i] = src_weight_gpu[dst_i];
else weight_deform_gpu[dst_i] = src_weight_gpu[src_i];
}
}
}
else if (stage_id == 1)
{
// 90 degree clockwise rotation - 1
for (int y = 0; y < kernel_size; ++y) {
for (int x = 0; x < kernel_size; ++x) {
const int src_i = x + y*kernel_size + i;
const int dst_i = (kernel_size - 1 - y) + x*kernel_size + i;
if (reverse) weight_deform_gpu[src_i] = src_weight_gpu[dst_i];
else weight_deform_gpu[dst_i] = src_weight_gpu[src_i];
}
}
}
else if (stage_id == 2)
{
// 180 degree clockwise rotation - 2
for (int y = 0; y < kernel_size; ++y) {
for (int x = 0; x < kernel_size; ++x) {
const int src_i = x + y*kernel_size + i;
const int dst_i = (kernel_size - 1 - x) + (kernel_size - 1 - y)*kernel_size + i;
if (reverse) weight_deform_gpu[src_i] = src_weight_gpu[dst_i];
else weight_deform_gpu[dst_i] = src_weight_gpu[src_i];
}
}
}
else if (stage_id == 3)
{
// 270 degree clockwise rotation - 3
for (int y = 0; y < kernel_size; ++y) {
for (int x = 0; x < kernel_size; ++x) {
const int src_i = x + y*kernel_size + i;
const int dst_i = y + (kernel_size - 1 - x)*kernel_size + i;
if (reverse) weight_deform_gpu[src_i] = src_weight_gpu[dst_i];
else weight_deform_gpu[dst_i] = src_weight_gpu[src_i];
}
}
}
}
} |
21,180 | //N-Body Physics Simulation
//Randomly generates and displays an N-Body system
//Code from Nvidia's GPU Gems 3 Chapter 31
#ifndef __CUDACC__
#define __CUDACC__
#endif
#include "cuda_runtime_api.h"
#include "cuda_runtime.h"
#include "cuda.h"
#include "device_functions.h"
#include "device_launch_parameters.h"
#include <stdio.h>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <iostream>
using namespace std;
//Gravitational constant
#define G 1
//Time interval
#define dx 0.001
//N, number of bodies
const unsigned int N = 100;
//p, number of blocks
const unsigned int p = 5;
//Upper bounds for location
const float upperX = 100.0;
const float upperY = 100.0;
const float upperZ = 100.0;
//Lower bounds for location
const float lowerX = -100.0;
const float lowerY = -100.0;
const float lowerZ = -100.0;
//Mass bounds
const float upperMass = 100.0;
const float lowerMass = 1.0;
//Interaction between two bodies
//Integrate using leapfrog-Verlet integrator
//a ~= G * summation(1, N, m[j]*r[i][j] / (r^2 + E^2)^3/2
//G = 1 for simplicity
__device__ float3 bobyBodyInteraction(float4 b1, float4 b2, float3 a1) {
//Distance between bodies
float3 d;
//3 FLOPS
d.x = b2.x - b1.x;
d.y = b2.y - b1.y;
d.z = b2.z - b1.z;
//Square distance
//6 FLOPS
float square = d.x * d.x + d.y * d.y + d.z * d.z;
//Cube
//2 FLOPS
float cube = square * square * square;
//Invert and sqrt
//2 FLOPS
float invert = 1.0f / sqrtf(cube);
//Calculate s
float s = b2.w * invert;
//Calculate a
a1.x += d.x * s * G;
a1.y += d.y * s * G;
a1.z += d.z * s * G;
return a1;
}
//Calculate all interactions within a tile
__device__ float3 tile_calculation(float4 pos, float3 a) {
int i;
//Used shared memory
extern __shared__ float4 sPos[];
for (i = 0; i < blockDim.x; i++) {
a = bobyBodyInteraction(pos, sPos[i], a);
}
return a;
}
//Calculate acceleration for p bodies with p threads resulting from N interactions
__global__ void calculate_forces(void *devX, void *devA) {
//Declare shared position
extern __shared__ float4 sPos[];
//Get from memory
float4 *globalX = (float4 *)devX;
float4 *globalA = (float4 *)devA;
//Initialize position
float4 pos;
//Initialize variables
int i, tile;
float3 acc = { 0.0f, 0.0f, 0.0f };
//Get index
int getId = blockIdx.x * blockDim.x + threadIdx.x;
//Get position
pos = globalX[getId];
//Calculate N bodies
for (i = 0, tile = 0; i < N; i += p, tile++) {
//Get index
int idx = tile * blockDim.x + threadIdx.x;
//Update position
sPos[threadIdx.x] = globalX[idx];
//Barrier
__syncthreads();
//Get acceleration
acc = tile_calculation(pos, acc);
//Barrier
__syncthreads();
}
//Save in global memory
float4 acc4 = { acc.x, acc.y, acc.z, 0.0f };
globalA[getId] = acc4;
}
int main()
{
//Generate N random bodies with locations defined by bounds
float4 *h_s = (float4*)malloc(N * sizeof(float4));
float3 *h_v = (float3*)malloc(N * sizeof(float3));
float3 *h_a = (float3*)malloc(N * sizeof(float3));
srand(time(NULL));
for (int i = 0; i < N; i++) {
h_s[i].x = rand();
h_s[i].y = rand();
h_s[i].z = rand();
h_s[i].w = rand();
//No initial velocity or acceleration
h_v[i].x = 0;
h_v[i].y = 0;
h_v[i].z = 0;
h_a[i].x = 0;
h_a[i].y = 0;
h_a[i].z = 0;
}
//Create memory on device
float4 *d_s;
cudaMalloc(&d_s, N * sizeof(float4));
float3 *d_v;
cudaMalloc(&d_v, N * sizeof(float3));
float3 *d_a;
cudaMalloc(&d_a, N * sizeof(float3));
//Copy memory to device
cudaMemcpy(d_s, h_s, N * sizeof(float4), cudaMemcpyHostToDevice);
cudaMemcpy(d_v, h_v, N * sizeof(float3), cudaMemcpyHostToDevice);
cudaMemcpy(d_a, h_a, N * sizeof(float3), cudaMemcpyHostToDevice);
//Calculate accelerations
calculate_forces <<<1, N>>>(d_s, d_a);
//Return accelerations
cudaMemcpy(h_a, d_a, N * sizeof(float3), cudaMemcpyDeviceToHost);
//Print accelerations
for (unsigned int i = 0; i < N; i++) {
cout << h_a[i].x << ", " << h_a[i].y << ", " << h_a[i].z << endl;
}
return 0;
} |
21,181 | // @file main.cu
#include <stdio.h>
__global__ void hello_world(){
unsigned int idx = blockIdx.x * blockDim.x + threadIdx.x;
printf("[ %d ] Hello world from GPU\n", idx);
}
int main() {
printf("Hello world from CPU\n");
hello_world<<< 1, 10 >>>();
cudaDeviceSynchronize();
return 0;
}
|
21,182 | #include "use_GMRES.cuh"
int main()
{
useGMRES();
useGMRES2();
useGMRES3();
useGMRES_n256();
return 0;
}
|
21,183 | /*
@Author: 3sne ( Mukur Panchani )
@FileName: q4MatrixTranspose.cu
@Task: CUDA program compute transpose of a matrix parallely.
*/
#include <stdio.h>
#include <stdlib.h>
#include <cuda_runtime.h>
__global__ void transpose(int *a, int *b, int m, int n) {
/*
Generates b: transpose of a
*/
int ci = threadIdx.x;
int ri = threadIdx.y;
b[ci * m + ri] = a[ri * n + ci];
}
int main() {
int *matA, *matB;
int *da, *db;
int m, n;
printf("== Enter Dimension of Matrix A (m x n) ==\n");
printf("m >> "); scanf("%d", &m);
printf("n >> "); scanf("%d", &n);
matA = (int*)malloc(sizeof(int) * m * n);
matB = (int*)malloc(sizeof(int) * m * n);
printf("== Matrix A Elements ==\n");
for(int i = 0; i < m * n; i++) {
scanf("%d", &matA[i]);
}
cudaMalloc((void **)&da, sizeof(int) * m * n);
cudaMalloc((void **)&db, sizeof(int) * m * n);
cudaMemcpy(da, matA, sizeof(int) * m * n, cudaMemcpyHostToDevice);
dim3 block_conf (n, m);
transpose<<<1, block_conf>>>(da, db, m, n);
cudaMemcpy(matB, db, sizeof(int) * m * n, cudaMemcpyDeviceToHost);
printf("== Matrix B Elements ==\n");
for ( int i = 0; i < n; i++ ) {
for ( int j = 0; j < m; j++ ) {
printf("%d ", matB[i * m + j]);
}
printf("\n");
}
cudaFree(da);
cudaFree(db);
free(matA);
free(matB);
return 0;
} |
21,184 | #include "includes.h"
#define N 512
__global__ void calculate(int *a, int *b, int *c){
c[threadIdx.x] = ((a[threadIdx.x]+2)+b[threadIdx.x])*3;
} |
21,185 | #include <stdio.h>
#include <stdlib.h>
#define N 128 // 2^7
#define THREAD_PER_BLOCK 32 // 2^5
// GPU function for adding two vectors 'a' and 'b'
__global__ void add (int *a, int *b, int *c)
{
// Calculate the index of the current thread
// of the current block
int index = threadIdx.x + blockDim.x*blockIdx.x;
c[index] = a[index] + b[index];
}
// Gera um vetor aleatorio
void random_ints (int *v)
{
for (int i = 0; i < N; i++)
v[i] = rand() % 10;
}
void checkSolution (int *a, int *b, int *c)
{
printf("===== RESULT OF THE SUM =====\n");
printf("CPU\tGPU\n");
for (int i = 0; i < N; i++)
printf("%d\t%d\n",a[i]+b[i],c[i]);
}
int main ()
{
int *a, *b, *c; // CPU pointers
int *da, *db, *dc; // GPU pointers
int size;
size = sizeof(int)*N;
// Alloc memory space for GPU
cudaMalloc((void**)&da,size);
cudaMalloc((void**)&db,size);
cudaMalloc((void**)&dc,size);
// Alloc space for the CPU
a = (int*)malloc(size); random_ints(a);
b = (int*)malloc(size); random_ints(b);
c = (int*)malloc(size);
// Copy the inputs to the device
cudaMemcpy(da,a,size,cudaMemcpyHostToDevice);
cudaMemcpy(db,b,size,cudaMemcpyHostToDevice);
// Lauch the kernel on the GPU
add<<<N/THREAD_PER_BLOCK,N>>>(da,db,dc);
// Copy the result back to the CPU
cudaMemcpy(c,dc,size,cudaMemcpyDeviceToHost);
// Check the solution
checkSolution(a,b,c);
// Cleanup
free(a); free(b); free(c);
cudaFree(da); cudaFree(db); cudaFree(dc);
return 0;
}
|
21,186 | #include <stdio.h>
#include <cuda.h>
#include <cuda_runtime.h>
const int N= 1024; // matrix size is NxN
const int K= 32; // tile size is KxK
struct GpuTimer
{
cudaEvent_t start;
cudaEvent_t stop;
GpuTimer ()
{
cudaEventCreate(&start);
cudaEventCreate(&stop);
}
~GpuTimer ()
{
cudaEventDestroy(start);
cudaEventDestroy(stop);
}
void Start ()
{
cudaEventRecord(start, 0);
}
void Stop ()
{
cudaEventRecord(stop, 0);
}
float Elapsed ()
{
cudaEventSynchronize(stop);
float elapsed;
cudaEventElapsedTime(&elapsed, start, stop);
return elapsed;
}
};
int compare_matrices (float *m1, float *m2)
{
for (int y = 0; y < N; y++) {
for (int x = 0; x < N; x++) {
if (m1[x + y*N] != m2[x + y*N])
return 1;
}
}
// if m1 == m2: return 0
return 0;
}
// fill a matrix with sequential numbers in the range 0..N-1
void fill_matrix (float *mat)
{
for (int i = 0; i < N*N; i++) {
mat[i] = (float)i;
}
}
void
transpose_CPU (float in[], float out[])
{
for (int y = 0; y < N; y++) {
for (int x = 0; x < N; x++) {
out[y + x*N] = in[x + y*N]; // out(y, x) = in(x, y)
}
}
}
// to be launched on a single thread
__global__ void
transpose_serial (float in[], float out[])
{
for (int y = 0; y < N; y++) {
for (int x = 0; x < N; x++) {
out[y + x*N] = in[x + y*N]; // out(y, x) = in(x, y)
}
}
}
// to be launched with one thread per row of output matrix
__global__ void
transpose_parallel_per_row (float in[], float out[])
{
int x = threadIdx.x;
for (int y = 0; y < N; y++) {
out[y + x*N] = in[x + y*N]; // out(y, x) = in(x, y)
}
}
// to be launched with one thread per element, in KxK threadblocks
// thread (x,y) in grid writes element (i,j) of output matrix
__global__ void
transpose_parallel_per_element (float in[], float out[])
{
int x = blockIdx.x * K + threadIdx.x;
int y = blockIdx.y * K + threadIdx.y;
out[y + x*N] = in[x + y*N]; // out(y, x) = in(x, y)
}
// to be launched with one thread per element, in (tilesize)x(tilesize) threadblocks
// thread blocks read & write tiles, in coalesced fashion
// adjacent threads read adjacent input elements, write adjacent output elements
__global__ void
transpose_parallel_per_element_tiled (float in[], float out[])
{
// (x, y) locations of the tile corners for input & output matrices:
int in_corner_x = blockIdx.x * K, in_corner_y = blockIdx.y * K;
// transpose coordinates
int out_corner_x = in_corner_y, out_corner_y = in_corner_x;
int x = threadIdx.x, y = threadIdx.y;
__shared__ float tile[K][K];
// coalesced read from global mem, TRANSPOSED write into shared mem:
tile[y][x] = in[(in_corner_x + x) + (in_corner_y + y)*N];
__syncthreads();
// read from shared mem, coalesced write to global mem:
out[(out_corner_x + x) + (out_corner_y + y)*N] = tile[x][y];;
}
// to be launched with one thread per element, in (tilesize)x(tilesize) threadblocks
// thread blocks read & write tiles, in coalesced fashion
// adjacent threads read adjacent input elements, write adjacent output elements
__global__ void
transpose_parallel_per_element_tiled16 (float in[], float out[])
{
// (x, y) locations of the tile corners for input & output matrices:
int in_corner_x = blockIdx.x * 16, in_corner_y = blockIdx.y * 16;
int out_corner_x = in_corner_y, out_corner_y = in_corner_x;
int x = threadIdx.x, y = threadIdx.y;
// move and transpose data to shared memory
__shared__ float tile[16][16];
// coalesced read from global mem, TRANSPOSED write into shared mem:
tile[y][x] = in[(in_corner_x + x) + (in_corner_y + y) * N];
__syncthreads();
// read from shared mem, coalesced write to global mem:
out[(out_corner_x + x) + (out_corner_y + y)*N] = tile[x][y];
}
// to be launched with one thread per element, in KxK threadblocks
// thread blocks read & write tiles, in coalesced fashion
// shared memory array padded to avoid bank conflicts
__global__ void
transpose_parallel_per_element_tiled_padded16 (float in[], float out[])
{
// (x, y) locations of the tile corners for input & output matrices:
int in_corner_x = blockIdx.x * 16, in_corner_y = blockIdx.y * 16;
int out_corner_x = in_corner_y, out_corner_y = in_corner_x;
int x = threadIdx.x, y = threadIdx.y;
// declared shared memory with odd size
__shared__ float tile[16][16+1];
// coalesced read from global mem, TRANSPOSED write into shared mem:
tile[y][x] = in[(in_corner_x + x) + (in_corner_y + y)*N];
__syncthreads();
// read from shared mem, coalesced write to global mem:
out[(out_corner_x + x) + (out_corner_y + y) * N] = tile[x][y];
}
int main (int argc, char **argv)
{
const int numbytes = N * N * sizeof(float);
float *in = (float *) malloc(numbytes);
float *out = (float *) malloc(numbytes);
float *gold = (float *) malloc(numbytes);
// init in-matrix
fill_matrix(in);
transpose_CPU(in, gold);
float *d_in, *d_out;
// Alloc GPU mem
cudaMalloc(&d_in, numbytes);
cudaMalloc(&d_out, numbytes);
cudaMemcpy(d_in, in, numbytes, cudaMemcpyHostToDevice);
GpuTimer timer;
/*
* Now time each kernel and verify that it produces the correct result.
*
* To be really careful about benchmarking purposes, we should run every kernel once
* to "warm" the system and avoid any compilation or code-caching effects, then run
* every kernel 10 or 100 times and average the timings to smooth out any variance.
* But this makes for messy code and our goal is teaching, not detailed benchmarking.
*/
timer.Start();
transpose_serial<<<1, 1>>>(d_in, d_out);
timer.Stop();
cudaMemcpy(out, d_out, numbytes, cudaMemcpyDeviceToHost);
printf("transpose_serial: %g ms.\nVerifying transpose...%s\n",
timer.Elapsed(), compare_matrices(out, gold) ? "Failed" : "Success");
timer.Start();
transpose_parallel_per_row<<<1, N>>>(d_in, d_out);
timer.Stop();
cudaMemcpy(out, d_out, numbytes, cudaMemcpyDeviceToHost);
printf("transpose_parallel_per_row: %g ms.\nVerifying transpose...%s\n",
timer.Elapsed(), compare_matrices(out, gold) ? "Failed" : "Success");
dim3 blocks(N/K, N/K); // blocks per grid
dim3 threads(K, K); // threads per block
timer.Start();
transpose_parallel_per_element<<<blocks, threads>>>(d_in, d_out);
timer.Stop();
cudaMemcpy(out, d_out, numbytes, cudaMemcpyDeviceToHost);
printf("transpose_parallel_per_element: %g ms.\nVerifying transpose...%s\n",
timer.Elapsed(), compare_matrices(out, gold) ? "Failed" : "Success");
dim3 blocksKxK(N/K, N/K); // blocks per grid
dim3 threadsKxK(K, K); // threads per block
timer.Start();
transpose_parallel_per_element_tiled<<<blocksKxK, threadsKxK>>>(d_in, d_out);
timer.Stop();
cudaMemcpy(out, d_out, numbytes, cudaMemcpyDeviceToHost);
printf("transpose_parallel_per_element_tiled %dx%d: %g ms.\nVerifying ...%s\n",
K, K, timer.Elapsed(), compare_matrices(out, gold) ? "Failed" : "Success");
dim3 blocks16x16(N/16,N/16); // blocks per grid
dim3 threads16x16(16,16); // threads per block
timer.Start();
transpose_parallel_per_element_tiled16<<<blocks16x16, threads16x16>>>(d_in, d_out);
timer.Stop();
cudaMemcpy(out, d_out, numbytes, cudaMemcpyDeviceToHost);
printf("transpose_parallel_per_element_tiled 16x16: %g ms.\nVerifying ...%s\n",
timer.Elapsed(), compare_matrices(out, gold) ? "Failed" : "Success");
timer.Start();
transpose_parallel_per_element_tiled_padded16<<<blocks16x16, threads16x16>>>(d_in, d_out);
timer.Stop();
cudaMemcpy(out, d_out, numbytes, cudaMemcpyDeviceToHost);
printf("transpose_parallel_per_element_tiled_padded 16x16: %g ms.\nVerifying...%s\n",
timer.Elapsed(), compare_matrices(out, gold) ? "Failed" : "Success");
// Free memory
cudaFree(d_in);
cudaFree(d_out);
free(in);
free(out);
free(gold);
return 0;
}
|
21,187 | #include "includes.h"
__global__ void transposeDiagonal(float *odata, float *idata, int width, int height)
{
__shared__ float tile[TILE_DIM][TILE_DIM+1];
int blockIdx_x, blockIdx_y;
// do diagonal reordering
if (width == height)
{
blockIdx_y = blockIdx.x;
blockIdx_x = (blockIdx.x+blockIdx.y)%gridDim.x;
}
else
{
int bid = blockIdx.x + gridDim.x*blockIdx.y;
blockIdx_y = bid%gridDim.y;
blockIdx_x = ((bid/gridDim.y)+blockIdx_y)%gridDim.x;
}
// from here on the code is same as previous kernel except blockIdx_x replaces blockIdx.x
// and similarly for y
int xIndex = blockIdx_x * TILE_DIM + threadIdx.x;
int yIndex = blockIdx_y * TILE_DIM + threadIdx.y;
int index_in = xIndex + (yIndex)*width;
xIndex = blockIdx_y * TILE_DIM + threadIdx.x;
yIndex = blockIdx_x * TILE_DIM + threadIdx.y;
int index_out = xIndex + (yIndex)*height;
for (int i=0; i<TILE_DIM; i+=BLOCK_ROWS)
{
tile[threadIdx.y+i][threadIdx.x] = idata[index_in+i*width];
}
__syncthreads();
for (int i=0; i<TILE_DIM; i+=BLOCK_ROWS)
{
odata[index_out+i*height] = tile[threadIdx.x][threadIdx.y+i];
}
} |
21,188 | #include <stdio.h>
#include "reduction.h"
/*
Parallel sum reduction using shared memory
- takes log(n) steps for n input elements
- uses n threads
- only works for power-of-2 arrays
*/
// cuda thread synchronization
__global__ void
reduction_kernel_1(float* g_out, float* g_in, unsigned int size)
{
unsigned int idx_x = blockIdx.x * blockDim.x + threadIdx.x;
extern __shared__ float s_data[];
s_data[threadIdx.x] = (idx_x < size) ? g_in[idx_x] : 0.f;
__syncthreads();
// do reduction
// interleaved addressing
for (unsigned int stride = 1; stride < blockDim.x; stride *= 2)
{
int index = 2 * stride * threadIdx.x;
if (index < blockDim.x)
s_data[index] += s_data[index + stride];
__syncthreads();
}
if (threadIdx.x == 0)
g_out[blockIdx.x] = s_data[0];
}
int reduction(float *g_outPtr, float *g_inPtr, int size, int n_threads)
{
int n_blocks = (size + n_threads - 1) / n_threads;
reduction_kernel_1<<< n_blocks, n_threads, n_threads * sizeof(float), 0 >>>(g_outPtr, g_inPtr, size);
return n_blocks;
}
|
21,189 | #include "includes.h"
__global__ void calculateBodyForce(float4 *p, float4 *v, float dt, int n) {
int i = blockDim.x * blockIdx.x + threadIdx.x;
if (i < n) {
float Fx = 0.0f; float Fy = 0.0f; float Fz = 0.0f;
for (int tile = 0; tile < gridDim.x; tile++) {
__shared__ float3 shared_position[BLOCK_SIZE];
float4 temp_position = p[tile * blockDim.x + threadIdx.x];
shared_position[threadIdx.x] = make_float3(temp_position.x, temp_position.y, temp_position.z);
__syncthreads(); //synchronoze to make sure all tile data is available in shared memory
for (int j = 0; j < BLOCK_SIZE; j++) {
float dx = shared_position[j].x - p[i].x;
float dy = shared_position[j].y - p[i].y;
float dz = shared_position[j].z - p[i].z;
float distSqr = dx*dx + dy*dy + dz*dz + SOFTENING;
float invDist = rsqrtf(distSqr);
float invDist3 = invDist * invDist * invDist;
Fx += dx * invDist3; Fy += dy * invDist3; Fz += dz * invDist3;
}
__syncthreads(); // synchrnize before looping to other time
} //tile loop ends here
v[i].x += dt*Fx; v[i].y += dt*Fy; v[i].z += dt*Fz;
} //if ends here
} |
21,190 | //pass
//--blockDim=32 --gridDim=1
#include <cuda.h>
__global__ void test_Prog(int *A, int N) {
const int tid = threadIdx.x;
int alpha=0;
if(tid%2==0)
{
alpha=A[tid+2];
}
if(tid%6==0)
{
A[tid]=A[tid]+alpha;
}
} |
21,191 | #include <stdio.h>
#include <stdlib.h>
#include <cuda.h>
//nvcc shortestPath.cu
struct node
{
int nodeID, ancestor;
char label[20]; //max size of label is 20
};//node
void setNode(node &phy, int numNodes, int id, int aID, char * label)
{
phy.nodeID = id;
phy.ancestor = aID;
memset(phy.label, '\0', sizeof(label));
strcpy(phy.label, label);
}//setNode
__global__ void kernel(node * array, int numNodes, int id1, int id2,
int * ancestorID1, int * ancestorID2)
{
int idx = blockIdx.x * blockDim.x + threadIdx.x;
if (idx < numNodes)
{
if (array[idx].nodeID == id1) //if found target node
{
int ancestorIndex = 0;
node temp = array[idx]; //start from current node
while (temp.ancestor != 0)
{
ancestorID1[ancestorIndex++] = temp.ancestor; //add all ancestors
for (int i=0; i<numNodes; i++)
{
if (array[i].nodeID == temp.ancestor)
{
temp = array[i];
break;
}//if
}//for
}//while
}//if
else if (array[idx].nodeID == id2) //if found target node
{
int ancestorIndex = 0;
node temp = array[idx]; //start from current node
while (temp.ancestor != 0)
{
ancestorID2[ancestorIndex++] = temp.ancestor; //add all ancestors
for (int i=0; i<numNodes; i++)
{
if (array[i].nodeID == temp.ancestor)
{
temp = array[i];
break;
}//if
}//for
}//while
}//if
}//if
}//kernel
void shortestPath(node * phy, int numNodes, char * label1, char * label2)
{
node * deviceArray;
int * deviceID1;
int * deviceID2;
int * ancestorID1 = new int[numNodes]; //initialize max size to number of nodes
int * ancestorID2 = new int[numNodes];
float blockSize = 1024; //num threads per block
//check if invalid query
node temp1, temp2;
for (int i=0; i<numNodes; i++)
{
ancestorID1[i] = 0;
ancestorID2[i] = 0;
if (strcmp(label1, phy[i].label) == 0)
temp1 = phy[i];
else if (strcmp(label2, phy[i].label) == 0)
temp2 = phy[i];
}//for
if ((temp1.ancestor == temp2.nodeID) || (temp2.ancestor == temp1.nodeID))
{
printf("named integer(0)\n");
return;
}//if
//allocate device memory
cudaMalloc(&deviceArray, sizeof(node) * numNodes);
cudaMalloc(&deviceID1, sizeof(int) * numNodes);
cudaMalloc(&deviceID2, sizeof(int) * numNodes);
cudaMemcpy(deviceArray, phy, sizeof(node) * numNodes, cudaMemcpyHostToDevice);
cudaMemcpy(deviceID1, ancestorID1, sizeof(int) * numNodes, cudaMemcpyHostToDevice);
cudaMemcpy(deviceID2, ancestorID2, sizeof(int) * numNodes, cudaMemcpyHostToDevice);
dim3 dimBlock(blockSize);
dim3 dimGrid(ceil(numNodes/blockSize));
//compute ancestors
kernel <<< dimGrid, dimBlock >>> (deviceArray, numNodes, temp1.nodeID, temp2.nodeID, deviceID1, deviceID2);
cudaMemcpy(ancestorID1, deviceID1, sizeof(int) * numNodes, cudaMemcpyDeviceToHost);
cudaMemcpy(ancestorID2, deviceID2, sizeof(int) * numNodes, cudaMemcpyDeviceToHost);
cudaFree(deviceArray);
cudaFree(deviceID1);
cudaFree(deviceID2);
//find shortest path
int * path = new int[numNodes];
int currentPath = ancestorID1[0];
int pathIndex = 0;
bool isLCAPath = false;
//check if path converges at LCA
for (int i=0; i<numNodes; i++)
{
path[i] = 0;
if (temp1.nodeID == ancestorID2[i])
{
for (int j=0; j<i; j++)
path[j] = ancestorID2[j];
isLCAPath = true;
break;
}//if
else if (temp2.nodeID == ancestorID1[i])
{
for (int j=0; j<i; j++)
path[j] = ancestorID1[j];
isLCAPath = true;
break;
}//else if
}//for
//if one node is the ancestor of another
if (!isLCAPath)
{
for(int i=0; i<numNodes; i++)
{
for (int j=0; j<numNodes; j++)
{
if (currentPath == ancestorID2[j])
break;
if ((ancestorID2[j] == 0) || (j == numNodes-1))
{
path[pathIndex++] = ancestorID1[i];
currentPath = ancestorID1[i];
break;
}//if
}//for
}//for
if (pathIndex == 0)
path[pathIndex++] = currentPath;
for (int i=0; i<numNodes; i++)
{
if (ancestorID2[i] == currentPath)
break;
path[pathIndex++] = ancestorID2[i];
}//for
}//if
for (int i=0; i<numNodes; i++)
{
if (path[i] == 0)
break;
for (int j=0; j<numNodes; j++)
{
if (path[i] == phy[j].nodeID)
{
printf("%s ", phy[j].label);
break;
}//if
}//for
}//for
printf("\n");
for (int i=0; i<numNodes; i++)
{
if (path[i] == 0)
break;
printf("%d ", path[i]);
}//for
printf("\n");
delete [] ancestorID1;
delete [] ancestorID2;
delete [] path;
}//shortestPath
int main()
{
int numNodes = 27;
node * phy = new node[numNodes];
FILE * infile = fopen("geospiza", "r");
int nodeID, ancestor;
char label[20];
for (int i=0; i<numNodes; i++)
{
fscanf(infile, "%d", &nodeID);
fscanf(infile, "%d", &ancestor);
fscanf(infile, "%s", &label);
setNode(phy[i], numNodes, nodeID, ancestor, label);
}//for
fclose(infile);
//test shortest path
shortestPath(phy, numNodes, "fusca", "fortis");
delete [] phy;
return 0;
}//main
|
21,192 | #include <cuda.h>
#include <stdio.h>
#include <math.h>
#include <sys/time.h>
double wtime() {
struct timeval t;
gettimeofday(&t, NULL);
return (double)t.tv_sec + (double)t.tv_usec * 1E-6;
}
__global__ void gpuSum(float *a, float *b, float *c) {
int i = threadIdx.x + blockDim.x * blockIdx.x;
c[i] = a[i] + b[i];
// c[i] *= c[i];
}
int main() {
float *h_a, *h_b, *h_c, *d_a, *d_b, *d_c;
int threads_per_block = 1024;
int N = pow(2,10);
int num_of_blocks = N / threads_per_block;
h_a = (float*)calloc(N, sizeof(float));
h_b = (float*)calloc(N, sizeof(float));
h_c = (float*)calloc(N, sizeof(float));
for(int i = 0; i < N; i++) {
h_a[i] = i * 2;
h_b[i] = i * 3;
}
cudaMalloc((void**)&d_a, N*sizeof(float));
cudaMalloc((void**)&d_b, N*sizeof(float));
cudaMalloc((void**)&d_c, N*sizeof(float));
cudaMemcpy(d_a, h_a, N*sizeof(float), cudaMemcpyHostToDevice);
cudaMemcpy(d_b, h_b, N*sizeof(float), cudaMemcpyHostToDevice);
double t = wtime();
gpuSum<<<dim3(num_of_blocks),dim3(threads_per_block)>>>(d_a, d_b, d_c);
cudaDeviceSynchronize();
t = wtime() - t;
cudaMemcpy(h_c, d_c, N*sizeof(float), cudaMemcpyDeviceToHost);
// for(int i = 0; i < N; i++) {
// printf("%g\n", h_c[i]);
// }
printf("Elapsed time: %.6fsec. \n", t);
free(h_a);
free(h_b);
free(h_c);
cudaFree(d_a);
cudaFree(d_b);
cudaFree(d_c);
return 0;
}
|
21,193 | #include <stdio.h>
#include <time.h>
#include <cstring>
#include "cuda.h"
#include "cuda_runtime.h"
#define gpuErrchk(ans) { gpu_assert((ans), __FILE__, __LINE__); }
inline void gpu_assert(cudaError_t code, const char *file, int line, bool abort = true)
{
if(code != cudaSuccess)
{
fprintf(stderr, "GPUassert: %s %s %d\n", cudaGetErrorString(code), file, line);
if (abort) exit(code);
}
}
void compare_arrays(int *a, int *b, int size)
{
for(int i = 0; i < size; i++)
{
if(a[i] != b[i])
{
printf("Arrays are different :-(\n");
return;
}
}
printf("Arrays are the same :-)\n");
}
__global__ void sum_array_gpu(int *a, int *b, int *c, int *d, int size) {
int gid = blockIdx.x * blockDim.x + threadIdx.x;
if (gid < size) {
d[gid] = a[gid] + b[gid] + c[gid];
}
}
void sum_array_cpu(int *a, int *b, int *c, int *d, int size) {
for (int i = 0; i < size; i++) {
d[i] = a[i] + b[i] + c[i];
}
}
int main(int argc, char *argv[]) {
int size = 1 << 22;
printf("size: %d \n", size);
//int block_size = atoi(argv[1]);
int block_size = 64;
int NO_BYTES = size * sizeof(int);
// host pointers
int *h_a, *h_b, *h_c, *h_d, *gpu_results;
h_a = (int *)malloc(NO_BYTES);
h_b = (int *)malloc(NO_BYTES);
h_c = (int *)malloc(NO_BYTES);
gpu_results = (int *)malloc(NO_BYTES);
h_d = (int *)malloc(NO_BYTES);
// initialize host pointer
time_t t;
srand((unsigned)time(&t));
for (int i = 0; i < size; i++) {
h_a[i] = (int)(rand() & 0xFF);
h_b[i] = (int)(rand() & 0xFF);
h_c[i] = (int)(rand() & 0xFF);
}
// summation in CPU
clock_t cpu_start, cpu_end;
cpu_start = clock();
sum_array_cpu(h_a, h_b, h_c, h_d, size);
cpu_end = clock();
memset(gpu_results, 0, NO_BYTES);
// device pointer
int *d_a, *d_b, *d_c, *d_d;
gpuErrchk(cudaMalloc((int **)&d_a, NO_BYTES));
gpuErrchk(cudaMalloc((int **)&d_b, NO_BYTES));
gpuErrchk(cudaMalloc((int **)&d_c, NO_BYTES));
gpuErrchk(cudaMalloc((int **)&d_d, NO_BYTES));
clock_t htod_start, htod_end;
htod_start = clock();
gpuErrchk(cudaMemcpy(d_a, h_a, NO_BYTES, cudaMemcpyHostToDevice));
gpuErrchk(cudaMemcpy(d_b, h_b, NO_BYTES, cudaMemcpyHostToDevice));
gpuErrchk(cudaMemcpy(d_c, h_c, NO_BYTES, cudaMemcpyHostToDevice));
htod_end = clock();
// launching the grid
dim3 block(block_size);
dim3 grid((size + block.x - 1) / block.x);
// execution time mesuring in GPU
clock_t gpu_start, gpu_end;
gpu_start = clock();
sum_array_gpu<<<grid, block>>>(d_a, d_b, d_c, d_d, size);
gpuErrchk(cudaDeviceSynchronize());
gpu_end = clock();
// memory transfer back to host
clock_t dtoh_start, dtoh_end;
dtoh_start = clock();
gpuErrchk(cudaMemcpy(gpu_results, d_d, NO_BYTES, cudaMemcpyDeviceToHost));
dtoh_end = clock();
// array comparison
compare_arrays(gpu_results, h_d, size);
printf("Sum array CPU execution time : % 4.6f \n",
(double)((double)(cpu_end - cpu_start) / CLOCKS_PER_SEC));
printf("Sum array GPU execution time : % 4.6f \n",
(double)((double)(gpu_end - gpu_start) / CLOCKS_PER_SEC));
printf("htod mem transfer time : % 4.6f \n",
(double)((double)(htod_end - htod_start) / CLOCKS_PER_SEC));
printf("dtoh mem transfer time : % 4.6f \n",
(double)((double)(dtoh_end - dtoh_start) / CLOCKS_PER_SEC));
printf("Sum array GPU total execution time : % 4.6f \n",
(double)((double)(dtoh_end - htod_start) / CLOCKS_PER_SEC));
gpuErrchk(cudaFree(d_a));
gpuErrchk(cudaFree(d_b));
gpuErrchk(cudaFree(d_c));
gpuErrchk(cudaFree(d_d));
free(h_a);
free(h_b);
free(h_c);
free(h_d);
free(gpu_results);
cudaDeviceReset();
return 0;
}
|
21,194 | #include "vscale.cuh"
__global__ void vscale(const float *a, float *b, unsigned int n) {
int i = blockIdx.x * blockDim.x + threadIdx.x;
if (i < n) {
b[i] *= a[i];
}
}
|
21,195 | #include <cuda.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
//max value for element in array
#define MAX 100000
//defined threads per block for cims machines
#define THREADS_PER_BLOCK 1024
//defined warp number
#define WARP 32
void generate(int *a, const int sie);
__global__ void get_max(int *array, const int size);
//generate random array
void generate(int *a, const int size){
int i;
time_t t;
srand((unsigned) time(&t));
for(i = 0; i < size; i++){
a[i] = random() % MAX;;
}
}
//get the maximum value in the array
__global__ void get_max(int *array, const int size){
int temp;
int index = threadIdx.x + (blockDim.x * blockIdx.x);
int numThreads = size;
//if the number of threads is bigger than size of the warp
while(numThreads > WARP){
int half = numThreads / 2;
if (index < half){
temp = array[index + half];
//replace with bigger value
if (temp > array[index]) {
array[index] = temp;
}
}
__syncthreads();
numThreads = numThreads / 2;
}
}
int main(int argc, char *argv[]){
//initialize arrays
int *host_a;
int *device_a;
//initialize max value
int max = 0;
//get size from argument from command line
const int size = atoi(argv[1]);
//malloc host array
host_a = (int *)malloc(size * sizeof(int));
//generate random array
generate(host_a, size);
//malloc for device array
cudaMalloc( (void **)&device_a, sizeof(int) * size );
//copy contents of host array into device array
cudaMemcpy(device_a, host_a, sizeof(int) * size, cudaMemcpyHostToDevice);
const int NUM_BLOCKS = size / THREADS_PER_BLOCK;
//run get_max function
get_max<<<NUM_BLOCKS,THREADS_PER_BLOCK>>>(device_a, size);
//copy contents of device array back to host array
cudaMemcpy(host_a, device_a, sizeof(int) * size, cudaMemcpyDeviceToHost);
//go through host array and get the max value
int i;
for(i = 0; i < WARP; i++){
if(max < host_a[i]){
max = host_a[i];
}
}
printf("Max value in the array: %d\n", max);
//free the arrays
free(host_a);
cudaFree(device_a);
return 0;
}
|
21,196 | #include "includes.h"
__global__ void cpy(int *a, int *b, int n) {
unsigned int i = blockIdx.x * blockDim.x + threadIdx.x;
int sum = 0;
while (i < n) {
int val = b[i];
sum += val;
i += blockDim.x * gridDim.x;
}
atomicAdd(a, sum);
} |
21,197 |
/*
* Function: best_shuffle
* --------------------
* Shuffles given string (char array) with the use of a deterministic function
*
* s: pointer of the char array (constant)
* r: pointer of a copy of char array (will contain final string)
* diff: pointer of int array, which will contain the difference between initial & final string
* n: number of characters of the word
*
*/
__global__ void best_shuffle(const int *s, int *r, int *diff, int n){
int idx = threadIdx.x + blockDim.x * blockIdx.x;
if (idx < n){
int i, j = 0, max = 0, cnt[128] = {0};
char buf[256] = {0};
for(i = 0; i < n; ++i)
if (++cnt[(int)s[i]] > max) max = cnt[(int)s[i]];
for(i = 0; i < 128; ++i)
while (cnt[i]--) buf[j++] = i;
for(i = 0; i < n; ++i){
if (r[idx] == buf[i]) {
r[idx] = buf[(i + max) % n] & ~128;
buf[i] |= 128;
break;
}
}
atomicAdd(&(diff[0]), diff[0]+(r[idx] == s[idx]));
}
}
|
21,198 | #include <stdio.h>
#include <stdlib.h>
int main( void )
{
int deviceCount;
cudaGetDeviceCount( &deviceCount );
printf("Hello, Physics 244 Class! You have %d devices\n", deviceCount );
return 0;
}
|
21,199 | #include <stdio.h>
#include <stdlib.h>
#include <math.h>
#define NUM_ELEMENTS 1<<30
#define BLOCK_SIZE 1024
#define CUDA_ERROR_CHECK(func) { gpuAssert((func), __FILE__, __LINE__); }
inline void gpuAssert(cudaError_t code, const char *file, int line, bool abort=true){
if (code != cudaSuccess) {
fprintf(stderr,"GPUassert: %s %s %d\n", cudaGetErrorString(code), file, line);
if (abort) exit(code);
}
}
__global__ void reduce(int *input, int *output) {
extern __shared__ int sdata[];
unsigned int tid = threadIdx.x;
unsigned int i = blockIdx.x * blockDim.x + threadIdx.x;
sdata[tid] = input[i];
__syncthreads();
for (unsigned int s = 1; s < blockDim.x; s *= 2) {
if (tid % (2 * s) == 0) {
sdata[tid] += sdata[tid + s];
}
__syncthreads();
}
if (tid == 0){
output[blockIdx.x] = sdata[0];
}
}
int main(){
size_t elems = NUM_ELEMENTS;
size_t grid_size = (size_t)(ceill((long double)elems/(long double)BLOCK_SIZE));
size_t input_size = elems * sizeof(int);
size_t output_size = grid_size * sizeof(int);
int *deviceInput = NULL;
int *deviceOutput = NULL;
int *hostInput = NULL;
int *hostOutput = NULL;
hostInput = (int *)malloc(input_size);
hostOutput = (int *)malloc(output_size);
if(hostInput == NULL){
fprintf(stderr, "Failed to allocate %zu bytes for input!\n", input_size);
exit(EXIT_FAILURE);
}
if(hostOutput == NULL){
fprintf(stderr, "Failed to allocate %zu bytes for output!\n", output_size);
exit(EXIT_FAILURE);
}
CUDA_ERROR_CHECK(cudaMalloc((void **)&deviceInput, input_size));
CUDA_ERROR_CHECK(cudaMalloc((void **)&deviceOutput, output_size));
size_t i = 0;
int host_sum = 0;
for(i = 0; i < elems; i++){
hostInput[i] = 1;
host_sum += hostInput[i]; //Used later to verify GPU result
}
CUDA_ERROR_CHECK(cudaMemcpy(deviceInput, hostInput, input_size, cudaMemcpyHostToDevice));
reduce<<<grid_size, BLOCK_SIZE, BLOCK_SIZE*sizeof(int)>>>(deviceInput, deviceOutput);
CUDA_ERROR_CHECK(cudaPeekAtLastError());
CUDA_ERROR_CHECK(cudaMemcpy(hostOutput, deviceOutput, output_size, cudaMemcpyDeviceToHost));
for(i = 1; i < grid_size; i++){
hostOutput[0] += hostOutput[i];
}
fprintf(stdout, "Result: ");
if(host_sum == hostOutput[0]){
fprintf(stdout, "PASS\n");
}else{
fprintf(stdout, "FAIL\n");
}
fprintf(stdout, "Sum = %d\n", hostOutput[0]);
free(hostInput);
free(hostOutput);
CUDA_ERROR_CHECK(cudaFree(deviceInput));
CUDA_ERROR_CHECK(cudaFree(deviceOutput));
CUDA_ERROR_CHECK(cudaDeviceReset());
return EXIT_SUCCESS;
}
|
21,200 | #include "includes.h"
__global__ void MatrixCopy(float* in, float *out, int size)
{
int id = blockDim.x*blockIdx.y*gridDim.x + blockDim.x*blockIdx.x + threadIdx.x;
if (id < size)
out[id] = in[id];
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.